From 4df8d25236b9b590f8164b52dd2c483f153199b0 Mon Sep 17 00:00:00 2001 From: kovacsv Date: Sat, 12 Jun 2021 19:49:26 +0200 Subject: [PATCH] Add experimental importer for ifc. --- libs/web-ifc-api.js | 45410 ++++++++++++++++++++ libs/web-ifc.license.md | 375 + libs/web-ifc.wasm | Bin 0 -> 379639 bytes sandbox/embed_selfhost_fullscreen.html | 1 + sandbox/embed_selfhost_multiple.html | 1 + sandbox/embed_selfhost_single.html | 1 + sandbox/embed_selfhost_single_scroll.html | 1 + source/external/ifcimporter.js | 134 + source/external/threemodelloader.js | 1 + tools/config.json | 1 + website/embed.html | 1 + website/index.html | 1 + 12 files changed, 45927 insertions(+) create mode 100644 libs/web-ifc-api.js create mode 100644 libs/web-ifc.license.md create mode 100644 libs/web-ifc.wasm create mode 100644 source/external/ifcimporter.js diff --git a/libs/web-ifc-api.js b/libs/web-ifc-api.js new file mode 100644 index 0000000..904984c --- /dev/null +++ b/libs/web-ifc-api.js @@ -0,0 +1,45410 @@ +var __commonJS = (callback, module) => () => { + if (!module) { + module = {exports: {}}; + callback(module.exports, module); + } + return module.exports; +}; + +// dist/web-ifc.js +var require_web_ifc = __commonJS((exports, module) => { + var WebIFCWasm2 = function() { + var _scriptDir = typeof document !== "undefined" && document.currentScript ? document.currentScript.src : void 0; + if (typeof __filename !== "undefined") + _scriptDir = _scriptDir || __filename; + return function(WebIFCWasm3) { + WebIFCWasm3 = WebIFCWasm3 || {}; + var Module = typeof WebIFCWasm3 !== "undefined" ? WebIFCWasm3 : {}; + var readyPromiseResolve, readyPromiseReject; + Module["ready"] = new Promise(function(resolve, reject) { + readyPromiseResolve = resolve; + readyPromiseReject = reject; + }); + var moduleOverrides = {}; + var key; + for (key in Module) { + if (Module.hasOwnProperty(key)) { + moduleOverrides[key] = Module[key]; + } + } + var arguments_ = []; + var thisProgram = "./this.program"; + var quit_ = function(status, toThrow) { + throw toThrow; + }; + var ENVIRONMENT_IS_WEB = false; + var ENVIRONMENT_IS_WORKER = false; + var ENVIRONMENT_IS_NODE = false; + var ENVIRONMENT_IS_SHELL = false; + ENVIRONMENT_IS_WEB = typeof window === "object"; + ENVIRONMENT_IS_WORKER = typeof importScripts === "function"; + ENVIRONMENT_IS_NODE = typeof process === "object" && typeof process.versions === "object" && typeof process.versions.node === "string"; + ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; + var scriptDirectory = ""; + function locateFile(path) { + if (Module["locateFile"]) { + return Module["locateFile"](path, scriptDirectory); + } + return scriptDirectory + path; + } + var read_, readAsync, readBinary, setWindowTitle; + var nodeFS; + var nodePath; + if (ENVIRONMENT_IS_NODE) { + if (ENVIRONMENT_IS_WORKER) { + scriptDirectory = require("path").dirname(scriptDirectory) + "/"; + } else { + scriptDirectory = __dirname + "/"; + } + read_ = function shell_read(filename, binary) { + if (!nodeFS) + nodeFS = require("fs"); + if (!nodePath) + nodePath = require("path"); + filename = nodePath["normalize"](filename); + return nodeFS["readFileSync"](filename, binary ? null : "utf8"); + }; + readBinary = function readBinary2(filename) { + var ret = read_(filename, true); + if (!ret.buffer) { + ret = new Uint8Array(ret); + } + assert(ret.buffer); + return ret; + }; + if (process["argv"].length > 1) { + thisProgram = process["argv"][1].replace(/\\/g, "/"); + } + arguments_ = process["argv"].slice(2); + process["on"]("uncaughtException", function(ex) { + if (!(ex instanceof ExitStatus)) { + throw ex; + } + }); + process["on"]("unhandledRejection", abort); + quit_ = function(status) { + process["exit"](status); + }; + Module["inspect"] = function() { + return "[Emscripten Module object]"; + }; + } else if (ENVIRONMENT_IS_SHELL) { + if (typeof read != "undefined") { + read_ = function shell_read(f) { + return read(f); + }; + } + readBinary = function readBinary2(f) { + var data; + if (typeof readbuffer === "function") { + return new Uint8Array(readbuffer(f)); + } + data = read(f, "binary"); + assert(typeof data === "object"); + return data; + }; + if (typeof scriptArgs != "undefined") { + arguments_ = scriptArgs; + } else if (typeof arguments != "undefined") { + arguments_ = arguments; + } + if (typeof quit === "function") { + quit_ = function(status) { + quit(status); + }; + } + if (typeof print !== "undefined") { + if (typeof console === "undefined") + console = {}; + console.log = print; + console.warn = console.error = typeof printErr !== "undefined" ? printErr : print; + } + } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { + scriptDirectory = self.location.href; + } else if (typeof document !== "undefined" && document.currentScript) { + scriptDirectory = document.currentScript.src; + } + if (_scriptDir) { + scriptDirectory = _scriptDir; + } + if (scriptDirectory.indexOf("blob:") !== 0) { + scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf("/") + 1); + } else { + scriptDirectory = ""; + } + { + read_ = function shell_read(url) { + var xhr = new XMLHttpRequest(); + xhr.open("GET", url, false); + xhr.send(null); + return xhr.responseText; + }; + if (ENVIRONMENT_IS_WORKER) { + readBinary = function readBinary2(url) { + var xhr = new XMLHttpRequest(); + xhr.open("GET", url, false); + xhr.responseType = "arraybuffer"; + xhr.send(null); + return new Uint8Array(xhr.response); + }; + } + readAsync = function readAsync2(url, onload, onerror) { + var xhr = new XMLHttpRequest(); + xhr.open("GET", url, true); + xhr.responseType = "arraybuffer"; + xhr.onload = function xhr_onload() { + if (xhr.status == 200 || xhr.status == 0 && xhr.response) { + onload(xhr.response); + return; + } + onerror(); + }; + xhr.onerror = onerror; + xhr.send(null); + }; + } + setWindowTitle = function(title) { + document.title = title; + }; + } else { + } + var out = Module["print"] || console.log.bind(console); + var err = Module["printErr"] || console.warn.bind(console); + for (key in moduleOverrides) { + if (moduleOverrides.hasOwnProperty(key)) { + Module[key] = moduleOverrides[key]; + } + } + moduleOverrides = null; + if (Module["arguments"]) + arguments_ = Module["arguments"]; + if (Module["thisProgram"]) + thisProgram = Module["thisProgram"]; + if (Module["quit"]) + quit_ = Module["quit"]; + var STACK_ALIGN = 16; + function alignMemory(size, factor) { + if (!factor) + factor = STACK_ALIGN; + return Math.ceil(size / factor) * factor; + } + var tempRet0 = 0; + var setTempRet0 = function(value) { + tempRet0 = value; + }; + var wasmBinary; + if (Module["wasmBinary"]) + wasmBinary = Module["wasmBinary"]; + var noExitRuntime; + if (Module["noExitRuntime"]) + noExitRuntime = Module["noExitRuntime"]; + if (typeof WebAssembly !== "object") { + abort("no native wasm support detected"); + } + var wasmMemory; + var ABORT = false; + var EXITSTATUS = 0; + function assert(condition, text) { + if (!condition) { + abort("Assertion failed: " + text); + } + } + var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : void 0; + function UTF8ArrayToString(heap, idx, maxBytesToRead) { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + while (heap[endPtr] && !(endPtr >= endIdx)) + ++endPtr; + if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) { + return UTF8Decoder.decode(heap.subarray(idx, endPtr)); + } else { + var str = ""; + while (idx < endPtr) { + var u0 = heap[idx++]; + if (!(u0 & 128)) { + str += String.fromCharCode(u0); + continue; + } + var u1 = heap[idx++] & 63; + if ((u0 & 224) == 192) { + str += String.fromCharCode((u0 & 31) << 6 | u1); + continue; + } + var u2 = heap[idx++] & 63; + if ((u0 & 240) == 224) { + u0 = (u0 & 15) << 12 | u1 << 6 | u2; + } else { + u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heap[idx++] & 63; + } + if (u0 < 65536) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 65536; + str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023); + } + } + } + return str; + } + function UTF8ToString(ptr, maxBytesToRead) { + return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ""; + } + function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) { + if (!(maxBytesToWrite > 0)) + return 0; + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; + for (var i = 0; i < str.length; ++i) { + var u = str.charCodeAt(i); + if (u >= 55296 && u <= 57343) { + var u1 = str.charCodeAt(++i); + u = 65536 + ((u & 1023) << 10) | u1 & 1023; + } + if (u <= 127) { + if (outIdx >= endIdx) + break; + heap[outIdx++] = u; + } else if (u <= 2047) { + if (outIdx + 1 >= endIdx) + break; + heap[outIdx++] = 192 | u >> 6; + heap[outIdx++] = 128 | u & 63; + } else if (u <= 65535) { + if (outIdx + 2 >= endIdx) + break; + heap[outIdx++] = 224 | u >> 12; + heap[outIdx++] = 128 | u >> 6 & 63; + heap[outIdx++] = 128 | u & 63; + } else { + if (outIdx + 3 >= endIdx) + break; + heap[outIdx++] = 240 | u >> 18; + heap[outIdx++] = 128 | u >> 12 & 63; + heap[outIdx++] = 128 | u >> 6 & 63; + heap[outIdx++] = 128 | u & 63; + } + } + heap[outIdx] = 0; + return outIdx - startIdx; + } + function stringToUTF8(str, outPtr, maxBytesToWrite) { + return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite); + } + function lengthBytesUTF8(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + var u = str.charCodeAt(i); + if (u >= 55296 && u <= 57343) + u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023; + if (u <= 127) + ++len; + else if (u <= 2047) + len += 2; + else if (u <= 65535) + len += 3; + else + len += 4; + } + return len; + } + var UTF16Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : void 0; + function UTF16ToString(ptr, maxBytesToRead) { + var endPtr = ptr; + var idx = endPtr >> 1; + var maxIdx = idx + maxBytesToRead / 2; + while (!(idx >= maxIdx) && HEAPU16[idx]) + ++idx; + endPtr = idx << 1; + if (endPtr - ptr > 32 && UTF16Decoder) { + return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr)); + } else { + var str = ""; + for (var i = 0; !(i >= maxBytesToRead / 2); ++i) { + var codeUnit = HEAP16[ptr + i * 2 >> 1]; + if (codeUnit == 0) + break; + str += String.fromCharCode(codeUnit); + } + return str; + } + } + function stringToUTF16(str, outPtr, maxBytesToWrite) { + if (maxBytesToWrite === void 0) { + maxBytesToWrite = 2147483647; + } + if (maxBytesToWrite < 2) + return 0; + maxBytesToWrite -= 2; + var startPtr = outPtr; + var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + var codeUnit = str.charCodeAt(i); + HEAP16[outPtr >> 1] = codeUnit; + outPtr += 2; + } + HEAP16[outPtr >> 1] = 0; + return outPtr - startPtr; + } + function lengthBytesUTF16(str) { + return str.length * 2; + } + function UTF32ToString(ptr, maxBytesToRead) { + var i = 0; + var str = ""; + while (!(i >= maxBytesToRead / 4)) { + var utf32 = HEAP32[ptr + i * 4 >> 2]; + if (utf32 == 0) + break; + ++i; + if (utf32 >= 65536) { + var ch = utf32 - 65536; + str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023); + } else { + str += String.fromCharCode(utf32); + } + } + return str; + } + function stringToUTF32(str, outPtr, maxBytesToWrite) { + if (maxBytesToWrite === void 0) { + maxBytesToWrite = 2147483647; + } + if (maxBytesToWrite < 4) + return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + for (var i = 0; i < str.length; ++i) { + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 55296 && codeUnit <= 57343) { + var trailSurrogate = str.charCodeAt(++i); + codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023; + } + HEAP32[outPtr >> 2] = codeUnit; + outPtr += 4; + if (outPtr + 4 > endPtr) + break; + } + HEAP32[outPtr >> 2] = 0; + return outPtr - startPtr; + } + function lengthBytesUTF32(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 55296 && codeUnit <= 57343) + ++i; + len += 4; + } + return len; + } + function writeArrayToMemory(array, buffer2) { + HEAP8.set(array, buffer2); + } + function writeAsciiToMemory(str, buffer2, dontAddNull) { + for (var i = 0; i < str.length; ++i) { + HEAP8[buffer2++ >> 0] = str.charCodeAt(i); + } + if (!dontAddNull) + HEAP8[buffer2 >> 0] = 0; + } + function alignUp(x, multiple) { + if (x % multiple > 0) { + x += multiple - x % multiple; + } + return x; + } + var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64; + function updateGlobalBufferAndViews(buf) { + buffer = buf; + Module["HEAP8"] = HEAP8 = new Int8Array(buf); + Module["HEAP16"] = HEAP16 = new Int16Array(buf); + Module["HEAP32"] = HEAP32 = new Int32Array(buf); + Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf); + Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf); + Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf); + Module["HEAPF32"] = HEAPF32 = new Float32Array(buf); + Module["HEAPF64"] = HEAPF64 = new Float64Array(buf); + } + var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216; + if (Module["wasmMemory"]) { + wasmMemory = Module["wasmMemory"]; + } else { + wasmMemory = new WebAssembly.Memory({initial: INITIAL_MEMORY / 65536, maximum: 2147483648 / 65536}); + } + if (wasmMemory) { + buffer = wasmMemory.buffer; + } + INITIAL_MEMORY = buffer.byteLength; + updateGlobalBufferAndViews(buffer); + var wasmTable; + var __ATPRERUN__ = []; + var __ATINIT__ = []; + var __ATMAIN__ = []; + var __ATPOSTRUN__ = []; + var runtimeInitialized = false; + var runtimeExited = false; + function preRun() { + if (Module["preRun"]) { + if (typeof Module["preRun"] == "function") + Module["preRun"] = [Module["preRun"]]; + while (Module["preRun"].length) { + addOnPreRun(Module["preRun"].shift()); + } + } + callRuntimeCallbacks(__ATPRERUN__); + } + function initRuntime() { + runtimeInitialized = true; + if (!Module["noFSInit"] && !FS.init.initialized) + FS.init(); + TTY.init(); + callRuntimeCallbacks(__ATINIT__); + } + function preMain() { + FS.ignorePermissions = false; + callRuntimeCallbacks(__ATMAIN__); + } + function exitRuntime() { + runtimeExited = true; + } + function postRun() { + if (Module["postRun"]) { + if (typeof Module["postRun"] == "function") + Module["postRun"] = [Module["postRun"]]; + while (Module["postRun"].length) { + addOnPostRun(Module["postRun"].shift()); + } + } + callRuntimeCallbacks(__ATPOSTRUN__); + } + function addOnPreRun(cb) { + __ATPRERUN__.unshift(cb); + } + function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); + } + var runDependencies = 0; + var runDependencyWatcher = null; + var dependenciesFulfilled = null; + function getUniqueRunDependency(id) { + return id; + } + function addRunDependency(id) { + runDependencies++; + if (Module["monitorRunDependencies"]) { + Module["monitorRunDependencies"](runDependencies); + } + } + function removeRunDependency(id) { + runDependencies--; + if (Module["monitorRunDependencies"]) { + Module["monitorRunDependencies"](runDependencies); + } + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + } + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback(); + } + } + } + Module["preloadedImages"] = {}; + Module["preloadedAudios"] = {}; + function abort(what) { + if (Module["onAbort"]) { + Module["onAbort"](what); + } + what += ""; + err(what); + ABORT = true; + EXITSTATUS = 1; + what = "abort(" + what + "). Build with -s ASSERTIONS=1 for more info."; + var e = new WebAssembly.RuntimeError(what); + readyPromiseReject(e); + throw e; + } + function hasPrefix(str, prefix) { + return String.prototype.startsWith ? str.startsWith(prefix) : str.indexOf(prefix) === 0; + } + var dataURIPrefix = "data:application/octet-stream;base64,"; + function isDataURI(filename) { + return hasPrefix(filename, dataURIPrefix); + } + var fileURIPrefix = "file://"; + function isFileURI(filename) { + return hasPrefix(filename, fileURIPrefix); + } + var wasmBinaryFile = WasmPath + "web-ifc.wasm"; + if (!isDataURI(wasmBinaryFile)) { + wasmBinaryFile = locateFile(wasmBinaryFile); + } + function getBinary() { + try { + if (wasmBinary) { + return new Uint8Array(wasmBinary); + } + if (readBinary) { + return readBinary(wasmBinaryFile); + } else { + throw "both async and sync fetching of the wasm failed"; + } + } catch (err2) { + abort(err2); + } + } + function getBinaryPromise() { + if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === "function" && !isFileURI(wasmBinaryFile)) { + return fetch(wasmBinaryFile, {credentials: "same-origin"}).then(function(response) { + if (!response["ok"]) { + throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"; + } + return response["arrayBuffer"](); + }).catch(function() { + return getBinary(); + }); + } + return Promise.resolve().then(getBinary); + } + function createWasm() { + var info = {a: asmLibraryArg}; + function receiveInstance(instance, module2) { + var exports3 = instance.exports; + Module["asm"] = exports3; + wasmTable = Module["asm"]["W"]; + removeRunDependency("wasm-instantiate"); + } + addRunDependency("wasm-instantiate"); + function receiveInstantiatedSource(output) { + receiveInstance(output["instance"]); + } + function instantiateArrayBuffer(receiver) { + return getBinaryPromise().then(function(binary) { + return WebAssembly.instantiate(binary, info); + }).then(receiver, function(reason) { + err("failed to asynchronously prepare wasm: " + reason); + abort(reason); + }); + } + function instantiateAsync() { + if (!wasmBinary && typeof WebAssembly.instantiateStreaming === "function" && !isDataURI(wasmBinaryFile) && !isFileURI(wasmBinaryFile) && typeof fetch === "function") { + return fetch(wasmBinaryFile, {credentials: "same-origin"}).then(function(response) { + var result = WebAssembly.instantiateStreaming(response, info); + return result.then(receiveInstantiatedSource, function(reason) { + err("wasm streaming compile failed: " + reason); + err("falling back to ArrayBuffer instantiation"); + return instantiateArrayBuffer(receiveInstantiatedSource); + }); + }); + } else { + return instantiateArrayBuffer(receiveInstantiatedSource); + } + } + if (Module["instantiateWasm"]) { + try { + var exports2 = Module["instantiateWasm"](info, receiveInstance); + return exports2; + } catch (e) { + err("Module.instantiateWasm callback failed with error: " + e); + return false; + } + } + instantiateAsync().catch(readyPromiseReject); + return {}; + } + var tempDouble; + var tempI64; + function callRuntimeCallbacks(callbacks) { + while (callbacks.length > 0) { + var callback = callbacks.shift(); + if (typeof callback == "function") { + callback(Module); + continue; + } + var func = callback.func; + if (typeof func === "number") { + if (callback.arg === void 0) { + wasmTable.get(func)(); + } else { + wasmTable.get(func)(callback.arg); + } + } else { + func(callback.arg === void 0 ? null : callback.arg); + } + } + } + function dynCallLegacy(sig, ptr, args) { + if (args && args.length) { + return Module["dynCall_" + sig].apply(null, [ptr].concat(args)); + } + return Module["dynCall_" + sig].call(null, ptr); + } + function dynCall(sig, ptr, args) { + if (sig.indexOf("j") != -1) { + return dynCallLegacy(sig, ptr, args); + } + return wasmTable.get(ptr).apply(null, args); + } + function ___assert_fail(condition, filename, line, func) { + abort("Assertion failed: " + UTF8ToString(condition) + ", at: " + [filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function"]); + } + function setErrNo(value) { + HEAP32[___errno_location() >> 2] = value; + return value; + } + var PATH = {splitPath: function(filename) { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; + return splitPathRe.exec(filename).slice(1); + }, normalizeArray: function(parts, allowAboveRoot) { + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === ".") { + parts.splice(i, 1); + } else if (last === "..") { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + if (allowAboveRoot) { + for (; up; up--) { + parts.unshift(".."); + } + } + return parts; + }, normalize: function(path) { + var isAbsolute = path.charAt(0) === "/", trailingSlash = path.substr(-1) === "/"; + path = PATH.normalizeArray(path.split("/").filter(function(p) { + return !!p; + }), !isAbsolute).join("/"); + if (!path && !isAbsolute) { + path = "."; + } + if (path && trailingSlash) { + path += "/"; + } + return (isAbsolute ? "/" : "") + path; + }, dirname: function(path) { + var result = PATH.splitPath(path), root = result[0], dir = result[1]; + if (!root && !dir) { + return "."; + } + if (dir) { + dir = dir.substr(0, dir.length - 1); + } + return root + dir; + }, basename: function(path) { + if (path === "/") + return "/"; + path = PATH.normalize(path); + path = path.replace(/\/$/, ""); + var lastSlash = path.lastIndexOf("/"); + if (lastSlash === -1) + return path; + return path.substr(lastSlash + 1); + }, extname: function(path) { + return PATH.splitPath(path)[3]; + }, join: function() { + var paths = Array.prototype.slice.call(arguments, 0); + return PATH.normalize(paths.join("/")); + }, join2: function(l, r) { + return PATH.normalize(l + "/" + r); + }}; + function getRandomDevice() { + if (typeof crypto === "object" && typeof crypto["getRandomValues"] === "function") { + var randomBuffer = new Uint8Array(1); + return function() { + crypto.getRandomValues(randomBuffer); + return randomBuffer[0]; + }; + } else if (ENVIRONMENT_IS_NODE) { + try { + var crypto_module = require("crypto"); + return function() { + return crypto_module["randomBytes"](1)[0]; + }; + } catch (e) { + } + } + return function() { + abort("randomDevice"); + }; + } + var PATH_FS = {resolve: function() { + var resolvedPath = "", resolvedAbsolute = false; + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = i >= 0 ? arguments[i] : FS.cwd(); + if (typeof path !== "string") { + throw new TypeError("Arguments to path.resolve must be strings"); + } else if (!path) { + return ""; + } + resolvedPath = path + "/" + resolvedPath; + resolvedAbsolute = path.charAt(0) === "/"; + } + resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter(function(p) { + return !!p; + }), !resolvedAbsolute).join("/"); + return (resolvedAbsolute ? "/" : "") + resolvedPath || "."; + }, relative: function(from, to) { + from = PATH_FS.resolve(from).substr(1); + to = PATH_FS.resolve(to).substr(1); + function trim(arr) { + var start = 0; + for (; start < arr.length; start++) { + if (arr[start] !== "") + break; + } + var end = arr.length - 1; + for (; end >= 0; end--) { + if (arr[end] !== "") + break; + } + if (start > end) + return []; + return arr.slice(start, end - start + 1); + } + var fromParts = trim(from.split("/")); + var toParts = trim(to.split("/")); + var length = Math.min(fromParts.length, toParts.length); + var samePartsLength = length; + for (var i = 0; i < length; i++) { + if (fromParts[i] !== toParts[i]) { + samePartsLength = i; + break; + } + } + var outputParts = []; + for (var i = samePartsLength; i < fromParts.length; i++) { + outputParts.push(".."); + } + outputParts = outputParts.concat(toParts.slice(samePartsLength)); + return outputParts.join("/"); + }}; + var TTY = {ttys: [], init: function() { + }, shutdown: function() { + }, register: function(dev, ops) { + TTY.ttys[dev] = {input: [], output: [], ops}; + FS.registerDevice(dev, TTY.stream_ops); + }, stream_ops: {open: function(stream) { + var tty = TTY.ttys[stream.node.rdev]; + if (!tty) { + throw new FS.ErrnoError(43); + } + stream.tty = tty; + stream.seekable = false; + }, close: function(stream) { + stream.tty.ops.flush(stream.tty); + }, flush: function(stream) { + stream.tty.ops.flush(stream.tty); + }, read: function(stream, buffer2, offset, length, pos) { + if (!stream.tty || !stream.tty.ops.get_char) { + throw new FS.ErrnoError(60); + } + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = stream.tty.ops.get_char(stream.tty); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === void 0 && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === void 0) + break; + bytesRead++; + buffer2[offset + i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + }, write: function(stream, buffer2, offset, length, pos) { + if (!stream.tty || !stream.tty.ops.put_char) { + throw new FS.ErrnoError(60); + } + try { + for (var i = 0; i < length; i++) { + stream.tty.ops.put_char(stream.tty, buffer2[offset + i]); + } + } catch (e) { + throw new FS.ErrnoError(29); + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + }}, default_tty_ops: {get_char: function(tty) { + if (!tty.input.length) { + var result = null; + if (ENVIRONMENT_IS_NODE) { + var BUFSIZE = 256; + var buf = Buffer.alloc ? Buffer.alloc(BUFSIZE) : new Buffer(BUFSIZE); + var bytesRead = 0; + try { + bytesRead = nodeFS.readSync(process.stdin.fd, buf, 0, BUFSIZE, null); + } catch (e) { + if (e.toString().indexOf("EOF") != -1) + bytesRead = 0; + else + throw e; + } + if (bytesRead > 0) { + result = buf.slice(0, bytesRead).toString("utf-8"); + } else { + result = null; + } + } else if (typeof window != "undefined" && typeof window.prompt == "function") { + result = window.prompt("Input: "); + if (result !== null) { + result += "\n"; + } + } else if (typeof readline == "function") { + result = readline(); + if (result !== null) { + result += "\n"; + } + } + if (!result) { + return null; + } + tty.input = intArrayFromString(result, true); + } + return tty.input.shift(); + }, put_char: function(tty, val) { + if (val === null || val === 10) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) + tty.output.push(val); + } + }, flush: function(tty) { + if (tty.output && tty.output.length > 0) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }}, default_tty1_ops: {put_char: function(tty, val) { + if (val === null || val === 10) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } else { + if (val != 0) + tty.output.push(val); + } + }, flush: function(tty) { + if (tty.output && tty.output.length > 0) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = []; + } + }}}; + function mmapAlloc(size) { + var alignedSize = alignMemory(size, 16384); + var ptr = _malloc(alignedSize); + while (size < alignedSize) + HEAP8[ptr + size++] = 0; + return ptr; + } + var MEMFS = {ops_table: null, mount: function(mount) { + return MEMFS.createNode(null, "/", 16384 | 511, 0); + }, createNode: function(parent, name2, mode, dev) { + if (FS.isBlkdev(mode) || FS.isFIFO(mode)) { + throw new FS.ErrnoError(63); + } + if (!MEMFS.ops_table) { + MEMFS.ops_table = {dir: {node: {getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr, lookup: MEMFS.node_ops.lookup, mknod: MEMFS.node_ops.mknod, rename: MEMFS.node_ops.rename, unlink: MEMFS.node_ops.unlink, rmdir: MEMFS.node_ops.rmdir, readdir: MEMFS.node_ops.readdir, symlink: MEMFS.node_ops.symlink}, stream: {llseek: MEMFS.stream_ops.llseek}}, file: {node: {getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr}, stream: {llseek: MEMFS.stream_ops.llseek, read: MEMFS.stream_ops.read, write: MEMFS.stream_ops.write, allocate: MEMFS.stream_ops.allocate, mmap: MEMFS.stream_ops.mmap, msync: MEMFS.stream_ops.msync}}, link: {node: {getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr, readlink: MEMFS.node_ops.readlink}, stream: {}}, chrdev: {node: {getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr}, stream: FS.chrdev_stream_ops}}; + } + var node = FS.createNode(parent, name2, mode, dev); + if (FS.isDir(node.mode)) { + node.node_ops = MEMFS.ops_table.dir.node; + node.stream_ops = MEMFS.ops_table.dir.stream; + node.contents = {}; + } else if (FS.isFile(node.mode)) { + node.node_ops = MEMFS.ops_table.file.node; + node.stream_ops = MEMFS.ops_table.file.stream; + node.usedBytes = 0; + node.contents = null; + } else if (FS.isLink(node.mode)) { + node.node_ops = MEMFS.ops_table.link.node; + node.stream_ops = MEMFS.ops_table.link.stream; + } else if (FS.isChrdev(node.mode)) { + node.node_ops = MEMFS.ops_table.chrdev.node; + node.stream_ops = MEMFS.ops_table.chrdev.stream; + } + node.timestamp = Date.now(); + if (parent) { + parent.contents[name2] = node; + } + return node; + }, getFileDataAsRegularArray: function(node) { + if (node.contents && node.contents.subarray) { + var arr = []; + for (var i = 0; i < node.usedBytes; ++i) + arr.push(node.contents[i]); + return arr; + } + return node.contents; + }, getFileDataAsTypedArray: function(node) { + if (!node.contents) + return new Uint8Array(0); + if (node.contents.subarray) + return node.contents.subarray(0, node.usedBytes); + return new Uint8Array(node.contents); + }, expandFileStorage: function(node, newCapacity) { + var prevCapacity = node.contents ? node.contents.length : 0; + if (prevCapacity >= newCapacity) + return; + var CAPACITY_DOUBLING_MAX = 1024 * 1024; + newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0); + if (prevCapacity != 0) + newCapacity = Math.max(newCapacity, 256); + var oldContents = node.contents; + node.contents = new Uint8Array(newCapacity); + if (node.usedBytes > 0) + node.contents.set(oldContents.subarray(0, node.usedBytes), 0); + return; + }, resizeFileStorage: function(node, newSize) { + if (node.usedBytes == newSize) + return; + if (newSize == 0) { + node.contents = null; + node.usedBytes = 0; + return; + } + if (!node.contents || node.contents.subarray) { + var oldContents = node.contents; + node.contents = new Uint8Array(newSize); + if (oldContents) { + node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))); + } + node.usedBytes = newSize; + return; + } + if (!node.contents) + node.contents = []; + if (node.contents.length > newSize) + node.contents.length = newSize; + else + while (node.contents.length < newSize) + node.contents.push(0); + node.usedBytes = newSize; + }, node_ops: {getattr: function(node) { + var attr = {}; + attr.dev = FS.isChrdev(node.mode) ? node.id : 1; + attr.ino = node.id; + attr.mode = node.mode; + attr.nlink = 1; + attr.uid = 0; + attr.gid = 0; + attr.rdev = node.rdev; + if (FS.isDir(node.mode)) { + attr.size = 4096; + } else if (FS.isFile(node.mode)) { + attr.size = node.usedBytes; + } else if (FS.isLink(node.mode)) { + attr.size = node.link.length; + } else { + attr.size = 0; + } + attr.atime = new Date(node.timestamp); + attr.mtime = new Date(node.timestamp); + attr.ctime = new Date(node.timestamp); + attr.blksize = 4096; + attr.blocks = Math.ceil(attr.size / attr.blksize); + return attr; + }, setattr: function(node, attr) { + if (attr.mode !== void 0) { + node.mode = attr.mode; + } + if (attr.timestamp !== void 0) { + node.timestamp = attr.timestamp; + } + if (attr.size !== void 0) { + MEMFS.resizeFileStorage(node, attr.size); + } + }, lookup: function(parent, name2) { + throw FS.genericErrors[44]; + }, mknod: function(parent, name2, mode, dev) { + return MEMFS.createNode(parent, name2, mode, dev); + }, rename: function(old_node, new_dir, new_name) { + if (FS.isDir(old_node.mode)) { + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) { + } + if (new_node) { + for (var i in new_node.contents) { + throw new FS.ErrnoError(55); + } + } + } + delete old_node.parent.contents[old_node.name]; + old_node.name = new_name; + new_dir.contents[new_name] = old_node; + old_node.parent = new_dir; + }, unlink: function(parent, name2) { + delete parent.contents[name2]; + }, rmdir: function(parent, name2) { + var node = FS.lookupNode(parent, name2); + for (var i in node.contents) { + throw new FS.ErrnoError(55); + } + delete parent.contents[name2]; + }, readdir: function(node) { + var entries = [".", ".."]; + for (var key2 in node.contents) { + if (!node.contents.hasOwnProperty(key2)) { + continue; + } + entries.push(key2); + } + return entries; + }, symlink: function(parent, newname, oldpath) { + var node = MEMFS.createNode(parent, newname, 511 | 40960, 0); + node.link = oldpath; + return node; + }, readlink: function(node) { + if (!FS.isLink(node.mode)) { + throw new FS.ErrnoError(28); + } + return node.link; + }}, stream_ops: {read: function(stream, buffer2, offset, length, position) { + var contents = stream.node.contents; + if (position >= stream.node.usedBytes) + return 0; + var size = Math.min(stream.node.usedBytes - position, length); + if (size > 8 && contents.subarray) { + buffer2.set(contents.subarray(position, position + size), offset); + } else { + for (var i = 0; i < size; i++) + buffer2[offset + i] = contents[position + i]; + } + return size; + }, write: function(stream, buffer2, offset, length, position, canOwn) { + if (buffer2.buffer === HEAP8.buffer) { + canOwn = false; + } + if (!length) + return 0; + var node = stream.node; + node.timestamp = Date.now(); + if (buffer2.subarray && (!node.contents || node.contents.subarray)) { + if (canOwn) { + node.contents = buffer2.subarray(offset, offset + length); + node.usedBytes = length; + return length; + } else if (node.usedBytes === 0 && position === 0) { + node.contents = buffer2.slice(offset, offset + length); + node.usedBytes = length; + return length; + } else if (position + length <= node.usedBytes) { + node.contents.set(buffer2.subarray(offset, offset + length), position); + return length; + } + } + MEMFS.expandFileStorage(node, position + length); + if (node.contents.subarray && buffer2.subarray) { + node.contents.set(buffer2.subarray(offset, offset + length), position); + } else { + for (var i = 0; i < length; i++) { + node.contents[position + i] = buffer2[offset + i]; + } + } + node.usedBytes = Math.max(node.usedBytes, position + length); + return length; + }, llseek: function(stream, offset, whence) { + var position = offset; + if (whence === 1) { + position += stream.position; + } else if (whence === 2) { + if (FS.isFile(stream.node.mode)) { + position += stream.node.usedBytes; + } + } + if (position < 0) { + throw new FS.ErrnoError(28); + } + return position; + }, allocate: function(stream, offset, length) { + MEMFS.expandFileStorage(stream.node, offset + length); + stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length); + }, mmap: function(stream, address, length, position, prot, flags) { + assert(address === 0); + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + var ptr; + var allocated; + var contents = stream.node.contents; + if (!(flags & 2) && contents.buffer === buffer) { + allocated = false; + ptr = contents.byteOffset; + } else { + if (position > 0 || position + length < contents.length) { + if (contents.subarray) { + contents = contents.subarray(position, position + length); + } else { + contents = Array.prototype.slice.call(contents, position, position + length); + } + } + allocated = true; + ptr = mmapAlloc(length); + if (!ptr) { + throw new FS.ErrnoError(48); + } + HEAP8.set(contents, ptr); + } + return {ptr, allocated}; + }, msync: function(stream, buffer2, offset, length, mmapFlags) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (mmapFlags & 2) { + return 0; + } + var bytesWritten = MEMFS.stream_ops.write(stream, buffer2, 0, length, offset, false); + return 0; + }}}; + var FS = {root: null, mounts: [], devices: {}, streams: [], nextInode: 1, nameTable: null, currentPath: "/", initialized: false, ignorePermissions: true, trackingDelegate: {}, tracking: {openFlags: {READ: 1, WRITE: 2}}, ErrnoError: null, genericErrors: {}, filesystems: null, syncFSRequests: 0, lookupPath: function(path, opts) { + path = PATH_FS.resolve(FS.cwd(), path); + opts = opts || {}; + if (!path) + return {path: "", node: null}; + var defaults = {follow_mount: true, recurse_count: 0}; + for (var key2 in defaults) { + if (opts[key2] === void 0) { + opts[key2] = defaults[key2]; + } + } + if (opts.recurse_count > 8) { + throw new FS.ErrnoError(32); + } + var parts = PATH.normalizeArray(path.split("/").filter(function(p) { + return !!p; + }), false); + var current = FS.root; + var current_path = "/"; + for (var i = 0; i < parts.length; i++) { + var islast = i === parts.length - 1; + if (islast && opts.parent) { + break; + } + current = FS.lookupNode(current, parts[i]); + current_path = PATH.join2(current_path, parts[i]); + if (FS.isMountpoint(current)) { + if (!islast || islast && opts.follow_mount) { + current = current.mounted.root; + } + } + if (!islast || opts.follow) { + var count = 0; + while (FS.isLink(current.mode)) { + var link = FS.readlink(current_path); + current_path = PATH_FS.resolve(PATH.dirname(current_path), link); + var lookup = FS.lookupPath(current_path, {recurse_count: opts.recurse_count}); + current = lookup.node; + if (count++ > 40) { + throw new FS.ErrnoError(32); + } + } + } + } + return {path: current_path, node: current}; + }, getPath: function(node) { + var path; + while (true) { + if (FS.isRoot(node)) { + var mount = node.mount.mountpoint; + if (!path) + return mount; + return mount[mount.length - 1] !== "/" ? mount + "/" + path : mount + path; + } + path = path ? node.name + "/" + path : node.name; + node = node.parent; + } + }, hashName: function(parentid, name2) { + var hash = 0; + for (var i = 0; i < name2.length; i++) { + hash = (hash << 5) - hash + name2.charCodeAt(i) | 0; + } + return (parentid + hash >>> 0) % FS.nameTable.length; + }, hashAddNode: function(node) { + var hash = FS.hashName(node.parent.id, node.name); + node.name_next = FS.nameTable[hash]; + FS.nameTable[hash] = node; + }, hashRemoveNode: function(node) { + var hash = FS.hashName(node.parent.id, node.name); + if (FS.nameTable[hash] === node) { + FS.nameTable[hash] = node.name_next; + } else { + var current = FS.nameTable[hash]; + while (current) { + if (current.name_next === node) { + current.name_next = node.name_next; + break; + } + current = current.name_next; + } + } + }, lookupNode: function(parent, name2) { + var errCode = FS.mayLookup(parent); + if (errCode) { + throw new FS.ErrnoError(errCode, parent); + } + var hash = FS.hashName(parent.id, name2); + for (var node = FS.nameTable[hash]; node; node = node.name_next) { + var nodeName = node.name; + if (node.parent.id === parent.id && nodeName === name2) { + return node; + } + } + return FS.lookup(parent, name2); + }, createNode: function(parent, name2, mode, rdev) { + var node = new FS.FSNode(parent, name2, mode, rdev); + FS.hashAddNode(node); + return node; + }, destroyNode: function(node) { + FS.hashRemoveNode(node); + }, isRoot: function(node) { + return node === node.parent; + }, isMountpoint: function(node) { + return !!node.mounted; + }, isFile: function(mode) { + return (mode & 61440) === 32768; + }, isDir: function(mode) { + return (mode & 61440) === 16384; + }, isLink: function(mode) { + return (mode & 61440) === 40960; + }, isChrdev: function(mode) { + return (mode & 61440) === 8192; + }, isBlkdev: function(mode) { + return (mode & 61440) === 24576; + }, isFIFO: function(mode) { + return (mode & 61440) === 4096; + }, isSocket: function(mode) { + return (mode & 49152) === 49152; + }, flagModes: {r: 0, "r+": 2, w: 577, "w+": 578, a: 1089, "a+": 1090}, modeStringToFlags: function(str) { + var flags = FS.flagModes[str]; + if (typeof flags === "undefined") { + throw new Error("Unknown file open mode: " + str); + } + return flags; + }, flagsToPermissionString: function(flag) { + var perms = ["r", "w", "rw"][flag & 3]; + if (flag & 512) { + perms += "w"; + } + return perms; + }, nodePermissions: function(node, perms) { + if (FS.ignorePermissions) { + return 0; + } + if (perms.indexOf("r") !== -1 && !(node.mode & 292)) { + return 2; + } else if (perms.indexOf("w") !== -1 && !(node.mode & 146)) { + return 2; + } else if (perms.indexOf("x") !== -1 && !(node.mode & 73)) { + return 2; + } + return 0; + }, mayLookup: function(dir) { + var errCode = FS.nodePermissions(dir, "x"); + if (errCode) + return errCode; + if (!dir.node_ops.lookup) + return 2; + return 0; + }, mayCreate: function(dir, name2) { + try { + var node = FS.lookupNode(dir, name2); + return 20; + } catch (e) { + } + return FS.nodePermissions(dir, "wx"); + }, mayDelete: function(dir, name2, isdir) { + var node; + try { + node = FS.lookupNode(dir, name2); + } catch (e) { + return e.errno; + } + var errCode = FS.nodePermissions(dir, "wx"); + if (errCode) { + return errCode; + } + if (isdir) { + if (!FS.isDir(node.mode)) { + return 54; + } + if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) { + return 10; + } + } else { + if (FS.isDir(node.mode)) { + return 31; + } + } + return 0; + }, mayOpen: function(node, flags) { + if (!node) { + return 44; + } + if (FS.isLink(node.mode)) { + return 32; + } else if (FS.isDir(node.mode)) { + if (FS.flagsToPermissionString(flags) !== "r" || flags & 512) { + return 31; + } + } + return FS.nodePermissions(node, FS.flagsToPermissionString(flags)); + }, MAX_OPEN_FDS: 4096, nextfd: function(fd_start, fd_end) { + fd_start = fd_start || 0; + fd_end = fd_end || FS.MAX_OPEN_FDS; + for (var fd = fd_start; fd <= fd_end; fd++) { + if (!FS.streams[fd]) { + return fd; + } + } + throw new FS.ErrnoError(33); + }, getStream: function(fd) { + return FS.streams[fd]; + }, createStream: function(stream, fd_start, fd_end) { + if (!FS.FSStream) { + FS.FSStream = function() { + }; + FS.FSStream.prototype = {object: {get: function() { + return this.node; + }, set: function(val) { + this.node = val; + }}, isRead: {get: function() { + return (this.flags & 2097155) !== 1; + }}, isWrite: {get: function() { + return (this.flags & 2097155) !== 0; + }}, isAppend: {get: function() { + return this.flags & 1024; + }}}; + } + var newStream = new FS.FSStream(); + for (var p in stream) { + newStream[p] = stream[p]; + } + stream = newStream; + var fd = FS.nextfd(fd_start, fd_end); + stream.fd = fd; + FS.streams[fd] = stream; + return stream; + }, closeStream: function(fd) { + FS.streams[fd] = null; + }, chrdev_stream_ops: {open: function(stream) { + var device = FS.getDevice(stream.node.rdev); + stream.stream_ops = device.stream_ops; + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + }, llseek: function() { + throw new FS.ErrnoError(70); + }}, major: function(dev) { + return dev >> 8; + }, minor: function(dev) { + return dev & 255; + }, makedev: function(ma, mi) { + return ma << 8 | mi; + }, registerDevice: function(dev, ops) { + FS.devices[dev] = {stream_ops: ops}; + }, getDevice: function(dev) { + return FS.devices[dev]; + }, getMounts: function(mount) { + var mounts = []; + var check = [mount]; + while (check.length) { + var m = check.pop(); + mounts.push(m); + check.push.apply(check, m.mounts); + } + return mounts; + }, syncfs: function(populate, callback) { + if (typeof populate === "function") { + callback = populate; + populate = false; + } + FS.syncFSRequests++; + if (FS.syncFSRequests > 1) { + err("warning: " + FS.syncFSRequests + " FS.syncfs operations in flight at once, probably just doing extra work"); + } + var mounts = FS.getMounts(FS.root.mount); + var completed = 0; + function doCallback(errCode) { + FS.syncFSRequests--; + return callback(errCode); + } + function done(errCode) { + if (errCode) { + if (!done.errored) { + done.errored = true; + return doCallback(errCode); + } + return; + } + if (++completed >= mounts.length) { + doCallback(null); + } + } + mounts.forEach(function(mount) { + if (!mount.type.syncfs) { + return done(null); + } + mount.type.syncfs(mount, populate, done); + }); + }, mount: function(type, opts, mountpoint) { + var root = mountpoint === "/"; + var pseudo = !mountpoint; + var node; + if (root && FS.root) { + throw new FS.ErrnoError(10); + } else if (!root && !pseudo) { + var lookup = FS.lookupPath(mountpoint, {follow_mount: false}); + mountpoint = lookup.path; + node = lookup.node; + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + if (!FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + } + var mount = {type, opts, mountpoint, mounts: []}; + var mountRoot = type.mount(mount); + mountRoot.mount = mount; + mount.root = mountRoot; + if (root) { + FS.root = mountRoot; + } else if (node) { + node.mounted = mount; + if (node.mount) { + node.mount.mounts.push(mount); + } + } + return mountRoot; + }, unmount: function(mountpoint) { + var lookup = FS.lookupPath(mountpoint, {follow_mount: false}); + if (!FS.isMountpoint(lookup.node)) { + throw new FS.ErrnoError(28); + } + var node = lookup.node; + var mount = node.mounted; + var mounts = FS.getMounts(mount); + Object.keys(FS.nameTable).forEach(function(hash) { + var current = FS.nameTable[hash]; + while (current) { + var next = current.name_next; + if (mounts.indexOf(current.mount) !== -1) { + FS.destroyNode(current); + } + current = next; + } + }); + node.mounted = null; + var idx = node.mount.mounts.indexOf(mount); + node.mount.mounts.splice(idx, 1); + }, lookup: function(parent, name2) { + return parent.node_ops.lookup(parent, name2); + }, mknod: function(path, mode, dev) { + var lookup = FS.lookupPath(path, {parent: true}); + var parent = lookup.node; + var name2 = PATH.basename(path); + if (!name2 || name2 === "." || name2 === "..") { + throw new FS.ErrnoError(28); + } + var errCode = FS.mayCreate(parent, name2); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.mknod) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.mknod(parent, name2, mode, dev); + }, create: function(path, mode) { + mode = mode !== void 0 ? mode : 438; + mode &= 4095; + mode |= 32768; + return FS.mknod(path, mode, 0); + }, mkdir: function(path, mode) { + mode = mode !== void 0 ? mode : 511; + mode &= 511 | 512; + mode |= 16384; + return FS.mknod(path, mode, 0); + }, mkdirTree: function(path, mode) { + var dirs = path.split("/"); + var d = ""; + for (var i = 0; i < dirs.length; ++i) { + if (!dirs[i]) + continue; + d += "/" + dirs[i]; + try { + FS.mkdir(d, mode); + } catch (e) { + if (e.errno != 20) + throw e; + } + } + }, mkdev: function(path, mode, dev) { + if (typeof dev === "undefined") { + dev = mode; + mode = 438; + } + mode |= 8192; + return FS.mknod(path, mode, dev); + }, symlink: function(oldpath, newpath) { + if (!PATH_FS.resolve(oldpath)) { + throw new FS.ErrnoError(44); + } + var lookup = FS.lookupPath(newpath, {parent: true}); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44); + } + var newname = PATH.basename(newpath); + var errCode = FS.mayCreate(parent, newname); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.symlink) { + throw new FS.ErrnoError(63); + } + return parent.node_ops.symlink(parent, newname, oldpath); + }, rename: function(old_path, new_path) { + var old_dirname = PATH.dirname(old_path); + var new_dirname = PATH.dirname(new_path); + var old_name = PATH.basename(old_path); + var new_name = PATH.basename(new_path); + var lookup, old_dir, new_dir; + lookup = FS.lookupPath(old_path, {parent: true}); + old_dir = lookup.node; + lookup = FS.lookupPath(new_path, {parent: true}); + new_dir = lookup.node; + if (!old_dir || !new_dir) + throw new FS.ErrnoError(44); + if (old_dir.mount !== new_dir.mount) { + throw new FS.ErrnoError(75); + } + var old_node = FS.lookupNode(old_dir, old_name); + var relative = PATH_FS.relative(old_path, new_dirname); + if (relative.charAt(0) !== ".") { + throw new FS.ErrnoError(28); + } + relative = PATH_FS.relative(new_path, old_dirname); + if (relative.charAt(0) !== ".") { + throw new FS.ErrnoError(55); + } + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name); + } catch (e) { + } + if (old_node === new_node) { + return; + } + var isdir = FS.isDir(old_node.mode); + var errCode = FS.mayDelete(old_dir, old_name, isdir); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + errCode = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!old_dir.node_ops.rename) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) { + throw new FS.ErrnoError(10); + } + if (new_dir !== old_dir) { + errCode = FS.nodePermissions(old_dir, "w"); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + try { + if (FS.trackingDelegate["willMovePath"]) { + FS.trackingDelegate["willMovePath"](old_path, new_path); + } + } catch (e) { + err("FS.trackingDelegate['willMovePath']('" + old_path + "', '" + new_path + "') threw an exception: " + e.message); + } + FS.hashRemoveNode(old_node); + try { + old_dir.node_ops.rename(old_node, new_dir, new_name); + } catch (e) { + throw e; + } finally { + FS.hashAddNode(old_node); + } + try { + if (FS.trackingDelegate["onMovePath"]) + FS.trackingDelegate["onMovePath"](old_path, new_path); + } catch (e) { + err("FS.trackingDelegate['onMovePath']('" + old_path + "', '" + new_path + "') threw an exception: " + e.message); + } + }, rmdir: function(path) { + var lookup = FS.lookupPath(path, {parent: true}); + var parent = lookup.node; + var name2 = PATH.basename(path); + var node = FS.lookupNode(parent, name2); + var errCode = FS.mayDelete(parent, name2, true); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.rmdir) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + try { + if (FS.trackingDelegate["willDeletePath"]) { + FS.trackingDelegate["willDeletePath"](path); + } + } catch (e) { + err("FS.trackingDelegate['willDeletePath']('" + path + "') threw an exception: " + e.message); + } + parent.node_ops.rmdir(parent, name2); + FS.destroyNode(node); + try { + if (FS.trackingDelegate["onDeletePath"]) + FS.trackingDelegate["onDeletePath"](path); + } catch (e) { + err("FS.trackingDelegate['onDeletePath']('" + path + "') threw an exception: " + e.message); + } + }, readdir: function(path) { + var lookup = FS.lookupPath(path, {follow: true}); + var node = lookup.node; + if (!node.node_ops.readdir) { + throw new FS.ErrnoError(54); + } + return node.node_ops.readdir(node); + }, unlink: function(path) { + var lookup = FS.lookupPath(path, {parent: true}); + var parent = lookup.node; + var name2 = PATH.basename(path); + var node = FS.lookupNode(parent, name2); + var errCode = FS.mayDelete(parent, name2, false); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + if (!parent.node_ops.unlink) { + throw new FS.ErrnoError(63); + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10); + } + try { + if (FS.trackingDelegate["willDeletePath"]) { + FS.trackingDelegate["willDeletePath"](path); + } + } catch (e) { + err("FS.trackingDelegate['willDeletePath']('" + path + "') threw an exception: " + e.message); + } + parent.node_ops.unlink(parent, name2); + FS.destroyNode(node); + try { + if (FS.trackingDelegate["onDeletePath"]) + FS.trackingDelegate["onDeletePath"](path); + } catch (e) { + err("FS.trackingDelegate['onDeletePath']('" + path + "') threw an exception: " + e.message); + } + }, readlink: function(path) { + var lookup = FS.lookupPath(path); + var link = lookup.node; + if (!link) { + throw new FS.ErrnoError(44); + } + if (!link.node_ops.readlink) { + throw new FS.ErrnoError(28); + } + return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link)); + }, stat: function(path, dontFollow) { + var lookup = FS.lookupPath(path, {follow: !dontFollow}); + var node = lookup.node; + if (!node) { + throw new FS.ErrnoError(44); + } + if (!node.node_ops.getattr) { + throw new FS.ErrnoError(63); + } + return node.node_ops.getattr(node); + }, lstat: function(path) { + return FS.stat(path, true); + }, chmod: function(path, mode, dontFollow) { + var node; + if (typeof path === "string") { + var lookup = FS.lookupPath(path, {follow: !dontFollow}); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, {mode: mode & 4095 | node.mode & ~4095, timestamp: Date.now()}); + }, lchmod: function(path, mode) { + FS.chmod(path, mode, true); + }, fchmod: function(fd, mode) { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chmod(stream.node, mode); + }, chown: function(path, uid, gid, dontFollow) { + var node; + if (typeof path === "string") { + var lookup = FS.lookupPath(path, {follow: !dontFollow}); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + node.node_ops.setattr(node, {timestamp: Date.now()}); + }, lchown: function(path, uid, gid) { + FS.chown(path, uid, gid, true); + }, fchown: function(fd, uid, gid) { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + FS.chown(stream.node, uid, gid); + }, truncate: function(path, len) { + if (len < 0) { + throw new FS.ErrnoError(28); + } + var node; + if (typeof path === "string") { + var lookup = FS.lookupPath(path, {follow: true}); + node = lookup.node; + } else { + node = path; + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63); + } + if (FS.isDir(node.mode)) { + throw new FS.ErrnoError(31); + } + if (!FS.isFile(node.mode)) { + throw new FS.ErrnoError(28); + } + var errCode = FS.nodePermissions(node, "w"); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + node.node_ops.setattr(node, {size: len, timestamp: Date.now()}); + }, ftruncate: function(fd, len) { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(28); + } + FS.truncate(stream.node, len); + }, utime: function(path, atime, mtime) { + var lookup = FS.lookupPath(path, {follow: true}); + var node = lookup.node; + node.node_ops.setattr(node, {timestamp: Math.max(atime, mtime)}); + }, open: function(path, flags, mode, fd_start, fd_end) { + if (path === "") { + throw new FS.ErrnoError(44); + } + flags = typeof flags === "string" ? FS.modeStringToFlags(flags) : flags; + mode = typeof mode === "undefined" ? 438 : mode; + if (flags & 64) { + mode = mode & 4095 | 32768; + } else { + mode = 0; + } + var node; + if (typeof path === "object") { + node = path; + } else { + path = PATH.normalize(path); + try { + var lookup = FS.lookupPath(path, {follow: !(flags & 131072)}); + node = lookup.node; + } catch (e) { + } + } + var created = false; + if (flags & 64) { + if (node) { + if (flags & 128) { + throw new FS.ErrnoError(20); + } + } else { + node = FS.mknod(path, mode, 0); + created = true; + } + } + if (!node) { + throw new FS.ErrnoError(44); + } + if (FS.isChrdev(node.mode)) { + flags &= ~512; + } + if (flags & 65536 && !FS.isDir(node.mode)) { + throw new FS.ErrnoError(54); + } + if (!created) { + var errCode = FS.mayOpen(node, flags); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + } + if (flags & 512) { + FS.truncate(node, 0); + } + flags &= ~(128 | 512 | 131072); + var stream = FS.createStream({node, path: FS.getPath(node), flags, seekable: true, position: 0, stream_ops: node.stream_ops, ungotten: [], error: false}, fd_start, fd_end); + if (stream.stream_ops.open) { + stream.stream_ops.open(stream); + } + if (Module["logReadFiles"] && !(flags & 1)) { + if (!FS.readFiles) + FS.readFiles = {}; + if (!(path in FS.readFiles)) { + FS.readFiles[path] = 1; + err("FS.trackingDelegate error on read file: " + path); + } + } + try { + if (FS.trackingDelegate["onOpenFile"]) { + var trackingFlags = 0; + if ((flags & 2097155) !== 1) { + trackingFlags |= FS.tracking.openFlags.READ; + } + if ((flags & 2097155) !== 0) { + trackingFlags |= FS.tracking.openFlags.WRITE; + } + FS.trackingDelegate["onOpenFile"](path, trackingFlags); + } + } catch (e) { + err("FS.trackingDelegate['onOpenFile']('" + path + "', flags) threw an exception: " + e.message); + } + return stream; + }, close: function(stream) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (stream.getdents) + stream.getdents = null; + try { + if (stream.stream_ops.close) { + stream.stream_ops.close(stream); + } + } catch (e) { + throw e; + } finally { + FS.closeStream(stream.fd); + } + stream.fd = null; + }, isClosed: function(stream) { + return stream.fd === null; + }, llseek: function(stream, offset, whence) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (!stream.seekable || !stream.stream_ops.llseek) { + throw new FS.ErrnoError(70); + } + if (whence != 0 && whence != 1 && whence != 2) { + throw new FS.ErrnoError(28); + } + stream.position = stream.stream_ops.llseek(stream, offset, whence); + stream.ungotten = []; + return stream.position; + }, read: function(stream, buffer2, offset, length, position) { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.read) { + throw new FS.ErrnoError(28); + } + var seeking = typeof position !== "undefined"; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesRead = stream.stream_ops.read(stream, buffer2, offset, length, position); + if (!seeking) + stream.position += bytesRead; + return bytesRead; + }, write: function(stream, buffer2, offset, length, position, canOwn) { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28); + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31); + } + if (!stream.stream_ops.write) { + throw new FS.ErrnoError(28); + } + if (stream.seekable && stream.flags & 1024) { + FS.llseek(stream, 0, 2); + } + var seeking = typeof position !== "undefined"; + if (!seeking) { + position = stream.position; + } else if (!stream.seekable) { + throw new FS.ErrnoError(70); + } + var bytesWritten = stream.stream_ops.write(stream, buffer2, offset, length, position, canOwn); + if (!seeking) + stream.position += bytesWritten; + try { + if (stream.path && FS.trackingDelegate["onWriteToFile"]) + FS.trackingDelegate["onWriteToFile"](stream.path); + } catch (e) { + err("FS.trackingDelegate['onWriteToFile']('" + stream.path + "') threw an exception: " + e.message); + } + return bytesWritten; + }, allocate: function(stream, offset, length) { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8); + } + if (offset < 0 || length <= 0) { + throw new FS.ErrnoError(28); + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8); + } + if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(43); + } + if (!stream.stream_ops.allocate) { + throw new FS.ErrnoError(138); + } + stream.stream_ops.allocate(stream, offset, length); + }, mmap: function(stream, address, length, position, prot, flags) { + if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) { + throw new FS.ErrnoError(2); + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(2); + } + if (!stream.stream_ops.mmap) { + throw new FS.ErrnoError(43); + } + return stream.stream_ops.mmap(stream, address, length, position, prot, flags); + }, msync: function(stream, buffer2, offset, length, mmapFlags) { + if (!stream || !stream.stream_ops.msync) { + return 0; + } + return stream.stream_ops.msync(stream, buffer2, offset, length, mmapFlags); + }, munmap: function(stream) { + return 0; + }, ioctl: function(stream, cmd, arg) { + if (!stream.stream_ops.ioctl) { + throw new FS.ErrnoError(59); + } + return stream.stream_ops.ioctl(stream, cmd, arg); + }, readFile: function(path, opts) { + opts = opts || {}; + opts.flags = opts.flags || 0; + opts.encoding = opts.encoding || "binary"; + if (opts.encoding !== "utf8" && opts.encoding !== "binary") { + throw new Error('Invalid encoding type "' + opts.encoding + '"'); + } + var ret; + var stream = FS.open(path, opts.flags); + var stat = FS.stat(path); + var length = stat.size; + var buf = new Uint8Array(length); + FS.read(stream, buf, 0, length, 0); + if (opts.encoding === "utf8") { + ret = UTF8ArrayToString(buf, 0); + } else if (opts.encoding === "binary") { + ret = buf; + } + FS.close(stream); + return ret; + }, writeFile: function(path, data, opts) { + opts = opts || {}; + opts.flags = opts.flags || 577; + var stream = FS.open(path, opts.flags, opts.mode); + if (typeof data === "string") { + var buf = new Uint8Array(lengthBytesUTF8(data) + 1); + var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length); + FS.write(stream, buf, 0, actualNumBytes, void 0, opts.canOwn); + } else if (ArrayBuffer.isView(data)) { + FS.write(stream, data, 0, data.byteLength, void 0, opts.canOwn); + } else { + throw new Error("Unsupported data type"); + } + FS.close(stream); + }, cwd: function() { + return FS.currentPath; + }, chdir: function(path) { + var lookup = FS.lookupPath(path, {follow: true}); + if (lookup.node === null) { + throw new FS.ErrnoError(44); + } + if (!FS.isDir(lookup.node.mode)) { + throw new FS.ErrnoError(54); + } + var errCode = FS.nodePermissions(lookup.node, "x"); + if (errCode) { + throw new FS.ErrnoError(errCode); + } + FS.currentPath = lookup.path; + }, createDefaultDirectories: function() { + FS.mkdir("/tmp"); + FS.mkdir("/home"); + FS.mkdir("/home/web_user"); + }, createDefaultDevices: function() { + FS.mkdir("/dev"); + FS.registerDevice(FS.makedev(1, 3), {read: function() { + return 0; + }, write: function(stream, buffer2, offset, length, pos) { + return length; + }}); + FS.mkdev("/dev/null", FS.makedev(1, 3)); + TTY.register(FS.makedev(5, 0), TTY.default_tty_ops); + TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops); + FS.mkdev("/dev/tty", FS.makedev(5, 0)); + FS.mkdev("/dev/tty1", FS.makedev(6, 0)); + var random_device = getRandomDevice(); + FS.createDevice("/dev", "random", random_device); + FS.createDevice("/dev", "urandom", random_device); + FS.mkdir("/dev/shm"); + FS.mkdir("/dev/shm/tmp"); + }, createSpecialDirectories: function() { + FS.mkdir("/proc"); + FS.mkdir("/proc/self"); + FS.mkdir("/proc/self/fd"); + FS.mount({mount: function() { + var node = FS.createNode("/proc/self", "fd", 16384 | 511, 73); + node.node_ops = {lookup: function(parent, name2) { + var fd = +name2; + var stream = FS.getStream(fd); + if (!stream) + throw new FS.ErrnoError(8); + var ret = {parent: null, mount: {mountpoint: "fake"}, node_ops: {readlink: function() { + return stream.path; + }}}; + ret.parent = ret; + return ret; + }}; + return node; + }}, {}, "/proc/self/fd"); + }, createStandardStreams: function() { + if (Module["stdin"]) { + FS.createDevice("/dev", "stdin", Module["stdin"]); + } else { + FS.symlink("/dev/tty", "/dev/stdin"); + } + if (Module["stdout"]) { + FS.createDevice("/dev", "stdout", null, Module["stdout"]); + } else { + FS.symlink("/dev/tty", "/dev/stdout"); + } + if (Module["stderr"]) { + FS.createDevice("/dev", "stderr", null, Module["stderr"]); + } else { + FS.symlink("/dev/tty1", "/dev/stderr"); + } + var stdin = FS.open("/dev/stdin", 0); + var stdout = FS.open("/dev/stdout", 1); + var stderr = FS.open("/dev/stderr", 1); + }, ensureErrnoError: function() { + if (FS.ErrnoError) + return; + FS.ErrnoError = function ErrnoError(errno, node) { + this.node = node; + this.setErrno = function(errno2) { + this.errno = errno2; + }; + this.setErrno(errno); + this.message = "FS error"; + }; + FS.ErrnoError.prototype = new Error(); + FS.ErrnoError.prototype.constructor = FS.ErrnoError; + [44].forEach(function(code) { + FS.genericErrors[code] = new FS.ErrnoError(code); + FS.genericErrors[code].stack = ""; + }); + }, staticInit: function() { + FS.ensureErrnoError(); + FS.nameTable = new Array(4096); + FS.mount(MEMFS, {}, "/"); + FS.createDefaultDirectories(); + FS.createDefaultDevices(); + FS.createSpecialDirectories(); + FS.filesystems = {MEMFS}; + }, init: function(input, output, error) { + FS.init.initialized = true; + FS.ensureErrnoError(); + Module["stdin"] = input || Module["stdin"]; + Module["stdout"] = output || Module["stdout"]; + Module["stderr"] = error || Module["stderr"]; + FS.createStandardStreams(); + }, quit: function() { + FS.init.initialized = false; + var fflush = Module["_fflush"]; + if (fflush) + fflush(0); + for (var i = 0; i < FS.streams.length; i++) { + var stream = FS.streams[i]; + if (!stream) { + continue; + } + FS.close(stream); + } + }, getMode: function(canRead, canWrite) { + var mode = 0; + if (canRead) + mode |= 292 | 73; + if (canWrite) + mode |= 146; + return mode; + }, findObject: function(path, dontResolveLastLink) { + var ret = FS.analyzePath(path, dontResolveLastLink); + if (ret.exists) { + return ret.object; + } else { + return null; + } + }, analyzePath: function(path, dontResolveLastLink) { + try { + var lookup = FS.lookupPath(path, {follow: !dontResolveLastLink}); + path = lookup.path; + } catch (e) { + } + var ret = {isRoot: false, exists: false, error: 0, name: null, path: null, object: null, parentExists: false, parentPath: null, parentObject: null}; + try { + var lookup = FS.lookupPath(path, {parent: true}); + ret.parentExists = true; + ret.parentPath = lookup.path; + ret.parentObject = lookup.node; + ret.name = PATH.basename(path); + lookup = FS.lookupPath(path, {follow: !dontResolveLastLink}); + ret.exists = true; + ret.path = lookup.path; + ret.object = lookup.node; + ret.name = lookup.node.name; + ret.isRoot = lookup.path === "/"; + } catch (e) { + ret.error = e.errno; + } + return ret; + }, createPath: function(parent, path, canRead, canWrite) { + parent = typeof parent === "string" ? parent : FS.getPath(parent); + var parts = path.split("/").reverse(); + while (parts.length) { + var part = parts.pop(); + if (!part) + continue; + var current = PATH.join2(parent, part); + try { + FS.mkdir(current); + } catch (e) { + } + parent = current; + } + return current; + }, createFile: function(parent, name2, properties, canRead, canWrite) { + var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name2); + var mode = FS.getMode(canRead, canWrite); + return FS.create(path, mode); + }, createDataFile: function(parent, name2, data, canRead, canWrite, canOwn) { + var path = name2 ? PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name2) : parent; + var mode = FS.getMode(canRead, canWrite); + var node = FS.create(path, mode); + if (data) { + if (typeof data === "string") { + var arr = new Array(data.length); + for (var i = 0, len = data.length; i < len; ++i) + arr[i] = data.charCodeAt(i); + data = arr; + } + FS.chmod(node, mode | 146); + var stream = FS.open(node, 577); + FS.write(stream, data, 0, data.length, 0, canOwn); + FS.close(stream); + FS.chmod(node, mode); + } + return node; + }, createDevice: function(parent, name2, input, output) { + var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name2); + var mode = FS.getMode(!!input, !!output); + if (!FS.createDevice.major) + FS.createDevice.major = 64; + var dev = FS.makedev(FS.createDevice.major++, 0); + FS.registerDevice(dev, {open: function(stream) { + stream.seekable = false; + }, close: function(stream) { + if (output && output.buffer && output.buffer.length) { + output(10); + } + }, read: function(stream, buffer2, offset, length, pos) { + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = input(); + } catch (e) { + throw new FS.ErrnoError(29); + } + if (result === void 0 && bytesRead === 0) { + throw new FS.ErrnoError(6); + } + if (result === null || result === void 0) + break; + bytesRead++; + buffer2[offset + i] = result; + } + if (bytesRead) { + stream.node.timestamp = Date.now(); + } + return bytesRead; + }, write: function(stream, buffer2, offset, length, pos) { + for (var i = 0; i < length; i++) { + try { + output(buffer2[offset + i]); + } catch (e) { + throw new FS.ErrnoError(29); + } + } + if (length) { + stream.node.timestamp = Date.now(); + } + return i; + }}); + return FS.mkdev(path, mode, dev); + }, forceLoadFile: function(obj) { + if (obj.isDevice || obj.isFolder || obj.link || obj.contents) + return true; + if (typeof XMLHttpRequest !== "undefined") { + throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread."); + } else if (read_) { + try { + obj.contents = intArrayFromString(read_(obj.url), true); + obj.usedBytes = obj.contents.length; + } catch (e) { + throw new FS.ErrnoError(29); + } + } else { + throw new Error("Cannot load without read() or XMLHttpRequest."); + } + }, createLazyFile: function(parent, name2, url, canRead, canWrite) { + function LazyUint8Array() { + this.lengthKnown = false; + this.chunks = []; + } + LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) { + if (idx > this.length - 1 || idx < 0) { + return void 0; + } + var chunkOffset = idx % this.chunkSize; + var chunkNum = idx / this.chunkSize | 0; + return this.getter(chunkNum)[chunkOffset]; + }; + LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) { + this.getter = getter; + }; + LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() { + var xhr = new XMLHttpRequest(); + xhr.open("HEAD", url, false); + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) + throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + var datalength = Number(xhr.getResponseHeader("Content-length")); + var header; + var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes"; + var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip"; + var chunkSize = 1024 * 1024; + if (!hasByteServing) + chunkSize = datalength; + var doXHR = function(from, to) { + if (from > to) + throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!"); + if (to > datalength - 1) + throw new Error("only " + datalength + " bytes available! programmer error!"); + var xhr2 = new XMLHttpRequest(); + xhr2.open("GET", url, false); + if (datalength !== chunkSize) + xhr2.setRequestHeader("Range", "bytes=" + from + "-" + to); + if (typeof Uint8Array != "undefined") + xhr2.responseType = "arraybuffer"; + if (xhr2.overrideMimeType) { + xhr2.overrideMimeType("text/plain; charset=x-user-defined"); + } + xhr2.send(null); + if (!(xhr2.status >= 200 && xhr2.status < 300 || xhr2.status === 304)) + throw new Error("Couldn't load " + url + ". Status: " + xhr2.status); + if (xhr2.response !== void 0) { + return new Uint8Array(xhr2.response || []); + } else { + return intArrayFromString(xhr2.responseText || "", true); + } + }; + var lazyArray2 = this; + lazyArray2.setDataGetter(function(chunkNum) { + var start = chunkNum * chunkSize; + var end = (chunkNum + 1) * chunkSize - 1; + end = Math.min(end, datalength - 1); + if (typeof lazyArray2.chunks[chunkNum] === "undefined") { + lazyArray2.chunks[chunkNum] = doXHR(start, end); + } + if (typeof lazyArray2.chunks[chunkNum] === "undefined") + throw new Error("doXHR failed!"); + return lazyArray2.chunks[chunkNum]; + }); + if (usesGzip || !datalength) { + chunkSize = datalength = 1; + datalength = this.getter(0).length; + chunkSize = datalength; + out("LazyFiles on gzip forces download of the whole file when length is accessed"); + } + this._length = datalength; + this._chunkSize = chunkSize; + this.lengthKnown = true; + }; + if (typeof XMLHttpRequest !== "undefined") { + if (!ENVIRONMENT_IS_WORKER) + throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc"; + var lazyArray = new LazyUint8Array(); + Object.defineProperties(lazyArray, {length: {get: function() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._length; + }}, chunkSize: {get: function() { + if (!this.lengthKnown) { + this.cacheLength(); + } + return this._chunkSize; + }}}); + var properties = {isDevice: false, contents: lazyArray}; + } else { + var properties = {isDevice: false, url}; + } + var node = FS.createFile(parent, name2, properties, canRead, canWrite); + if (properties.contents) { + node.contents = properties.contents; + } else if (properties.url) { + node.contents = null; + node.url = properties.url; + } + Object.defineProperties(node, {usedBytes: {get: function() { + return this.contents.length; + }}}); + var stream_ops = {}; + var keys = Object.keys(node.stream_ops); + keys.forEach(function(key2) { + var fn = node.stream_ops[key2]; + stream_ops[key2] = function forceLoadLazyFile() { + FS.forceLoadFile(node); + return fn.apply(null, arguments); + }; + }); + stream_ops.read = function stream_ops_read(stream, buffer2, offset, length, position) { + FS.forceLoadFile(node); + var contents = stream.node.contents; + if (position >= contents.length) + return 0; + var size = Math.min(contents.length - position, length); + if (contents.slice) { + for (var i = 0; i < size; i++) { + buffer2[offset + i] = contents[position + i]; + } + } else { + for (var i = 0; i < size; i++) { + buffer2[offset + i] = contents.get(position + i); + } + } + return size; + }; + node.stream_ops = stream_ops; + return node; + }, createPreloadedFile: function(parent, name2, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) { + Browser.init(); + var fullname = name2 ? PATH_FS.resolve(PATH.join2(parent, name2)) : parent; + var dep = getUniqueRunDependency("cp " + fullname); + function processData(byteArray) { + function finish(byteArray2) { + if (preFinish) + preFinish(); + if (!dontCreateFile) { + FS.createDataFile(parent, name2, byteArray2, canRead, canWrite, canOwn); + } + if (onload) + onload(); + removeRunDependency(dep); + } + var handled = false; + Module["preloadPlugins"].forEach(function(plugin) { + if (handled) + return; + if (plugin["canHandle"](fullname)) { + plugin["handle"](byteArray, fullname, finish, function() { + if (onerror) + onerror(); + removeRunDependency(dep); + }); + handled = true; + } + }); + if (!handled) + finish(byteArray); + } + addRunDependency(dep); + if (typeof url == "string") { + Browser.asyncLoad(url, function(byteArray) { + processData(byteArray); + }, onerror); + } else { + processData(url); + } + }, indexedDB: function() { + return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB; + }, DB_NAME: function() { + return "EM_FS_" + window.location.pathname; + }, DB_VERSION: 20, DB_STORE_NAME: "FILE_DATA", saveFilesToDB: function(paths, onload, onerror) { + onload = onload || function() { + }; + onerror = onerror || function() { + }; + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); + } catch (e) { + return onerror(e); + } + openRequest.onupgradeneeded = function openRequest_onupgradeneeded() { + out("creating db"); + var db = openRequest.result; + db.createObjectStore(FS.DB_STORE_NAME); + }; + openRequest.onsuccess = function openRequest_onsuccess() { + var db = openRequest.result; + var transaction = db.transaction([FS.DB_STORE_NAME], "readwrite"); + var files = transaction.objectStore(FS.DB_STORE_NAME); + var ok = 0, fail = 0, total = paths.length; + function finish() { + if (fail == 0) + onload(); + else + onerror(); + } + paths.forEach(function(path) { + var putRequest = files.put(FS.analyzePath(path).object.contents, path); + putRequest.onsuccess = function putRequest_onsuccess() { + ok++; + if (ok + fail == total) + finish(); + }; + putRequest.onerror = function putRequest_onerror() { + fail++; + if (ok + fail == total) + finish(); + }; + }); + transaction.onerror = onerror; + }; + openRequest.onerror = onerror; + }, loadFilesFromDB: function(paths, onload, onerror) { + onload = onload || function() { + }; + onerror = onerror || function() { + }; + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); + } catch (e) { + return onerror(e); + } + openRequest.onupgradeneeded = onerror; + openRequest.onsuccess = function openRequest_onsuccess() { + var db = openRequest.result; + try { + var transaction = db.transaction([FS.DB_STORE_NAME], "readonly"); + } catch (e) { + onerror(e); + return; + } + var files = transaction.objectStore(FS.DB_STORE_NAME); + var ok = 0, fail = 0, total = paths.length; + function finish() { + if (fail == 0) + onload(); + else + onerror(); + } + paths.forEach(function(path) { + var getRequest = files.get(path); + getRequest.onsuccess = function getRequest_onsuccess() { + if (FS.analyzePath(path).exists) { + FS.unlink(path); + } + FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true); + ok++; + if (ok + fail == total) + finish(); + }; + getRequest.onerror = function getRequest_onerror() { + fail++; + if (ok + fail == total) + finish(); + }; + }); + transaction.onerror = onerror; + }; + openRequest.onerror = onerror; + }}; + var SYSCALLS = {mappings: {}, DEFAULT_POLLMASK: 5, umask: 511, calculateAt: function(dirfd, path) { + if (path[0] !== "/") { + var dir; + if (dirfd === -100) { + dir = FS.cwd(); + } else { + var dirstream = FS.getStream(dirfd); + if (!dirstream) + throw new FS.ErrnoError(8); + dir = dirstream.path; + } + path = PATH.join2(dir, path); + } + return path; + }, doStat: function(func, path, buf) { + try { + var stat = func(path); + } catch (e) { + if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) { + return -54; + } + throw e; + } + HEAP32[buf >> 2] = stat.dev; + HEAP32[buf + 4 >> 2] = 0; + HEAP32[buf + 8 >> 2] = stat.ino; + HEAP32[buf + 12 >> 2] = stat.mode; + HEAP32[buf + 16 >> 2] = stat.nlink; + HEAP32[buf + 20 >> 2] = stat.uid; + HEAP32[buf + 24 >> 2] = stat.gid; + HEAP32[buf + 28 >> 2] = stat.rdev; + HEAP32[buf + 32 >> 2] = 0; + tempI64 = [stat.size >>> 0, (tempDouble = stat.size, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[buf + 40 >> 2] = tempI64[0], HEAP32[buf + 44 >> 2] = tempI64[1]; + HEAP32[buf + 48 >> 2] = 4096; + HEAP32[buf + 52 >> 2] = stat.blocks; + HEAP32[buf + 56 >> 2] = stat.atime.getTime() / 1e3 | 0; + HEAP32[buf + 60 >> 2] = 0; + HEAP32[buf + 64 >> 2] = stat.mtime.getTime() / 1e3 | 0; + HEAP32[buf + 68 >> 2] = 0; + HEAP32[buf + 72 >> 2] = stat.ctime.getTime() / 1e3 | 0; + HEAP32[buf + 76 >> 2] = 0; + tempI64 = [stat.ino >>> 0, (tempDouble = stat.ino, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[buf + 80 >> 2] = tempI64[0], HEAP32[buf + 84 >> 2] = tempI64[1]; + return 0; + }, doMsync: function(addr, stream, len, flags, offset) { + var buffer2 = HEAPU8.slice(addr, addr + len); + FS.msync(stream, buffer2, offset, len, flags); + }, doMkdir: function(path, mode) { + path = PATH.normalize(path); + if (path[path.length - 1] === "/") + path = path.substr(0, path.length - 1); + FS.mkdir(path, mode, 0); + return 0; + }, doMknod: function(path, mode, dev) { + switch (mode & 61440) { + case 32768: + case 8192: + case 24576: + case 4096: + case 49152: + break; + default: + return -28; + } + FS.mknod(path, mode, dev); + return 0; + }, doReadlink: function(path, buf, bufsize) { + if (bufsize <= 0) + return -28; + var ret = FS.readlink(path); + var len = Math.min(bufsize, lengthBytesUTF8(ret)); + var endChar = HEAP8[buf + len]; + stringToUTF8(ret, buf, bufsize + 1); + HEAP8[buf + len] = endChar; + return len; + }, doAccess: function(path, amode) { + if (amode & ~7) { + return -28; + } + var node; + var lookup = FS.lookupPath(path, {follow: true}); + node = lookup.node; + if (!node) { + return -44; + } + var perms = ""; + if (amode & 4) + perms += "r"; + if (amode & 2) + perms += "w"; + if (amode & 1) + perms += "x"; + if (perms && FS.nodePermissions(node, perms)) { + return -2; + } + return 0; + }, doDup: function(path, flags, suggestFD) { + var suggest = FS.getStream(suggestFD); + if (suggest) + FS.close(suggest); + return FS.open(path, flags, 0, suggestFD, suggestFD).fd; + }, doReadv: function(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAP32[iov + i * 8 >> 2]; + var len = HEAP32[iov + (i * 8 + 4) >> 2]; + var curr = FS.read(stream, HEAP8, ptr, len, offset); + if (curr < 0) + return -1; + ret += curr; + if (curr < len) + break; + } + return ret; + }, doWritev: function(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAP32[iov + i * 8 >> 2]; + var len = HEAP32[iov + (i * 8 + 4) >> 2]; + var curr = FS.write(stream, HEAP8, ptr, len, offset); + if (curr < 0) + return -1; + ret += curr; + } + return ret; + }, varargs: void 0, get: function() { + SYSCALLS.varargs += 4; + var ret = HEAP32[SYSCALLS.varargs - 4 >> 2]; + return ret; + }, getStr: function(ptr) { + var ret = UTF8ToString(ptr); + return ret; + }, getStreamFromFD: function(fd) { + var stream = FS.getStream(fd); + if (!stream) + throw new FS.ErrnoError(8); + return stream; + }, get64: function(low, high) { + return low; + }}; + function ___sys_fcntl64(fd, cmd, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(fd); + switch (cmd) { + case 0: { + var arg = SYSCALLS.get(); + if (arg < 0) { + return -28; + } + var newStream; + newStream = FS.open(stream.path, stream.flags, 0, arg); + return newStream.fd; + } + case 1: + case 2: + return 0; + case 3: + return stream.flags; + case 4: { + var arg = SYSCALLS.get(); + stream.flags |= arg; + return 0; + } + case 12: { + var arg = SYSCALLS.get(); + var offset = 0; + HEAP16[arg + offset >> 1] = 2; + return 0; + } + case 13: + case 14: + return 0; + case 16: + case 8: + return -28; + case 9: + setErrNo(28); + return -1; + default: { + return -28; + } + } + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) + abort(e); + return -e.errno; + } + } + function ___sys_ioctl(fd, op, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(fd); + switch (op) { + case 21509: + case 21505: { + if (!stream.tty) + return -59; + return 0; + } + case 21510: + case 21511: + case 21512: + case 21506: + case 21507: + case 21508: { + if (!stream.tty) + return -59; + return 0; + } + case 21519: { + if (!stream.tty) + return -59; + var argp = SYSCALLS.get(); + HEAP32[argp >> 2] = 0; + return 0; + } + case 21520: { + if (!stream.tty) + return -59; + return -28; + } + case 21531: { + var argp = SYSCALLS.get(); + return FS.ioctl(stream, op, argp); + } + case 21523: { + if (!stream.tty) + return -59; + return 0; + } + case 21524: { + if (!stream.tty) + return -59; + return 0; + } + default: + abort("bad ioctl syscall " + op); + } + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) + abort(e); + return -e.errno; + } + } + function ___sys_open(path, flags, varargs) { + SYSCALLS.varargs = varargs; + try { + var pathname = SYSCALLS.getStr(path); + var mode = SYSCALLS.get(); + var stream = FS.open(pathname, flags, mode); + return stream.fd; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) + abort(e); + return -e.errno; + } + } + var tupleRegistrations = {}; + function runDestructors(destructors) { + while (destructors.length) { + var ptr = destructors.pop(); + var del = destructors.pop(); + del(ptr); + } + } + function simpleReadValueFromPointer(pointer) { + return this["fromWireType"](HEAPU32[pointer >> 2]); + } + var awaitingDependencies = {}; + var registeredTypes = {}; + var typeDependencies = {}; + var char_0 = 48; + var char_9 = 57; + function makeLegalFunctionName(name2) { + if (name2 === void 0) { + return "_unknown"; + } + name2 = name2.replace(/[^a-zA-Z0-9_]/g, "$"); + var f = name2.charCodeAt(0); + if (f >= char_0 && f <= char_9) { + return "_" + name2; + } else { + return name2; + } + } + function createNamedFunction(name2, body) { + name2 = makeLegalFunctionName(name2); + return new Function("body", "return function " + name2 + '() {\n "use strict"; return body.apply(this, arguments);\n};\n')(body); + } + function extendError(baseErrorType, errorName) { + var errorClass = createNamedFunction(errorName, function(message) { + this.name = errorName; + this.message = message; + var stack = new Error(message).stack; + if (stack !== void 0) { + this.stack = this.toString() + "\n" + stack.replace(/^Error(:[^\n]*)?\n/, ""); + } + }); + errorClass.prototype = Object.create(baseErrorType.prototype); + errorClass.prototype.constructor = errorClass; + errorClass.prototype.toString = function() { + if (this.message === void 0) { + return this.name; + } else { + return this.name + ": " + this.message; + } + }; + return errorClass; + } + var InternalError = void 0; + function throwInternalError(message) { + throw new InternalError(message); + } + function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) { + myTypes.forEach(function(type) { + typeDependencies[type] = dependentTypes; + }); + function onComplete(typeConverters2) { + var myTypeConverters = getTypeConverters(typeConverters2); + if (myTypeConverters.length !== myTypes.length) { + throwInternalError("Mismatched type converter count"); + } + for (var i = 0; i < myTypes.length; ++i) { + registerType(myTypes[i], myTypeConverters[i]); + } + } + var typeConverters = new Array(dependentTypes.length); + var unregisteredTypes = []; + var registered = 0; + dependentTypes.forEach(function(dt, i) { + if (registeredTypes.hasOwnProperty(dt)) { + typeConverters[i] = registeredTypes[dt]; + } else { + unregisteredTypes.push(dt); + if (!awaitingDependencies.hasOwnProperty(dt)) { + awaitingDependencies[dt] = []; + } + awaitingDependencies[dt].push(function() { + typeConverters[i] = registeredTypes[dt]; + ++registered; + if (registered === unregisteredTypes.length) { + onComplete(typeConverters); + } + }); + } + }); + if (unregisteredTypes.length === 0) { + onComplete(typeConverters); + } + } + function __embind_finalize_value_array(rawTupleType) { + var reg = tupleRegistrations[rawTupleType]; + delete tupleRegistrations[rawTupleType]; + var elements = reg.elements; + var elementsLength = elements.length; + var elementTypes = elements.map(function(elt) { + return elt.getterReturnType; + }).concat(elements.map(function(elt) { + return elt.setterArgumentType; + })); + var rawConstructor = reg.rawConstructor; + var rawDestructor = reg.rawDestructor; + whenDependentTypesAreResolved([rawTupleType], elementTypes, function(elementTypes2) { + elements.forEach(function(elt, i) { + var getterReturnType = elementTypes2[i]; + var getter = elt.getter; + var getterContext = elt.getterContext; + var setterArgumentType = elementTypes2[i + elementsLength]; + var setter = elt.setter; + var setterContext = elt.setterContext; + elt.read = function(ptr) { + return getterReturnType["fromWireType"](getter(getterContext, ptr)); + }; + elt.write = function(ptr, o) { + var destructors = []; + setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, o)); + runDestructors(destructors); + }; + }); + return [{name: reg.name, fromWireType: function(ptr) { + var rv = new Array(elementsLength); + for (var i = 0; i < elementsLength; ++i) { + rv[i] = elements[i].read(ptr); + } + rawDestructor(ptr); + return rv; + }, toWireType: function(destructors, o) { + if (elementsLength !== o.length) { + throw new TypeError("Incorrect number of tuple elements for " + reg.name + ": expected=" + elementsLength + ", actual=" + o.length); + } + var ptr = rawConstructor(); + for (var i = 0; i < elementsLength; ++i) { + elements[i].write(ptr, o[i]); + } + if (destructors !== null) { + destructors.push(rawDestructor, ptr); + } + return ptr; + }, argPackAdvance: 8, readValueFromPointer: simpleReadValueFromPointer, destructorFunction: rawDestructor}]; + }); + } + var structRegistrations = {}; + function __embind_finalize_value_object(structType) { + var reg = structRegistrations[structType]; + delete structRegistrations[structType]; + var rawConstructor = reg.rawConstructor; + var rawDestructor = reg.rawDestructor; + var fieldRecords = reg.fields; + var fieldTypes = fieldRecords.map(function(field) { + return field.getterReturnType; + }).concat(fieldRecords.map(function(field) { + return field.setterArgumentType; + })); + whenDependentTypesAreResolved([structType], fieldTypes, function(fieldTypes2) { + var fields = {}; + fieldRecords.forEach(function(field, i) { + var fieldName = field.fieldName; + var getterReturnType = fieldTypes2[i]; + var getter = field.getter; + var getterContext = field.getterContext; + var setterArgumentType = fieldTypes2[i + fieldRecords.length]; + var setter = field.setter; + var setterContext = field.setterContext; + fields[fieldName] = {read: function(ptr) { + return getterReturnType["fromWireType"](getter(getterContext, ptr)); + }, write: function(ptr, o) { + var destructors = []; + setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, o)); + runDestructors(destructors); + }}; + }); + return [{name: reg.name, fromWireType: function(ptr) { + var rv = {}; + for (var i in fields) { + rv[i] = fields[i].read(ptr); + } + rawDestructor(ptr); + return rv; + }, toWireType: function(destructors, o) { + for (var fieldName in fields) { + if (!(fieldName in o)) { + throw new TypeError('Missing field: "' + fieldName + '"'); + } + } + var ptr = rawConstructor(); + for (fieldName in fields) { + fields[fieldName].write(ptr, o[fieldName]); + } + if (destructors !== null) { + destructors.push(rawDestructor, ptr); + } + return ptr; + }, argPackAdvance: 8, readValueFromPointer: simpleReadValueFromPointer, destructorFunction: rawDestructor}]; + }); + } + function getShiftFromSize(size) { + switch (size) { + case 1: + return 0; + case 2: + return 1; + case 4: + return 2; + case 8: + return 3; + default: + throw new TypeError("Unknown type size: " + size); + } + } + function embind_init_charCodes() { + var codes = new Array(256); + for (var i = 0; i < 256; ++i) { + codes[i] = String.fromCharCode(i); + } + embind_charCodes = codes; + } + var embind_charCodes = void 0; + function readLatin1String(ptr) { + var ret = ""; + var c = ptr; + while (HEAPU8[c]) { + ret += embind_charCodes[HEAPU8[c++]]; + } + return ret; + } + var BindingError = void 0; + function throwBindingError(message) { + throw new BindingError(message); + } + function registerType(rawType, registeredInstance, options) { + options = options || {}; + if (!("argPackAdvance" in registeredInstance)) { + throw new TypeError("registerType registeredInstance requires argPackAdvance"); + } + var name2 = registeredInstance.name; + if (!rawType) { + throwBindingError('type "' + name2 + '" must have a positive integer typeid pointer'); + } + if (registeredTypes.hasOwnProperty(rawType)) { + if (options.ignoreDuplicateRegistrations) { + return; + } else { + throwBindingError("Cannot register type '" + name2 + "' twice"); + } + } + registeredTypes[rawType] = registeredInstance; + delete typeDependencies[rawType]; + if (awaitingDependencies.hasOwnProperty(rawType)) { + var callbacks = awaitingDependencies[rawType]; + delete awaitingDependencies[rawType]; + callbacks.forEach(function(cb) { + cb(); + }); + } + } + function __embind_register_bool(rawType, name2, size, trueValue, falseValue) { + var shift = getShiftFromSize(size); + name2 = readLatin1String(name2); + registerType(rawType, {name: name2, fromWireType: function(wt) { + return !!wt; + }, toWireType: function(destructors, o) { + return o ? trueValue : falseValue; + }, argPackAdvance: 8, readValueFromPointer: function(pointer) { + var heap; + if (size === 1) { + heap = HEAP8; + } else if (size === 2) { + heap = HEAP16; + } else if (size === 4) { + heap = HEAP32; + } else { + throw new TypeError("Unknown boolean type size: " + name2); + } + return this["fromWireType"](heap[pointer >> shift]); + }, destructorFunction: null}); + } + function ClassHandle_isAliasOf(other) { + if (!(this instanceof ClassHandle)) { + return false; + } + if (!(other instanceof ClassHandle)) { + return false; + } + var leftClass = this.$$.ptrType.registeredClass; + var left = this.$$.ptr; + var rightClass = other.$$.ptrType.registeredClass; + var right = other.$$.ptr; + while (leftClass.baseClass) { + left = leftClass.upcast(left); + leftClass = leftClass.baseClass; + } + while (rightClass.baseClass) { + right = rightClass.upcast(right); + rightClass = rightClass.baseClass; + } + return leftClass === rightClass && left === right; + } + function shallowCopyInternalPointer(o) { + return {count: o.count, deleteScheduled: o.deleteScheduled, preservePointerOnDelete: o.preservePointerOnDelete, ptr: o.ptr, ptrType: o.ptrType, smartPtr: o.smartPtr, smartPtrType: o.smartPtrType}; + } + function throwInstanceAlreadyDeleted(obj) { + function getInstanceTypeName(handle) { + return handle.$$.ptrType.registeredClass.name; + } + throwBindingError(getInstanceTypeName(obj) + " instance already deleted"); + } + var finalizationGroup = false; + function detachFinalizer(handle) { + } + function runDestructor($$) { + if ($$.smartPtr) { + $$.smartPtrType.rawDestructor($$.smartPtr); + } else { + $$.ptrType.registeredClass.rawDestructor($$.ptr); + } + } + function releaseClassHandle($$) { + $$.count.value -= 1; + var toDelete = $$.count.value === 0; + if (toDelete) { + runDestructor($$); + } + } + function attachFinalizer(handle) { + if (typeof FinalizationGroup === "undefined") { + attachFinalizer = function(handle2) { + return handle2; + }; + return handle; + } + finalizationGroup = new FinalizationGroup(function(iter) { + for (var result = iter.next(); !result.done; result = iter.next()) { + var $$ = result.value; + if (!$$.ptr) { + console.warn("object already deleted: " + $$.ptr); + } else { + releaseClassHandle($$); + } + } + }); + attachFinalizer = function(handle2) { + finalizationGroup.register(handle2, handle2.$$, handle2.$$); + return handle2; + }; + detachFinalizer = function(handle2) { + finalizationGroup.unregister(handle2.$$); + }; + return attachFinalizer(handle); + } + function ClassHandle_clone() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + if (this.$$.preservePointerOnDelete) { + this.$$.count.value += 1; + return this; + } else { + var clone = attachFinalizer(Object.create(Object.getPrototypeOf(this), {$$: {value: shallowCopyInternalPointer(this.$$)}})); + clone.$$.count.value += 1; + clone.$$.deleteScheduled = false; + return clone; + } + } + function ClassHandle_delete() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) { + throwBindingError("Object already scheduled for deletion"); + } + detachFinalizer(this); + releaseClassHandle(this.$$); + if (!this.$$.preservePointerOnDelete) { + this.$$.smartPtr = void 0; + this.$$.ptr = void 0; + } + } + function ClassHandle_isDeleted() { + return !this.$$.ptr; + } + var delayFunction = void 0; + var deletionQueue = []; + function flushPendingDeletes() { + while (deletionQueue.length) { + var obj = deletionQueue.pop(); + obj.$$.deleteScheduled = false; + obj["delete"](); + } + } + function ClassHandle_deleteLater() { + if (!this.$$.ptr) { + throwInstanceAlreadyDeleted(this); + } + if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) { + throwBindingError("Object already scheduled for deletion"); + } + deletionQueue.push(this); + if (deletionQueue.length === 1 && delayFunction) { + delayFunction(flushPendingDeletes); + } + this.$$.deleteScheduled = true; + return this; + } + function init_ClassHandle() { + ClassHandle.prototype["isAliasOf"] = ClassHandle_isAliasOf; + ClassHandle.prototype["clone"] = ClassHandle_clone; + ClassHandle.prototype["delete"] = ClassHandle_delete; + ClassHandle.prototype["isDeleted"] = ClassHandle_isDeleted; + ClassHandle.prototype["deleteLater"] = ClassHandle_deleteLater; + } + function ClassHandle() { + } + var registeredPointers = {}; + function ensureOverloadTable(proto, methodName, humanName) { + if (proto[methodName].overloadTable === void 0) { + var prevFunc = proto[methodName]; + proto[methodName] = function() { + if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) { + throwBindingError("Function '" + humanName + "' called with an invalid number of arguments (" + arguments.length + ") - expects one of (" + proto[methodName].overloadTable + ")!"); + } + return proto[methodName].overloadTable[arguments.length].apply(this, arguments); + }; + proto[methodName].overloadTable = []; + proto[methodName].overloadTable[prevFunc.argCount] = prevFunc; + } + } + function exposePublicSymbol(name2, value, numArguments) { + if (Module.hasOwnProperty(name2)) { + if (numArguments === void 0 || Module[name2].overloadTable !== void 0 && Module[name2].overloadTable[numArguments] !== void 0) { + throwBindingError("Cannot register public name '" + name2 + "' twice"); + } + ensureOverloadTable(Module, name2, name2); + if (Module.hasOwnProperty(numArguments)) { + throwBindingError("Cannot register multiple overloads of a function with the same number of arguments (" + numArguments + ")!"); + } + Module[name2].overloadTable[numArguments] = value; + } else { + Module[name2] = value; + if (numArguments !== void 0) { + Module[name2].numArguments = numArguments; + } + } + } + function RegisteredClass(name2, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast) { + this.name = name2; + this.constructor = constructor; + this.instancePrototype = instancePrototype; + this.rawDestructor = rawDestructor; + this.baseClass = baseClass; + this.getActualType = getActualType; + this.upcast = upcast; + this.downcast = downcast; + this.pureVirtualFunctions = []; + } + function upcastPointer(ptr, ptrClass, desiredClass) { + while (ptrClass !== desiredClass) { + if (!ptrClass.upcast) { + throwBindingError("Expected null or instance of " + desiredClass.name + ", got an instance of " + ptrClass.name); + } + ptr = ptrClass.upcast(ptr); + ptrClass = ptrClass.baseClass; + } + return ptr; + } + function constNoSmartPtrRawPointerToWireType(destructors, handle) { + if (handle === null) { + if (this.isReference) { + throwBindingError("null is not a valid " + this.name); + } + return 0; + } + if (!handle.$$) { + throwBindingError('Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name); + } + if (!handle.$$.ptr) { + throwBindingError("Cannot pass deleted object as a pointer of type " + this.name); + } + var handleClass = handle.$$.ptrType.registeredClass; + var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + return ptr; + } + function genericPointerToWireType(destructors, handle) { + var ptr; + if (handle === null) { + if (this.isReference) { + throwBindingError("null is not a valid " + this.name); + } + if (this.isSmartPointer) { + ptr = this.rawConstructor(); + if (destructors !== null) { + destructors.push(this.rawDestructor, ptr); + } + return ptr; + } else { + return 0; + } + } + if (!handle.$$) { + throwBindingError('Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name); + } + if (!handle.$$.ptr) { + throwBindingError("Cannot pass deleted object as a pointer of type " + this.name); + } + if (!this.isConst && handle.$$.ptrType.isConst) { + throwBindingError("Cannot convert argument of type " + (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) + " to parameter type " + this.name); + } + var handleClass = handle.$$.ptrType.registeredClass; + ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + if (this.isSmartPointer) { + if (handle.$$.smartPtr === void 0) { + throwBindingError("Passing raw pointer to smart pointer is illegal"); + } + switch (this.sharingPolicy) { + case 0: + if (handle.$$.smartPtrType === this) { + ptr = handle.$$.smartPtr; + } else { + throwBindingError("Cannot convert argument of type " + (handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name) + " to parameter type " + this.name); + } + break; + case 1: + ptr = handle.$$.smartPtr; + break; + case 2: + if (handle.$$.smartPtrType === this) { + ptr = handle.$$.smartPtr; + } else { + var clonedHandle = handle["clone"](); + ptr = this.rawShare(ptr, __emval_register(function() { + clonedHandle["delete"](); + })); + if (destructors !== null) { + destructors.push(this.rawDestructor, ptr); + } + } + break; + default: + throwBindingError("Unsupporting sharing policy"); + } + } + return ptr; + } + function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) { + if (handle === null) { + if (this.isReference) { + throwBindingError("null is not a valid " + this.name); + } + return 0; + } + if (!handle.$$) { + throwBindingError('Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name); + } + if (!handle.$$.ptr) { + throwBindingError("Cannot pass deleted object as a pointer of type " + this.name); + } + if (handle.$$.ptrType.isConst) { + throwBindingError("Cannot convert argument of type " + handle.$$.ptrType.name + " to parameter type " + this.name); + } + var handleClass = handle.$$.ptrType.registeredClass; + var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass); + return ptr; + } + function RegisteredPointer_getPointee(ptr) { + if (this.rawGetPointee) { + ptr = this.rawGetPointee(ptr); + } + return ptr; + } + function RegisteredPointer_destructor(ptr) { + if (this.rawDestructor) { + this.rawDestructor(ptr); + } + } + function RegisteredPointer_deleteObject(handle) { + if (handle !== null) { + handle["delete"](); + } + } + function downcastPointer(ptr, ptrClass, desiredClass) { + if (ptrClass === desiredClass) { + return ptr; + } + if (desiredClass.baseClass === void 0) { + return null; + } + var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass); + if (rv === null) { + return null; + } + return desiredClass.downcast(rv); + } + function getInheritedInstanceCount() { + return Object.keys(registeredInstances).length; + } + function getLiveInheritedInstances() { + var rv = []; + for (var k in registeredInstances) { + if (registeredInstances.hasOwnProperty(k)) { + rv.push(registeredInstances[k]); + } + } + return rv; + } + function setDelayFunction(fn) { + delayFunction = fn; + if (deletionQueue.length && delayFunction) { + delayFunction(flushPendingDeletes); + } + } + function init_embind() { + Module["getInheritedInstanceCount"] = getInheritedInstanceCount; + Module["getLiveInheritedInstances"] = getLiveInheritedInstances; + Module["flushPendingDeletes"] = flushPendingDeletes; + Module["setDelayFunction"] = setDelayFunction; + } + var registeredInstances = {}; + function getBasestPointer(class_, ptr) { + if (ptr === void 0) { + throwBindingError("ptr should not be undefined"); + } + while (class_.baseClass) { + ptr = class_.upcast(ptr); + class_ = class_.baseClass; + } + return ptr; + } + function getInheritedInstance(class_, ptr) { + ptr = getBasestPointer(class_, ptr); + return registeredInstances[ptr]; + } + function makeClassHandle(prototype, record) { + if (!record.ptrType || !record.ptr) { + throwInternalError("makeClassHandle requires ptr and ptrType"); + } + var hasSmartPtrType = !!record.smartPtrType; + var hasSmartPtr = !!record.smartPtr; + if (hasSmartPtrType !== hasSmartPtr) { + throwInternalError("Both smartPtrType and smartPtr must be specified"); + } + record.count = {value: 1}; + return attachFinalizer(Object.create(prototype, {$$: {value: record}})); + } + function RegisteredPointer_fromWireType(ptr) { + var rawPointer = this.getPointee(ptr); + if (!rawPointer) { + this.destructor(ptr); + return null; + } + var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer); + if (registeredInstance !== void 0) { + if (registeredInstance.$$.count.value === 0) { + registeredInstance.$$.ptr = rawPointer; + registeredInstance.$$.smartPtr = ptr; + return registeredInstance["clone"](); + } else { + var rv = registeredInstance["clone"](); + this.destructor(ptr); + return rv; + } + } + function makeDefaultHandle() { + if (this.isSmartPointer) { + return makeClassHandle(this.registeredClass.instancePrototype, {ptrType: this.pointeeType, ptr: rawPointer, smartPtrType: this, smartPtr: ptr}); + } else { + return makeClassHandle(this.registeredClass.instancePrototype, {ptrType: this, ptr}); + } + } + var actualType = this.registeredClass.getActualType(rawPointer); + var registeredPointerRecord = registeredPointers[actualType]; + if (!registeredPointerRecord) { + return makeDefaultHandle.call(this); + } + var toType; + if (this.isConst) { + toType = registeredPointerRecord.constPointerType; + } else { + toType = registeredPointerRecord.pointerType; + } + var dp = downcastPointer(rawPointer, this.registeredClass, toType.registeredClass); + if (dp === null) { + return makeDefaultHandle.call(this); + } + if (this.isSmartPointer) { + return makeClassHandle(toType.registeredClass.instancePrototype, {ptrType: toType, ptr: dp, smartPtrType: this, smartPtr: ptr}); + } else { + return makeClassHandle(toType.registeredClass.instancePrototype, {ptrType: toType, ptr: dp}); + } + } + function init_RegisteredPointer() { + RegisteredPointer.prototype.getPointee = RegisteredPointer_getPointee; + RegisteredPointer.prototype.destructor = RegisteredPointer_destructor; + RegisteredPointer.prototype["argPackAdvance"] = 8; + RegisteredPointer.prototype["readValueFromPointer"] = simpleReadValueFromPointer; + RegisteredPointer.prototype["deleteObject"] = RegisteredPointer_deleteObject; + RegisteredPointer.prototype["fromWireType"] = RegisteredPointer_fromWireType; + } + function RegisteredPointer(name2, registeredClass, isReference, isConst, isSmartPointer, pointeeType, sharingPolicy, rawGetPointee, rawConstructor, rawShare, rawDestructor) { + this.name = name2; + this.registeredClass = registeredClass; + this.isReference = isReference; + this.isConst = isConst; + this.isSmartPointer = isSmartPointer; + this.pointeeType = pointeeType; + this.sharingPolicy = sharingPolicy; + this.rawGetPointee = rawGetPointee; + this.rawConstructor = rawConstructor; + this.rawShare = rawShare; + this.rawDestructor = rawDestructor; + if (!isSmartPointer && registeredClass.baseClass === void 0) { + if (isConst) { + this["toWireType"] = constNoSmartPtrRawPointerToWireType; + this.destructorFunction = null; + } else { + this["toWireType"] = nonConstNoSmartPtrRawPointerToWireType; + this.destructorFunction = null; + } + } else { + this["toWireType"] = genericPointerToWireType; + } + } + function replacePublicSymbol(name2, value, numArguments) { + if (!Module.hasOwnProperty(name2)) { + throwInternalError("Replacing nonexistant public symbol"); + } + if (Module[name2].overloadTable !== void 0 && numArguments !== void 0) { + Module[name2].overloadTable[numArguments] = value; + } else { + Module[name2] = value; + Module[name2].argCount = numArguments; + } + } + function getDynCaller(sig, ptr) { + assert(sig.indexOf("j") >= 0, "getDynCaller should only be called with i64 sigs"); + var argCache = []; + return function() { + argCache.length = arguments.length; + for (var i = 0; i < arguments.length; i++) { + argCache[i] = arguments[i]; + } + return dynCall(sig, ptr, argCache); + }; + } + function embind__requireFunction(signature, rawFunction) { + signature = readLatin1String(signature); + function makeDynCaller() { + if (signature.indexOf("j") != -1) { + return getDynCaller(signature, rawFunction); + } + return wasmTable.get(rawFunction); + } + var fp = makeDynCaller(); + if (typeof fp !== "function") { + throwBindingError("unknown function pointer with signature " + signature + ": " + rawFunction); + } + return fp; + } + var UnboundTypeError = void 0; + function getTypeName(type) { + var ptr = ___getTypeName(type); + var rv = readLatin1String(ptr); + _free(ptr); + return rv; + } + function throwUnboundTypeError(message, types) { + var unboundTypes = []; + var seen = {}; + function visit(type) { + if (seen[type]) { + return; + } + if (registeredTypes[type]) { + return; + } + if (typeDependencies[type]) { + typeDependencies[type].forEach(visit); + return; + } + unboundTypes.push(type); + seen[type] = true; + } + types.forEach(visit); + throw new UnboundTypeError(message + ": " + unboundTypes.map(getTypeName).join([", "])); + } + function __embind_register_class(rawType, rawPointerType, rawConstPointerType, baseClassRawType, getActualTypeSignature, getActualType, upcastSignature, upcast, downcastSignature, downcast, name2, destructorSignature, rawDestructor) { + name2 = readLatin1String(name2); + getActualType = embind__requireFunction(getActualTypeSignature, getActualType); + if (upcast) { + upcast = embind__requireFunction(upcastSignature, upcast); + } + if (downcast) { + downcast = embind__requireFunction(downcastSignature, downcast); + } + rawDestructor = embind__requireFunction(destructorSignature, rawDestructor); + var legalFunctionName = makeLegalFunctionName(name2); + exposePublicSymbol(legalFunctionName, function() { + throwUnboundTypeError("Cannot construct " + name2 + " due to unbound types", [baseClassRawType]); + }); + whenDependentTypesAreResolved([rawType, rawPointerType, rawConstPointerType], baseClassRawType ? [baseClassRawType] : [], function(base) { + base = base[0]; + var baseClass; + var basePrototype; + if (baseClassRawType) { + baseClass = base.registeredClass; + basePrototype = baseClass.instancePrototype; + } else { + basePrototype = ClassHandle.prototype; + } + var constructor = createNamedFunction(legalFunctionName, function() { + if (Object.getPrototypeOf(this) !== instancePrototype) { + throw new BindingError("Use 'new' to construct " + name2); + } + if (registeredClass.constructor_body === void 0) { + throw new BindingError(name2 + " has no accessible constructor"); + } + var body = registeredClass.constructor_body[arguments.length]; + if (body === void 0) { + throw new BindingError("Tried to invoke ctor of " + name2 + " with invalid number of parameters (" + arguments.length + ") - expected (" + Object.keys(registeredClass.constructor_body).toString() + ") parameters instead!"); + } + return body.apply(this, arguments); + }); + var instancePrototype = Object.create(basePrototype, {constructor: {value: constructor}}); + constructor.prototype = instancePrototype; + var registeredClass = new RegisteredClass(name2, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast); + var referenceConverter = new RegisteredPointer(name2, registeredClass, true, false, false); + var pointerConverter = new RegisteredPointer(name2 + "*", registeredClass, false, false, false); + var constPointerConverter = new RegisteredPointer(name2 + " const*", registeredClass, false, true, false); + registeredPointers[rawType] = {pointerType: pointerConverter, constPointerType: constPointerConverter}; + replacePublicSymbol(legalFunctionName, constructor); + return [referenceConverter, pointerConverter, constPointerConverter]; + }); + } + function heap32VectorToArray(count, firstElement) { + var array = []; + for (var i = 0; i < count; i++) { + array.push(HEAP32[(firstElement >> 2) + i]); + } + return array; + } + function __embind_register_class_constructor(rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) { + assert(argCount > 0); + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + invoker = embind__requireFunction(invokerSignature, invoker); + var args = [rawConstructor]; + var destructors = []; + whenDependentTypesAreResolved([], [rawClassType], function(classType) { + classType = classType[0]; + var humanName = "constructor " + classType.name; + if (classType.registeredClass.constructor_body === void 0) { + classType.registeredClass.constructor_body = []; + } + if (classType.registeredClass.constructor_body[argCount - 1] !== void 0) { + throw new BindingError("Cannot register multiple constructors with identical number of parameters (" + (argCount - 1) + ") for class '" + classType.name + "'! Overload resolution is currently only performed using the parameter count, not actual type info!"); + } + classType.registeredClass.constructor_body[argCount - 1] = function unboundTypeHandler() { + throwUnboundTypeError("Cannot construct " + classType.name + " due to unbound types", rawArgTypes); + }; + whenDependentTypesAreResolved([], rawArgTypes, function(argTypes) { + classType.registeredClass.constructor_body[argCount - 1] = function constructor_body() { + if (arguments.length !== argCount - 1) { + throwBindingError(humanName + " called with " + arguments.length + " arguments, expected " + (argCount - 1)); + } + destructors.length = 0; + args.length = argCount; + for (var i = 1; i < argCount; ++i) { + args[i] = argTypes[i]["toWireType"](destructors, arguments[i - 1]); + } + var ptr = invoker.apply(null, args); + runDestructors(destructors); + return argTypes[0]["fromWireType"](ptr); + }; + return []; + }); + return []; + }); + } + function new_(constructor, argumentList) { + if (!(constructor instanceof Function)) { + throw new TypeError("new_ called with constructor type " + typeof constructor + " which is not a function"); + } + var dummy = createNamedFunction(constructor.name || "unknownFunctionName", function() { + }); + dummy.prototype = constructor.prototype; + var obj = new dummy(); + var r = constructor.apply(obj, argumentList); + return r instanceof Object ? r : obj; + } + function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc) { + var argCount = argTypes.length; + if (argCount < 2) { + throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!"); + } + var isClassMethodFunc = argTypes[1] !== null && classType !== null; + var needsDestructorStack = false; + for (var i = 1; i < argTypes.length; ++i) { + if (argTypes[i] !== null && argTypes[i].destructorFunction === void 0) { + needsDestructorStack = true; + break; + } + } + var returns = argTypes[0].name !== "void"; + var argsList = ""; + var argsListWired = ""; + for (var i = 0; i < argCount - 2; ++i) { + argsList += (i !== 0 ? ", " : "") + "arg" + i; + argsListWired += (i !== 0 ? ", " : "") + "arg" + i + "Wired"; + } + var invokerFnBody = "return function " + makeLegalFunctionName(humanName) + "(" + argsList + ") {\nif (arguments.length !== " + (argCount - 2) + ") {\nthrowBindingError('function " + humanName + " called with ' + arguments.length + ' arguments, expected " + (argCount - 2) + " args!');\n}\n"; + if (needsDestructorStack) { + invokerFnBody += "var destructors = [];\n"; + } + var dtorStack = needsDestructorStack ? "destructors" : "null"; + var args1 = ["throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam"]; + var args2 = [throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]]; + if (isClassMethodFunc) { + invokerFnBody += "var thisWired = classParam.toWireType(" + dtorStack + ", this);\n"; + } + for (var i = 0; i < argCount - 2; ++i) { + invokerFnBody += "var arg" + i + "Wired = argType" + i + ".toWireType(" + dtorStack + ", arg" + i + "); // " + argTypes[i + 2].name + "\n"; + args1.push("argType" + i); + args2.push(argTypes[i + 2]); + } + if (isClassMethodFunc) { + argsListWired = "thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired; + } + invokerFnBody += (returns ? "var rv = " : "") + "invoker(fn" + (argsListWired.length > 0 ? ", " : "") + argsListWired + ");\n"; + if (needsDestructorStack) { + invokerFnBody += "runDestructors(destructors);\n"; + } else { + for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) { + var paramName = i === 1 ? "thisWired" : "arg" + (i - 2) + "Wired"; + if (argTypes[i].destructorFunction !== null) { + invokerFnBody += paramName + "_dtor(" + paramName + "); // " + argTypes[i].name + "\n"; + args1.push(paramName + "_dtor"); + args2.push(argTypes[i].destructorFunction); + } + } + } + if (returns) { + invokerFnBody += "var ret = retType.fromWireType(rv);\nreturn ret;\n"; + } else { + } + invokerFnBody += "}\n"; + args1.push(invokerFnBody); + var invokerFunction = new_(Function, args1).apply(null, args2); + return invokerFunction; + } + function __embind_register_class_function(rawClassType, methodName, argCount, rawArgTypesAddr, invokerSignature, rawInvoker, context, isPureVirtual) { + var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + methodName = readLatin1String(methodName); + rawInvoker = embind__requireFunction(invokerSignature, rawInvoker); + whenDependentTypesAreResolved([], [rawClassType], function(classType) { + classType = classType[0]; + var humanName = classType.name + "." + methodName; + if (isPureVirtual) { + classType.registeredClass.pureVirtualFunctions.push(methodName); + } + function unboundTypesHandler() { + throwUnboundTypeError("Cannot call " + humanName + " due to unbound types", rawArgTypes); + } + var proto = classType.registeredClass.instancePrototype; + var method = proto[methodName]; + if (method === void 0 || method.overloadTable === void 0 && method.className !== classType.name && method.argCount === argCount - 2) { + unboundTypesHandler.argCount = argCount - 2; + unboundTypesHandler.className = classType.name; + proto[methodName] = unboundTypesHandler; + } else { + ensureOverloadTable(proto, methodName, humanName); + proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler; + } + whenDependentTypesAreResolved([], rawArgTypes, function(argTypes) { + var memberFunction = craftInvokerFunction(humanName, argTypes, classType, rawInvoker, context); + if (proto[methodName].overloadTable === void 0) { + memberFunction.argCount = argCount - 2; + proto[methodName] = memberFunction; + } else { + proto[methodName].overloadTable[argCount - 2] = memberFunction; + } + return []; + }); + return []; + }); + } + var emval_free_list = []; + var emval_handle_array = [{}, {value: void 0}, {value: null}, {value: true}, {value: false}]; + function __emval_decref(handle) { + if (handle > 4 && --emval_handle_array[handle].refcount === 0) { + emval_handle_array[handle] = void 0; + emval_free_list.push(handle); + } + } + function count_emval_handles() { + var count = 0; + for (var i = 5; i < emval_handle_array.length; ++i) { + if (emval_handle_array[i] !== void 0) { + ++count; + } + } + return count; + } + function get_first_emval() { + for (var i = 5; i < emval_handle_array.length; ++i) { + if (emval_handle_array[i] !== void 0) { + return emval_handle_array[i]; + } + } + return null; + } + function init_emval() { + Module["count_emval_handles"] = count_emval_handles; + Module["get_first_emval"] = get_first_emval; + } + function __emval_register(value) { + switch (value) { + case void 0: { + return 1; + } + case null: { + return 2; + } + case true: { + return 3; + } + case false: { + return 4; + } + default: { + var handle = emval_free_list.length ? emval_free_list.pop() : emval_handle_array.length; + emval_handle_array[handle] = {refcount: 1, value}; + return handle; + } + } + } + function __embind_register_emval(rawType, name2) { + name2 = readLatin1String(name2); + registerType(rawType, {name: name2, fromWireType: function(handle) { + var rv = emval_handle_array[handle].value; + __emval_decref(handle); + return rv; + }, toWireType: function(destructors, value) { + return __emval_register(value); + }, argPackAdvance: 8, readValueFromPointer: simpleReadValueFromPointer, destructorFunction: null}); + } + function _embind_repr(v) { + if (v === null) { + return "null"; + } + var t = typeof v; + if (t === "object" || t === "array" || t === "function") { + return v.toString(); + } else { + return "" + v; + } + } + function floatReadValueFromPointer(name2, shift) { + switch (shift) { + case 2: + return function(pointer) { + return this["fromWireType"](HEAPF32[pointer >> 2]); + }; + case 3: + return function(pointer) { + return this["fromWireType"](HEAPF64[pointer >> 3]); + }; + default: + throw new TypeError("Unknown float type: " + name2); + } + } + function __embind_register_float(rawType, name2, size) { + var shift = getShiftFromSize(size); + name2 = readLatin1String(name2); + registerType(rawType, {name: name2, fromWireType: function(value) { + return value; + }, toWireType: function(destructors, value) { + if (typeof value !== "number" && typeof value !== "boolean") { + throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name); + } + return value; + }, argPackAdvance: 8, readValueFromPointer: floatReadValueFromPointer(name2, shift), destructorFunction: null}); + } + function __embind_register_function(name2, argCount, rawArgTypesAddr, signature, rawInvoker, fn) { + var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + name2 = readLatin1String(name2); + rawInvoker = embind__requireFunction(signature, rawInvoker); + exposePublicSymbol(name2, function() { + throwUnboundTypeError("Cannot call " + name2 + " due to unbound types", argTypes); + }, argCount - 1); + whenDependentTypesAreResolved([], argTypes, function(argTypes2) { + var invokerArgsArray = [argTypes2[0], null].concat(argTypes2.slice(1)); + replacePublicSymbol(name2, craftInvokerFunction(name2, invokerArgsArray, null, rawInvoker, fn), argCount - 1); + return []; + }); + } + function integerReadValueFromPointer(name2, shift, signed) { + switch (shift) { + case 0: + return signed ? function readS8FromPointer(pointer) { + return HEAP8[pointer]; + } : function readU8FromPointer(pointer) { + return HEAPU8[pointer]; + }; + case 1: + return signed ? function readS16FromPointer(pointer) { + return HEAP16[pointer >> 1]; + } : function readU16FromPointer(pointer) { + return HEAPU16[pointer >> 1]; + }; + case 2: + return signed ? function readS32FromPointer(pointer) { + return HEAP32[pointer >> 2]; + } : function readU32FromPointer(pointer) { + return HEAPU32[pointer >> 2]; + }; + default: + throw new TypeError("Unknown integer type: " + name2); + } + } + function __embind_register_integer(primitiveType, name2, size, minRange, maxRange) { + name2 = readLatin1String(name2); + if (maxRange === -1) { + maxRange = 4294967295; + } + var shift = getShiftFromSize(size); + var fromWireType = function(value) { + return value; + }; + if (minRange === 0) { + var bitshift = 32 - 8 * size; + fromWireType = function(value) { + return value << bitshift >>> bitshift; + }; + } + var isUnsignedType = name2.indexOf("unsigned") != -1; + registerType(primitiveType, {name: name2, fromWireType, toWireType: function(destructors, value) { + if (typeof value !== "number" && typeof value !== "boolean") { + throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name); + } + if (value < minRange || value > maxRange) { + throw new TypeError('Passing a number "' + _embind_repr(value) + '" from JS side to C/C++ side to an argument of type "' + name2 + '", which is outside the valid range [' + minRange + ", " + maxRange + "]!"); + } + return isUnsignedType ? value >>> 0 : value | 0; + }, argPackAdvance: 8, readValueFromPointer: integerReadValueFromPointer(name2, shift, minRange !== 0), destructorFunction: null}); + } + function __embind_register_memory_view(rawType, dataTypeIndex, name2) { + var typeMapping = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array]; + var TA = typeMapping[dataTypeIndex]; + function decodeMemoryView(handle) { + handle = handle >> 2; + var heap = HEAPU32; + var size = heap[handle]; + var data = heap[handle + 1]; + return new TA(buffer, data, size); + } + name2 = readLatin1String(name2); + registerType(rawType, {name: name2, fromWireType: decodeMemoryView, argPackAdvance: 8, readValueFromPointer: decodeMemoryView}, {ignoreDuplicateRegistrations: true}); + } + function __embind_register_std_string(rawType, name2) { + name2 = readLatin1String(name2); + var stdStringIsUTF8 = name2 === "std::string"; + registerType(rawType, {name: name2, fromWireType: function(value) { + var length = HEAPU32[value >> 2]; + var str; + if (stdStringIsUTF8) { + var decodeStartPtr = value + 4; + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i; + if (i == length || HEAPU8[currentBytePtr] == 0) { + var maxRead = currentBytePtr - decodeStartPtr; + var stringSegment = UTF8ToString(decodeStartPtr, maxRead); + if (str === void 0) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + 1; + } + } + } else { + var a = new Array(length); + for (var i = 0; i < length; ++i) { + a[i] = String.fromCharCode(HEAPU8[value + 4 + i]); + } + str = a.join(""); + } + _free(value); + return str; + }, toWireType: function(destructors, value) { + if (value instanceof ArrayBuffer) { + value = new Uint8Array(value); + } + var getLength; + var valueIsOfTypeString = typeof value === "string"; + if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) { + throwBindingError("Cannot pass non-string to std::string"); + } + if (stdStringIsUTF8 && valueIsOfTypeString) { + getLength = function() { + return lengthBytesUTF8(value); + }; + } else { + getLength = function() { + return value.length; + }; + } + var length = getLength(); + var ptr = _malloc(4 + length + 1); + HEAPU32[ptr >> 2] = length; + if (stdStringIsUTF8 && valueIsOfTypeString) { + stringToUTF8(value, ptr + 4, length + 1); + } else { + if (valueIsOfTypeString) { + for (var i = 0; i < length; ++i) { + var charCode = value.charCodeAt(i); + if (charCode > 255) { + _free(ptr); + throwBindingError("String has UTF-16 code units that do not fit in 8 bits"); + } + HEAPU8[ptr + 4 + i] = charCode; + } + } else { + for (var i = 0; i < length; ++i) { + HEAPU8[ptr + 4 + i] = value[i]; + } + } + } + if (destructors !== null) { + destructors.push(_free, ptr); + } + return ptr; + }, argPackAdvance: 8, readValueFromPointer: simpleReadValueFromPointer, destructorFunction: function(ptr) { + _free(ptr); + }}); + } + function __embind_register_std_wstring(rawType, charSize, name2) { + name2 = readLatin1String(name2); + var decodeString, encodeString, getHeap, lengthBytesUTF, shift; + if (charSize === 2) { + decodeString = UTF16ToString; + encodeString = stringToUTF16; + lengthBytesUTF = lengthBytesUTF16; + getHeap = function() { + return HEAPU16; + }; + shift = 1; + } else if (charSize === 4) { + decodeString = UTF32ToString; + encodeString = stringToUTF32; + lengthBytesUTF = lengthBytesUTF32; + getHeap = function() { + return HEAPU32; + }; + shift = 2; + } + registerType(rawType, {name: name2, fromWireType: function(value) { + var length = HEAPU32[value >> 2]; + var HEAP = getHeap(); + var str; + var decodeStartPtr = value + 4; + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i * charSize; + if (i == length || HEAP[currentBytePtr >> shift] == 0) { + var maxReadBytes = currentBytePtr - decodeStartPtr; + var stringSegment = decodeString(decodeStartPtr, maxReadBytes); + if (str === void 0) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + charSize; + } + } + _free(value); + return str; + }, toWireType: function(destructors, value) { + if (!(typeof value === "string")) { + throwBindingError("Cannot pass non-string to C++ string type " + name2); + } + var length = lengthBytesUTF(value); + var ptr = _malloc(4 + length + charSize); + HEAPU32[ptr >> 2] = length >> shift; + encodeString(value, ptr + 4, length + charSize); + if (destructors !== null) { + destructors.push(_free, ptr); + } + return ptr; + }, argPackAdvance: 8, readValueFromPointer: simpleReadValueFromPointer, destructorFunction: function(ptr) { + _free(ptr); + }}); + } + function __embind_register_value_array(rawType, name2, constructorSignature, rawConstructor, destructorSignature, rawDestructor) { + tupleRegistrations[rawType] = {name: readLatin1String(name2), rawConstructor: embind__requireFunction(constructorSignature, rawConstructor), rawDestructor: embind__requireFunction(destructorSignature, rawDestructor), elements: []}; + } + function __embind_register_value_array_element(rawTupleType, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) { + tupleRegistrations[rawTupleType].elements.push({getterReturnType, getter: embind__requireFunction(getterSignature, getter), getterContext, setterArgumentType, setter: embind__requireFunction(setterSignature, setter), setterContext}); + } + function __embind_register_value_object(rawType, name2, constructorSignature, rawConstructor, destructorSignature, rawDestructor) { + structRegistrations[rawType] = {name: readLatin1String(name2), rawConstructor: embind__requireFunction(constructorSignature, rawConstructor), rawDestructor: embind__requireFunction(destructorSignature, rawDestructor), fields: []}; + } + function __embind_register_value_object_field(structType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) { + structRegistrations[structType].fields.push({fieldName: readLatin1String(fieldName), getterReturnType, getter: embind__requireFunction(getterSignature, getter), getterContext, setterArgumentType, setter: embind__requireFunction(setterSignature, setter), setterContext}); + } + function __embind_register_void(rawType, name2) { + name2 = readLatin1String(name2); + registerType(rawType, {isVoid: true, name: name2, argPackAdvance: 0, fromWireType: function() { + return void 0; + }, toWireType: function(destructors, o) { + return void 0; + }}); + } + function requireHandle(handle) { + if (!handle) { + throwBindingError("Cannot use deleted val. handle = " + handle); + } + return emval_handle_array[handle].value; + } + function requireRegisteredType(rawType, humanName) { + var impl = registeredTypes[rawType]; + if (impl === void 0) { + throwBindingError(humanName + " has unknown type " + getTypeName(rawType)); + } + return impl; + } + function __emval_as(handle, returnType, destructorsRef) { + handle = requireHandle(handle); + returnType = requireRegisteredType(returnType, "emval::as"); + var destructors = []; + var rd = __emval_register(destructors); + HEAP32[destructorsRef >> 2] = rd; + return returnType["toWireType"](destructors, handle); + } + var emval_symbols = {}; + function getStringOrSymbol(address) { + var symbol = emval_symbols[address]; + if (symbol === void 0) { + return readLatin1String(address); + } else { + return symbol; + } + } + function emval_get_global() { + if (typeof globalThis === "object") { + return globalThis; + } + return function() { + return Function; + }()("return this")(); + } + function __emval_get_global(name2) { + if (name2 === 0) { + return __emval_register(emval_get_global()); + } else { + name2 = getStringOrSymbol(name2); + return __emval_register(emval_get_global()[name2]); + } + } + function __emval_get_property(handle, key2) { + handle = requireHandle(handle); + key2 = requireHandle(key2); + return __emval_register(handle[key2]); + } + function __emval_incref(handle) { + if (handle > 4) { + emval_handle_array[handle].refcount += 1; + } + } + function __emval_instanceof(object, constructor) { + object = requireHandle(object); + constructor = requireHandle(constructor); + return object instanceof constructor; + } + function __emval_is_number(handle) { + handle = requireHandle(handle); + return typeof handle === "number"; + } + function __emval_new_array() { + return __emval_register([]); + } + function __emval_new_cstring(v) { + return __emval_register(getStringOrSymbol(v)); + } + function __emval_new_object() { + return __emval_register({}); + } + function __emval_run_destructors(handle) { + var destructors = emval_handle_array[handle].value; + runDestructors(destructors); + __emval_decref(handle); + } + function __emval_set_property(handle, key2, value) { + handle = requireHandle(handle); + key2 = requireHandle(key2); + value = requireHandle(value); + handle[key2] = value; + } + function __emval_take_value(type, argv) { + type = requireRegisteredType(type, "_emval_take_value"); + var v = type["readValueFromPointer"](argv); + return __emval_register(v); + } + function _abort() { + abort(); + } + var _emscripten_get_now; + if (ENVIRONMENT_IS_NODE) { + _emscripten_get_now = function() { + var t = process["hrtime"](); + return t[0] * 1e3 + t[1] / 1e6; + }; + } else if (typeof dateNow !== "undefined") { + _emscripten_get_now = dateNow; + } else + _emscripten_get_now = function() { + return performance.now(); + }; + var _emscripten_get_now_is_monotonic = true; + function _clock_gettime(clk_id, tp) { + var now; + if (clk_id === 0) { + now = Date.now(); + } else if ((clk_id === 1 || clk_id === 4) && _emscripten_get_now_is_monotonic) { + now = _emscripten_get_now(); + } else { + setErrNo(28); + return -1; + } + HEAP32[tp >> 2] = now / 1e3 | 0; + HEAP32[tp + 4 >> 2] = now % 1e3 * 1e3 * 1e3 | 0; + return 0; + } + function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.copyWithin(dest, src, src + num); + } + function _emscripten_get_heap_size() { + return HEAPU8.length; + } + function emscripten_realloc_buffer(size) { + try { + wasmMemory.grow(size - buffer.byteLength + 65535 >>> 16); + updateGlobalBufferAndViews(wasmMemory.buffer); + return 1; + } catch (e) { + } + } + function _emscripten_resize_heap(requestedSize) { + requestedSize = requestedSize >>> 0; + var oldSize = _emscripten_get_heap_size(); + var maxHeapSize = 2147483648; + if (requestedSize > maxHeapSize) { + return false; + } + var minHeapSize = 16777216; + for (var cutDown = 1; cutDown <= 4; cutDown *= 2) { + var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); + overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296); + var newSize = Math.min(maxHeapSize, alignUp(Math.max(minHeapSize, requestedSize, overGrownHeapSize), 65536)); + var replacement = emscripten_realloc_buffer(newSize); + if (replacement) { + return true; + } + } + return false; + } + var ENV = {}; + function getExecutableName() { + return thisProgram || "./this.program"; + } + function getEnvStrings() { + if (!getEnvStrings.strings) { + var lang = (typeof navigator === "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8"; + var env = {USER: "web_user", LOGNAME: "web_user", PATH: "/", PWD: "/", HOME: "/home/web_user", LANG: lang, _: getExecutableName()}; + for (var x in ENV) { + env[x] = ENV[x]; + } + var strings = []; + for (var x in env) { + strings.push(x + "=" + env[x]); + } + getEnvStrings.strings = strings; + } + return getEnvStrings.strings; + } + function _environ_get(__environ, environ_buf) { + try { + var bufSize = 0; + getEnvStrings().forEach(function(string, i) { + var ptr = environ_buf + bufSize; + HEAP32[__environ + i * 4 >> 2] = ptr; + writeAsciiToMemory(string, ptr); + bufSize += string.length + 1; + }); + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) + abort(e); + return e.errno; + } + } + function _environ_sizes_get(penviron_count, penviron_buf_size) { + try { + var strings = getEnvStrings(); + HEAP32[penviron_count >> 2] = strings.length; + var bufSize = 0; + strings.forEach(function(string) { + bufSize += string.length + 1; + }); + HEAP32[penviron_buf_size >> 2] = bufSize; + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) + abort(e); + return e.errno; + } + } + function _fd_close(fd) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + FS.close(stream); + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) + abort(e); + return e.errno; + } + } + function _fd_read(fd, iov, iovcnt, pnum) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var num = SYSCALLS.doReadv(stream, iov, iovcnt); + HEAP32[pnum >> 2] = num; + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) + abort(e); + return e.errno; + } + } + function _fd_seek(fd, offset_low, offset_high, whence, newOffset) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var HIGH_OFFSET = 4294967296; + var offset = offset_high * HIGH_OFFSET + (offset_low >>> 0); + var DOUBLE_LIMIT = 9007199254740992; + if (offset <= -DOUBLE_LIMIT || offset >= DOUBLE_LIMIT) { + return -61; + } + FS.llseek(stream, offset, whence); + tempI64 = [stream.position >>> 0, (tempDouble = stream.position, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[newOffset >> 2] = tempI64[0], HEAP32[newOffset + 4 >> 2] = tempI64[1]; + if (stream.getdents && offset === 0 && whence === 0) + stream.getdents = null; + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) + abort(e); + return e.errno; + } + } + function _fd_write(fd, iov, iovcnt, pnum) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var num = SYSCALLS.doWritev(stream, iov, iovcnt); + HEAP32[pnum >> 2] = num; + return 0; + } catch (e) { + if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) + abort(e); + return e.errno; + } + } + function _setTempRet0($i) { + setTempRet0($i | 0); + } + function __isLeapYear(year) { + return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0); + } + function __arraySum(array, index) { + var sum = 0; + for (var i = 0; i <= index; sum += array[i++]) { + } + return sum; + } + var __MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; + var __MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; + function __addDays(date, days) { + var newDate = new Date(date.getTime()); + while (days > 0) { + var leap = __isLeapYear(newDate.getFullYear()); + var currentMonth = newDate.getMonth(); + var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth]; + if (days > daysInCurrentMonth - newDate.getDate()) { + days -= daysInCurrentMonth - newDate.getDate() + 1; + newDate.setDate(1); + if (currentMonth < 11) { + newDate.setMonth(currentMonth + 1); + } else { + newDate.setMonth(0); + newDate.setFullYear(newDate.getFullYear() + 1); + } + } else { + newDate.setDate(newDate.getDate() + days); + return newDate; + } + } + return newDate; + } + function _strftime(s, maxsize, format, tm) { + var tm_zone = HEAP32[tm + 40 >> 2]; + var date = {tm_sec: HEAP32[tm >> 2], tm_min: HEAP32[tm + 4 >> 2], tm_hour: HEAP32[tm + 8 >> 2], tm_mday: HEAP32[tm + 12 >> 2], tm_mon: HEAP32[tm + 16 >> 2], tm_year: HEAP32[tm + 20 >> 2], tm_wday: HEAP32[tm + 24 >> 2], tm_yday: HEAP32[tm + 28 >> 2], tm_isdst: HEAP32[tm + 32 >> 2], tm_gmtoff: HEAP32[tm + 36 >> 2], tm_zone: tm_zone ? UTF8ToString(tm_zone) : ""}; + var pattern = UTF8ToString(format); + var EXPANSION_RULES_1 = {"%c": "%a %b %d %H:%M:%S %Y", "%D": "%m/%d/%y", "%F": "%Y-%m-%d", "%h": "%b", "%r": "%I:%M:%S %p", "%R": "%H:%M", "%T": "%H:%M:%S", "%x": "%m/%d/%y", "%X": "%H:%M:%S", "%Ec": "%c", "%EC": "%C", "%Ex": "%m/%d/%y", "%EX": "%H:%M:%S", "%Ey": "%y", "%EY": "%Y", "%Od": "%d", "%Oe": "%e", "%OH": "%H", "%OI": "%I", "%Om": "%m", "%OM": "%M", "%OS": "%S", "%Ou": "%u", "%OU": "%U", "%OV": "%V", "%Ow": "%w", "%OW": "%W", "%Oy": "%y"}; + for (var rule in EXPANSION_RULES_1) { + pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_1[rule]); + } + var WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]; + var MONTHS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]; + function leadingSomething(value, digits, character) { + var str = typeof value === "number" ? value.toString() : value || ""; + while (str.length < digits) { + str = character[0] + str; + } + return str; + } + function leadingNulls(value, digits) { + return leadingSomething(value, digits, "0"); + } + function compareByDay(date1, date2) { + function sgn(value) { + return value < 0 ? -1 : value > 0 ? 1 : 0; + } + var compare; + if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) { + if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) { + compare = sgn(date1.getDate() - date2.getDate()); + } + } + return compare; + } + function getFirstWeekStartDate(janFourth) { + switch (janFourth.getDay()) { + case 0: + return new Date(janFourth.getFullYear() - 1, 11, 29); + case 1: + return janFourth; + case 2: + return new Date(janFourth.getFullYear(), 0, 3); + case 3: + return new Date(janFourth.getFullYear(), 0, 2); + case 4: + return new Date(janFourth.getFullYear(), 0, 1); + case 5: + return new Date(janFourth.getFullYear() - 1, 11, 31); + case 6: + return new Date(janFourth.getFullYear() - 1, 11, 30); + } + } + function getWeekBasedYear(date2) { + var thisDate = __addDays(new Date(date2.tm_year + 1900, 0, 1), date2.tm_yday); + var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4); + var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4); + var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear); + var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear); + if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) { + if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) { + return thisDate.getFullYear() + 1; + } else { + return thisDate.getFullYear(); + } + } else { + return thisDate.getFullYear() - 1; + } + } + var EXPANSION_RULES_2 = {"%a": function(date2) { + return WEEKDAYS[date2.tm_wday].substring(0, 3); + }, "%A": function(date2) { + return WEEKDAYS[date2.tm_wday]; + }, "%b": function(date2) { + return MONTHS[date2.tm_mon].substring(0, 3); + }, "%B": function(date2) { + return MONTHS[date2.tm_mon]; + }, "%C": function(date2) { + var year = date2.tm_year + 1900; + return leadingNulls(year / 100 | 0, 2); + }, "%d": function(date2) { + return leadingNulls(date2.tm_mday, 2); + }, "%e": function(date2) { + return leadingSomething(date2.tm_mday, 2, " "); + }, "%g": function(date2) { + return getWeekBasedYear(date2).toString().substring(2); + }, "%G": function(date2) { + return getWeekBasedYear(date2); + }, "%H": function(date2) { + return leadingNulls(date2.tm_hour, 2); + }, "%I": function(date2) { + var twelveHour = date2.tm_hour; + if (twelveHour == 0) + twelveHour = 12; + else if (twelveHour > 12) + twelveHour -= 12; + return leadingNulls(twelveHour, 2); + }, "%j": function(date2) { + return leadingNulls(date2.tm_mday + __arraySum(__isLeapYear(date2.tm_year + 1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, date2.tm_mon - 1), 3); + }, "%m": function(date2) { + return leadingNulls(date2.tm_mon + 1, 2); + }, "%M": function(date2) { + return leadingNulls(date2.tm_min, 2); + }, "%n": function() { + return "\n"; + }, "%p": function(date2) { + if (date2.tm_hour >= 0 && date2.tm_hour < 12) { + return "AM"; + } else { + return "PM"; + } + }, "%S": function(date2) { + return leadingNulls(date2.tm_sec, 2); + }, "%t": function() { + return " "; + }, "%u": function(date2) { + return date2.tm_wday || 7; + }, "%U": function(date2) { + var janFirst = new Date(date2.tm_year + 1900, 0, 1); + var firstSunday = janFirst.getDay() === 0 ? janFirst : __addDays(janFirst, 7 - janFirst.getDay()); + var endDate = new Date(date2.tm_year + 1900, date2.tm_mon, date2.tm_mday); + if (compareByDay(firstSunday, endDate) < 0) { + var februaryFirstUntilEndMonth = __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth() - 1) - 31; + var firstSundayUntilEndJanuary = 31 - firstSunday.getDate(); + var days = firstSundayUntilEndJanuary + februaryFirstUntilEndMonth + endDate.getDate(); + return leadingNulls(Math.ceil(days / 7), 2); + } + return compareByDay(firstSunday, janFirst) === 0 ? "01" : "00"; + }, "%V": function(date2) { + var janFourthThisYear = new Date(date2.tm_year + 1900, 0, 4); + var janFourthNextYear = new Date(date2.tm_year + 1901, 0, 4); + var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear); + var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear); + var endDate = __addDays(new Date(date2.tm_year + 1900, 0, 1), date2.tm_yday); + if (compareByDay(endDate, firstWeekStartThisYear) < 0) { + return "53"; + } + if (compareByDay(firstWeekStartNextYear, endDate) <= 0) { + return "01"; + } + var daysDifference; + if (firstWeekStartThisYear.getFullYear() < date2.tm_year + 1900) { + daysDifference = date2.tm_yday + 32 - firstWeekStartThisYear.getDate(); + } else { + daysDifference = date2.tm_yday + 1 - firstWeekStartThisYear.getDate(); + } + return leadingNulls(Math.ceil(daysDifference / 7), 2); + }, "%w": function(date2) { + return date2.tm_wday; + }, "%W": function(date2) { + var janFirst = new Date(date2.tm_year, 0, 1); + var firstMonday = janFirst.getDay() === 1 ? janFirst : __addDays(janFirst, janFirst.getDay() === 0 ? 1 : 7 - janFirst.getDay() + 1); + var endDate = new Date(date2.tm_year + 1900, date2.tm_mon, date2.tm_mday); + if (compareByDay(firstMonday, endDate) < 0) { + var februaryFirstUntilEndMonth = __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth() - 1) - 31; + var firstMondayUntilEndJanuary = 31 - firstMonday.getDate(); + var days = firstMondayUntilEndJanuary + februaryFirstUntilEndMonth + endDate.getDate(); + return leadingNulls(Math.ceil(days / 7), 2); + } + return compareByDay(firstMonday, janFirst) === 0 ? "01" : "00"; + }, "%y": function(date2) { + return (date2.tm_year + 1900).toString().substring(2); + }, "%Y": function(date2) { + return date2.tm_year + 1900; + }, "%z": function(date2) { + var off = date2.tm_gmtoff; + var ahead = off >= 0; + off = Math.abs(off) / 60; + off = off / 60 * 100 + off % 60; + return (ahead ? "+" : "-") + String("0000" + off).slice(-4); + }, "%Z": function(date2) { + return date2.tm_zone; + }, "%%": function() { + return "%"; + }}; + for (var rule in EXPANSION_RULES_2) { + if (pattern.indexOf(rule) >= 0) { + pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_2[rule](date)); + } + } + var bytes = intArrayFromString(pattern, false); + if (bytes.length > maxsize) { + return 0; + } + writeArrayToMemory(bytes, s); + return bytes.length - 1; + } + function _strftime_l(s, maxsize, format, tm) { + return _strftime(s, maxsize, format, tm); + } + var FSNode = function(parent, name2, mode, rdev) { + if (!parent) { + parent = this; + } + this.parent = parent; + this.mount = parent.mount; + this.mounted = null; + this.id = FS.nextInode++; + this.name = name2; + this.mode = mode; + this.node_ops = {}; + this.stream_ops = {}; + this.rdev = rdev; + }; + var readMode = 292 | 73; + var writeMode = 146; + Object.defineProperties(FSNode.prototype, {read: {get: function() { + return (this.mode & readMode) === readMode; + }, set: function(val) { + val ? this.mode |= readMode : this.mode &= ~readMode; + }}, write: {get: function() { + return (this.mode & writeMode) === writeMode; + }, set: function(val) { + val ? this.mode |= writeMode : this.mode &= ~writeMode; + }}, isFolder: {get: function() { + return FS.isDir(this.mode); + }}, isDevice: {get: function() { + return FS.isChrdev(this.mode); + }}}); + FS.FSNode = FSNode; + FS.staticInit(); + Module["FS_createPath"] = FS.createPath; + Module["FS_createDataFile"] = FS.createDataFile; + Module["FS_createPreloadedFile"] = FS.createPreloadedFile; + Module["FS_createLazyFile"] = FS.createLazyFile; + Module["FS_createDevice"] = FS.createDevice; + Module["FS_unlink"] = FS.unlink; + InternalError = Module["InternalError"] = extendError(Error, "InternalError"); + embind_init_charCodes(); + BindingError = Module["BindingError"] = extendError(Error, "BindingError"); + init_ClassHandle(); + init_RegisteredPointer(); + init_embind(); + UnboundTypeError = Module["UnboundTypeError"] = extendError(Error, "UnboundTypeError"); + init_emval(); + function intArrayFromString(stringy, dontAddNull, length) { + var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1; + var u8array = new Array(len); + var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); + if (dontAddNull) + u8array.length = numBytesWritten; + return u8array; + } + __ATINIT__.push({func: function() { + ___wasm_call_ctors(); + }}); + var asmLibraryArg = {x: ___assert_fail, A: ___sys_fcntl64, O: ___sys_ioctl, P: ___sys_open, U: __embind_finalize_value_array, s: __embind_finalize_value_object, S: __embind_register_bool, v: __embind_register_class, u: __embind_register_class_constructor, d: __embind_register_class_function, R: __embind_register_emval, C: __embind_register_float, j: __embind_register_function, m: __embind_register_integer, i: __embind_register_memory_view, D: __embind_register_std_string, w: __embind_register_std_wstring, V: __embind_register_value_array, g: __embind_register_value_array_element, t: __embind_register_value_object, k: __embind_register_value_object_field, T: __embind_register_void, q: __emval_as, b: __emval_decref, L: __emval_get_global, n: __emval_get_property, l: __emval_incref, Q: __emval_instanceof, E: __emval_is_number, y: __emval_new_array, f: __emval_new_cstring, r: __emval_new_object, p: __emval_run_destructors, h: __emval_set_property, e: __emval_take_value, c: _abort, M: _clock_gettime, H: _emscripten_memcpy_big, o: _emscripten_resize_heap, J: _environ_get, K: _environ_sizes_get, B: _fd_close, N: _fd_read, F: _fd_seek, z: _fd_write, a: wasmMemory, G: _setTempRet0, I: _strftime_l}; + var asm = createWasm(); + var ___wasm_call_ctors = Module["___wasm_call_ctors"] = function() { + return (___wasm_call_ctors = Module["___wasm_call_ctors"] = Module["asm"]["X"]).apply(null, arguments); + }; + var _main = Module["_main"] = function() { + return (_main = Module["_main"] = Module["asm"]["Y"]).apply(null, arguments); + }; + var _malloc = Module["_malloc"] = function() { + return (_malloc = Module["_malloc"] = Module["asm"]["Z"]).apply(null, arguments); + }; + var ___getTypeName = Module["___getTypeName"] = function() { + return (___getTypeName = Module["___getTypeName"] = Module["asm"]["_"]).apply(null, arguments); + }; + var ___embind_register_native_and_builtin_types = Module["___embind_register_native_and_builtin_types"] = function() { + return (___embind_register_native_and_builtin_types = Module["___embind_register_native_and_builtin_types"] = Module["asm"]["$"]).apply(null, arguments); + }; + var ___errno_location = Module["___errno_location"] = function() { + return (___errno_location = Module["___errno_location"] = Module["asm"]["aa"]).apply(null, arguments); + }; + var _free = Module["_free"] = function() { + return (_free = Module["_free"] = Module["asm"]["ba"]).apply(null, arguments); + }; + var dynCall_jiji = Module["dynCall_jiji"] = function() { + return (dynCall_jiji = Module["dynCall_jiji"] = Module["asm"]["ca"]).apply(null, arguments); + }; + var dynCall_viijii = Module["dynCall_viijii"] = function() { + return (dynCall_viijii = Module["dynCall_viijii"] = Module["asm"]["da"]).apply(null, arguments); + }; + var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = function() { + return (dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = Module["asm"]["ea"]).apply(null, arguments); + }; + var dynCall_iiiiij = Module["dynCall_iiiiij"] = function() { + return (dynCall_iiiiij = Module["dynCall_iiiiij"] = Module["asm"]["fa"]).apply(null, arguments); + }; + var dynCall_iiiiijj = Module["dynCall_iiiiijj"] = function() { + return (dynCall_iiiiijj = Module["dynCall_iiiiijj"] = Module["asm"]["ga"]).apply(null, arguments); + }; + Module["addRunDependency"] = addRunDependency; + Module["removeRunDependency"] = removeRunDependency; + Module["FS_createPath"] = FS.createPath; + Module["FS_createDataFile"] = FS.createDataFile; + Module["FS_createPreloadedFile"] = FS.createPreloadedFile; + Module["FS_createLazyFile"] = FS.createLazyFile; + Module["FS_createDevice"] = FS.createDevice; + Module["FS_unlink"] = FS.unlink; + Module["FS"] = FS; + var calledRun; + function ExitStatus(status) { + this.name = "ExitStatus"; + this.message = "Program terminated with exit(" + status + ")"; + this.status = status; + } + var calledMain = false; + dependenciesFulfilled = function runCaller() { + if (!calledRun) + run(); + if (!calledRun) + dependenciesFulfilled = runCaller; + }; + function callMain(args) { + var entryFunction = Module["_main"]; + var argc = 0; + var argv = 0; + try { + var ret = entryFunction(argc, argv); + exit(ret, true); + } catch (e) { + if (e instanceof ExitStatus) { + return; + } else if (e == "unwind") { + noExitRuntime = true; + return; + } else { + var toLog = e; + if (e && typeof e === "object" && e.stack) { + toLog = [e, e.stack]; + } + err("exception thrown: " + toLog); + quit_(1, e); + } + } finally { + calledMain = true; + } + } + function run(args) { + args = args || arguments_; + if (runDependencies > 0) { + return; + } + preRun(); + if (runDependencies > 0) + return; + function doRun() { + if (calledRun) + return; + calledRun = true; + Module["calledRun"] = true; + if (ABORT) + return; + initRuntime(); + preMain(); + readyPromiseResolve(Module); + if (Module["onRuntimeInitialized"]) + Module["onRuntimeInitialized"](); + if (shouldRunNow) + callMain(args); + postRun(); + } + if (Module["setStatus"]) { + Module["setStatus"]("Running..."); + setTimeout(function() { + setTimeout(function() { + Module["setStatus"](""); + }, 1); + doRun(); + }, 1); + } else { + doRun(); + } + } + Module["run"] = run; + function exit(status, implicit) { + if (implicit && noExitRuntime && status === 0) { + return; + } + if (noExitRuntime) { + } else { + EXITSTATUS = status; + exitRuntime(); + if (Module["onExit"]) + Module["onExit"](status); + ABORT = true; + } + quit_(status, new ExitStatus(status)); + } + if (Module["preInit"]) { + if (typeof Module["preInit"] == "function") + Module["preInit"] = [Module["preInit"]]; + while (Module["preInit"].length > 0) { + Module["preInit"].pop()(); + } + } + var shouldRunNow = true; + if (Module["noInitialRun"]) + shouldRunNow = false; + noExitRuntime = true; + run(); + return WebIFCWasm3.ready; + }; + }(); + if (typeof exports === "object" && typeof module === "object") + module.exports = WebIFCWasm2; + else if (typeof define === "function" && define["amd"]) + define([], function() { + return WebIFCWasm2; + }); + else if (typeof exports === "object") + exports["WebIFCWasm"] = WebIFCWasm2; +}); + +// dist/ifc2x4.ts +var IFCACTIONREQUEST = 3821786052; +var IFCACTOR = 2296667514; +var IFCACTORROLE = 3630933823; +var IFCACTUATOR = 4288193352; +var IFCACTUATORTYPE = 2874132201; +var IFCADDRESS = 618182010; +var IFCADVANCEDBREP = 1635779807; +var IFCADVANCEDBREPWITHVOIDS = 2603310189; +var IFCADVANCEDFACE = 3406155212; +var IFCAIRTERMINAL = 1634111441; +var IFCAIRTERMINALBOX = 177149247; +var IFCAIRTERMINALBOXTYPE = 1411407467; +var IFCAIRTERMINALTYPE = 3352864051; +var IFCAIRTOAIRHEATRECOVERY = 2056796094; +var IFCAIRTOAIRHEATRECOVERYTYPE = 1871374353; +var IFCALARM = 3087945054; +var IFCALARMTYPE = 3001207471; +var IFCALIGNMENT = 325726236; +var IFCALIGNMENT2DHORIZONTAL = 749761778; +var IFCALIGNMENT2DHORIZONTALSEGMENT = 3199563722; +var IFCALIGNMENT2DSEGMENT = 2483840362; +var IFCALIGNMENT2DVERSEGCIRCULARARC = 3379348081; +var IFCALIGNMENT2DVERSEGLINE = 3239324667; +var IFCALIGNMENT2DVERSEGPARABOLICARC = 4263986512; +var IFCALIGNMENT2DVERTICAL = 53199957; +var IFCALIGNMENT2DVERTICALSEGMENT = 2029264950; +var IFCALIGNMENTCURVE = 3512275521; +var IFCANNOTATION = 1674181508; +var IFCANNOTATIONFILLAREA = 669184980; +var IFCAPPLICATION = 639542469; +var IFCAPPLIEDVALUE = 411424972; +var IFCAPPROVAL = 130549933; +var IFCAPPROVALRELATIONSHIP = 3869604511; +var IFCARBITRARYCLOSEDPROFILEDEF = 3798115385; +var IFCARBITRARYOPENPROFILEDEF = 1310608509; +var IFCARBITRARYPROFILEDEFWITHVOIDS = 2705031697; +var IFCASSET = 3460190687; +var IFCASYMMETRICISHAPEPROFILEDEF = 3207858831; +var IFCAUDIOVISUALAPPLIANCE = 277319702; +var IFCAUDIOVISUALAPPLIANCETYPE = 1532957894; +var IFCAXIS1PLACEMENT = 4261334040; +var IFCAXIS2PLACEMENT2D = 3125803723; +var IFCAXIS2PLACEMENT3D = 2740243338; +var IFCBSPLINECURVE = 1967976161; +var IFCBSPLINECURVEWITHKNOTS = 2461110595; +var IFCBSPLINESURFACE = 2887950389; +var IFCBSPLINESURFACEWITHKNOTS = 167062518; +var IFCBEAM = 753842376; +var IFCBEAMSTANDARDCASE = 2906023776; +var IFCBEAMTYPE = 819618141; +var IFCBEARING = 4196446775; +var IFCBEARINGTYPE = 3649138523; +var IFCBLOBTEXTURE = 616511568; +var IFCBLOCK = 1334484129; +var IFCBOILER = 32344328; +var IFCBOILERTYPE = 231477066; +var IFCBOOLEANCLIPPINGRESULT = 3649129432; +var IFCBOOLEANRESULT = 2736907675; +var IFCBOUNDARYCONDITION = 4037036970; +var IFCBOUNDARYCURVE = 1136057603; +var IFCBOUNDARYEDGECONDITION = 1560379544; +var IFCBOUNDARYFACECONDITION = 3367102660; +var IFCBOUNDARYNODECONDITION = 1387855156; +var IFCBOUNDARYNODECONDITIONWARPING = 2069777674; +var IFCBOUNDEDCURVE = 1260505505; +var IFCBOUNDEDSURFACE = 4182860854; +var IFCBOUNDINGBOX = 2581212453; +var IFCBOXEDHALFSPACE = 2713105998; +var IFCBRIDGE = 644574406; +var IFCBRIDGEPART = 963979645; +var IFCBUILDING = 4031249490; +var IFCBUILDINGELEMENT = 3299480353; +var IFCBUILDINGELEMENTPART = 2979338954; +var IFCBUILDINGELEMENTPARTTYPE = 39481116; +var IFCBUILDINGELEMENTPROXY = 1095909175; +var IFCBUILDINGELEMENTPROXYTYPE = 1909888760; +var IFCBUILDINGELEMENTTYPE = 1950629157; +var IFCBUILDINGSTOREY = 3124254112; +var IFCBUILDINGSYSTEM = 1177604601; +var IFCBURNER = 2938176219; +var IFCBURNERTYPE = 2188180465; +var IFCCSHAPEPROFILEDEF = 2898889636; +var IFCCABLECARRIERFITTING = 635142910; +var IFCCABLECARRIERFITTINGTYPE = 395041908; +var IFCCABLECARRIERSEGMENT = 3758799889; +var IFCCABLECARRIERSEGMENTTYPE = 3293546465; +var IFCCABLEFITTING = 1051757585; +var IFCCABLEFITTINGTYPE = 2674252688; +var IFCCABLESEGMENT = 4217484030; +var IFCCABLESEGMENTTYPE = 1285652485; +var IFCCAISSONFOUNDATION = 3999819293; +var IFCCAISSONFOUNDATIONTYPE = 3203706013; +var IFCCARTESIANPOINT = 1123145078; +var IFCCARTESIANPOINTLIST = 574549367; +var IFCCARTESIANPOINTLIST2D = 1675464909; +var IFCCARTESIANPOINTLIST3D = 2059837836; +var IFCCARTESIANTRANSFORMATIONOPERATOR = 59481748; +var IFCCARTESIANTRANSFORMATIONOPERATOR2D = 3749851601; +var IFCCARTESIANTRANSFORMATIONOPERATOR2DNONUNIFORM = 3486308946; +var IFCCARTESIANTRANSFORMATIONOPERATOR3D = 3331915920; +var IFCCARTESIANTRANSFORMATIONOPERATOR3DNONUNIFORM = 1416205885; +var IFCCENTERLINEPROFILEDEF = 3150382593; +var IFCCHILLER = 3902619387; +var IFCCHILLERTYPE = 2951183804; +var IFCCHIMNEY = 3296154744; +var IFCCHIMNEYTYPE = 2197970202; +var IFCCIRCLE = 2611217952; +var IFCCIRCLEHOLLOWPROFILEDEF = 2937912522; +var IFCCIRCLEPROFILEDEF = 1383045692; +var IFCCIRCULARARCSEGMENT2D = 1062206242; +var IFCCIVILELEMENT = 1677625105; +var IFCCIVILELEMENTTYPE = 3893394355; +var IFCCLASSIFICATION = 747523909; +var IFCCLASSIFICATIONREFERENCE = 647927063; +var IFCCLOSEDSHELL = 2205249479; +var IFCCOIL = 639361253; +var IFCCOILTYPE = 2301859152; +var IFCCOLOURRGB = 776857604; +var IFCCOLOURRGBLIST = 3285139300; +var IFCCOLOURSPECIFICATION = 3264961684; +var IFCCOLUMN = 843113511; +var IFCCOLUMNSTANDARDCASE = 905975707; +var IFCCOLUMNTYPE = 300633059; +var IFCCOMMUNICATIONSAPPLIANCE = 3221913625; +var IFCCOMMUNICATIONSAPPLIANCETYPE = 400855858; +var IFCCOMPLEXPROPERTY = 2542286263; +var IFCCOMPLEXPROPERTYTEMPLATE = 3875453745; +var IFCCOMPOSITECURVE = 3732776249; +var IFCCOMPOSITECURVEONSURFACE = 15328376; +var IFCCOMPOSITECURVESEGMENT = 2485617015; +var IFCCOMPOSITEPROFILEDEF = 1485152156; +var IFCCOMPRESSOR = 3571504051; +var IFCCOMPRESSORTYPE = 3850581409; +var IFCCONDENSER = 2272882330; +var IFCCONDENSERTYPE = 2816379211; +var IFCCONIC = 2510884976; +var IFCCONNECTEDFACESET = 370225590; +var IFCCONNECTIONCURVEGEOMETRY = 1981873012; +var IFCCONNECTIONGEOMETRY = 2859738748; +var IFCCONNECTIONPOINTECCENTRICITY = 45288368; +var IFCCONNECTIONPOINTGEOMETRY = 2614616156; +var IFCCONNECTIONSURFACEGEOMETRY = 2732653382; +var IFCCONNECTIONVOLUMEGEOMETRY = 775493141; +var IFCCONSTRAINT = 1959218052; +var IFCCONSTRUCTIONEQUIPMENTRESOURCE = 3898045240; +var IFCCONSTRUCTIONEQUIPMENTRESOURCETYPE = 2185764099; +var IFCCONSTRUCTIONMATERIALRESOURCE = 1060000209; +var IFCCONSTRUCTIONMATERIALRESOURCETYPE = 4105962743; +var IFCCONSTRUCTIONPRODUCTRESOURCE = 488727124; +var IFCCONSTRUCTIONPRODUCTRESOURCETYPE = 1525564444; +var IFCCONSTRUCTIONRESOURCE = 2559216714; +var IFCCONSTRUCTIONRESOURCETYPE = 2574617495; +var IFCCONTEXT = 3419103109; +var IFCCONTEXTDEPENDENTUNIT = 3050246964; +var IFCCONTROL = 3293443760; +var IFCCONTROLLER = 25142252; +var IFCCONTROLLERTYPE = 578613899; +var IFCCONVERSIONBASEDUNIT = 2889183280; +var IFCCONVERSIONBASEDUNITWITHOFFSET = 2713554722; +var IFCCOOLEDBEAM = 4136498852; +var IFCCOOLEDBEAMTYPE = 335055490; +var IFCCOOLINGTOWER = 3640358203; +var IFCCOOLINGTOWERTYPE = 2954562838; +var IFCCOORDINATEOPERATION = 1785450214; +var IFCCOORDINATEREFERENCESYSTEM = 1466758467; +var IFCCOSTITEM = 3895139033; +var IFCCOSTSCHEDULE = 1419761937; +var IFCCOSTVALUE = 602808272; +var IFCCOVERING = 1973544240; +var IFCCOVERINGTYPE = 1916426348; +var IFCCREWRESOURCE = 3295246426; +var IFCCREWRESOURCETYPE = 1815067380; +var IFCCSGPRIMITIVE3D = 2506170314; +var IFCCSGSOLID = 2147822146; +var IFCCURRENCYRELATIONSHIP = 539742890; +var IFCCURTAINWALL = 3495092785; +var IFCCURTAINWALLTYPE = 1457835157; +var IFCCURVE = 2601014836; +var IFCCURVEBOUNDEDPLANE = 2827736869; +var IFCCURVEBOUNDEDSURFACE = 2629017746; +var IFCCURVESEGMENT2D = 1186437898; +var IFCCURVESTYLE = 3800577675; +var IFCCURVESTYLEFONT = 1105321065; +var IFCCURVESTYLEFONTANDSCALING = 2367409068; +var IFCCURVESTYLEFONTPATTERN = 3510044353; +var IFCCYLINDRICALSURFACE = 1213902940; +var IFCDAMPER = 4074379575; +var IFCDAMPERTYPE = 3961806047; +var IFCDEEPFOUNDATION = 3426335179; +var IFCDEEPFOUNDATIONTYPE = 1306400036; +var IFCDERIVEDPROFILEDEF = 3632507154; +var IFCDERIVEDUNIT = 1765591967; +var IFCDERIVEDUNITELEMENT = 1045800335; +var IFCDIMENSIONALEXPONENTS = 2949456006; +var IFCDIRECTION = 32440307; +var IFCDISCRETEACCESSORY = 1335981549; +var IFCDISCRETEACCESSORYTYPE = 2635815018; +var IFCDISTANCEEXPRESSION = 1945343521; +var IFCDISTRIBUTIONCHAMBERELEMENT = 1052013943; +var IFCDISTRIBUTIONCHAMBERELEMENTTYPE = 1599208980; +var IFCDISTRIBUTIONCIRCUIT = 562808652; +var IFCDISTRIBUTIONCONTROLELEMENT = 1062813311; +var IFCDISTRIBUTIONCONTROLELEMENTTYPE = 2063403501; +var IFCDISTRIBUTIONELEMENT = 1945004755; +var IFCDISTRIBUTIONELEMENTTYPE = 3256556792; +var IFCDISTRIBUTIONFLOWELEMENT = 3040386961; +var IFCDISTRIBUTIONFLOWELEMENTTYPE = 3849074793; +var IFCDISTRIBUTIONPORT = 3041715199; +var IFCDISTRIBUTIONSYSTEM = 3205830791; +var IFCDOCUMENTINFORMATION = 1154170062; +var IFCDOCUMENTINFORMATIONRELATIONSHIP = 770865208; +var IFCDOCUMENTREFERENCE = 3732053477; +var IFCDOOR = 395920057; +var IFCDOORLININGPROPERTIES = 2963535650; +var IFCDOORPANELPROPERTIES = 1714330368; +var IFCDOORSTANDARDCASE = 3242481149; +var IFCDOORSTYLE = 526551008; +var IFCDOORTYPE = 2323601079; +var IFCDRAUGHTINGPREDEFINEDCOLOUR = 445594917; +var IFCDRAUGHTINGPREDEFINEDCURVEFONT = 4006246654; +var IFCDUCTFITTING = 342316401; +var IFCDUCTFITTINGTYPE = 869906466; +var IFCDUCTSEGMENT = 3518393246; +var IFCDUCTSEGMENTTYPE = 3760055223; +var IFCDUCTSILENCER = 1360408905; +var IFCDUCTSILENCERTYPE = 2030761528; +var IFCEDGE = 3900360178; +var IFCEDGECURVE = 476780140; +var IFCEDGELOOP = 1472233963; +var IFCELECTRICAPPLIANCE = 1904799276; +var IFCELECTRICAPPLIANCETYPE = 663422040; +var IFCELECTRICDISTRIBUTIONBOARD = 862014818; +var IFCELECTRICDISTRIBUTIONBOARDTYPE = 2417008758; +var IFCELECTRICFLOWSTORAGEDEVICE = 3310460725; +var IFCELECTRICFLOWSTORAGEDEVICETYPE = 3277789161; +var IFCELECTRICGENERATOR = 264262732; +var IFCELECTRICGENERATORTYPE = 1534661035; +var IFCELECTRICMOTOR = 402227799; +var IFCELECTRICMOTORTYPE = 1217240411; +var IFCELECTRICTIMECONTROL = 1003880860; +var IFCELECTRICTIMECONTROLTYPE = 712377611; +var IFCELEMENT = 1758889154; +var IFCELEMENTASSEMBLY = 4123344466; +var IFCELEMENTASSEMBLYTYPE = 2397081782; +var IFCELEMENTCOMPONENT = 1623761950; +var IFCELEMENTCOMPONENTTYPE = 2590856083; +var IFCELEMENTQUANTITY = 1883228015; +var IFCELEMENTTYPE = 339256511; +var IFCELEMENTARYSURFACE = 2777663545; +var IFCELLIPSE = 1704287377; +var IFCELLIPSEPROFILEDEF = 2835456948; +var IFCENERGYCONVERSIONDEVICE = 1658829314; +var IFCENERGYCONVERSIONDEVICETYPE = 2107101300; +var IFCENGINE = 2814081492; +var IFCENGINETYPE = 132023988; +var IFCEVAPORATIVECOOLER = 3747195512; +var IFCEVAPORATIVECOOLERTYPE = 3174744832; +var IFCEVAPORATOR = 484807127; +var IFCEVAPORATORTYPE = 3390157468; +var IFCEVENT = 4148101412; +var IFCEVENTTIME = 211053100; +var IFCEVENTTYPE = 4024345920; +var IFCEXTENDEDPROPERTIES = 297599258; +var IFCEXTERNALINFORMATION = 4294318154; +var IFCEXTERNALREFERENCE = 3200245327; +var IFCEXTERNALREFERENCERELATIONSHIP = 1437805879; +var IFCEXTERNALSPATIALELEMENT = 1209101575; +var IFCEXTERNALSPATIALSTRUCTUREELEMENT = 2853485674; +var IFCEXTERNALLYDEFINEDHATCHSTYLE = 2242383968; +var IFCEXTERNALLYDEFINEDSURFACESTYLE = 1040185647; +var IFCEXTERNALLYDEFINEDTEXTFONT = 3548104201; +var IFCEXTRUDEDAREASOLID = 477187591; +var IFCEXTRUDEDAREASOLIDTAPERED = 2804161546; +var IFCFACE = 2556980723; +var IFCFACEBASEDSURFACEMODEL = 2047409740; +var IFCFACEBOUND = 1809719519; +var IFCFACEOUTERBOUND = 803316827; +var IFCFACESURFACE = 3008276851; +var IFCFACETEDBREP = 807026263; +var IFCFACETEDBREPWITHVOIDS = 3737207727; +var IFCFACILITY = 24185140; +var IFCFACILITYPART = 1310830890; +var IFCFAILURECONNECTIONCONDITION = 4219587988; +var IFCFAN = 3415622556; +var IFCFANTYPE = 346874300; +var IFCFASTENER = 647756555; +var IFCFASTENERTYPE = 2489546625; +var IFCFEATUREELEMENT = 2827207264; +var IFCFEATUREELEMENTADDITION = 2143335405; +var IFCFEATUREELEMENTSUBTRACTION = 1287392070; +var IFCFILLAREASTYLE = 738692330; +var IFCFILLAREASTYLEHATCHING = 374418227; +var IFCFILLAREASTYLETILES = 315944413; +var IFCFILTER = 819412036; +var IFCFILTERTYPE = 1810631287; +var IFCFIRESUPPRESSIONTERMINAL = 1426591983; +var IFCFIRESUPPRESSIONTERMINALTYPE = 4222183408; +var IFCFIXEDREFERENCESWEPTAREASOLID = 2652556860; +var IFCFLOWCONTROLLER = 2058353004; +var IFCFLOWCONTROLLERTYPE = 3907093117; +var IFCFLOWFITTING = 4278956645; +var IFCFLOWFITTINGTYPE = 3198132628; +var IFCFLOWINSTRUMENT = 182646315; +var IFCFLOWINSTRUMENTTYPE = 4037862832; +var IFCFLOWMETER = 2188021234; +var IFCFLOWMETERTYPE = 3815607619; +var IFCFLOWMOVINGDEVICE = 3132237377; +var IFCFLOWMOVINGDEVICETYPE = 1482959167; +var IFCFLOWSEGMENT = 987401354; +var IFCFLOWSEGMENTTYPE = 1834744321; +var IFCFLOWSTORAGEDEVICE = 707683696; +var IFCFLOWSTORAGEDEVICETYPE = 1339347760; +var IFCFLOWTERMINAL = 2223149337; +var IFCFLOWTERMINALTYPE = 2297155007; +var IFCFLOWTREATMENTDEVICE = 3508470533; +var IFCFLOWTREATMENTDEVICETYPE = 3009222698; +var IFCFOOTING = 900683007; +var IFCFOOTINGTYPE = 1893162501; +var IFCFURNISHINGELEMENT = 263784265; +var IFCFURNISHINGELEMENTTYPE = 4238390223; +var IFCFURNITURE = 1509553395; +var IFCFURNITURETYPE = 1268542332; +var IFCGEOGRAPHICELEMENT = 3493046030; +var IFCGEOGRAPHICELEMENTTYPE = 4095422895; +var IFCGEOMETRICCURVESET = 987898635; +var IFCGEOMETRICREPRESENTATIONCONTEXT = 3448662350; +var IFCGEOMETRICREPRESENTATIONITEM = 2453401579; +var IFCGEOMETRICREPRESENTATIONSUBCONTEXT = 4142052618; +var IFCGEOMETRICSET = 3590301190; +var IFCGRID = 3009204131; +var IFCGRIDAXIS = 852622518; +var IFCGRIDPLACEMENT = 178086475; +var IFCGROUP = 2706460486; +var IFCHALFSPACESOLID = 812098782; +var IFCHEATEXCHANGER = 3319311131; +var IFCHEATEXCHANGERTYPE = 1251058090; +var IFCHUMIDIFIER = 2068733104; +var IFCHUMIDIFIERTYPE = 1806887404; +var IFCISHAPEPROFILEDEF = 1484403080; +var IFCIMAGETEXTURE = 3905492369; +var IFCINDEXEDCOLOURMAP = 3570813810; +var IFCINDEXEDPOLYCURVE = 2571569899; +var IFCINDEXEDPOLYGONALFACE = 178912537; +var IFCINDEXEDPOLYGONALFACEWITHVOIDS = 2294589976; +var IFCINDEXEDTEXTUREMAP = 1437953363; +var IFCINDEXEDTRIANGLETEXTUREMAP = 2133299955; +var IFCINTERCEPTOR = 4175244083; +var IFCINTERCEPTORTYPE = 3946677679; +var IFCINTERSECTIONCURVE = 3113134337; +var IFCINVENTORY = 2391368822; +var IFCIRREGULARTIMESERIES = 3741457305; +var IFCIRREGULARTIMESERIESVALUE = 3020489413; +var IFCJUNCTIONBOX = 2176052936; +var IFCJUNCTIONBOXTYPE = 4288270099; +var IFCLSHAPEPROFILEDEF = 572779678; +var IFCLABORRESOURCE = 3827777499; +var IFCLABORRESOURCETYPE = 428585644; +var IFCLAGTIME = 1585845231; +var IFCLAMP = 76236018; +var IFCLAMPTYPE = 1051575348; +var IFCLIBRARYINFORMATION = 2655187982; +var IFCLIBRARYREFERENCE = 3452421091; +var IFCLIGHTDISTRIBUTIONDATA = 4162380809; +var IFCLIGHTFIXTURE = 629592764; +var IFCLIGHTFIXTURETYPE = 1161773419; +var IFCLIGHTINTENSITYDISTRIBUTION = 1566485204; +var IFCLIGHTSOURCE = 1402838566; +var IFCLIGHTSOURCEAMBIENT = 125510826; +var IFCLIGHTSOURCEDIRECTIONAL = 2604431987; +var IFCLIGHTSOURCEGONIOMETRIC = 4266656042; +var IFCLIGHTSOURCEPOSITIONAL = 1520743889; +var IFCLIGHTSOURCESPOT = 3422422726; +var IFCLINE = 1281925730; +var IFCLINESEGMENT2D = 3092502836; +var IFCLINEARPLACEMENT = 388784114; +var IFCLINEARPOSITIONINGELEMENT = 1154579445; +var IFCLOCALPLACEMENT = 2624227202; +var IFCLOOP = 1008929658; +var IFCMANIFOLDSOLIDBREP = 1425443689; +var IFCMAPCONVERSION = 3057273783; +var IFCMAPPEDITEM = 2347385850; +var IFCMATERIAL = 1838606355; +var IFCMATERIALCLASSIFICATIONRELATIONSHIP = 1847130766; +var IFCMATERIALCONSTITUENT = 3708119e3; +var IFCMATERIALCONSTITUENTSET = 2852063980; +var IFCMATERIALDEFINITION = 760658860; +var IFCMATERIALDEFINITIONREPRESENTATION = 2022407955; +var IFCMATERIALLAYER = 248100487; +var IFCMATERIALLAYERSET = 3303938423; +var IFCMATERIALLAYERSETUSAGE = 1303795690; +var IFCMATERIALLAYERWITHOFFSETS = 1847252529; +var IFCMATERIALLIST = 2199411900; +var IFCMATERIALPROFILE = 2235152071; +var IFCMATERIALPROFILESET = 164193824; +var IFCMATERIALPROFILESETUSAGE = 3079605661; +var IFCMATERIALPROFILESETUSAGETAPERING = 3404854881; +var IFCMATERIALPROFILEWITHOFFSETS = 552965576; +var IFCMATERIALPROPERTIES = 3265635763; +var IFCMATERIALRELATIONSHIP = 853536259; +var IFCMATERIALUSAGEDEFINITION = 1507914824; +var IFCMEASUREWITHUNIT = 2597039031; +var IFCMECHANICALFASTENER = 377706215; +var IFCMECHANICALFASTENERTYPE = 2108223431; +var IFCMEDICALDEVICE = 1437502449; +var IFCMEDICALDEVICETYPE = 1114901282; +var IFCMEMBER = 1073191201; +var IFCMEMBERSTANDARDCASE = 1911478936; +var IFCMEMBERTYPE = 3181161470; +var IFCMETRIC = 3368373690; +var IFCMIRROREDPROFILEDEF = 2998442950; +var IFCMONETARYUNIT = 2706619895; +var IFCMOTORCONNECTION = 2474470126; +var IFCMOTORCONNECTIONTYPE = 977012517; +var IFCNAMEDUNIT = 1918398963; +var IFCOBJECT = 3888040117; +var IFCOBJECTDEFINITION = 219451334; +var IFCOBJECTPLACEMENT = 3701648758; +var IFCOBJECTIVE = 2251480897; +var IFCOCCUPANT = 4143007308; +var IFCOFFSETCURVE = 590820931; +var IFCOFFSETCURVE2D = 3388369263; +var IFCOFFSETCURVE3D = 3505215534; +var IFCOFFSETCURVEBYDISTANCES = 2485787929; +var IFCOPENSHELL = 2665983363; +var IFCOPENINGELEMENT = 3588315303; +var IFCOPENINGSTANDARDCASE = 3079942009; +var IFCORGANIZATION = 4251960020; +var IFCORGANIZATIONRELATIONSHIP = 1411181986; +var IFCORIENTATIONEXPRESSION = 643959842; +var IFCORIENTEDEDGE = 1029017970; +var IFCOUTERBOUNDARYCURVE = 144952367; +var IFCOUTLET = 3694346114; +var IFCOUTLETTYPE = 2837617999; +var IFCOWNERHISTORY = 1207048766; +var IFCPARAMETERIZEDPROFILEDEF = 2529465313; +var IFCPATH = 2519244187; +var IFCPCURVE = 1682466193; +var IFCPERFORMANCEHISTORY = 2382730787; +var IFCPERMEABLECOVERINGPROPERTIES = 3566463478; +var IFCPERMIT = 3327091369; +var IFCPERSON = 2077209135; +var IFCPERSONANDORGANIZATION = 101040310; +var IFCPHYSICALCOMPLEXQUANTITY = 3021840470; +var IFCPHYSICALQUANTITY = 2483315170; +var IFCPHYSICALSIMPLEQUANTITY = 2226359599; +var IFCPILE = 1687234759; +var IFCPILETYPE = 1158309216; +var IFCPIPEFITTING = 310824031; +var IFCPIPEFITTINGTYPE = 804291784; +var IFCPIPESEGMENT = 3612865200; +var IFCPIPESEGMENTTYPE = 4231323485; +var IFCPIXELTEXTURE = 597895409; +var IFCPLACEMENT = 2004835150; +var IFCPLANARBOX = 603570806; +var IFCPLANAREXTENT = 1663979128; +var IFCPLANE = 220341763; +var IFCPLATE = 3171933400; +var IFCPLATESTANDARDCASE = 1156407060; +var IFCPLATETYPE = 4017108033; +var IFCPOINT = 2067069095; +var IFCPOINTONCURVE = 4022376103; +var IFCPOINTONSURFACE = 1423911732; +var IFCPOLYLOOP = 2924175390; +var IFCPOLYGONALBOUNDEDHALFSPACE = 2775532180; +var IFCPOLYGONALFACESET = 2839578677; +var IFCPOLYLINE = 3724593414; +var IFCPORT = 3740093272; +var IFCPOSITIONINGELEMENT = 1946335990; +var IFCPOSTALADDRESS = 3355820592; +var IFCPREDEFINEDCOLOUR = 759155922; +var IFCPREDEFINEDCURVEFONT = 2559016684; +var IFCPREDEFINEDITEM = 3727388367; +var IFCPREDEFINEDPROPERTIES = 3778827333; +var IFCPREDEFINEDPROPERTYSET = 3967405729; +var IFCPREDEFINEDTEXTFONT = 1775413392; +var IFCPRESENTATIONITEM = 677532197; +var IFCPRESENTATIONLAYERASSIGNMENT = 2022622350; +var IFCPRESENTATIONLAYERWITHSTYLE = 1304840413; +var IFCPRESENTATIONSTYLE = 3119450353; +var IFCPRESENTATIONSTYLEASSIGNMENT = 2417041796; +var IFCPROCEDURE = 2744685151; +var IFCPROCEDURETYPE = 569719735; +var IFCPROCESS = 2945172077; +var IFCPRODUCT = 4208778838; +var IFCPRODUCTDEFINITIONSHAPE = 673634403; +var IFCPRODUCTREPRESENTATION = 2095639259; +var IFCPROFILEDEF = 3958567839; +var IFCPROFILEPROPERTIES = 2802850158; +var IFCPROJECT = 103090709; +var IFCPROJECTLIBRARY = 653396225; +var IFCPROJECTORDER = 2904328755; +var IFCPROJECTEDCRS = 3843373140; +var IFCPROJECTIONELEMENT = 3651124850; +var IFCPROPERTY = 2598011224; +var IFCPROPERTYABSTRACTION = 986844984; +var IFCPROPERTYBOUNDEDVALUE = 871118103; +var IFCPROPERTYDEFINITION = 1680319473; +var IFCPROPERTYDEPENDENCYRELATIONSHIP = 148025276; +var IFCPROPERTYENUMERATEDVALUE = 4166981789; +var IFCPROPERTYENUMERATION = 3710013099; +var IFCPROPERTYLISTVALUE = 2752243245; +var IFCPROPERTYREFERENCEVALUE = 941946838; +var IFCPROPERTYSET = 1451395588; +var IFCPROPERTYSETDEFINITION = 3357820518; +var IFCPROPERTYSETTEMPLATE = 492091185; +var IFCPROPERTYSINGLEVALUE = 3650150729; +var IFCPROPERTYTABLEVALUE = 110355661; +var IFCPROPERTYTEMPLATE = 3521284610; +var IFCPROPERTYTEMPLATEDEFINITION = 1482703590; +var IFCPROTECTIVEDEVICE = 738039164; +var IFCPROTECTIVEDEVICETRIPPINGUNIT = 2295281155; +var IFCPROTECTIVEDEVICETRIPPINGUNITTYPE = 655969474; +var IFCPROTECTIVEDEVICETYPE = 1842657554; +var IFCPROXY = 3219374653; +var IFCPUMP = 90941305; +var IFCPUMPTYPE = 2250791053; +var IFCQUANTITYAREA = 2044713172; +var IFCQUANTITYCOUNT = 2093928680; +var IFCQUANTITYLENGTH = 931644368; +var IFCQUANTITYSET = 2090586900; +var IFCQUANTITYTIME = 3252649465; +var IFCQUANTITYVOLUME = 2405470396; +var IFCQUANTITYWEIGHT = 825690147; +var IFCRAILING = 2262370178; +var IFCRAILINGTYPE = 2893384427; +var IFCRAMP = 3024970846; +var IFCRAMPFLIGHT = 3283111854; +var IFCRAMPFLIGHTTYPE = 2324767716; +var IFCRAMPTYPE = 1469900589; +var IFCRATIONALBSPLINECURVEWITHKNOTS = 1232101972; +var IFCRATIONALBSPLINESURFACEWITHKNOTS = 683857671; +var IFCRECTANGLEHOLLOWPROFILEDEF = 2770003689; +var IFCRECTANGLEPROFILEDEF = 3615266464; +var IFCRECTANGULARPYRAMID = 2798486643; +var IFCRECTANGULARTRIMMEDSURFACE = 3454111270; +var IFCRECURRENCEPATTERN = 3915482550; +var IFCREFERENCE = 2433181523; +var IFCREFERENT = 4021432810; +var IFCREGULARTIMESERIES = 3413951693; +var IFCREINFORCEMENTBARPROPERTIES = 1580146022; +var IFCREINFORCEMENTDEFINITIONPROPERTIES = 3765753017; +var IFCREINFORCINGBAR = 979691226; +var IFCREINFORCINGBARTYPE = 2572171363; +var IFCREINFORCINGELEMENT = 3027567501; +var IFCREINFORCINGELEMENTTYPE = 964333572; +var IFCREINFORCINGMESH = 2320036040; +var IFCREINFORCINGMESHTYPE = 2310774935; +var IFCRELAGGREGATES = 160246688; +var IFCRELASSIGNS = 3939117080; +var IFCRELASSIGNSTOACTOR = 1683148259; +var IFCRELASSIGNSTOCONTROL = 2495723537; +var IFCRELASSIGNSTOGROUP = 1307041759; +var IFCRELASSIGNSTOGROUPBYFACTOR = 1027710054; +var IFCRELASSIGNSTOPROCESS = 4278684876; +var IFCRELASSIGNSTOPRODUCT = 2857406711; +var IFCRELASSIGNSTORESOURCE = 205026976; +var IFCRELASSOCIATES = 1865459582; +var IFCRELASSOCIATESAPPROVAL = 4095574036; +var IFCRELASSOCIATESCLASSIFICATION = 919958153; +var IFCRELASSOCIATESCONSTRAINT = 2728634034; +var IFCRELASSOCIATESDOCUMENT = 982818633; +var IFCRELASSOCIATESLIBRARY = 3840914261; +var IFCRELASSOCIATESMATERIAL = 2655215786; +var IFCRELCONNECTS = 826625072; +var IFCRELCONNECTSELEMENTS = 1204542856; +var IFCRELCONNECTSPATHELEMENTS = 3945020480; +var IFCRELCONNECTSPORTTOELEMENT = 4201705270; +var IFCRELCONNECTSPORTS = 3190031847; +var IFCRELCONNECTSSTRUCTURALACTIVITY = 2127690289; +var IFCRELCONNECTSSTRUCTURALMEMBER = 1638771189; +var IFCRELCONNECTSWITHECCENTRICITY = 504942748; +var IFCRELCONNECTSWITHREALIZINGELEMENTS = 3678494232; +var IFCRELCONTAINEDINSPATIALSTRUCTURE = 3242617779; +var IFCRELCOVERSBLDGELEMENTS = 886880790; +var IFCRELCOVERSSPACES = 2802773753; +var IFCRELDECLARES = 2565941209; +var IFCRELDECOMPOSES = 2551354335; +var IFCRELDEFINES = 693640335; +var IFCRELDEFINESBYOBJECT = 1462361463; +var IFCRELDEFINESBYPROPERTIES = 4186316022; +var IFCRELDEFINESBYTEMPLATE = 307848117; +var IFCRELDEFINESBYTYPE = 781010003; +var IFCRELFILLSELEMENT = 3940055652; +var IFCRELFLOWCONTROLELEMENTS = 279856033; +var IFCRELINTERFERESELEMENTS = 427948657; +var IFCRELNESTS = 3268803585; +var IFCRELPOSITIONS = 1441486842; +var IFCRELPROJECTSELEMENT = 750771296; +var IFCRELREFERENCEDINSPATIALSTRUCTURE = 1245217292; +var IFCRELSEQUENCE = 4122056220; +var IFCRELSERVICESBUILDINGS = 366585022; +var IFCRELSPACEBOUNDARY = 3451746338; +var IFCRELSPACEBOUNDARY1STLEVEL = 3523091289; +var IFCRELSPACEBOUNDARY2NDLEVEL = 1521410863; +var IFCRELVOIDSELEMENT = 1401173127; +var IFCRELATIONSHIP = 478536968; +var IFCREPARAMETRISEDCOMPOSITECURVESEGMENT = 816062949; +var IFCREPRESENTATION = 1076942058; +var IFCREPRESENTATIONCONTEXT = 3377609919; +var IFCREPRESENTATIONITEM = 3008791417; +var IFCREPRESENTATIONMAP = 1660063152; +var IFCRESOURCE = 2914609552; +var IFCRESOURCEAPPROVALRELATIONSHIP = 2943643501; +var IFCRESOURCECONSTRAINTRELATIONSHIP = 1608871552; +var IFCRESOURCELEVELRELATIONSHIP = 2439245199; +var IFCRESOURCETIME = 1042787934; +var IFCREVOLVEDAREASOLID = 1856042241; +var IFCREVOLVEDAREASOLIDTAPERED = 3243963512; +var IFCRIGHTCIRCULARCONE = 4158566097; +var IFCRIGHTCIRCULARCYLINDER = 3626867408; +var IFCROOF = 2016517767; +var IFCROOFTYPE = 2781568857; +var IFCROOT = 2341007311; +var IFCROUNDEDRECTANGLEPROFILEDEF = 2778083089; +var IFCSIUNIT = 448429030; +var IFCSANITARYTERMINAL = 3053780830; +var IFCSANITARYTERMINALTYPE = 1768891740; +var IFCSCHEDULINGTIME = 1054537805; +var IFCSEAMCURVE = 2157484638; +var IFCSECTIONPROPERTIES = 2042790032; +var IFCSECTIONREINFORCEMENTPROPERTIES = 4165799628; +var IFCSECTIONEDSOLID = 1862484736; +var IFCSECTIONEDSOLIDHORIZONTAL = 1290935644; +var IFCSECTIONEDSPINE = 1509187699; +var IFCSENSOR = 4086658281; +var IFCSENSORTYPE = 1783015770; +var IFCSHADINGDEVICE = 1329646415; +var IFCSHADINGDEVICETYPE = 4074543187; +var IFCSHAPEASPECT = 867548509; +var IFCSHAPEMODEL = 3982875396; +var IFCSHAPEREPRESENTATION = 4240577450; +var IFCSHELLBASEDSURFACEMODEL = 4124623270; +var IFCSIMPLEPROPERTY = 3692461612; +var IFCSIMPLEPROPERTYTEMPLATE = 3663146110; +var IFCSITE = 4097777520; +var IFCSLAB = 1529196076; +var IFCSLABELEMENTEDCASE = 3127900445; +var IFCSLABSTANDARDCASE = 3027962421; +var IFCSLABTYPE = 2533589738; +var IFCSLIPPAGECONNECTIONCONDITION = 2609359061; +var IFCSOLARDEVICE = 3420628829; +var IFCSOLARDEVICETYPE = 1072016465; +var IFCSOLIDMODEL = 723233188; +var IFCSPACE = 3856911033; +var IFCSPACEHEATER = 1999602285; +var IFCSPACEHEATERTYPE = 1305183839; +var IFCSPACETYPE = 3812236995; +var IFCSPATIALELEMENT = 1412071761; +var IFCSPATIALELEMENTTYPE = 710998568; +var IFCSPATIALSTRUCTUREELEMENT = 2706606064; +var IFCSPATIALSTRUCTUREELEMENTTYPE = 3893378262; +var IFCSPATIALZONE = 463610769; +var IFCSPATIALZONETYPE = 2481509218; +var IFCSPHERE = 451544542; +var IFCSPHERICALSURFACE = 4015995234; +var IFCSTACKTERMINAL = 1404847402; +var IFCSTACKTERMINALTYPE = 3112655638; +var IFCSTAIR = 331165859; +var IFCSTAIRFLIGHT = 4252922144; +var IFCSTAIRFLIGHTTYPE = 1039846685; +var IFCSTAIRTYPE = 338393293; +var IFCSTRUCTURALACTION = 682877961; +var IFCSTRUCTURALACTIVITY = 3544373492; +var IFCSTRUCTURALANALYSISMODEL = 2515109513; +var IFCSTRUCTURALCONNECTION = 1179482911; +var IFCSTRUCTURALCONNECTIONCONDITION = 2273995522; +var IFCSTRUCTURALCURVEACTION = 1004757350; +var IFCSTRUCTURALCURVECONNECTION = 4243806635; +var IFCSTRUCTURALCURVEMEMBER = 214636428; +var IFCSTRUCTURALCURVEMEMBERVARYING = 2445595289; +var IFCSTRUCTURALCURVEREACTION = 2757150158; +var IFCSTRUCTURALITEM = 3136571912; +var IFCSTRUCTURALLINEARACTION = 1807405624; +var IFCSTRUCTURALLOAD = 2162789131; +var IFCSTRUCTURALLOADCASE = 385403989; +var IFCSTRUCTURALLOADCONFIGURATION = 3478079324; +var IFCSTRUCTURALLOADGROUP = 1252848954; +var IFCSTRUCTURALLOADLINEARFORCE = 1595516126; +var IFCSTRUCTURALLOADORRESULT = 609421318; +var IFCSTRUCTURALLOADPLANARFORCE = 2668620305; +var IFCSTRUCTURALLOADSINGLEDISPLACEMENT = 2473145415; +var IFCSTRUCTURALLOADSINGLEDISPLACEMENTDISTORTION = 1973038258; +var IFCSTRUCTURALLOADSINGLEFORCE = 1597423693; +var IFCSTRUCTURALLOADSINGLEFORCEWARPING = 1190533807; +var IFCSTRUCTURALLOADSTATIC = 2525727697; +var IFCSTRUCTURALLOADTEMPERATURE = 3408363356; +var IFCSTRUCTURALMEMBER = 530289379; +var IFCSTRUCTURALPLANARACTION = 1621171031; +var IFCSTRUCTURALPOINTACTION = 2082059205; +var IFCSTRUCTURALPOINTCONNECTION = 734778138; +var IFCSTRUCTURALPOINTREACTION = 1235345126; +var IFCSTRUCTURALREACTION = 3689010777; +var IFCSTRUCTURALRESULTGROUP = 2986769608; +var IFCSTRUCTURALSURFACEACTION = 3657597509; +var IFCSTRUCTURALSURFACECONNECTION = 1975003073; +var IFCSTRUCTURALSURFACEMEMBER = 3979015343; +var IFCSTRUCTURALSURFACEMEMBERVARYING = 2218152070; +var IFCSTRUCTURALSURFACEREACTION = 603775116; +var IFCSTYLEMODEL = 2830218821; +var IFCSTYLEDITEM = 3958052878; +var IFCSTYLEDREPRESENTATION = 3049322572; +var IFCSUBCONTRACTRESOURCE = 148013059; +var IFCSUBCONTRACTRESOURCETYPE = 4095615324; +var IFCSUBEDGE = 2233826070; +var IFCSURFACE = 2513912981; +var IFCSURFACECURVE = 699246055; +var IFCSURFACECURVESWEPTAREASOLID = 2028607225; +var IFCSURFACEFEATURE = 3101698114; +var IFCSURFACEOFLINEAREXTRUSION = 2809605785; +var IFCSURFACEOFREVOLUTION = 4124788165; +var IFCSURFACEREINFORCEMENTAREA = 2934153892; +var IFCSURFACESTYLE = 1300840506; +var IFCSURFACESTYLELIGHTING = 3303107099; +var IFCSURFACESTYLEREFRACTION = 1607154358; +var IFCSURFACESTYLERENDERING = 1878645084; +var IFCSURFACESTYLESHADING = 846575682; +var IFCSURFACESTYLEWITHTEXTURES = 1351298697; +var IFCSURFACETEXTURE = 626085974; +var IFCSWEPTAREASOLID = 2247615214; +var IFCSWEPTDISKSOLID = 1260650574; +var IFCSWEPTDISKSOLIDPOLYGONAL = 1096409881; +var IFCSWEPTSURFACE = 230924584; +var IFCSWITCHINGDEVICE = 1162798199; +var IFCSWITCHINGDEVICETYPE = 2315554128; +var IFCSYSTEM = 2254336722; +var IFCSYSTEMFURNITUREELEMENT = 413509423; +var IFCSYSTEMFURNITUREELEMENTTYPE = 1580310250; +var IFCTSHAPEPROFILEDEF = 3071757647; +var IFCTABLE = 985171141; +var IFCTABLECOLUMN = 2043862942; +var IFCTABLEROW = 531007025; +var IFCTANK = 812556717; +var IFCTANKTYPE = 5716631; +var IFCTASK = 3473067441; +var IFCTASKTIME = 1549132990; +var IFCTASKTIMERECURRING = 2771591690; +var IFCTASKTYPE = 3206491090; +var IFCTELECOMADDRESS = 912023232; +var IFCTENDON = 3824725483; +var IFCTENDONANCHOR = 2347447852; +var IFCTENDONANCHORTYPE = 3081323446; +var IFCTENDONCONDUIT = 3663046924; +var IFCTENDONCONDUITTYPE = 2281632017; +var IFCTENDONTYPE = 2415094496; +var IFCTESSELLATEDFACESET = 2387106220; +var IFCTESSELLATEDITEM = 901063453; +var IFCTEXTLITERAL = 4282788508; +var IFCTEXTLITERALWITHEXTENT = 3124975700; +var IFCTEXTSTYLE = 1447204868; +var IFCTEXTSTYLEFONTMODEL = 1983826977; +var IFCTEXTSTYLEFORDEFINEDFONT = 2636378356; +var IFCTEXTSTYLETEXTMODEL = 1640371178; +var IFCTEXTURECOORDINATE = 280115917; +var IFCTEXTURECOORDINATEGENERATOR = 1742049831; +var IFCTEXTUREMAP = 2552916305; +var IFCTEXTUREVERTEX = 1210645708; +var IFCTEXTUREVERTEXLIST = 3611470254; +var IFCTIMEPERIOD = 1199560280; +var IFCTIMESERIES = 3101149627; +var IFCTIMESERIESVALUE = 581633288; +var IFCTOPOLOGICALREPRESENTATIONITEM = 1377556343; +var IFCTOPOLOGYREPRESENTATION = 1735638870; +var IFCTOROIDALSURFACE = 1935646853; +var IFCTRANSFORMER = 3825984169; +var IFCTRANSFORMERTYPE = 1692211062; +var IFCTRANSITIONCURVESEGMENT2D = 2595432518; +var IFCTRANSPORTELEMENT = 1620046519; +var IFCTRANSPORTELEMENTTYPE = 2097647324; +var IFCTRAPEZIUMPROFILEDEF = 2715220739; +var IFCTRIANGULATEDFACESET = 2916149573; +var IFCTRIANGULATEDIRREGULARNETWORK = 1229763772; +var IFCTRIMMEDCURVE = 3593883385; +var IFCTUBEBUNDLE = 3026737570; +var IFCTUBEBUNDLETYPE = 1600972822; +var IFCTYPEOBJECT = 1628702193; +var IFCTYPEPROCESS = 3736923433; +var IFCTYPEPRODUCT = 2347495698; +var IFCTYPERESOURCE = 3698973494; +var IFCUSHAPEPROFILEDEF = 427810014; +var IFCUNITASSIGNMENT = 180925521; +var IFCUNITARYCONTROLELEMENT = 630975310; +var IFCUNITARYCONTROLELEMENTTYPE = 3179687236; +var IFCUNITARYEQUIPMENT = 4292641817; +var IFCUNITARYEQUIPMENTTYPE = 1911125066; +var IFCVALVE = 4207607924; +var IFCVALVETYPE = 728799441; +var IFCVECTOR = 1417489154; +var IFCVERTEX = 2799835756; +var IFCVERTEXLOOP = 2759199220; +var IFCVERTEXPOINT = 1907098498; +var IFCVIBRATIONDAMPER = 1530820697; +var IFCVIBRATIONDAMPERTYPE = 3956297820; +var IFCVIBRATIONISOLATOR = 2391383451; +var IFCVIBRATIONISOLATORTYPE = 3313531582; +var IFCVIRTUALELEMENT = 2769231204; +var IFCVIRTUALGRIDINTERSECTION = 891718957; +var IFCVOIDINGFEATURE = 926996030; +var IFCWALL = 2391406946; +var IFCWALLELEMENTEDCASE = 4156078855; +var IFCWALLSTANDARDCASE = 3512223829; +var IFCWALLTYPE = 1898987631; +var IFCWASTETERMINAL = 4237592921; +var IFCWASTETERMINALTYPE = 1133259667; +var IFCWINDOW = 3304561284; +var IFCWINDOWLININGPROPERTIES = 336235671; +var IFCWINDOWPANELPROPERTIES = 512836454; +var IFCWINDOWSTANDARDCASE = 486154966; +var IFCWINDOWSTYLE = 1299126871; +var IFCWINDOWTYPE = 4009809668; +var IFCWORKCALENDAR = 4088093105; +var IFCWORKCONTROL = 1028945134; +var IFCWORKPLAN = 4218914973; +var IFCWORKSCHEDULE = 3342526732; +var IFCWORKTIME = 1236880293; +var IFCZSHAPEPROFILEDEF = 2543172580; +var IFCZONE = 1033361043; +var IfcElements = [ + 4288193352, + 1634111441, + 177149247, + 2056796094, + 3087945054, + 277319702, + 753842376, + 2906023776, + 32344328, + 2979338954, + 1095909175, + 2938176219, + 635142910, + 3758799889, + 1051757585, + 4217484030, + 3902619387, + 3296154744, + 1677625105, + 639361253, + 843113511, + 905975707, + 3221913625, + 3571504051, + 2272882330, + 25142252, + 4136498852, + 3640358203, + 1973544240, + 3495092785, + 4074379575, + 1335981549, + 1052013943, + 1062813311, + 1945004755, + 3040386961, + 395920057, + 3242481149, + 342316401, + 3518393246, + 1360408905, + 1904799276, + 862014818, + 3310460725, + 264262732, + 402227799, + 1003880860, + 4123344466, + 1658829314, + 2814081492, + 3747195512, + 484807127, + 3415622556, + 647756555, + 819412036, + 1426591983, + 2058353004, + 4278956645, + 182646315, + 2188021234, + 3132237377, + 987401354, + 707683696, + 2223149337, + 3508470533, + 900683007, + 263784265, + 1509553395, + 3493046030, + 3319311131, + 2068733104, + 4175244083, + 2176052936, + 76236018, + 629592764, + 377706215, + 1437502449, + 1073191201, + 1911478936, + 2474470126, + 3588315303, + 3079942009, + 3694346114, + 1687234759, + 310824031, + 3612865200, + 3171933400, + 1156407060, + 3651124850, + 738039164, + 2295281155, + 90941305, + 2262370178, + 3024970846, + 3283111854, + 979691226, + 2320036040, + 2016517767, + 3053780830, + 4086658281, + 1329646415, + 1529196076, + 3127900445, + 3027962421, + 3420628829, + 1999602285, + 1404847402, + 331165859, + 4252922144, + 3101698114, + 1162798199, + 413509423, + 812556717, + 3824725483, + 2347447852, + 3825984169, + 1620046519, + 3026737570, + 630975310, + 4292641817, + 4207607924, + 2391383451, + 2769231204, + 926996030, + 2391406946, + 4156078855, + 3512223829, + 4237592921, + 3304561284, + 486154966 +]; + +// dist/ifc2x4_helper.ts +var FromRawLineData = {}; +FromRawLineData[IFCACTIONREQUEST] = (d) => { + return IfcActionRequest.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCACTOR] = (d) => { + return IfcActor.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCACTORROLE] = (d) => { + return IfcActorRole.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCACTUATOR] = (d) => { + return IfcActuator.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCACTUATORTYPE] = (d) => { + return IfcActuatorType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCADDRESS] = (d) => { + return IfcAddress.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCADVANCEDBREP] = (d) => { + return IfcAdvancedBrep.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCADVANCEDBREPWITHVOIDS] = (d) => { + return IfcAdvancedBrepWithVoids.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCADVANCEDFACE] = (d) => { + return IfcAdvancedFace.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCAIRTERMINAL] = (d) => { + return IfcAirTerminal.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCAIRTERMINALBOX] = (d) => { + return IfcAirTerminalBox.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCAIRTERMINALBOXTYPE] = (d) => { + return IfcAirTerminalBoxType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCAIRTERMINALTYPE] = (d) => { + return IfcAirTerminalType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCAIRTOAIRHEATRECOVERY] = (d) => { + return IfcAirToAirHeatRecovery.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCAIRTOAIRHEATRECOVERYTYPE] = (d) => { + return IfcAirToAirHeatRecoveryType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCALARM] = (d) => { + return IfcAlarm.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCALARMTYPE] = (d) => { + return IfcAlarmType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCALIGNMENT] = (d) => { + return IfcAlignment.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCALIGNMENT2DHORIZONTAL] = (d) => { + return IfcAlignment2DHorizontal.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCALIGNMENT2DHORIZONTALSEGMENT] = (d) => { + return IfcAlignment2DHorizontalSegment.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCALIGNMENT2DSEGMENT] = (d) => { + return IfcAlignment2DSegment.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCALIGNMENT2DVERSEGCIRCULARARC] = (d) => { + return IfcAlignment2DVerSegCircularArc.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCALIGNMENT2DVERSEGLINE] = (d) => { + return IfcAlignment2DVerSegLine.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCALIGNMENT2DVERSEGPARABOLICARC] = (d) => { + return IfcAlignment2DVerSegParabolicArc.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCALIGNMENT2DVERTICAL] = (d) => { + return IfcAlignment2DVertical.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCALIGNMENT2DVERTICALSEGMENT] = (d) => { + return IfcAlignment2DVerticalSegment.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCALIGNMENTCURVE] = (d) => { + return IfcAlignmentCurve.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCANNOTATION] = (d) => { + return IfcAnnotation.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCANNOTATIONFILLAREA] = (d) => { + return IfcAnnotationFillArea.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCAPPLICATION] = (d) => { + return IfcApplication.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCAPPLIEDVALUE] = (d) => { + return IfcAppliedValue.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCAPPROVAL] = (d) => { + return IfcApproval.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCAPPROVALRELATIONSHIP] = (d) => { + return IfcApprovalRelationship.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCARBITRARYCLOSEDPROFILEDEF] = (d) => { + return IfcArbitraryClosedProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCARBITRARYOPENPROFILEDEF] = (d) => { + return IfcArbitraryOpenProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCARBITRARYPROFILEDEFWITHVOIDS] = (d) => { + return IfcArbitraryProfileDefWithVoids.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCASSET] = (d) => { + return IfcAsset.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCASYMMETRICISHAPEPROFILEDEF] = (d) => { + return IfcAsymmetricIShapeProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCAUDIOVISUALAPPLIANCE] = (d) => { + return IfcAudioVisualAppliance.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCAUDIOVISUALAPPLIANCETYPE] = (d) => { + return IfcAudioVisualApplianceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCAXIS1PLACEMENT] = (d) => { + return IfcAxis1Placement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCAXIS2PLACEMENT2D] = (d) => { + return IfcAxis2Placement2D.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCAXIS2PLACEMENT3D] = (d) => { + return IfcAxis2Placement3D.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBSPLINECURVE] = (d) => { + return IfcBSplineCurve.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBSPLINECURVEWITHKNOTS] = (d) => { + return IfcBSplineCurveWithKnots.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBSPLINESURFACE] = (d) => { + return IfcBSplineSurface.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBSPLINESURFACEWITHKNOTS] = (d) => { + return IfcBSplineSurfaceWithKnots.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBEAM] = (d) => { + return IfcBeam.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBEAMSTANDARDCASE] = (d) => { + return IfcBeamStandardCase.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBEAMTYPE] = (d) => { + return IfcBeamType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBEARING] = (d) => { + return IfcBearing.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBEARINGTYPE] = (d) => { + return IfcBearingType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBLOBTEXTURE] = (d) => { + return IfcBlobTexture.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBLOCK] = (d) => { + return IfcBlock.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBOILER] = (d) => { + return IfcBoiler.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBOILERTYPE] = (d) => { + return IfcBoilerType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBOOLEANCLIPPINGRESULT] = (d) => { + return IfcBooleanClippingResult.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBOOLEANRESULT] = (d) => { + return IfcBooleanResult.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBOUNDARYCONDITION] = (d) => { + return IfcBoundaryCondition.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBOUNDARYCURVE] = (d) => { + return IfcBoundaryCurve.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBOUNDARYEDGECONDITION] = (d) => { + return IfcBoundaryEdgeCondition.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBOUNDARYFACECONDITION] = (d) => { + return IfcBoundaryFaceCondition.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBOUNDARYNODECONDITION] = (d) => { + return IfcBoundaryNodeCondition.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBOUNDARYNODECONDITIONWARPING] = (d) => { + return IfcBoundaryNodeConditionWarping.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBOUNDEDCURVE] = (d) => { + return IfcBoundedCurve.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBOUNDEDSURFACE] = (d) => { + return IfcBoundedSurface.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBOUNDINGBOX] = (d) => { + return IfcBoundingBox.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBOXEDHALFSPACE] = (d) => { + return IfcBoxedHalfSpace.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBRIDGE] = (d) => { + return IfcBridge.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBRIDGEPART] = (d) => { + return IfcBridgePart.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBUILDING] = (d) => { + return IfcBuilding.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBUILDINGELEMENT] = (d) => { + return IfcBuildingElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBUILDINGELEMENTPART] = (d) => { + return IfcBuildingElementPart.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBUILDINGELEMENTPARTTYPE] = (d) => { + return IfcBuildingElementPartType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBUILDINGELEMENTPROXY] = (d) => { + return IfcBuildingElementProxy.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBUILDINGELEMENTPROXYTYPE] = (d) => { + return IfcBuildingElementProxyType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBUILDINGELEMENTTYPE] = (d) => { + return IfcBuildingElementType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBUILDINGSTOREY] = (d) => { + return IfcBuildingStorey.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBUILDINGSYSTEM] = (d) => { + return IfcBuildingSystem.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBURNER] = (d) => { + return IfcBurner.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCBURNERTYPE] = (d) => { + return IfcBurnerType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCSHAPEPROFILEDEF] = (d) => { + return IfcCShapeProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCABLECARRIERFITTING] = (d) => { + return IfcCableCarrierFitting.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCABLECARRIERFITTINGTYPE] = (d) => { + return IfcCableCarrierFittingType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCABLECARRIERSEGMENT] = (d) => { + return IfcCableCarrierSegment.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCABLECARRIERSEGMENTTYPE] = (d) => { + return IfcCableCarrierSegmentType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCABLEFITTING] = (d) => { + return IfcCableFitting.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCABLEFITTINGTYPE] = (d) => { + return IfcCableFittingType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCABLESEGMENT] = (d) => { + return IfcCableSegment.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCABLESEGMENTTYPE] = (d) => { + return IfcCableSegmentType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCAISSONFOUNDATION] = (d) => { + return IfcCaissonFoundation.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCAISSONFOUNDATIONTYPE] = (d) => { + return IfcCaissonFoundationType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCARTESIANPOINT] = (d) => { + return IfcCartesianPoint.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCARTESIANPOINTLIST] = (d) => { + return IfcCartesianPointList.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCARTESIANPOINTLIST2D] = (d) => { + return IfcCartesianPointList2D.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCARTESIANPOINTLIST3D] = (d) => { + return IfcCartesianPointList3D.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCARTESIANTRANSFORMATIONOPERATOR] = (d) => { + return IfcCartesianTransformationOperator.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCARTESIANTRANSFORMATIONOPERATOR2D] = (d) => { + return IfcCartesianTransformationOperator2D.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCARTESIANTRANSFORMATIONOPERATOR2DNONUNIFORM] = (d) => { + return IfcCartesianTransformationOperator2DnonUniform.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCARTESIANTRANSFORMATIONOPERATOR3D] = (d) => { + return IfcCartesianTransformationOperator3D.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCARTESIANTRANSFORMATIONOPERATOR3DNONUNIFORM] = (d) => { + return IfcCartesianTransformationOperator3DnonUniform.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCENTERLINEPROFILEDEF] = (d) => { + return IfcCenterLineProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCHILLER] = (d) => { + return IfcChiller.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCHILLERTYPE] = (d) => { + return IfcChillerType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCHIMNEY] = (d) => { + return IfcChimney.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCHIMNEYTYPE] = (d) => { + return IfcChimneyType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCIRCLE] = (d) => { + return IfcCircle.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCIRCLEHOLLOWPROFILEDEF] = (d) => { + return IfcCircleHollowProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCIRCLEPROFILEDEF] = (d) => { + return IfcCircleProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCIRCULARARCSEGMENT2D] = (d) => { + return IfcCircularArcSegment2D.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCIVILELEMENT] = (d) => { + return IfcCivilElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCIVILELEMENTTYPE] = (d) => { + return IfcCivilElementType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCLASSIFICATION] = (d) => { + return IfcClassification.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCLASSIFICATIONREFERENCE] = (d) => { + return IfcClassificationReference.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCLOSEDSHELL] = (d) => { + return IfcClosedShell.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOIL] = (d) => { + return IfcCoil.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOILTYPE] = (d) => { + return IfcCoilType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOLOURRGB] = (d) => { + return IfcColourRgb.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOLOURRGBLIST] = (d) => { + return IfcColourRgbList.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOLOURSPECIFICATION] = (d) => { + return IfcColourSpecification.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOLUMN] = (d) => { + return IfcColumn.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOLUMNSTANDARDCASE] = (d) => { + return IfcColumnStandardCase.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOLUMNTYPE] = (d) => { + return IfcColumnType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOMMUNICATIONSAPPLIANCE] = (d) => { + return IfcCommunicationsAppliance.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOMMUNICATIONSAPPLIANCETYPE] = (d) => { + return IfcCommunicationsApplianceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOMPLEXPROPERTY] = (d) => { + return IfcComplexProperty.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOMPLEXPROPERTYTEMPLATE] = (d) => { + return IfcComplexPropertyTemplate.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOMPOSITECURVE] = (d) => { + return IfcCompositeCurve.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOMPOSITECURVEONSURFACE] = (d) => { + return IfcCompositeCurveOnSurface.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOMPOSITECURVESEGMENT] = (d) => { + return IfcCompositeCurveSegment.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOMPOSITEPROFILEDEF] = (d) => { + return IfcCompositeProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOMPRESSOR] = (d) => { + return IfcCompressor.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOMPRESSORTYPE] = (d) => { + return IfcCompressorType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONDENSER] = (d) => { + return IfcCondenser.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONDENSERTYPE] = (d) => { + return IfcCondenserType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONIC] = (d) => { + return IfcConic.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONNECTEDFACESET] = (d) => { + return IfcConnectedFaceSet.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONNECTIONCURVEGEOMETRY] = (d) => { + return IfcConnectionCurveGeometry.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONNECTIONGEOMETRY] = (d) => { + return IfcConnectionGeometry.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONNECTIONPOINTECCENTRICITY] = (d) => { + return IfcConnectionPointEccentricity.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONNECTIONPOINTGEOMETRY] = (d) => { + return IfcConnectionPointGeometry.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONNECTIONSURFACEGEOMETRY] = (d) => { + return IfcConnectionSurfaceGeometry.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONNECTIONVOLUMEGEOMETRY] = (d) => { + return IfcConnectionVolumeGeometry.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONSTRAINT] = (d) => { + return IfcConstraint.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONSTRUCTIONEQUIPMENTRESOURCE] = (d) => { + return IfcConstructionEquipmentResource.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONSTRUCTIONEQUIPMENTRESOURCETYPE] = (d) => { + return IfcConstructionEquipmentResourceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONSTRUCTIONMATERIALRESOURCE] = (d) => { + return IfcConstructionMaterialResource.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONSTRUCTIONMATERIALRESOURCETYPE] = (d) => { + return IfcConstructionMaterialResourceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONSTRUCTIONPRODUCTRESOURCE] = (d) => { + return IfcConstructionProductResource.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONSTRUCTIONPRODUCTRESOURCETYPE] = (d) => { + return IfcConstructionProductResourceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONSTRUCTIONRESOURCE] = (d) => { + return IfcConstructionResource.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONSTRUCTIONRESOURCETYPE] = (d) => { + return IfcConstructionResourceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONTEXT] = (d) => { + return IfcContext.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONTEXTDEPENDENTUNIT] = (d) => { + return IfcContextDependentUnit.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONTROL] = (d) => { + return IfcControl.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONTROLLER] = (d) => { + return IfcController.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONTROLLERTYPE] = (d) => { + return IfcControllerType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONVERSIONBASEDUNIT] = (d) => { + return IfcConversionBasedUnit.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCONVERSIONBASEDUNITWITHOFFSET] = (d) => { + return IfcConversionBasedUnitWithOffset.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOOLEDBEAM] = (d) => { + return IfcCooledBeam.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOOLEDBEAMTYPE] = (d) => { + return IfcCooledBeamType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOOLINGTOWER] = (d) => { + return IfcCoolingTower.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOOLINGTOWERTYPE] = (d) => { + return IfcCoolingTowerType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOORDINATEOPERATION] = (d) => { + return IfcCoordinateOperation.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOORDINATEREFERENCESYSTEM] = (d) => { + return IfcCoordinateReferenceSystem.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOSTITEM] = (d) => { + return IfcCostItem.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOSTSCHEDULE] = (d) => { + return IfcCostSchedule.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOSTVALUE] = (d) => { + return IfcCostValue.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOVERING] = (d) => { + return IfcCovering.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCOVERINGTYPE] = (d) => { + return IfcCoveringType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCREWRESOURCE] = (d) => { + return IfcCrewResource.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCREWRESOURCETYPE] = (d) => { + return IfcCrewResourceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCSGPRIMITIVE3D] = (d) => { + return IfcCsgPrimitive3D.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCSGSOLID] = (d) => { + return IfcCsgSolid.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCURRENCYRELATIONSHIP] = (d) => { + return IfcCurrencyRelationship.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCURTAINWALL] = (d) => { + return IfcCurtainWall.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCURTAINWALLTYPE] = (d) => { + return IfcCurtainWallType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCURVE] = (d) => { + return IfcCurve.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCURVEBOUNDEDPLANE] = (d) => { + return IfcCurveBoundedPlane.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCURVEBOUNDEDSURFACE] = (d) => { + return IfcCurveBoundedSurface.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCURVESEGMENT2D] = (d) => { + return IfcCurveSegment2D.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCURVESTYLE] = (d) => { + return IfcCurveStyle.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCURVESTYLEFONT] = (d) => { + return IfcCurveStyleFont.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCURVESTYLEFONTANDSCALING] = (d) => { + return IfcCurveStyleFontAndScaling.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCURVESTYLEFONTPATTERN] = (d) => { + return IfcCurveStyleFontPattern.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCCYLINDRICALSURFACE] = (d) => { + return IfcCylindricalSurface.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDAMPER] = (d) => { + return IfcDamper.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDAMPERTYPE] = (d) => { + return IfcDamperType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDEEPFOUNDATION] = (d) => { + return IfcDeepFoundation.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDEEPFOUNDATIONTYPE] = (d) => { + return IfcDeepFoundationType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDERIVEDPROFILEDEF] = (d) => { + return IfcDerivedProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDERIVEDUNIT] = (d) => { + return IfcDerivedUnit.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDERIVEDUNITELEMENT] = (d) => { + return IfcDerivedUnitElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDIMENSIONALEXPONENTS] = (d) => { + return IfcDimensionalExponents.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDIRECTION] = (d) => { + return IfcDirection.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDISCRETEACCESSORY] = (d) => { + return IfcDiscreteAccessory.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDISCRETEACCESSORYTYPE] = (d) => { + return IfcDiscreteAccessoryType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDISTANCEEXPRESSION] = (d) => { + return IfcDistanceExpression.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDISTRIBUTIONCHAMBERELEMENT] = (d) => { + return IfcDistributionChamberElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDISTRIBUTIONCHAMBERELEMENTTYPE] = (d) => { + return IfcDistributionChamberElementType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDISTRIBUTIONCIRCUIT] = (d) => { + return IfcDistributionCircuit.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDISTRIBUTIONCONTROLELEMENT] = (d) => { + return IfcDistributionControlElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDISTRIBUTIONCONTROLELEMENTTYPE] = (d) => { + return IfcDistributionControlElementType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDISTRIBUTIONELEMENT] = (d) => { + return IfcDistributionElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDISTRIBUTIONELEMENTTYPE] = (d) => { + return IfcDistributionElementType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDISTRIBUTIONFLOWELEMENT] = (d) => { + return IfcDistributionFlowElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDISTRIBUTIONFLOWELEMENTTYPE] = (d) => { + return IfcDistributionFlowElementType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDISTRIBUTIONPORT] = (d) => { + return IfcDistributionPort.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDISTRIBUTIONSYSTEM] = (d) => { + return IfcDistributionSystem.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDOCUMENTINFORMATION] = (d) => { + return IfcDocumentInformation.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDOCUMENTINFORMATIONRELATIONSHIP] = (d) => { + return IfcDocumentInformationRelationship.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDOCUMENTREFERENCE] = (d) => { + return IfcDocumentReference.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDOOR] = (d) => { + return IfcDoor.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDOORLININGPROPERTIES] = (d) => { + return IfcDoorLiningProperties.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDOORPANELPROPERTIES] = (d) => { + return IfcDoorPanelProperties.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDOORSTANDARDCASE] = (d) => { + return IfcDoorStandardCase.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDOORSTYLE] = (d) => { + return IfcDoorStyle.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDOORTYPE] = (d) => { + return IfcDoorType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDRAUGHTINGPREDEFINEDCOLOUR] = (d) => { + return IfcDraughtingPreDefinedColour.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDRAUGHTINGPREDEFINEDCURVEFONT] = (d) => { + return IfcDraughtingPreDefinedCurveFont.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDUCTFITTING] = (d) => { + return IfcDuctFitting.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDUCTFITTINGTYPE] = (d) => { + return IfcDuctFittingType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDUCTSEGMENT] = (d) => { + return IfcDuctSegment.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDUCTSEGMENTTYPE] = (d) => { + return IfcDuctSegmentType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDUCTSILENCER] = (d) => { + return IfcDuctSilencer.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCDUCTSILENCERTYPE] = (d) => { + return IfcDuctSilencerType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEDGE] = (d) => { + return IfcEdge.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEDGECURVE] = (d) => { + return IfcEdgeCurve.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEDGELOOP] = (d) => { + return IfcEdgeLoop.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELECTRICAPPLIANCE] = (d) => { + return IfcElectricAppliance.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELECTRICAPPLIANCETYPE] = (d) => { + return IfcElectricApplianceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELECTRICDISTRIBUTIONBOARD] = (d) => { + return IfcElectricDistributionBoard.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELECTRICDISTRIBUTIONBOARDTYPE] = (d) => { + return IfcElectricDistributionBoardType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELECTRICFLOWSTORAGEDEVICE] = (d) => { + return IfcElectricFlowStorageDevice.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELECTRICFLOWSTORAGEDEVICETYPE] = (d) => { + return IfcElectricFlowStorageDeviceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELECTRICGENERATOR] = (d) => { + return IfcElectricGenerator.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELECTRICGENERATORTYPE] = (d) => { + return IfcElectricGeneratorType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELECTRICMOTOR] = (d) => { + return IfcElectricMotor.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELECTRICMOTORTYPE] = (d) => { + return IfcElectricMotorType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELECTRICTIMECONTROL] = (d) => { + return IfcElectricTimeControl.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELECTRICTIMECONTROLTYPE] = (d) => { + return IfcElectricTimeControlType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELEMENT] = (d) => { + return IfcElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELEMENTASSEMBLY] = (d) => { + return IfcElementAssembly.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELEMENTASSEMBLYTYPE] = (d) => { + return IfcElementAssemblyType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELEMENTCOMPONENT] = (d) => { + return IfcElementComponent.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELEMENTCOMPONENTTYPE] = (d) => { + return IfcElementComponentType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELEMENTQUANTITY] = (d) => { + return IfcElementQuantity.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELEMENTTYPE] = (d) => { + return IfcElementType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELEMENTARYSURFACE] = (d) => { + return IfcElementarySurface.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELLIPSE] = (d) => { + return IfcEllipse.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCELLIPSEPROFILEDEF] = (d) => { + return IfcEllipseProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCENERGYCONVERSIONDEVICE] = (d) => { + return IfcEnergyConversionDevice.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCENERGYCONVERSIONDEVICETYPE] = (d) => { + return IfcEnergyConversionDeviceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCENGINE] = (d) => { + return IfcEngine.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCENGINETYPE] = (d) => { + return IfcEngineType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEVAPORATIVECOOLER] = (d) => { + return IfcEvaporativeCooler.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEVAPORATIVECOOLERTYPE] = (d) => { + return IfcEvaporativeCoolerType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEVAPORATOR] = (d) => { + return IfcEvaporator.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEVAPORATORTYPE] = (d) => { + return IfcEvaporatorType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEVENT] = (d) => { + return IfcEvent.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEVENTTIME] = (d) => { + return IfcEventTime.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEVENTTYPE] = (d) => { + return IfcEventType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEXTENDEDPROPERTIES] = (d) => { + return IfcExtendedProperties.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEXTERNALINFORMATION] = (d) => { + return IfcExternalInformation.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEXTERNALREFERENCE] = (d) => { + return IfcExternalReference.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEXTERNALREFERENCERELATIONSHIP] = (d) => { + return IfcExternalReferenceRelationship.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEXTERNALSPATIALELEMENT] = (d) => { + return IfcExternalSpatialElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEXTERNALSPATIALSTRUCTUREELEMENT] = (d) => { + return IfcExternalSpatialStructureElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEXTERNALLYDEFINEDHATCHSTYLE] = (d) => { + return IfcExternallyDefinedHatchStyle.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEXTERNALLYDEFINEDSURFACESTYLE] = (d) => { + return IfcExternallyDefinedSurfaceStyle.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEXTERNALLYDEFINEDTEXTFONT] = (d) => { + return IfcExternallyDefinedTextFont.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEXTRUDEDAREASOLID] = (d) => { + return IfcExtrudedAreaSolid.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCEXTRUDEDAREASOLIDTAPERED] = (d) => { + return IfcExtrudedAreaSolidTapered.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFACE] = (d) => { + return IfcFace.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFACEBASEDSURFACEMODEL] = (d) => { + return IfcFaceBasedSurfaceModel.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFACEBOUND] = (d) => { + return IfcFaceBound.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFACEOUTERBOUND] = (d) => { + return IfcFaceOuterBound.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFACESURFACE] = (d) => { + return IfcFaceSurface.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFACETEDBREP] = (d) => { + return IfcFacetedBrep.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFACETEDBREPWITHVOIDS] = (d) => { + return IfcFacetedBrepWithVoids.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFACILITY] = (d) => { + return IfcFacility.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFACILITYPART] = (d) => { + return IfcFacilityPart.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFAILURECONNECTIONCONDITION] = (d) => { + return IfcFailureConnectionCondition.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFAN] = (d) => { + return IfcFan.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFANTYPE] = (d) => { + return IfcFanType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFASTENER] = (d) => { + return IfcFastener.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFASTENERTYPE] = (d) => { + return IfcFastenerType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFEATUREELEMENT] = (d) => { + return IfcFeatureElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFEATUREELEMENTADDITION] = (d) => { + return IfcFeatureElementAddition.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFEATUREELEMENTSUBTRACTION] = (d) => { + return IfcFeatureElementSubtraction.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFILLAREASTYLE] = (d) => { + return IfcFillAreaStyle.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFILLAREASTYLEHATCHING] = (d) => { + return IfcFillAreaStyleHatching.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFILLAREASTYLETILES] = (d) => { + return IfcFillAreaStyleTiles.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFILTER] = (d) => { + return IfcFilter.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFILTERTYPE] = (d) => { + return IfcFilterType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFIRESUPPRESSIONTERMINAL] = (d) => { + return IfcFireSuppressionTerminal.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFIRESUPPRESSIONTERMINALTYPE] = (d) => { + return IfcFireSuppressionTerminalType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFIXEDREFERENCESWEPTAREASOLID] = (d) => { + return IfcFixedReferenceSweptAreaSolid.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFLOWCONTROLLER] = (d) => { + return IfcFlowController.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFLOWCONTROLLERTYPE] = (d) => { + return IfcFlowControllerType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFLOWFITTING] = (d) => { + return IfcFlowFitting.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFLOWFITTINGTYPE] = (d) => { + return IfcFlowFittingType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFLOWINSTRUMENT] = (d) => { + return IfcFlowInstrument.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFLOWINSTRUMENTTYPE] = (d) => { + return IfcFlowInstrumentType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFLOWMETER] = (d) => { + return IfcFlowMeter.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFLOWMETERTYPE] = (d) => { + return IfcFlowMeterType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFLOWMOVINGDEVICE] = (d) => { + return IfcFlowMovingDevice.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFLOWMOVINGDEVICETYPE] = (d) => { + return IfcFlowMovingDeviceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFLOWSEGMENT] = (d) => { + return IfcFlowSegment.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFLOWSEGMENTTYPE] = (d) => { + return IfcFlowSegmentType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFLOWSTORAGEDEVICE] = (d) => { + return IfcFlowStorageDevice.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFLOWSTORAGEDEVICETYPE] = (d) => { + return IfcFlowStorageDeviceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFLOWTERMINAL] = (d) => { + return IfcFlowTerminal.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFLOWTERMINALTYPE] = (d) => { + return IfcFlowTerminalType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFLOWTREATMENTDEVICE] = (d) => { + return IfcFlowTreatmentDevice.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFLOWTREATMENTDEVICETYPE] = (d) => { + return IfcFlowTreatmentDeviceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFOOTING] = (d) => { + return IfcFooting.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFOOTINGTYPE] = (d) => { + return IfcFootingType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFURNISHINGELEMENT] = (d) => { + return IfcFurnishingElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFURNISHINGELEMENTTYPE] = (d) => { + return IfcFurnishingElementType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFURNITURE] = (d) => { + return IfcFurniture.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCFURNITURETYPE] = (d) => { + return IfcFurnitureType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCGEOGRAPHICELEMENT] = (d) => { + return IfcGeographicElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCGEOGRAPHICELEMENTTYPE] = (d) => { + return IfcGeographicElementType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCGEOMETRICCURVESET] = (d) => { + return IfcGeometricCurveSet.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCGEOMETRICREPRESENTATIONCONTEXT] = (d) => { + return IfcGeometricRepresentationContext.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCGEOMETRICREPRESENTATIONITEM] = (d) => { + return IfcGeometricRepresentationItem.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCGEOMETRICREPRESENTATIONSUBCONTEXT] = (d) => { + return IfcGeometricRepresentationSubContext.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCGEOMETRICSET] = (d) => { + return IfcGeometricSet.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCGRID] = (d) => { + return IfcGrid.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCGRIDAXIS] = (d) => { + return IfcGridAxis.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCGRIDPLACEMENT] = (d) => { + return IfcGridPlacement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCGROUP] = (d) => { + return IfcGroup.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCHALFSPACESOLID] = (d) => { + return IfcHalfSpaceSolid.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCHEATEXCHANGER] = (d) => { + return IfcHeatExchanger.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCHEATEXCHANGERTYPE] = (d) => { + return IfcHeatExchangerType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCHUMIDIFIER] = (d) => { + return IfcHumidifier.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCHUMIDIFIERTYPE] = (d) => { + return IfcHumidifierType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCISHAPEPROFILEDEF] = (d) => { + return IfcIShapeProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCIMAGETEXTURE] = (d) => { + return IfcImageTexture.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCINDEXEDCOLOURMAP] = (d) => { + return IfcIndexedColourMap.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCINDEXEDPOLYCURVE] = (d) => { + return IfcIndexedPolyCurve.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCINDEXEDPOLYGONALFACE] = (d) => { + return IfcIndexedPolygonalFace.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCINDEXEDPOLYGONALFACEWITHVOIDS] = (d) => { + return IfcIndexedPolygonalFaceWithVoids.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCINDEXEDTEXTUREMAP] = (d) => { + return IfcIndexedTextureMap.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCINDEXEDTRIANGLETEXTUREMAP] = (d) => { + return IfcIndexedTriangleTextureMap.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCINTERCEPTOR] = (d) => { + return IfcInterceptor.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCINTERCEPTORTYPE] = (d) => { + return IfcInterceptorType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCINTERSECTIONCURVE] = (d) => { + return IfcIntersectionCurve.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCINVENTORY] = (d) => { + return IfcInventory.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCIRREGULARTIMESERIES] = (d) => { + return IfcIrregularTimeSeries.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCIRREGULARTIMESERIESVALUE] = (d) => { + return IfcIrregularTimeSeriesValue.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCJUNCTIONBOX] = (d) => { + return IfcJunctionBox.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCJUNCTIONBOXTYPE] = (d) => { + return IfcJunctionBoxType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLSHAPEPROFILEDEF] = (d) => { + return IfcLShapeProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLABORRESOURCE] = (d) => { + return IfcLaborResource.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLABORRESOURCETYPE] = (d) => { + return IfcLaborResourceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLAGTIME] = (d) => { + return IfcLagTime.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLAMP] = (d) => { + return IfcLamp.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLAMPTYPE] = (d) => { + return IfcLampType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLIBRARYINFORMATION] = (d) => { + return IfcLibraryInformation.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLIBRARYREFERENCE] = (d) => { + return IfcLibraryReference.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLIGHTDISTRIBUTIONDATA] = (d) => { + return IfcLightDistributionData.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLIGHTFIXTURE] = (d) => { + return IfcLightFixture.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLIGHTFIXTURETYPE] = (d) => { + return IfcLightFixtureType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLIGHTINTENSITYDISTRIBUTION] = (d) => { + return IfcLightIntensityDistribution.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLIGHTSOURCE] = (d) => { + return IfcLightSource.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLIGHTSOURCEAMBIENT] = (d) => { + return IfcLightSourceAmbient.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLIGHTSOURCEDIRECTIONAL] = (d) => { + return IfcLightSourceDirectional.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLIGHTSOURCEGONIOMETRIC] = (d) => { + return IfcLightSourceGoniometric.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLIGHTSOURCEPOSITIONAL] = (d) => { + return IfcLightSourcePositional.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLIGHTSOURCESPOT] = (d) => { + return IfcLightSourceSpot.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLINE] = (d) => { + return IfcLine.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLINESEGMENT2D] = (d) => { + return IfcLineSegment2D.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLINEARPLACEMENT] = (d) => { + return IfcLinearPlacement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLINEARPOSITIONINGELEMENT] = (d) => { + return IfcLinearPositioningElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLOCALPLACEMENT] = (d) => { + return IfcLocalPlacement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCLOOP] = (d) => { + return IfcLoop.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMANIFOLDSOLIDBREP] = (d) => { + return IfcManifoldSolidBrep.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMAPCONVERSION] = (d) => { + return IfcMapConversion.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMAPPEDITEM] = (d) => { + return IfcMappedItem.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMATERIAL] = (d) => { + return IfcMaterial.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMATERIALCLASSIFICATIONRELATIONSHIP] = (d) => { + return IfcMaterialClassificationRelationship.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMATERIALCONSTITUENT] = (d) => { + return IfcMaterialConstituent.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMATERIALCONSTITUENTSET] = (d) => { + return IfcMaterialConstituentSet.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMATERIALDEFINITION] = (d) => { + return IfcMaterialDefinition.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMATERIALDEFINITIONREPRESENTATION] = (d) => { + return IfcMaterialDefinitionRepresentation.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMATERIALLAYER] = (d) => { + return IfcMaterialLayer.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMATERIALLAYERSET] = (d) => { + return IfcMaterialLayerSet.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMATERIALLAYERSETUSAGE] = (d) => { + return IfcMaterialLayerSetUsage.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMATERIALLAYERWITHOFFSETS] = (d) => { + return IfcMaterialLayerWithOffsets.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMATERIALLIST] = (d) => { + return IfcMaterialList.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMATERIALPROFILE] = (d) => { + return IfcMaterialProfile.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMATERIALPROFILESET] = (d) => { + return IfcMaterialProfileSet.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMATERIALPROFILESETUSAGE] = (d) => { + return IfcMaterialProfileSetUsage.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMATERIALPROFILESETUSAGETAPERING] = (d) => { + return IfcMaterialProfileSetUsageTapering.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMATERIALPROFILEWITHOFFSETS] = (d) => { + return IfcMaterialProfileWithOffsets.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMATERIALPROPERTIES] = (d) => { + return IfcMaterialProperties.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMATERIALRELATIONSHIP] = (d) => { + return IfcMaterialRelationship.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMATERIALUSAGEDEFINITION] = (d) => { + return IfcMaterialUsageDefinition.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMEASUREWITHUNIT] = (d) => { + return IfcMeasureWithUnit.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMECHANICALFASTENER] = (d) => { + return IfcMechanicalFastener.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMECHANICALFASTENERTYPE] = (d) => { + return IfcMechanicalFastenerType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMEDICALDEVICE] = (d) => { + return IfcMedicalDevice.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMEDICALDEVICETYPE] = (d) => { + return IfcMedicalDeviceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMEMBER] = (d) => { + return IfcMember.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMEMBERSTANDARDCASE] = (d) => { + return IfcMemberStandardCase.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMEMBERTYPE] = (d) => { + return IfcMemberType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMETRIC] = (d) => { + return IfcMetric.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMIRROREDPROFILEDEF] = (d) => { + return IfcMirroredProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMONETARYUNIT] = (d) => { + return IfcMonetaryUnit.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMOTORCONNECTION] = (d) => { + return IfcMotorConnection.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCMOTORCONNECTIONTYPE] = (d) => { + return IfcMotorConnectionType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCNAMEDUNIT] = (d) => { + return IfcNamedUnit.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCOBJECT] = (d) => { + return IfcObject.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCOBJECTDEFINITION] = (d) => { + return IfcObjectDefinition.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCOBJECTPLACEMENT] = (d) => { + return IfcObjectPlacement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCOBJECTIVE] = (d) => { + return IfcObjective.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCOCCUPANT] = (d) => { + return IfcOccupant.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCOFFSETCURVE] = (d) => { + return IfcOffsetCurve.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCOFFSETCURVE2D] = (d) => { + return IfcOffsetCurve2D.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCOFFSETCURVE3D] = (d) => { + return IfcOffsetCurve3D.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCOFFSETCURVEBYDISTANCES] = (d) => { + return IfcOffsetCurveByDistances.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCOPENSHELL] = (d) => { + return IfcOpenShell.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCOPENINGELEMENT] = (d) => { + return IfcOpeningElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCOPENINGSTANDARDCASE] = (d) => { + return IfcOpeningStandardCase.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCORGANIZATION] = (d) => { + return IfcOrganization.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCORGANIZATIONRELATIONSHIP] = (d) => { + return IfcOrganizationRelationship.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCORIENTATIONEXPRESSION] = (d) => { + return IfcOrientationExpression.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCORIENTEDEDGE] = (d) => { + return IfcOrientedEdge.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCOUTERBOUNDARYCURVE] = (d) => { + return IfcOuterBoundaryCurve.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCOUTLET] = (d) => { + return IfcOutlet.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCOUTLETTYPE] = (d) => { + return IfcOutletType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCOWNERHISTORY] = (d) => { + return IfcOwnerHistory.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPARAMETERIZEDPROFILEDEF] = (d) => { + return IfcParameterizedProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPATH] = (d) => { + return IfcPath.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPCURVE] = (d) => { + return IfcPcurve.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPERFORMANCEHISTORY] = (d) => { + return IfcPerformanceHistory.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPERMEABLECOVERINGPROPERTIES] = (d) => { + return IfcPermeableCoveringProperties.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPERMIT] = (d) => { + return IfcPermit.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPERSON] = (d) => { + return IfcPerson.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPERSONANDORGANIZATION] = (d) => { + return IfcPersonAndOrganization.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPHYSICALCOMPLEXQUANTITY] = (d) => { + return IfcPhysicalComplexQuantity.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPHYSICALQUANTITY] = (d) => { + return IfcPhysicalQuantity.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPHYSICALSIMPLEQUANTITY] = (d) => { + return IfcPhysicalSimpleQuantity.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPILE] = (d) => { + return IfcPile.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPILETYPE] = (d) => { + return IfcPileType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPIPEFITTING] = (d) => { + return IfcPipeFitting.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPIPEFITTINGTYPE] = (d) => { + return IfcPipeFittingType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPIPESEGMENT] = (d) => { + return IfcPipeSegment.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPIPESEGMENTTYPE] = (d) => { + return IfcPipeSegmentType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPIXELTEXTURE] = (d) => { + return IfcPixelTexture.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPLACEMENT] = (d) => { + return IfcPlacement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPLANARBOX] = (d) => { + return IfcPlanarBox.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPLANAREXTENT] = (d) => { + return IfcPlanarExtent.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPLANE] = (d) => { + return IfcPlane.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPLATE] = (d) => { + return IfcPlate.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPLATESTANDARDCASE] = (d) => { + return IfcPlateStandardCase.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPLATETYPE] = (d) => { + return IfcPlateType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPOINT] = (d) => { + return IfcPoint.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPOINTONCURVE] = (d) => { + return IfcPointOnCurve.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPOINTONSURFACE] = (d) => { + return IfcPointOnSurface.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPOLYLOOP] = (d) => { + return IfcPolyLoop.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPOLYGONALBOUNDEDHALFSPACE] = (d) => { + return IfcPolygonalBoundedHalfSpace.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPOLYGONALFACESET] = (d) => { + return IfcPolygonalFaceSet.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPOLYLINE] = (d) => { + return IfcPolyline.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPORT] = (d) => { + return IfcPort.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPOSITIONINGELEMENT] = (d) => { + return IfcPositioningElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPOSTALADDRESS] = (d) => { + return IfcPostalAddress.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPREDEFINEDCOLOUR] = (d) => { + return IfcPreDefinedColour.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPREDEFINEDCURVEFONT] = (d) => { + return IfcPreDefinedCurveFont.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPREDEFINEDITEM] = (d) => { + return IfcPreDefinedItem.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPREDEFINEDPROPERTIES] = (d) => { + return IfcPreDefinedProperties.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPREDEFINEDPROPERTYSET] = (d) => { + return IfcPreDefinedPropertySet.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPREDEFINEDTEXTFONT] = (d) => { + return IfcPreDefinedTextFont.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPRESENTATIONITEM] = (d) => { + return IfcPresentationItem.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPRESENTATIONLAYERASSIGNMENT] = (d) => { + return IfcPresentationLayerAssignment.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPRESENTATIONLAYERWITHSTYLE] = (d) => { + return IfcPresentationLayerWithStyle.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPRESENTATIONSTYLE] = (d) => { + return IfcPresentationStyle.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPRESENTATIONSTYLEASSIGNMENT] = (d) => { + return IfcPresentationStyleAssignment.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROCEDURE] = (d) => { + return IfcProcedure.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROCEDURETYPE] = (d) => { + return IfcProcedureType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROCESS] = (d) => { + return IfcProcess.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPRODUCT] = (d) => { + return IfcProduct.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPRODUCTDEFINITIONSHAPE] = (d) => { + return IfcProductDefinitionShape.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPRODUCTREPRESENTATION] = (d) => { + return IfcProductRepresentation.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROFILEDEF] = (d) => { + return IfcProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROFILEPROPERTIES] = (d) => { + return IfcProfileProperties.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROJECT] = (d) => { + return IfcProject.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROJECTLIBRARY] = (d) => { + return IfcProjectLibrary.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROJECTORDER] = (d) => { + return IfcProjectOrder.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROJECTEDCRS] = (d) => { + return IfcProjectedCRS.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROJECTIONELEMENT] = (d) => { + return IfcProjectionElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROPERTY] = (d) => { + return IfcProperty.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROPERTYABSTRACTION] = (d) => { + return IfcPropertyAbstraction.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROPERTYBOUNDEDVALUE] = (d) => { + return IfcPropertyBoundedValue.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROPERTYDEFINITION] = (d) => { + return IfcPropertyDefinition.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROPERTYDEPENDENCYRELATIONSHIP] = (d) => { + return IfcPropertyDependencyRelationship.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROPERTYENUMERATEDVALUE] = (d) => { + return IfcPropertyEnumeratedValue.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROPERTYENUMERATION] = (d) => { + return IfcPropertyEnumeration.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROPERTYLISTVALUE] = (d) => { + return IfcPropertyListValue.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROPERTYREFERENCEVALUE] = (d) => { + return IfcPropertyReferenceValue.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROPERTYSET] = (d) => { + return IfcPropertySet.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROPERTYSETDEFINITION] = (d) => { + return IfcPropertySetDefinition.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROPERTYSETTEMPLATE] = (d) => { + return IfcPropertySetTemplate.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROPERTYSINGLEVALUE] = (d) => { + return IfcPropertySingleValue.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROPERTYTABLEVALUE] = (d) => { + return IfcPropertyTableValue.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROPERTYTEMPLATE] = (d) => { + return IfcPropertyTemplate.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROPERTYTEMPLATEDEFINITION] = (d) => { + return IfcPropertyTemplateDefinition.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROTECTIVEDEVICE] = (d) => { + return IfcProtectiveDevice.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROTECTIVEDEVICETRIPPINGUNIT] = (d) => { + return IfcProtectiveDeviceTrippingUnit.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROTECTIVEDEVICETRIPPINGUNITTYPE] = (d) => { + return IfcProtectiveDeviceTrippingUnitType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROTECTIVEDEVICETYPE] = (d) => { + return IfcProtectiveDeviceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPROXY] = (d) => { + return IfcProxy.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPUMP] = (d) => { + return IfcPump.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCPUMPTYPE] = (d) => { + return IfcPumpType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCQUANTITYAREA] = (d) => { + return IfcQuantityArea.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCQUANTITYCOUNT] = (d) => { + return IfcQuantityCount.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCQUANTITYLENGTH] = (d) => { + return IfcQuantityLength.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCQUANTITYSET] = (d) => { + return IfcQuantitySet.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCQUANTITYTIME] = (d) => { + return IfcQuantityTime.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCQUANTITYVOLUME] = (d) => { + return IfcQuantityVolume.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCQUANTITYWEIGHT] = (d) => { + return IfcQuantityWeight.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRAILING] = (d) => { + return IfcRailing.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRAILINGTYPE] = (d) => { + return IfcRailingType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRAMP] = (d) => { + return IfcRamp.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRAMPFLIGHT] = (d) => { + return IfcRampFlight.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRAMPFLIGHTTYPE] = (d) => { + return IfcRampFlightType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRAMPTYPE] = (d) => { + return IfcRampType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRATIONALBSPLINECURVEWITHKNOTS] = (d) => { + return IfcRationalBSplineCurveWithKnots.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRATIONALBSPLINESURFACEWITHKNOTS] = (d) => { + return IfcRationalBSplineSurfaceWithKnots.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRECTANGLEHOLLOWPROFILEDEF] = (d) => { + return IfcRectangleHollowProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRECTANGLEPROFILEDEF] = (d) => { + return IfcRectangleProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRECTANGULARPYRAMID] = (d) => { + return IfcRectangularPyramid.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRECTANGULARTRIMMEDSURFACE] = (d) => { + return IfcRectangularTrimmedSurface.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRECURRENCEPATTERN] = (d) => { + return IfcRecurrencePattern.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCREFERENCE] = (d) => { + return IfcReference.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCREFERENT] = (d) => { + return IfcReferent.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCREGULARTIMESERIES] = (d) => { + return IfcRegularTimeSeries.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCREINFORCEMENTBARPROPERTIES] = (d) => { + return IfcReinforcementBarProperties.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCREINFORCEMENTDEFINITIONPROPERTIES] = (d) => { + return IfcReinforcementDefinitionProperties.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCREINFORCINGBAR] = (d) => { + return IfcReinforcingBar.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCREINFORCINGBARTYPE] = (d) => { + return IfcReinforcingBarType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCREINFORCINGELEMENT] = (d) => { + return IfcReinforcingElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCREINFORCINGELEMENTTYPE] = (d) => { + return IfcReinforcingElementType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCREINFORCINGMESH] = (d) => { + return IfcReinforcingMesh.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCREINFORCINGMESHTYPE] = (d) => { + return IfcReinforcingMeshType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELAGGREGATES] = (d) => { + return IfcRelAggregates.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELASSIGNS] = (d) => { + return IfcRelAssigns.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELASSIGNSTOACTOR] = (d) => { + return IfcRelAssignsToActor.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELASSIGNSTOCONTROL] = (d) => { + return IfcRelAssignsToControl.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELASSIGNSTOGROUP] = (d) => { + return IfcRelAssignsToGroup.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELASSIGNSTOGROUPBYFACTOR] = (d) => { + return IfcRelAssignsToGroupByFactor.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELASSIGNSTOPROCESS] = (d) => { + return IfcRelAssignsToProcess.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELASSIGNSTOPRODUCT] = (d) => { + return IfcRelAssignsToProduct.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELASSIGNSTORESOURCE] = (d) => { + return IfcRelAssignsToResource.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELASSOCIATES] = (d) => { + return IfcRelAssociates.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELASSOCIATESAPPROVAL] = (d) => { + return IfcRelAssociatesApproval.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELASSOCIATESCLASSIFICATION] = (d) => { + return IfcRelAssociatesClassification.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELASSOCIATESCONSTRAINT] = (d) => { + return IfcRelAssociatesConstraint.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELASSOCIATESDOCUMENT] = (d) => { + return IfcRelAssociatesDocument.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELASSOCIATESLIBRARY] = (d) => { + return IfcRelAssociatesLibrary.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELASSOCIATESMATERIAL] = (d) => { + return IfcRelAssociatesMaterial.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELCONNECTS] = (d) => { + return IfcRelConnects.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELCONNECTSELEMENTS] = (d) => { + return IfcRelConnectsElements.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELCONNECTSPATHELEMENTS] = (d) => { + return IfcRelConnectsPathElements.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELCONNECTSPORTTOELEMENT] = (d) => { + return IfcRelConnectsPortToElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELCONNECTSPORTS] = (d) => { + return IfcRelConnectsPorts.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELCONNECTSSTRUCTURALACTIVITY] = (d) => { + return IfcRelConnectsStructuralActivity.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELCONNECTSSTRUCTURALMEMBER] = (d) => { + return IfcRelConnectsStructuralMember.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELCONNECTSWITHECCENTRICITY] = (d) => { + return IfcRelConnectsWithEccentricity.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELCONNECTSWITHREALIZINGELEMENTS] = (d) => { + return IfcRelConnectsWithRealizingElements.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELCONTAINEDINSPATIALSTRUCTURE] = (d) => { + return IfcRelContainedInSpatialStructure.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELCOVERSBLDGELEMENTS] = (d) => { + return IfcRelCoversBldgElements.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELCOVERSSPACES] = (d) => { + return IfcRelCoversSpaces.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELDECLARES] = (d) => { + return IfcRelDeclares.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELDECOMPOSES] = (d) => { + return IfcRelDecomposes.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELDEFINES] = (d) => { + return IfcRelDefines.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELDEFINESBYOBJECT] = (d) => { + return IfcRelDefinesByObject.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELDEFINESBYPROPERTIES] = (d) => { + return IfcRelDefinesByProperties.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELDEFINESBYTEMPLATE] = (d) => { + return IfcRelDefinesByTemplate.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELDEFINESBYTYPE] = (d) => { + return IfcRelDefinesByType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELFILLSELEMENT] = (d) => { + return IfcRelFillsElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELFLOWCONTROLELEMENTS] = (d) => { + return IfcRelFlowControlElements.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELINTERFERESELEMENTS] = (d) => { + return IfcRelInterferesElements.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELNESTS] = (d) => { + return IfcRelNests.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELPOSITIONS] = (d) => { + return IfcRelPositions.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELPROJECTSELEMENT] = (d) => { + return IfcRelProjectsElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELREFERENCEDINSPATIALSTRUCTURE] = (d) => { + return IfcRelReferencedInSpatialStructure.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELSEQUENCE] = (d) => { + return IfcRelSequence.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELSERVICESBUILDINGS] = (d) => { + return IfcRelServicesBuildings.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELSPACEBOUNDARY] = (d) => { + return IfcRelSpaceBoundary.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELSPACEBOUNDARY1STLEVEL] = (d) => { + return IfcRelSpaceBoundary1stLevel.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELSPACEBOUNDARY2NDLEVEL] = (d) => { + return IfcRelSpaceBoundary2ndLevel.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELVOIDSELEMENT] = (d) => { + return IfcRelVoidsElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRELATIONSHIP] = (d) => { + return IfcRelationship.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCREPARAMETRISEDCOMPOSITECURVESEGMENT] = (d) => { + return IfcReparametrisedCompositeCurveSegment.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCREPRESENTATION] = (d) => { + return IfcRepresentation.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCREPRESENTATIONCONTEXT] = (d) => { + return IfcRepresentationContext.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCREPRESENTATIONITEM] = (d) => { + return IfcRepresentationItem.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCREPRESENTATIONMAP] = (d) => { + return IfcRepresentationMap.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRESOURCE] = (d) => { + return IfcResource.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRESOURCEAPPROVALRELATIONSHIP] = (d) => { + return IfcResourceApprovalRelationship.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRESOURCECONSTRAINTRELATIONSHIP] = (d) => { + return IfcResourceConstraintRelationship.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRESOURCELEVELRELATIONSHIP] = (d) => { + return IfcResourceLevelRelationship.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRESOURCETIME] = (d) => { + return IfcResourceTime.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCREVOLVEDAREASOLID] = (d) => { + return IfcRevolvedAreaSolid.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCREVOLVEDAREASOLIDTAPERED] = (d) => { + return IfcRevolvedAreaSolidTapered.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRIGHTCIRCULARCONE] = (d) => { + return IfcRightCircularCone.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCRIGHTCIRCULARCYLINDER] = (d) => { + return IfcRightCircularCylinder.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCROOF] = (d) => { + return IfcRoof.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCROOFTYPE] = (d) => { + return IfcRoofType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCROOT] = (d) => { + return IfcRoot.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCROUNDEDRECTANGLEPROFILEDEF] = (d) => { + return IfcRoundedRectangleProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSIUNIT] = (d) => { + return IfcSIUnit.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSANITARYTERMINAL] = (d) => { + return IfcSanitaryTerminal.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSANITARYTERMINALTYPE] = (d) => { + return IfcSanitaryTerminalType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSCHEDULINGTIME] = (d) => { + return IfcSchedulingTime.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSEAMCURVE] = (d) => { + return IfcSeamCurve.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSECTIONPROPERTIES] = (d) => { + return IfcSectionProperties.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSECTIONREINFORCEMENTPROPERTIES] = (d) => { + return IfcSectionReinforcementProperties.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSECTIONEDSOLID] = (d) => { + return IfcSectionedSolid.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSECTIONEDSOLIDHORIZONTAL] = (d) => { + return IfcSectionedSolidHorizontal.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSECTIONEDSPINE] = (d) => { + return IfcSectionedSpine.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSENSOR] = (d) => { + return IfcSensor.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSENSORTYPE] = (d) => { + return IfcSensorType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSHADINGDEVICE] = (d) => { + return IfcShadingDevice.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSHADINGDEVICETYPE] = (d) => { + return IfcShadingDeviceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSHAPEASPECT] = (d) => { + return IfcShapeAspect.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSHAPEMODEL] = (d) => { + return IfcShapeModel.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSHAPEREPRESENTATION] = (d) => { + return IfcShapeRepresentation.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSHELLBASEDSURFACEMODEL] = (d) => { + return IfcShellBasedSurfaceModel.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSIMPLEPROPERTY] = (d) => { + return IfcSimpleProperty.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSIMPLEPROPERTYTEMPLATE] = (d) => { + return IfcSimplePropertyTemplate.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSITE] = (d) => { + return IfcSite.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSLAB] = (d) => { + return IfcSlab.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSLABELEMENTEDCASE] = (d) => { + return IfcSlabElementedCase.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSLABSTANDARDCASE] = (d) => { + return IfcSlabStandardCase.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSLABTYPE] = (d) => { + return IfcSlabType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSLIPPAGECONNECTIONCONDITION] = (d) => { + return IfcSlippageConnectionCondition.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSOLARDEVICE] = (d) => { + return IfcSolarDevice.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSOLARDEVICETYPE] = (d) => { + return IfcSolarDeviceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSOLIDMODEL] = (d) => { + return IfcSolidModel.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSPACE] = (d) => { + return IfcSpace.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSPACEHEATER] = (d) => { + return IfcSpaceHeater.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSPACEHEATERTYPE] = (d) => { + return IfcSpaceHeaterType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSPACETYPE] = (d) => { + return IfcSpaceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSPATIALELEMENT] = (d) => { + return IfcSpatialElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSPATIALELEMENTTYPE] = (d) => { + return IfcSpatialElementType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSPATIALSTRUCTUREELEMENT] = (d) => { + return IfcSpatialStructureElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSPATIALSTRUCTUREELEMENTTYPE] = (d) => { + return IfcSpatialStructureElementType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSPATIALZONE] = (d) => { + return IfcSpatialZone.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSPATIALZONETYPE] = (d) => { + return IfcSpatialZoneType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSPHERE] = (d) => { + return IfcSphere.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSPHERICALSURFACE] = (d) => { + return IfcSphericalSurface.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTACKTERMINAL] = (d) => { + return IfcStackTerminal.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTACKTERMINALTYPE] = (d) => { + return IfcStackTerminalType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTAIR] = (d) => { + return IfcStair.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTAIRFLIGHT] = (d) => { + return IfcStairFlight.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTAIRFLIGHTTYPE] = (d) => { + return IfcStairFlightType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTAIRTYPE] = (d) => { + return IfcStairType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALACTION] = (d) => { + return IfcStructuralAction.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALACTIVITY] = (d) => { + return IfcStructuralActivity.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALANALYSISMODEL] = (d) => { + return IfcStructuralAnalysisModel.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALCONNECTION] = (d) => { + return IfcStructuralConnection.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALCONNECTIONCONDITION] = (d) => { + return IfcStructuralConnectionCondition.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALCURVEACTION] = (d) => { + return IfcStructuralCurveAction.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALCURVECONNECTION] = (d) => { + return IfcStructuralCurveConnection.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALCURVEMEMBER] = (d) => { + return IfcStructuralCurveMember.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALCURVEMEMBERVARYING] = (d) => { + return IfcStructuralCurveMemberVarying.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALCURVEREACTION] = (d) => { + return IfcStructuralCurveReaction.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALITEM] = (d) => { + return IfcStructuralItem.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALLINEARACTION] = (d) => { + return IfcStructuralLinearAction.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALLOAD] = (d) => { + return IfcStructuralLoad.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALLOADCASE] = (d) => { + return IfcStructuralLoadCase.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALLOADCONFIGURATION] = (d) => { + return IfcStructuralLoadConfiguration.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALLOADGROUP] = (d) => { + return IfcStructuralLoadGroup.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALLOADLINEARFORCE] = (d) => { + return IfcStructuralLoadLinearForce.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALLOADORRESULT] = (d) => { + return IfcStructuralLoadOrResult.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALLOADPLANARFORCE] = (d) => { + return IfcStructuralLoadPlanarForce.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALLOADSINGLEDISPLACEMENT] = (d) => { + return IfcStructuralLoadSingleDisplacement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALLOADSINGLEDISPLACEMENTDISTORTION] = (d) => { + return IfcStructuralLoadSingleDisplacementDistortion.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALLOADSINGLEFORCE] = (d) => { + return IfcStructuralLoadSingleForce.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALLOADSINGLEFORCEWARPING] = (d) => { + return IfcStructuralLoadSingleForceWarping.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALLOADSTATIC] = (d) => { + return IfcStructuralLoadStatic.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALLOADTEMPERATURE] = (d) => { + return IfcStructuralLoadTemperature.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALMEMBER] = (d) => { + return IfcStructuralMember.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALPLANARACTION] = (d) => { + return IfcStructuralPlanarAction.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALPOINTACTION] = (d) => { + return IfcStructuralPointAction.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALPOINTCONNECTION] = (d) => { + return IfcStructuralPointConnection.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALPOINTREACTION] = (d) => { + return IfcStructuralPointReaction.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALREACTION] = (d) => { + return IfcStructuralReaction.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALRESULTGROUP] = (d) => { + return IfcStructuralResultGroup.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALSURFACEACTION] = (d) => { + return IfcStructuralSurfaceAction.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALSURFACECONNECTION] = (d) => { + return IfcStructuralSurfaceConnection.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALSURFACEMEMBER] = (d) => { + return IfcStructuralSurfaceMember.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALSURFACEMEMBERVARYING] = (d) => { + return IfcStructuralSurfaceMemberVarying.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTRUCTURALSURFACEREACTION] = (d) => { + return IfcStructuralSurfaceReaction.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTYLEMODEL] = (d) => { + return IfcStyleModel.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTYLEDITEM] = (d) => { + return IfcStyledItem.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSTYLEDREPRESENTATION] = (d) => { + return IfcStyledRepresentation.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSUBCONTRACTRESOURCE] = (d) => { + return IfcSubContractResource.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSUBCONTRACTRESOURCETYPE] = (d) => { + return IfcSubContractResourceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSUBEDGE] = (d) => { + return IfcSubedge.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSURFACE] = (d) => { + return IfcSurface.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSURFACECURVE] = (d) => { + return IfcSurfaceCurve.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSURFACECURVESWEPTAREASOLID] = (d) => { + return IfcSurfaceCurveSweptAreaSolid.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSURFACEFEATURE] = (d) => { + return IfcSurfaceFeature.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSURFACEOFLINEAREXTRUSION] = (d) => { + return IfcSurfaceOfLinearExtrusion.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSURFACEOFREVOLUTION] = (d) => { + return IfcSurfaceOfRevolution.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSURFACEREINFORCEMENTAREA] = (d) => { + return IfcSurfaceReinforcementArea.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSURFACESTYLE] = (d) => { + return IfcSurfaceStyle.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSURFACESTYLELIGHTING] = (d) => { + return IfcSurfaceStyleLighting.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSURFACESTYLEREFRACTION] = (d) => { + return IfcSurfaceStyleRefraction.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSURFACESTYLERENDERING] = (d) => { + return IfcSurfaceStyleRendering.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSURFACESTYLESHADING] = (d) => { + return IfcSurfaceStyleShading.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSURFACESTYLEWITHTEXTURES] = (d) => { + return IfcSurfaceStyleWithTextures.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSURFACETEXTURE] = (d) => { + return IfcSurfaceTexture.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSWEPTAREASOLID] = (d) => { + return IfcSweptAreaSolid.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSWEPTDISKSOLID] = (d) => { + return IfcSweptDiskSolid.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSWEPTDISKSOLIDPOLYGONAL] = (d) => { + return IfcSweptDiskSolidPolygonal.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSWEPTSURFACE] = (d) => { + return IfcSweptSurface.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSWITCHINGDEVICE] = (d) => { + return IfcSwitchingDevice.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSWITCHINGDEVICETYPE] = (d) => { + return IfcSwitchingDeviceType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSYSTEM] = (d) => { + return IfcSystem.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSYSTEMFURNITUREELEMENT] = (d) => { + return IfcSystemFurnitureElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCSYSTEMFURNITUREELEMENTTYPE] = (d) => { + return IfcSystemFurnitureElementType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTSHAPEPROFILEDEF] = (d) => { + return IfcTShapeProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTABLE] = (d) => { + return IfcTable.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTABLECOLUMN] = (d) => { + return IfcTableColumn.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTABLEROW] = (d) => { + return IfcTableRow.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTANK] = (d) => { + return IfcTank.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTANKTYPE] = (d) => { + return IfcTankType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTASK] = (d) => { + return IfcTask.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTASKTIME] = (d) => { + return IfcTaskTime.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTASKTIMERECURRING] = (d) => { + return IfcTaskTimeRecurring.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTASKTYPE] = (d) => { + return IfcTaskType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTELECOMADDRESS] = (d) => { + return IfcTelecomAddress.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTENDON] = (d) => { + return IfcTendon.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTENDONANCHOR] = (d) => { + return IfcTendonAnchor.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTENDONANCHORTYPE] = (d) => { + return IfcTendonAnchorType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTENDONCONDUIT] = (d) => { + return IfcTendonConduit.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTENDONCONDUITTYPE] = (d) => { + return IfcTendonConduitType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTENDONTYPE] = (d) => { + return IfcTendonType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTESSELLATEDFACESET] = (d) => { + return IfcTessellatedFaceSet.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTESSELLATEDITEM] = (d) => { + return IfcTessellatedItem.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTEXTLITERAL] = (d) => { + return IfcTextLiteral.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTEXTLITERALWITHEXTENT] = (d) => { + return IfcTextLiteralWithExtent.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTEXTSTYLE] = (d) => { + return IfcTextStyle.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTEXTSTYLEFONTMODEL] = (d) => { + return IfcTextStyleFontModel.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTEXTSTYLEFORDEFINEDFONT] = (d) => { + return IfcTextStyleForDefinedFont.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTEXTSTYLETEXTMODEL] = (d) => { + return IfcTextStyleTextModel.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTEXTURECOORDINATE] = (d) => { + return IfcTextureCoordinate.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTEXTURECOORDINATEGENERATOR] = (d) => { + return IfcTextureCoordinateGenerator.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTEXTUREMAP] = (d) => { + return IfcTextureMap.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTEXTUREVERTEX] = (d) => { + return IfcTextureVertex.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTEXTUREVERTEXLIST] = (d) => { + return IfcTextureVertexList.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTIMEPERIOD] = (d) => { + return IfcTimePeriod.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTIMESERIES] = (d) => { + return IfcTimeSeries.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTIMESERIESVALUE] = (d) => { + return IfcTimeSeriesValue.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTOPOLOGICALREPRESENTATIONITEM] = (d) => { + return IfcTopologicalRepresentationItem.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTOPOLOGYREPRESENTATION] = (d) => { + return IfcTopologyRepresentation.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTOROIDALSURFACE] = (d) => { + return IfcToroidalSurface.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTRANSFORMER] = (d) => { + return IfcTransformer.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTRANSFORMERTYPE] = (d) => { + return IfcTransformerType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTRANSITIONCURVESEGMENT2D] = (d) => { + return IfcTransitionCurveSegment2D.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTRANSPORTELEMENT] = (d) => { + return IfcTransportElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTRANSPORTELEMENTTYPE] = (d) => { + return IfcTransportElementType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTRAPEZIUMPROFILEDEF] = (d) => { + return IfcTrapeziumProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTRIANGULATEDFACESET] = (d) => { + return IfcTriangulatedFaceSet.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTRIANGULATEDIRREGULARNETWORK] = (d) => { + return IfcTriangulatedIrregularNetwork.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTRIMMEDCURVE] = (d) => { + return IfcTrimmedCurve.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTUBEBUNDLE] = (d) => { + return IfcTubeBundle.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTUBEBUNDLETYPE] = (d) => { + return IfcTubeBundleType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTYPEOBJECT] = (d) => { + return IfcTypeObject.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTYPEPROCESS] = (d) => { + return IfcTypeProcess.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTYPEPRODUCT] = (d) => { + return IfcTypeProduct.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCTYPERESOURCE] = (d) => { + return IfcTypeResource.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCUSHAPEPROFILEDEF] = (d) => { + return IfcUShapeProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCUNITASSIGNMENT] = (d) => { + return IfcUnitAssignment.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCUNITARYCONTROLELEMENT] = (d) => { + return IfcUnitaryControlElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCUNITARYCONTROLELEMENTTYPE] = (d) => { + return IfcUnitaryControlElementType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCUNITARYEQUIPMENT] = (d) => { + return IfcUnitaryEquipment.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCUNITARYEQUIPMENTTYPE] = (d) => { + return IfcUnitaryEquipmentType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCVALVE] = (d) => { + return IfcValve.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCVALVETYPE] = (d) => { + return IfcValveType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCVECTOR] = (d) => { + return IfcVector.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCVERTEX] = (d) => { + return IfcVertex.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCVERTEXLOOP] = (d) => { + return IfcVertexLoop.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCVERTEXPOINT] = (d) => { + return IfcVertexPoint.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCVIBRATIONDAMPER] = (d) => { + return IfcVibrationDamper.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCVIBRATIONDAMPERTYPE] = (d) => { + return IfcVibrationDamperType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCVIBRATIONISOLATOR] = (d) => { + return IfcVibrationIsolator.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCVIBRATIONISOLATORTYPE] = (d) => { + return IfcVibrationIsolatorType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCVIRTUALELEMENT] = (d) => { + return IfcVirtualElement.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCVIRTUALGRIDINTERSECTION] = (d) => { + return IfcVirtualGridIntersection.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCVOIDINGFEATURE] = (d) => { + return IfcVoidingFeature.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCWALL] = (d) => { + return IfcWall.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCWALLELEMENTEDCASE] = (d) => { + return IfcWallElementedCase.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCWALLSTANDARDCASE] = (d) => { + return IfcWallStandardCase.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCWALLTYPE] = (d) => { + return IfcWallType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCWASTETERMINAL] = (d) => { + return IfcWasteTerminal.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCWASTETERMINALTYPE] = (d) => { + return IfcWasteTerminalType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCWINDOW] = (d) => { + return IfcWindow.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCWINDOWLININGPROPERTIES] = (d) => { + return IfcWindowLiningProperties.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCWINDOWPANELPROPERTIES] = (d) => { + return IfcWindowPanelProperties.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCWINDOWSTANDARDCASE] = (d) => { + return IfcWindowStandardCase.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCWINDOWSTYLE] = (d) => { + return IfcWindowStyle.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCWINDOWTYPE] = (d) => { + return IfcWindowType.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCWORKCALENDAR] = (d) => { + return IfcWorkCalendar.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCWORKCONTROL] = (d) => { + return IfcWorkControl.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCWORKPLAN] = (d) => { + return IfcWorkPlan.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCWORKSCHEDULE] = (d) => { + return IfcWorkSchedule.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCWORKTIME] = (d) => { + return IfcWorkTime.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCZSHAPEPROFILEDEF] = (d) => { + return IfcZShapeProfileDef.FromTape(d.ID, d.type, d.arguments); +}; +FromRawLineData[IFCZONE] = (d) => { + return IfcZone.FromTape(d.ID, d.type, d.arguments); +}; +var Handle = class { + constructor(id) { + this.value = id; + } + toTape(args) { + args.push({type: 5, value: this.value}); + } +}; +function Value(type, value) { + return {t: type, v: value}; +} +var IfcAbsorbedDoseMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcAccelerationMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcAmountOfSubstanceMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcAngularVelocityMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcAreaDensityMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcAreaMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcBinary = class { + constructor(v) { + this.value = v; + } +}; +var IfcBoolean = class { + constructor(v) { + this.value = v; + } +}; +var IfcBoxAlignment = class { + constructor(v) { + this.value = v; + } +}; +var IfcCardinalPointReference = class { + constructor(v) { + this.value = v; + } +}; +var IfcContextDependentMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcCountMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcCurvatureMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcDate = class { + constructor(v) { + this.value = v; + } +}; +var IfcDateTime = class { + constructor(v) { + this.value = v; + } +}; +var IfcDayInMonthNumber = class { + constructor(v) { + this.value = v; + } +}; +var IfcDayInWeekNumber = class { + constructor(v) { + this.value = v; + } +}; +var IfcDescriptiveMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcDimensionCount = class { + constructor(v) { + this.value = v; + } +}; +var IfcDoseEquivalentMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcDuration = class { + constructor(v) { + this.value = v; + } +}; +var IfcDynamicViscosityMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcElectricCapacitanceMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcElectricChargeMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcElectricConductanceMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcElectricCurrentMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcElectricResistanceMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcElectricVoltageMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcEnergyMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcFontStyle = class { + constructor(v) { + this.value = v; + } +}; +var IfcFontVariant = class { + constructor(v) { + this.value = v; + } +}; +var IfcFontWeight = class { + constructor(v) { + this.value = v; + } +}; +var IfcForceMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcFrequencyMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcGloballyUniqueId = class { + constructor(v) { + this.value = v; + } +}; +var IfcHeatFluxDensityMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcHeatingValueMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcIdentifier = class { + constructor(v) { + this.value = v; + } +}; +var IfcIlluminanceMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcInductanceMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcInteger = class { + constructor(v) { + this.value = v; + } +}; +var IfcIntegerCountRateMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcIonConcentrationMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcIsothermalMoistureCapacityMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcKinematicViscosityMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcLabel = class { + constructor(v) { + this.value = v; + } +}; +var IfcLanguageId = class { + constructor(v) { + this.value = v; + } +}; +var IfcLengthMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcLinearForceMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcLinearMomentMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcLinearStiffnessMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcLinearVelocityMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcLogical = class { + constructor(v) { + this.value = v; + } +}; +var IfcLuminousFluxMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcLuminousIntensityDistributionMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcLuminousIntensityMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcMagneticFluxDensityMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcMagneticFluxMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcMassDensityMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcMassFlowRateMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcMassMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcMassPerLengthMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcModulusOfElasticityMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcModulusOfLinearSubgradeReactionMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcModulusOfRotationalSubgradeReactionMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcModulusOfSubgradeReactionMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcMoistureDiffusivityMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcMolecularWeightMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcMomentOfInertiaMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcMonetaryMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcMonthInYearNumber = class { + constructor(v) { + this.value = v; + } +}; +var IfcNonNegativeLengthMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcNormalisedRatioMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcNumericMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcPHMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcParameterValue = class { + constructor(v) { + this.value = v; + } +}; +var IfcPlanarForceMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcPlaneAngleMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcPositiveInteger = class { + constructor(v) { + this.value = v; + } +}; +var IfcPositiveLengthMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcPositivePlaneAngleMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcPositiveRatioMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcPowerMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcPresentableText = class { + constructor(v) { + this.value = v; + } +}; +var IfcPressureMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcRadioActivityMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcRatioMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcReal = class { + constructor(v) { + this.value = v; + } +}; +var IfcRotationalFrequencyMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcRotationalMassMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcRotationalStiffnessMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcSectionModulusMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcSectionalAreaIntegralMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcShearModulusMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcSolidAngleMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcSoundPowerLevelMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcSoundPowerMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcSoundPressureLevelMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcSoundPressureMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcSpecificHeatCapacityMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcSpecularExponent = class { + constructor(v) { + this.value = v; + } +}; +var IfcSpecularRoughness = class { + constructor(v) { + this.value = v; + } +}; +var IfcTemperatureGradientMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcTemperatureRateOfChangeMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcText = class { + constructor(v) { + this.value = v; + } +}; +var IfcTextAlignment = class { + constructor(v) { + this.value = v; + } +}; +var IfcTextDecoration = class { + constructor(v) { + this.value = v; + } +}; +var IfcTextFontName = class { + constructor(v) { + this.value = v; + } +}; +var IfcTextTransformation = class { + constructor(v) { + this.value = v; + } +}; +var IfcThermalAdmittanceMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcThermalConductivityMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcThermalExpansionCoefficientMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcThermalResistanceMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcThermalTransmittanceMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcThermodynamicTemperatureMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcTime = class { + constructor(v) { + this.value = v; + } +}; +var IfcTimeMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcTimeStamp = class { + constructor(v) { + this.value = v; + } +}; +var IfcTorqueMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcURIReference = class { + constructor(v) { + this.value = v; + } +}; +var IfcVaporPermeabilityMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcVolumeMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcVolumetricFlowRateMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcWarpingConstantMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcWarpingMomentMeasure = class { + constructor(v) { + this.value = v; + } +}; +var IfcActionRequestTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcActionRequestTypeEnum.EMAIL = "EMAIL"; +IfcActionRequestTypeEnum.FAX = "FAX"; +IfcActionRequestTypeEnum.PHONE = "PHONE"; +IfcActionRequestTypeEnum.POST = "POST"; +IfcActionRequestTypeEnum.VERBAL = "VERBAL"; +IfcActionRequestTypeEnum.USERDEFINED = "USERDEFINED"; +IfcActionRequestTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcActionSourceTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcActionSourceTypeEnum.DEAD_LOAD_G = "DEAD_LOAD_G"; +IfcActionSourceTypeEnum.COMPLETION_G1 = "COMPLETION_G1"; +IfcActionSourceTypeEnum.LIVE_LOAD_Q = "LIVE_LOAD_Q"; +IfcActionSourceTypeEnum.SNOW_S = "SNOW_S"; +IfcActionSourceTypeEnum.WIND_W = "WIND_W"; +IfcActionSourceTypeEnum.PRESTRESSING_P = "PRESTRESSING_P"; +IfcActionSourceTypeEnum.SETTLEMENT_U = "SETTLEMENT_U"; +IfcActionSourceTypeEnum.TEMPERATURE_T = "TEMPERATURE_T"; +IfcActionSourceTypeEnum.EARTHQUAKE_E = "EARTHQUAKE_E"; +IfcActionSourceTypeEnum.FIRE = "FIRE"; +IfcActionSourceTypeEnum.IMPULSE = "IMPULSE"; +IfcActionSourceTypeEnum.IMPACT = "IMPACT"; +IfcActionSourceTypeEnum.TRANSPORT = "TRANSPORT"; +IfcActionSourceTypeEnum.ERECTION = "ERECTION"; +IfcActionSourceTypeEnum.PROPPING = "PROPPING"; +IfcActionSourceTypeEnum.SYSTEM_IMPERFECTION = "SYSTEM_IMPERFECTION"; +IfcActionSourceTypeEnum.SHRINKAGE = "SHRINKAGE"; +IfcActionSourceTypeEnum.CREEP = "CREEP"; +IfcActionSourceTypeEnum.LACK_OF_FIT = "LACK_OF_FIT"; +IfcActionSourceTypeEnum.BUOYANCY = "BUOYANCY"; +IfcActionSourceTypeEnum.ICE = "ICE"; +IfcActionSourceTypeEnum.CURRENT = "CURRENT"; +IfcActionSourceTypeEnum.WAVE = "WAVE"; +IfcActionSourceTypeEnum.RAIN = "RAIN"; +IfcActionSourceTypeEnum.BRAKES = "BRAKES"; +IfcActionSourceTypeEnum.USERDEFINED = "USERDEFINED"; +IfcActionSourceTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcActionTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcActionTypeEnum.PERMANENT_G = "PERMANENT_G"; +IfcActionTypeEnum.VARIABLE_Q = "VARIABLE_Q"; +IfcActionTypeEnum.EXTRAORDINARY_A = "EXTRAORDINARY_A"; +IfcActionTypeEnum.USERDEFINED = "USERDEFINED"; +IfcActionTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcActuatorTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcActuatorTypeEnum.ELECTRICACTUATOR = "ELECTRICACTUATOR"; +IfcActuatorTypeEnum.HANDOPERATEDACTUATOR = "HANDOPERATEDACTUATOR"; +IfcActuatorTypeEnum.HYDRAULICACTUATOR = "HYDRAULICACTUATOR"; +IfcActuatorTypeEnum.PNEUMATICACTUATOR = "PNEUMATICACTUATOR"; +IfcActuatorTypeEnum.THERMOSTATICACTUATOR = "THERMOSTATICACTUATOR"; +IfcActuatorTypeEnum.USERDEFINED = "USERDEFINED"; +IfcActuatorTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcAddressTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcAddressTypeEnum.OFFICE = "OFFICE"; +IfcAddressTypeEnum.SITE = "SITE"; +IfcAddressTypeEnum.HOME = "HOME"; +IfcAddressTypeEnum.DISTRIBUTIONPOINT = "DISTRIBUTIONPOINT"; +IfcAddressTypeEnum.USERDEFINED = "USERDEFINED"; +var IfcAirTerminalBoxTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcAirTerminalBoxTypeEnum.CONSTANTFLOW = "CONSTANTFLOW"; +IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREDEPENDANT = "VARIABLEFLOWPRESSUREDEPENDANT"; +IfcAirTerminalBoxTypeEnum.VARIABLEFLOWPRESSUREINDEPENDANT = "VARIABLEFLOWPRESSUREINDEPENDANT"; +IfcAirTerminalBoxTypeEnum.USERDEFINED = "USERDEFINED"; +IfcAirTerminalBoxTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcAirTerminalTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcAirTerminalTypeEnum.DIFFUSER = "DIFFUSER"; +IfcAirTerminalTypeEnum.GRILLE = "GRILLE"; +IfcAirTerminalTypeEnum.LOUVRE = "LOUVRE"; +IfcAirTerminalTypeEnum.REGISTER = "REGISTER"; +IfcAirTerminalTypeEnum.USERDEFINED = "USERDEFINED"; +IfcAirTerminalTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcAirToAirHeatRecoveryTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECOUNTERFLOWEXCHANGER = "FIXEDPLATECOUNTERFLOWEXCHANGER"; +IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATECROSSFLOWEXCHANGER = "FIXEDPLATECROSSFLOWEXCHANGER"; +IfcAirToAirHeatRecoveryTypeEnum.FIXEDPLATEPARALLELFLOWEXCHANGER = "FIXEDPLATEPARALLELFLOWEXCHANGER"; +IfcAirToAirHeatRecoveryTypeEnum.ROTARYWHEEL = "ROTARYWHEEL"; +IfcAirToAirHeatRecoveryTypeEnum.RUNAROUNDCOILLOOP = "RUNAROUNDCOILLOOP"; +IfcAirToAirHeatRecoveryTypeEnum.HEATPIPE = "HEATPIPE"; +IfcAirToAirHeatRecoveryTypeEnum.TWINTOWERENTHALPYRECOVERYLOOPS = "TWINTOWERENTHALPYRECOVERYLOOPS"; +IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONSEALEDTUBEHEATEXCHANGERS = "THERMOSIPHONSEALEDTUBEHEATEXCHANGERS"; +IfcAirToAirHeatRecoveryTypeEnum.THERMOSIPHONCOILTYPEHEATEXCHANGERS = "THERMOSIPHONCOILTYPEHEATEXCHANGERS"; +IfcAirToAirHeatRecoveryTypeEnum.USERDEFINED = "USERDEFINED"; +IfcAirToAirHeatRecoveryTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcAlarmTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcAlarmTypeEnum.BELL = "BELL"; +IfcAlarmTypeEnum.BREAKGLASSBUTTON = "BREAKGLASSBUTTON"; +IfcAlarmTypeEnum.LIGHT = "LIGHT"; +IfcAlarmTypeEnum.MANUALPULLBOX = "MANUALPULLBOX"; +IfcAlarmTypeEnum.SIREN = "SIREN"; +IfcAlarmTypeEnum.WHISTLE = "WHISTLE"; +IfcAlarmTypeEnum.USERDEFINED = "USERDEFINED"; +IfcAlarmTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcAlignmentTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcAlignmentTypeEnum.USERDEFINED = "USERDEFINED"; +IfcAlignmentTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcAnalysisModelTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcAnalysisModelTypeEnum.IN_PLANE_LOADING_2D = "IN_PLANE_LOADING_2D"; +IfcAnalysisModelTypeEnum.OUT_PLANE_LOADING_2D = "OUT_PLANE_LOADING_2D"; +IfcAnalysisModelTypeEnum.LOADING_3D = "LOADING_3D"; +IfcAnalysisModelTypeEnum.USERDEFINED = "USERDEFINED"; +IfcAnalysisModelTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcAnalysisTheoryTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcAnalysisTheoryTypeEnum.FIRST_ORDER_THEORY = "FIRST_ORDER_THEORY"; +IfcAnalysisTheoryTypeEnum.SECOND_ORDER_THEORY = "SECOND_ORDER_THEORY"; +IfcAnalysisTheoryTypeEnum.THIRD_ORDER_THEORY = "THIRD_ORDER_THEORY"; +IfcAnalysisTheoryTypeEnum.FULL_NONLINEAR_THEORY = "FULL_NONLINEAR_THEORY"; +IfcAnalysisTheoryTypeEnum.USERDEFINED = "USERDEFINED"; +IfcAnalysisTheoryTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcArithmeticOperatorEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcArithmeticOperatorEnum.ADD = "ADD"; +IfcArithmeticOperatorEnum.DIVIDE = "DIVIDE"; +IfcArithmeticOperatorEnum.MULTIPLY = "MULTIPLY"; +IfcArithmeticOperatorEnum.SUBTRACT = "SUBTRACT"; +var IfcAssemblyPlaceEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcAssemblyPlaceEnum.SITE = "SITE"; +IfcAssemblyPlaceEnum.FACTORY = "FACTORY"; +IfcAssemblyPlaceEnum.NOTDEFINED = "NOTDEFINED"; +var IfcAudioVisualApplianceTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcAudioVisualApplianceTypeEnum.AMPLIFIER = "AMPLIFIER"; +IfcAudioVisualApplianceTypeEnum.CAMERA = "CAMERA"; +IfcAudioVisualApplianceTypeEnum.DISPLAY = "DISPLAY"; +IfcAudioVisualApplianceTypeEnum.MICROPHONE = "MICROPHONE"; +IfcAudioVisualApplianceTypeEnum.PLAYER = "PLAYER"; +IfcAudioVisualApplianceTypeEnum.PROJECTOR = "PROJECTOR"; +IfcAudioVisualApplianceTypeEnum.RECEIVER = "RECEIVER"; +IfcAudioVisualApplianceTypeEnum.SPEAKER = "SPEAKER"; +IfcAudioVisualApplianceTypeEnum.SWITCHER = "SWITCHER"; +IfcAudioVisualApplianceTypeEnum.TELEPHONE = "TELEPHONE"; +IfcAudioVisualApplianceTypeEnum.TUNER = "TUNER"; +IfcAudioVisualApplianceTypeEnum.USERDEFINED = "USERDEFINED"; +IfcAudioVisualApplianceTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcBSplineCurveForm = class { + constructor(v) { + this.value = v; + } +}; +IfcBSplineCurveForm.POLYLINE_FORM = "POLYLINE_FORM"; +IfcBSplineCurveForm.CIRCULAR_ARC = "CIRCULAR_ARC"; +IfcBSplineCurveForm.ELLIPTIC_ARC = "ELLIPTIC_ARC"; +IfcBSplineCurveForm.PARABOLIC_ARC = "PARABOLIC_ARC"; +IfcBSplineCurveForm.HYPERBOLIC_ARC = "HYPERBOLIC_ARC"; +IfcBSplineCurveForm.UNSPECIFIED = "UNSPECIFIED"; +var IfcBSplineSurfaceForm = class { + constructor(v) { + this.value = v; + } +}; +IfcBSplineSurfaceForm.PLANE_SURF = "PLANE_SURF"; +IfcBSplineSurfaceForm.CYLINDRICAL_SURF = "CYLINDRICAL_SURF"; +IfcBSplineSurfaceForm.CONICAL_SURF = "CONICAL_SURF"; +IfcBSplineSurfaceForm.SPHERICAL_SURF = "SPHERICAL_SURF"; +IfcBSplineSurfaceForm.TOROIDAL_SURF = "TOROIDAL_SURF"; +IfcBSplineSurfaceForm.SURF_OF_REVOLUTION = "SURF_OF_REVOLUTION"; +IfcBSplineSurfaceForm.RULED_SURF = "RULED_SURF"; +IfcBSplineSurfaceForm.GENERALISED_CONE = "GENERALISED_CONE"; +IfcBSplineSurfaceForm.QUADRIC_SURF = "QUADRIC_SURF"; +IfcBSplineSurfaceForm.SURF_OF_LINEAR_EXTRUSION = "SURF_OF_LINEAR_EXTRUSION"; +IfcBSplineSurfaceForm.UNSPECIFIED = "UNSPECIFIED"; +var IfcBeamTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcBeamTypeEnum.BEAM = "BEAM"; +IfcBeamTypeEnum.JOIST = "JOIST"; +IfcBeamTypeEnum.HOLLOWCORE = "HOLLOWCORE"; +IfcBeamTypeEnum.LINTEL = "LINTEL"; +IfcBeamTypeEnum.SPANDREL = "SPANDREL"; +IfcBeamTypeEnum.T_BEAM = "T_BEAM"; +IfcBeamTypeEnum.GIRDER_SEGMENT = "GIRDER_SEGMENT"; +IfcBeamTypeEnum.DIAPHRAGM = "DIAPHRAGM"; +IfcBeamTypeEnum.PIERCAP = "PIERCAP"; +IfcBeamTypeEnum.HATSTONE = "HATSTONE"; +IfcBeamTypeEnum.CORNICE = "CORNICE"; +IfcBeamTypeEnum.EDGEBEAM = "EDGEBEAM"; +IfcBeamTypeEnum.USERDEFINED = "USERDEFINED"; +IfcBeamTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcBearingTypeDisplacementEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcBearingTypeDisplacementEnum.FIXED_MOVEMENT = "FIXED_MOVEMENT"; +IfcBearingTypeDisplacementEnum.GUIDED_LONGITUDINAL = "GUIDED_LONGITUDINAL"; +IfcBearingTypeDisplacementEnum.GUIDED_TRANSVERSAL = "GUIDED_TRANSVERSAL"; +IfcBearingTypeDisplacementEnum.FREE_MOVEMENT = "FREE_MOVEMENT"; +IfcBearingTypeDisplacementEnum.NOTDEFINED = "NOTDEFINED"; +var IfcBearingTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcBearingTypeEnum.CYLINDRICAL = "CYLINDRICAL"; +IfcBearingTypeEnum.SPHERICAL = "SPHERICAL"; +IfcBearingTypeEnum.ELASTOMERIC = "ELASTOMERIC"; +IfcBearingTypeEnum.POT = "POT"; +IfcBearingTypeEnum.GUIDE = "GUIDE"; +IfcBearingTypeEnum.ROCKER = "ROCKER"; +IfcBearingTypeEnum.ROLLER = "ROLLER"; +IfcBearingTypeEnum.DISK = "DISK"; +IfcBearingTypeEnum.USERDEFINED = "USERDEFINED"; +IfcBearingTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcBenchmarkEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcBenchmarkEnum.GREATERTHAN = "GREATERTHAN"; +IfcBenchmarkEnum.GREATERTHANOREQUALTO = "GREATERTHANOREQUALTO"; +IfcBenchmarkEnum.LESSTHAN = "LESSTHAN"; +IfcBenchmarkEnum.LESSTHANOREQUALTO = "LESSTHANOREQUALTO"; +IfcBenchmarkEnum.EQUALTO = "EQUALTO"; +IfcBenchmarkEnum.NOTEQUALTO = "NOTEQUALTO"; +IfcBenchmarkEnum.INCLUDES = "INCLUDES"; +IfcBenchmarkEnum.NOTINCLUDES = "NOTINCLUDES"; +IfcBenchmarkEnum.INCLUDEDIN = "INCLUDEDIN"; +IfcBenchmarkEnum.NOTINCLUDEDIN = "NOTINCLUDEDIN"; +var IfcBoilerTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcBoilerTypeEnum.WATER = "WATER"; +IfcBoilerTypeEnum.STEAM = "STEAM"; +IfcBoilerTypeEnum.USERDEFINED = "USERDEFINED"; +IfcBoilerTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcBooleanOperator = class { + constructor(v) { + this.value = v; + } +}; +IfcBooleanOperator.UNION = "UNION"; +IfcBooleanOperator.INTERSECTION = "INTERSECTION"; +IfcBooleanOperator.DIFFERENCE = "DIFFERENCE"; +var IfcBridgePartTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcBridgePartTypeEnum.ABUTMENT = "ABUTMENT"; +IfcBridgePartTypeEnum.DECK = "DECK"; +IfcBridgePartTypeEnum.DECK_SEGMENT = "DECK_SEGMENT"; +IfcBridgePartTypeEnum.FOUNDATION = "FOUNDATION"; +IfcBridgePartTypeEnum.PIER = "PIER"; +IfcBridgePartTypeEnum.PIER_SEGMENT = "PIER_SEGMENT"; +IfcBridgePartTypeEnum.PYLON = "PYLON"; +IfcBridgePartTypeEnum.SUBSTRUCTURE = "SUBSTRUCTURE"; +IfcBridgePartTypeEnum.SUPERSTRUCTURE = "SUPERSTRUCTURE"; +IfcBridgePartTypeEnum.SURFACESTRUCTURE = "SURFACESTRUCTURE"; +IfcBridgePartTypeEnum.USERDEFINED = "USERDEFINED"; +IfcBridgePartTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcBridgeTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcBridgeTypeEnum.ARCHED = "ARCHED"; +IfcBridgeTypeEnum.CABLE_STAYED = "CABLE_STAYED"; +IfcBridgeTypeEnum.CANTILEVER = "CANTILEVER"; +IfcBridgeTypeEnum.CULVERT = "CULVERT"; +IfcBridgeTypeEnum.FRAMEWORK = "FRAMEWORK"; +IfcBridgeTypeEnum.GIRDER = "GIRDER"; +IfcBridgeTypeEnum.SUSPENSION = "SUSPENSION"; +IfcBridgeTypeEnum.TRUSS = "TRUSS"; +IfcBridgeTypeEnum.USERDEFINED = "USERDEFINED"; +IfcBridgeTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcBuildingElementPartTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcBuildingElementPartTypeEnum.INSULATION = "INSULATION"; +IfcBuildingElementPartTypeEnum.PRECASTPANEL = "PRECASTPANEL"; +IfcBuildingElementPartTypeEnum.APRON = "APRON"; +IfcBuildingElementPartTypeEnum.USERDEFINED = "USERDEFINED"; +IfcBuildingElementPartTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcBuildingElementProxyTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcBuildingElementProxyTypeEnum.COMPLEX = "COMPLEX"; +IfcBuildingElementProxyTypeEnum.ELEMENT = "ELEMENT"; +IfcBuildingElementProxyTypeEnum.PARTIAL = "PARTIAL"; +IfcBuildingElementProxyTypeEnum.PROVISIONFORVOID = "PROVISIONFORVOID"; +IfcBuildingElementProxyTypeEnum.PROVISIONFORSPACE = "PROVISIONFORSPACE"; +IfcBuildingElementProxyTypeEnum.USERDEFINED = "USERDEFINED"; +IfcBuildingElementProxyTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcBuildingSystemTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcBuildingSystemTypeEnum.FENESTRATION = "FENESTRATION"; +IfcBuildingSystemTypeEnum.FOUNDATION = "FOUNDATION"; +IfcBuildingSystemTypeEnum.LOADBEARING = "LOADBEARING"; +IfcBuildingSystemTypeEnum.OUTERSHELL = "OUTERSHELL"; +IfcBuildingSystemTypeEnum.SHADING = "SHADING"; +IfcBuildingSystemTypeEnum.TRANSPORT = "TRANSPORT"; +IfcBuildingSystemTypeEnum.REINFORCING = "REINFORCING"; +IfcBuildingSystemTypeEnum.PRESTRESSING = "PRESTRESSING"; +IfcBuildingSystemTypeEnum.USERDEFINED = "USERDEFINED"; +IfcBuildingSystemTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcBurnerTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcBurnerTypeEnum.USERDEFINED = "USERDEFINED"; +IfcBurnerTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcCableCarrierFittingTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcCableCarrierFittingTypeEnum.BEND = "BEND"; +IfcCableCarrierFittingTypeEnum.CROSS = "CROSS"; +IfcCableCarrierFittingTypeEnum.REDUCER = "REDUCER"; +IfcCableCarrierFittingTypeEnum.TEE = "TEE"; +IfcCableCarrierFittingTypeEnum.USERDEFINED = "USERDEFINED"; +IfcCableCarrierFittingTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcCableCarrierSegmentTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcCableCarrierSegmentTypeEnum.CABLELADDERSEGMENT = "CABLELADDERSEGMENT"; +IfcCableCarrierSegmentTypeEnum.CABLETRAYSEGMENT = "CABLETRAYSEGMENT"; +IfcCableCarrierSegmentTypeEnum.CABLETRUNKINGSEGMENT = "CABLETRUNKINGSEGMENT"; +IfcCableCarrierSegmentTypeEnum.CONDUITSEGMENT = "CONDUITSEGMENT"; +IfcCableCarrierSegmentTypeEnum.USERDEFINED = "USERDEFINED"; +IfcCableCarrierSegmentTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcCableFittingTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcCableFittingTypeEnum.CONNECTOR = "CONNECTOR"; +IfcCableFittingTypeEnum.ENTRY = "ENTRY"; +IfcCableFittingTypeEnum.EXIT = "EXIT"; +IfcCableFittingTypeEnum.JUNCTION = "JUNCTION"; +IfcCableFittingTypeEnum.TRANSITION = "TRANSITION"; +IfcCableFittingTypeEnum.USERDEFINED = "USERDEFINED"; +IfcCableFittingTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcCableSegmentTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcCableSegmentTypeEnum.BUSBARSEGMENT = "BUSBARSEGMENT"; +IfcCableSegmentTypeEnum.CABLESEGMENT = "CABLESEGMENT"; +IfcCableSegmentTypeEnum.CONDUCTORSEGMENT = "CONDUCTORSEGMENT"; +IfcCableSegmentTypeEnum.CORESEGMENT = "CORESEGMENT"; +IfcCableSegmentTypeEnum.USERDEFINED = "USERDEFINED"; +IfcCableSegmentTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcCaissonFoundationTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcCaissonFoundationTypeEnum.WELL = "WELL"; +IfcCaissonFoundationTypeEnum.CAISSON = "CAISSON"; +IfcCaissonFoundationTypeEnum.USERDEFINED = "USERDEFINED"; +IfcCaissonFoundationTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcChangeActionEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcChangeActionEnum.NOCHANGE = "NOCHANGE"; +IfcChangeActionEnum.MODIFIED = "MODIFIED"; +IfcChangeActionEnum.ADDED = "ADDED"; +IfcChangeActionEnum.DELETED = "DELETED"; +IfcChangeActionEnum.NOTDEFINED = "NOTDEFINED"; +var IfcChillerTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcChillerTypeEnum.AIRCOOLED = "AIRCOOLED"; +IfcChillerTypeEnum.WATERCOOLED = "WATERCOOLED"; +IfcChillerTypeEnum.HEATRECOVERY = "HEATRECOVERY"; +IfcChillerTypeEnum.USERDEFINED = "USERDEFINED"; +IfcChillerTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcChimneyTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcChimneyTypeEnum.USERDEFINED = "USERDEFINED"; +IfcChimneyTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcCoilTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcCoilTypeEnum.DXCOOLINGCOIL = "DXCOOLINGCOIL"; +IfcCoilTypeEnum.ELECTRICHEATINGCOIL = "ELECTRICHEATINGCOIL"; +IfcCoilTypeEnum.GASHEATINGCOIL = "GASHEATINGCOIL"; +IfcCoilTypeEnum.HYDRONICCOIL = "HYDRONICCOIL"; +IfcCoilTypeEnum.STEAMHEATINGCOIL = "STEAMHEATINGCOIL"; +IfcCoilTypeEnum.WATERCOOLINGCOIL = "WATERCOOLINGCOIL"; +IfcCoilTypeEnum.WATERHEATINGCOIL = "WATERHEATINGCOIL"; +IfcCoilTypeEnum.USERDEFINED = "USERDEFINED"; +IfcCoilTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcColumnTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcColumnTypeEnum.COLUMN = "COLUMN"; +IfcColumnTypeEnum.PILASTER = "PILASTER"; +IfcColumnTypeEnum.PIERSTEM = "PIERSTEM"; +IfcColumnTypeEnum.PIERSTEM_SEGMENT = "PIERSTEM_SEGMENT"; +IfcColumnTypeEnum.STANDCOLUMN = "STANDCOLUMN"; +IfcColumnTypeEnum.USERDEFINED = "USERDEFINED"; +IfcColumnTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcCommunicationsApplianceTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcCommunicationsApplianceTypeEnum.ANTENNA = "ANTENNA"; +IfcCommunicationsApplianceTypeEnum.COMPUTER = "COMPUTER"; +IfcCommunicationsApplianceTypeEnum.FAX = "FAX"; +IfcCommunicationsApplianceTypeEnum.GATEWAY = "GATEWAY"; +IfcCommunicationsApplianceTypeEnum.MODEM = "MODEM"; +IfcCommunicationsApplianceTypeEnum.NETWORKAPPLIANCE = "NETWORKAPPLIANCE"; +IfcCommunicationsApplianceTypeEnum.NETWORKBRIDGE = "NETWORKBRIDGE"; +IfcCommunicationsApplianceTypeEnum.NETWORKHUB = "NETWORKHUB"; +IfcCommunicationsApplianceTypeEnum.PRINTER = "PRINTER"; +IfcCommunicationsApplianceTypeEnum.REPEATER = "REPEATER"; +IfcCommunicationsApplianceTypeEnum.ROUTER = "ROUTER"; +IfcCommunicationsApplianceTypeEnum.SCANNER = "SCANNER"; +IfcCommunicationsApplianceTypeEnum.USERDEFINED = "USERDEFINED"; +IfcCommunicationsApplianceTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcComplexPropertyTemplateTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcComplexPropertyTemplateTypeEnum.P_COMPLEX = "P_COMPLEX"; +IfcComplexPropertyTemplateTypeEnum.Q_COMPLEX = "Q_COMPLEX"; +var IfcCompressorTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcCompressorTypeEnum.DYNAMIC = "DYNAMIC"; +IfcCompressorTypeEnum.RECIPROCATING = "RECIPROCATING"; +IfcCompressorTypeEnum.ROTARY = "ROTARY"; +IfcCompressorTypeEnum.SCROLL = "SCROLL"; +IfcCompressorTypeEnum.TROCHOIDAL = "TROCHOIDAL"; +IfcCompressorTypeEnum.SINGLESTAGE = "SINGLESTAGE"; +IfcCompressorTypeEnum.BOOSTER = "BOOSTER"; +IfcCompressorTypeEnum.OPENTYPE = "OPENTYPE"; +IfcCompressorTypeEnum.HERMETIC = "HERMETIC"; +IfcCompressorTypeEnum.SEMIHERMETIC = "SEMIHERMETIC"; +IfcCompressorTypeEnum.WELDEDSHELLHERMETIC = "WELDEDSHELLHERMETIC"; +IfcCompressorTypeEnum.ROLLINGPISTON = "ROLLINGPISTON"; +IfcCompressorTypeEnum.ROTARYVANE = "ROTARYVANE"; +IfcCompressorTypeEnum.SINGLESCREW = "SINGLESCREW"; +IfcCompressorTypeEnum.TWINSCREW = "TWINSCREW"; +IfcCompressorTypeEnum.USERDEFINED = "USERDEFINED"; +IfcCompressorTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcCondenserTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcCondenserTypeEnum.AIRCOOLED = "AIRCOOLED"; +IfcCondenserTypeEnum.EVAPORATIVECOOLED = "EVAPORATIVECOOLED"; +IfcCondenserTypeEnum.WATERCOOLED = "WATERCOOLED"; +IfcCondenserTypeEnum.WATERCOOLEDBRAZEDPLATE = "WATERCOOLEDBRAZEDPLATE"; +IfcCondenserTypeEnum.WATERCOOLEDSHELLCOIL = "WATERCOOLEDSHELLCOIL"; +IfcCondenserTypeEnum.WATERCOOLEDSHELLTUBE = "WATERCOOLEDSHELLTUBE"; +IfcCondenserTypeEnum.WATERCOOLEDTUBEINTUBE = "WATERCOOLEDTUBEINTUBE"; +IfcCondenserTypeEnum.USERDEFINED = "USERDEFINED"; +IfcCondenserTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcConnectionTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcConnectionTypeEnum.ATPATH = "ATPATH"; +IfcConnectionTypeEnum.ATSTART = "ATSTART"; +IfcConnectionTypeEnum.ATEND = "ATEND"; +IfcConnectionTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcConstraintEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcConstraintEnum.HARD = "HARD"; +IfcConstraintEnum.SOFT = "SOFT"; +IfcConstraintEnum.ADVISORY = "ADVISORY"; +IfcConstraintEnum.USERDEFINED = "USERDEFINED"; +IfcConstraintEnum.NOTDEFINED = "NOTDEFINED"; +var IfcConstructionEquipmentResourceTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcConstructionEquipmentResourceTypeEnum.DEMOLISHING = "DEMOLISHING"; +IfcConstructionEquipmentResourceTypeEnum.EARTHMOVING = "EARTHMOVING"; +IfcConstructionEquipmentResourceTypeEnum.ERECTING = "ERECTING"; +IfcConstructionEquipmentResourceTypeEnum.HEATING = "HEATING"; +IfcConstructionEquipmentResourceTypeEnum.LIGHTING = "LIGHTING"; +IfcConstructionEquipmentResourceTypeEnum.PAVING = "PAVING"; +IfcConstructionEquipmentResourceTypeEnum.PUMPING = "PUMPING"; +IfcConstructionEquipmentResourceTypeEnum.TRANSPORTING = "TRANSPORTING"; +IfcConstructionEquipmentResourceTypeEnum.USERDEFINED = "USERDEFINED"; +IfcConstructionEquipmentResourceTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcConstructionMaterialResourceTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcConstructionMaterialResourceTypeEnum.AGGREGATES = "AGGREGATES"; +IfcConstructionMaterialResourceTypeEnum.CONCRETE = "CONCRETE"; +IfcConstructionMaterialResourceTypeEnum.DRYWALL = "DRYWALL"; +IfcConstructionMaterialResourceTypeEnum.FUEL = "FUEL"; +IfcConstructionMaterialResourceTypeEnum.GYPSUM = "GYPSUM"; +IfcConstructionMaterialResourceTypeEnum.MASONRY = "MASONRY"; +IfcConstructionMaterialResourceTypeEnum.METAL = "METAL"; +IfcConstructionMaterialResourceTypeEnum.PLASTIC = "PLASTIC"; +IfcConstructionMaterialResourceTypeEnum.WOOD = "WOOD"; +IfcConstructionMaterialResourceTypeEnum.NOTDEFINED = "NOTDEFINED"; +IfcConstructionMaterialResourceTypeEnum.USERDEFINED = "USERDEFINED"; +var IfcConstructionProductResourceTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcConstructionProductResourceTypeEnum.ASSEMBLY = "ASSEMBLY"; +IfcConstructionProductResourceTypeEnum.FORMWORK = "FORMWORK"; +IfcConstructionProductResourceTypeEnum.USERDEFINED = "USERDEFINED"; +IfcConstructionProductResourceTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcControllerTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcControllerTypeEnum.FLOATING = "FLOATING"; +IfcControllerTypeEnum.PROGRAMMABLE = "PROGRAMMABLE"; +IfcControllerTypeEnum.PROPORTIONAL = "PROPORTIONAL"; +IfcControllerTypeEnum.MULTIPOSITION = "MULTIPOSITION"; +IfcControllerTypeEnum.TWOPOSITION = "TWOPOSITION"; +IfcControllerTypeEnum.USERDEFINED = "USERDEFINED"; +IfcControllerTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcCooledBeamTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcCooledBeamTypeEnum.ACTIVE = "ACTIVE"; +IfcCooledBeamTypeEnum.PASSIVE = "PASSIVE"; +IfcCooledBeamTypeEnum.USERDEFINED = "USERDEFINED"; +IfcCooledBeamTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcCoolingTowerTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcCoolingTowerTypeEnum.NATURALDRAFT = "NATURALDRAFT"; +IfcCoolingTowerTypeEnum.MECHANICALINDUCEDDRAFT = "MECHANICALINDUCEDDRAFT"; +IfcCoolingTowerTypeEnum.MECHANICALFORCEDDRAFT = "MECHANICALFORCEDDRAFT"; +IfcCoolingTowerTypeEnum.USERDEFINED = "USERDEFINED"; +IfcCoolingTowerTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcCostItemTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcCostItemTypeEnum.USERDEFINED = "USERDEFINED"; +IfcCostItemTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcCostScheduleTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcCostScheduleTypeEnum.BUDGET = "BUDGET"; +IfcCostScheduleTypeEnum.COSTPLAN = "COSTPLAN"; +IfcCostScheduleTypeEnum.ESTIMATE = "ESTIMATE"; +IfcCostScheduleTypeEnum.TENDER = "TENDER"; +IfcCostScheduleTypeEnum.PRICEDBILLOFQUANTITIES = "PRICEDBILLOFQUANTITIES"; +IfcCostScheduleTypeEnum.UNPRICEDBILLOFQUANTITIES = "UNPRICEDBILLOFQUANTITIES"; +IfcCostScheduleTypeEnum.SCHEDULEOFRATES = "SCHEDULEOFRATES"; +IfcCostScheduleTypeEnum.USERDEFINED = "USERDEFINED"; +IfcCostScheduleTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcCoveringTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcCoveringTypeEnum.CEILING = "CEILING"; +IfcCoveringTypeEnum.FLOORING = "FLOORING"; +IfcCoveringTypeEnum.CLADDING = "CLADDING"; +IfcCoveringTypeEnum.ROOFING = "ROOFING"; +IfcCoveringTypeEnum.MOLDING = "MOLDING"; +IfcCoveringTypeEnum.SKIRTINGBOARD = "SKIRTINGBOARD"; +IfcCoveringTypeEnum.INSULATION = "INSULATION"; +IfcCoveringTypeEnum.MEMBRANE = "MEMBRANE"; +IfcCoveringTypeEnum.SLEEVING = "SLEEVING"; +IfcCoveringTypeEnum.WRAPPING = "WRAPPING"; +IfcCoveringTypeEnum.COPING = "COPING"; +IfcCoveringTypeEnum.USERDEFINED = "USERDEFINED"; +IfcCoveringTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcCrewResourceTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcCrewResourceTypeEnum.OFFICE = "OFFICE"; +IfcCrewResourceTypeEnum.SITE = "SITE"; +IfcCrewResourceTypeEnum.USERDEFINED = "USERDEFINED"; +IfcCrewResourceTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcCurtainWallTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcCurtainWallTypeEnum.USERDEFINED = "USERDEFINED"; +IfcCurtainWallTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcCurveInterpolationEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcCurveInterpolationEnum.LINEAR = "LINEAR"; +IfcCurveInterpolationEnum.LOG_LINEAR = "LOG_LINEAR"; +IfcCurveInterpolationEnum.LOG_LOG = "LOG_LOG"; +IfcCurveInterpolationEnum.NOTDEFINED = "NOTDEFINED"; +var IfcDamperTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcDamperTypeEnum.BACKDRAFTDAMPER = "BACKDRAFTDAMPER"; +IfcDamperTypeEnum.BALANCINGDAMPER = "BALANCINGDAMPER"; +IfcDamperTypeEnum.BLASTDAMPER = "BLASTDAMPER"; +IfcDamperTypeEnum.CONTROLDAMPER = "CONTROLDAMPER"; +IfcDamperTypeEnum.FIREDAMPER = "FIREDAMPER"; +IfcDamperTypeEnum.FIRESMOKEDAMPER = "FIRESMOKEDAMPER"; +IfcDamperTypeEnum.FUMEHOODEXHAUST = "FUMEHOODEXHAUST"; +IfcDamperTypeEnum.GRAVITYDAMPER = "GRAVITYDAMPER"; +IfcDamperTypeEnum.GRAVITYRELIEFDAMPER = "GRAVITYRELIEFDAMPER"; +IfcDamperTypeEnum.RELIEFDAMPER = "RELIEFDAMPER"; +IfcDamperTypeEnum.SMOKEDAMPER = "SMOKEDAMPER"; +IfcDamperTypeEnum.USERDEFINED = "USERDEFINED"; +IfcDamperTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcDataOriginEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcDataOriginEnum.MEASURED = "MEASURED"; +IfcDataOriginEnum.PREDICTED = "PREDICTED"; +IfcDataOriginEnum.SIMULATED = "SIMULATED"; +IfcDataOriginEnum.USERDEFINED = "USERDEFINED"; +IfcDataOriginEnum.NOTDEFINED = "NOTDEFINED"; +var IfcDerivedUnitEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcDerivedUnitEnum.ANGULARVELOCITYUNIT = "ANGULARVELOCITYUNIT"; +IfcDerivedUnitEnum.AREADENSITYUNIT = "AREADENSITYUNIT"; +IfcDerivedUnitEnum.COMPOUNDPLANEANGLEUNIT = "COMPOUNDPLANEANGLEUNIT"; +IfcDerivedUnitEnum.DYNAMICVISCOSITYUNIT = "DYNAMICVISCOSITYUNIT"; +IfcDerivedUnitEnum.HEATFLUXDENSITYUNIT = "HEATFLUXDENSITYUNIT"; +IfcDerivedUnitEnum.INTEGERCOUNTRATEUNIT = "INTEGERCOUNTRATEUNIT"; +IfcDerivedUnitEnum.ISOTHERMALMOISTURECAPACITYUNIT = "ISOTHERMALMOISTURECAPACITYUNIT"; +IfcDerivedUnitEnum.KINEMATICVISCOSITYUNIT = "KINEMATICVISCOSITYUNIT"; +IfcDerivedUnitEnum.LINEARVELOCITYUNIT = "LINEARVELOCITYUNIT"; +IfcDerivedUnitEnum.MASSDENSITYUNIT = "MASSDENSITYUNIT"; +IfcDerivedUnitEnum.MASSFLOWRATEUNIT = "MASSFLOWRATEUNIT"; +IfcDerivedUnitEnum.MOISTUREDIFFUSIVITYUNIT = "MOISTUREDIFFUSIVITYUNIT"; +IfcDerivedUnitEnum.MOLECULARWEIGHTUNIT = "MOLECULARWEIGHTUNIT"; +IfcDerivedUnitEnum.SPECIFICHEATCAPACITYUNIT = "SPECIFICHEATCAPACITYUNIT"; +IfcDerivedUnitEnum.THERMALADMITTANCEUNIT = "THERMALADMITTANCEUNIT"; +IfcDerivedUnitEnum.THERMALCONDUCTANCEUNIT = "THERMALCONDUCTANCEUNIT"; +IfcDerivedUnitEnum.THERMALRESISTANCEUNIT = "THERMALRESISTANCEUNIT"; +IfcDerivedUnitEnum.THERMALTRANSMITTANCEUNIT = "THERMALTRANSMITTANCEUNIT"; +IfcDerivedUnitEnum.VAPORPERMEABILITYUNIT = "VAPORPERMEABILITYUNIT"; +IfcDerivedUnitEnum.VOLUMETRICFLOWRATEUNIT = "VOLUMETRICFLOWRATEUNIT"; +IfcDerivedUnitEnum.ROTATIONALFREQUENCYUNIT = "ROTATIONALFREQUENCYUNIT"; +IfcDerivedUnitEnum.TORQUEUNIT = "TORQUEUNIT"; +IfcDerivedUnitEnum.MOMENTOFINERTIAUNIT = "MOMENTOFINERTIAUNIT"; +IfcDerivedUnitEnum.LINEARMOMENTUNIT = "LINEARMOMENTUNIT"; +IfcDerivedUnitEnum.LINEARFORCEUNIT = "LINEARFORCEUNIT"; +IfcDerivedUnitEnum.PLANARFORCEUNIT = "PLANARFORCEUNIT"; +IfcDerivedUnitEnum.MODULUSOFELASTICITYUNIT = "MODULUSOFELASTICITYUNIT"; +IfcDerivedUnitEnum.SHEARMODULUSUNIT = "SHEARMODULUSUNIT"; +IfcDerivedUnitEnum.LINEARSTIFFNESSUNIT = "LINEARSTIFFNESSUNIT"; +IfcDerivedUnitEnum.ROTATIONALSTIFFNESSUNIT = "ROTATIONALSTIFFNESSUNIT"; +IfcDerivedUnitEnum.MODULUSOFSUBGRADEREACTIONUNIT = "MODULUSOFSUBGRADEREACTIONUNIT"; +IfcDerivedUnitEnum.ACCELERATIONUNIT = "ACCELERATIONUNIT"; +IfcDerivedUnitEnum.CURVATUREUNIT = "CURVATUREUNIT"; +IfcDerivedUnitEnum.HEATINGVALUEUNIT = "HEATINGVALUEUNIT"; +IfcDerivedUnitEnum.IONCONCENTRATIONUNIT = "IONCONCENTRATIONUNIT"; +IfcDerivedUnitEnum.LUMINOUSINTENSITYDISTRIBUTIONUNIT = "LUMINOUSINTENSITYDISTRIBUTIONUNIT"; +IfcDerivedUnitEnum.MASSPERLENGTHUNIT = "MASSPERLENGTHUNIT"; +IfcDerivedUnitEnum.MODULUSOFLINEARSUBGRADEREACTIONUNIT = "MODULUSOFLINEARSUBGRADEREACTIONUNIT"; +IfcDerivedUnitEnum.MODULUSOFROTATIONALSUBGRADEREACTIONUNIT = "MODULUSOFROTATIONALSUBGRADEREACTIONUNIT"; +IfcDerivedUnitEnum.PHUNIT = "PHUNIT"; +IfcDerivedUnitEnum.ROTATIONALMASSUNIT = "ROTATIONALMASSUNIT"; +IfcDerivedUnitEnum.SECTIONAREAINTEGRALUNIT = "SECTIONAREAINTEGRALUNIT"; +IfcDerivedUnitEnum.SECTIONMODULUSUNIT = "SECTIONMODULUSUNIT"; +IfcDerivedUnitEnum.SOUNDPOWERLEVELUNIT = "SOUNDPOWERLEVELUNIT"; +IfcDerivedUnitEnum.SOUNDPOWERUNIT = "SOUNDPOWERUNIT"; +IfcDerivedUnitEnum.SOUNDPRESSURELEVELUNIT = "SOUNDPRESSURELEVELUNIT"; +IfcDerivedUnitEnum.SOUNDPRESSUREUNIT = "SOUNDPRESSUREUNIT"; +IfcDerivedUnitEnum.TEMPERATUREGRADIENTUNIT = "TEMPERATUREGRADIENTUNIT"; +IfcDerivedUnitEnum.TEMPERATURERATEOFCHANGEUNIT = "TEMPERATURERATEOFCHANGEUNIT"; +IfcDerivedUnitEnum.THERMALEXPANSIONCOEFFICIENTUNIT = "THERMALEXPANSIONCOEFFICIENTUNIT"; +IfcDerivedUnitEnum.WARPINGCONSTANTUNIT = "WARPINGCONSTANTUNIT"; +IfcDerivedUnitEnum.WARPINGMOMENTUNIT = "WARPINGMOMENTUNIT"; +IfcDerivedUnitEnum.USERDEFINED = "USERDEFINED"; +var IfcDirectionSenseEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcDirectionSenseEnum.POSITIVE = "POSITIVE"; +IfcDirectionSenseEnum.NEGATIVE = "NEGATIVE"; +var IfcDiscreteAccessoryTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcDiscreteAccessoryTypeEnum.ANCHORPLATE = "ANCHORPLATE"; +IfcDiscreteAccessoryTypeEnum.BRACKET = "BRACKET"; +IfcDiscreteAccessoryTypeEnum.SHOE = "SHOE"; +IfcDiscreteAccessoryTypeEnum.EXPANSION_JOINT_DEVICE = "EXPANSION_JOINT_DEVICE"; +IfcDiscreteAccessoryTypeEnum.USERDEFINED = "USERDEFINED"; +IfcDiscreteAccessoryTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcDistributionChamberElementTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcDistributionChamberElementTypeEnum.FORMEDDUCT = "FORMEDDUCT"; +IfcDistributionChamberElementTypeEnum.INSPECTIONCHAMBER = "INSPECTIONCHAMBER"; +IfcDistributionChamberElementTypeEnum.INSPECTIONPIT = "INSPECTIONPIT"; +IfcDistributionChamberElementTypeEnum.MANHOLE = "MANHOLE"; +IfcDistributionChamberElementTypeEnum.METERCHAMBER = "METERCHAMBER"; +IfcDistributionChamberElementTypeEnum.SUMP = "SUMP"; +IfcDistributionChamberElementTypeEnum.TRENCH = "TRENCH"; +IfcDistributionChamberElementTypeEnum.VALVECHAMBER = "VALVECHAMBER"; +IfcDistributionChamberElementTypeEnum.USERDEFINED = "USERDEFINED"; +IfcDistributionChamberElementTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcDistributionPortTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcDistributionPortTypeEnum.CABLE = "CABLE"; +IfcDistributionPortTypeEnum.CABLECARRIER = "CABLECARRIER"; +IfcDistributionPortTypeEnum.DUCT = "DUCT"; +IfcDistributionPortTypeEnum.PIPE = "PIPE"; +IfcDistributionPortTypeEnum.USERDEFINED = "USERDEFINED"; +IfcDistributionPortTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcDistributionSystemEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcDistributionSystemEnum.AIRCONDITIONING = "AIRCONDITIONING"; +IfcDistributionSystemEnum.AUDIOVISUAL = "AUDIOVISUAL"; +IfcDistributionSystemEnum.CHEMICAL = "CHEMICAL"; +IfcDistributionSystemEnum.CHILLEDWATER = "CHILLEDWATER"; +IfcDistributionSystemEnum.COMMUNICATION = "COMMUNICATION"; +IfcDistributionSystemEnum.COMPRESSEDAIR = "COMPRESSEDAIR"; +IfcDistributionSystemEnum.CONDENSERWATER = "CONDENSERWATER"; +IfcDistributionSystemEnum.CONTROL = "CONTROL"; +IfcDistributionSystemEnum.CONVEYING = "CONVEYING"; +IfcDistributionSystemEnum.DATA = "DATA"; +IfcDistributionSystemEnum.DISPOSAL = "DISPOSAL"; +IfcDistributionSystemEnum.DOMESTICCOLDWATER = "DOMESTICCOLDWATER"; +IfcDistributionSystemEnum.DOMESTICHOTWATER = "DOMESTICHOTWATER"; +IfcDistributionSystemEnum.DRAINAGE = "DRAINAGE"; +IfcDistributionSystemEnum.EARTHING = "EARTHING"; +IfcDistributionSystemEnum.ELECTRICAL = "ELECTRICAL"; +IfcDistributionSystemEnum.ELECTROACOUSTIC = "ELECTROACOUSTIC"; +IfcDistributionSystemEnum.EXHAUST = "EXHAUST"; +IfcDistributionSystemEnum.FIREPROTECTION = "FIREPROTECTION"; +IfcDistributionSystemEnum.FUEL = "FUEL"; +IfcDistributionSystemEnum.GAS = "GAS"; +IfcDistributionSystemEnum.HAZARDOUS = "HAZARDOUS"; +IfcDistributionSystemEnum.HEATING = "HEATING"; +IfcDistributionSystemEnum.LIGHTING = "LIGHTING"; +IfcDistributionSystemEnum.LIGHTNINGPROTECTION = "LIGHTNINGPROTECTION"; +IfcDistributionSystemEnum.MUNICIPALSOLIDWASTE = "MUNICIPALSOLIDWASTE"; +IfcDistributionSystemEnum.OIL = "OIL"; +IfcDistributionSystemEnum.OPERATIONAL = "OPERATIONAL"; +IfcDistributionSystemEnum.POWERGENERATION = "POWERGENERATION"; +IfcDistributionSystemEnum.RAINWATER = "RAINWATER"; +IfcDistributionSystemEnum.REFRIGERATION = "REFRIGERATION"; +IfcDistributionSystemEnum.SECURITY = "SECURITY"; +IfcDistributionSystemEnum.SEWAGE = "SEWAGE"; +IfcDistributionSystemEnum.SIGNAL = "SIGNAL"; +IfcDistributionSystemEnum.STORMWATER = "STORMWATER"; +IfcDistributionSystemEnum.TELEPHONE = "TELEPHONE"; +IfcDistributionSystemEnum.TV = "TV"; +IfcDistributionSystemEnum.VACUUM = "VACUUM"; +IfcDistributionSystemEnum.VENT = "VENT"; +IfcDistributionSystemEnum.VENTILATION = "VENTILATION"; +IfcDistributionSystemEnum.WASTEWATER = "WASTEWATER"; +IfcDistributionSystemEnum.WATERSUPPLY = "WATERSUPPLY"; +IfcDistributionSystemEnum.USERDEFINED = "USERDEFINED"; +IfcDistributionSystemEnum.NOTDEFINED = "NOTDEFINED"; +var IfcDocumentConfidentialityEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcDocumentConfidentialityEnum.PUBLIC = "PUBLIC"; +IfcDocumentConfidentialityEnum.RESTRICTED = "RESTRICTED"; +IfcDocumentConfidentialityEnum.CONFIDENTIAL = "CONFIDENTIAL"; +IfcDocumentConfidentialityEnum.PERSONAL = "PERSONAL"; +IfcDocumentConfidentialityEnum.USERDEFINED = "USERDEFINED"; +IfcDocumentConfidentialityEnum.NOTDEFINED = "NOTDEFINED"; +var IfcDocumentStatusEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcDocumentStatusEnum.DRAFT = "DRAFT"; +IfcDocumentStatusEnum.FINALDRAFT = "FINALDRAFT"; +IfcDocumentStatusEnum.FINAL = "FINAL"; +IfcDocumentStatusEnum.REVISION = "REVISION"; +IfcDocumentStatusEnum.NOTDEFINED = "NOTDEFINED"; +var IfcDoorPanelOperationEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcDoorPanelOperationEnum.SWINGING = "SWINGING"; +IfcDoorPanelOperationEnum.DOUBLE_ACTING = "DOUBLE_ACTING"; +IfcDoorPanelOperationEnum.SLIDING = "SLIDING"; +IfcDoorPanelOperationEnum.FOLDING = "FOLDING"; +IfcDoorPanelOperationEnum.REVOLVING = "REVOLVING"; +IfcDoorPanelOperationEnum.ROLLINGUP = "ROLLINGUP"; +IfcDoorPanelOperationEnum.FIXEDPANEL = "FIXEDPANEL"; +IfcDoorPanelOperationEnum.USERDEFINED = "USERDEFINED"; +IfcDoorPanelOperationEnum.NOTDEFINED = "NOTDEFINED"; +var IfcDoorPanelPositionEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcDoorPanelPositionEnum.LEFT = "LEFT"; +IfcDoorPanelPositionEnum.MIDDLE = "MIDDLE"; +IfcDoorPanelPositionEnum.RIGHT = "RIGHT"; +IfcDoorPanelPositionEnum.NOTDEFINED = "NOTDEFINED"; +var IfcDoorStyleConstructionEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcDoorStyleConstructionEnum.ALUMINIUM = "ALUMINIUM"; +IfcDoorStyleConstructionEnum.HIGH_GRADE_STEEL = "HIGH_GRADE_STEEL"; +IfcDoorStyleConstructionEnum.STEEL = "STEEL"; +IfcDoorStyleConstructionEnum.WOOD = "WOOD"; +IfcDoorStyleConstructionEnum.ALUMINIUM_WOOD = "ALUMINIUM_WOOD"; +IfcDoorStyleConstructionEnum.ALUMINIUM_PLASTIC = "ALUMINIUM_PLASTIC"; +IfcDoorStyleConstructionEnum.PLASTIC = "PLASTIC"; +IfcDoorStyleConstructionEnum.USERDEFINED = "USERDEFINED"; +IfcDoorStyleConstructionEnum.NOTDEFINED = "NOTDEFINED"; +var IfcDoorStyleOperationEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcDoorStyleOperationEnum.SINGLE_SWING_LEFT = "SINGLE_SWING_LEFT"; +IfcDoorStyleOperationEnum.SINGLE_SWING_RIGHT = "SINGLE_SWING_RIGHT"; +IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING = "DOUBLE_DOOR_SINGLE_SWING"; +IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT = "DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT"; +IfcDoorStyleOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT = "DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT"; +IfcDoorStyleOperationEnum.DOUBLE_SWING_LEFT = "DOUBLE_SWING_LEFT"; +IfcDoorStyleOperationEnum.DOUBLE_SWING_RIGHT = "DOUBLE_SWING_RIGHT"; +IfcDoorStyleOperationEnum.DOUBLE_DOOR_DOUBLE_SWING = "DOUBLE_DOOR_DOUBLE_SWING"; +IfcDoorStyleOperationEnum.SLIDING_TO_LEFT = "SLIDING_TO_LEFT"; +IfcDoorStyleOperationEnum.SLIDING_TO_RIGHT = "SLIDING_TO_RIGHT"; +IfcDoorStyleOperationEnum.DOUBLE_DOOR_SLIDING = "DOUBLE_DOOR_SLIDING"; +IfcDoorStyleOperationEnum.FOLDING_TO_LEFT = "FOLDING_TO_LEFT"; +IfcDoorStyleOperationEnum.FOLDING_TO_RIGHT = "FOLDING_TO_RIGHT"; +IfcDoorStyleOperationEnum.DOUBLE_DOOR_FOLDING = "DOUBLE_DOOR_FOLDING"; +IfcDoorStyleOperationEnum.REVOLVING = "REVOLVING"; +IfcDoorStyleOperationEnum.ROLLINGUP = "ROLLINGUP"; +IfcDoorStyleOperationEnum.USERDEFINED = "USERDEFINED"; +IfcDoorStyleOperationEnum.NOTDEFINED = "NOTDEFINED"; +var IfcDoorTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcDoorTypeEnum.DOOR = "DOOR"; +IfcDoorTypeEnum.GATE = "GATE"; +IfcDoorTypeEnum.TRAPDOOR = "TRAPDOOR"; +IfcDoorTypeEnum.USERDEFINED = "USERDEFINED"; +IfcDoorTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcDoorTypeOperationEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcDoorTypeOperationEnum.SINGLE_SWING_LEFT = "SINGLE_SWING_LEFT"; +IfcDoorTypeOperationEnum.SINGLE_SWING_RIGHT = "SINGLE_SWING_RIGHT"; +IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING = "DOUBLE_DOOR_SINGLE_SWING"; +IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT = "DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT"; +IfcDoorTypeOperationEnum.DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT = "DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT"; +IfcDoorTypeOperationEnum.DOUBLE_SWING_LEFT = "DOUBLE_SWING_LEFT"; +IfcDoorTypeOperationEnum.DOUBLE_SWING_RIGHT = "DOUBLE_SWING_RIGHT"; +IfcDoorTypeOperationEnum.DOUBLE_DOOR_DOUBLE_SWING = "DOUBLE_DOOR_DOUBLE_SWING"; +IfcDoorTypeOperationEnum.SLIDING_TO_LEFT = "SLIDING_TO_LEFT"; +IfcDoorTypeOperationEnum.SLIDING_TO_RIGHT = "SLIDING_TO_RIGHT"; +IfcDoorTypeOperationEnum.DOUBLE_DOOR_SLIDING = "DOUBLE_DOOR_SLIDING"; +IfcDoorTypeOperationEnum.FOLDING_TO_LEFT = "FOLDING_TO_LEFT"; +IfcDoorTypeOperationEnum.FOLDING_TO_RIGHT = "FOLDING_TO_RIGHT"; +IfcDoorTypeOperationEnum.DOUBLE_DOOR_FOLDING = "DOUBLE_DOOR_FOLDING"; +IfcDoorTypeOperationEnum.REVOLVING = "REVOLVING"; +IfcDoorTypeOperationEnum.ROLLINGUP = "ROLLINGUP"; +IfcDoorTypeOperationEnum.SWING_FIXED_LEFT = "SWING_FIXED_LEFT"; +IfcDoorTypeOperationEnum.SWING_FIXED_RIGHT = "SWING_FIXED_RIGHT"; +IfcDoorTypeOperationEnum.USERDEFINED = "USERDEFINED"; +IfcDoorTypeOperationEnum.NOTDEFINED = "NOTDEFINED"; +var IfcDuctFittingTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcDuctFittingTypeEnum.BEND = "BEND"; +IfcDuctFittingTypeEnum.CONNECTOR = "CONNECTOR"; +IfcDuctFittingTypeEnum.ENTRY = "ENTRY"; +IfcDuctFittingTypeEnum.EXIT = "EXIT"; +IfcDuctFittingTypeEnum.JUNCTION = "JUNCTION"; +IfcDuctFittingTypeEnum.OBSTRUCTION = "OBSTRUCTION"; +IfcDuctFittingTypeEnum.TRANSITION = "TRANSITION"; +IfcDuctFittingTypeEnum.USERDEFINED = "USERDEFINED"; +IfcDuctFittingTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcDuctSegmentTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcDuctSegmentTypeEnum.RIGIDSEGMENT = "RIGIDSEGMENT"; +IfcDuctSegmentTypeEnum.FLEXIBLESEGMENT = "FLEXIBLESEGMENT"; +IfcDuctSegmentTypeEnum.USERDEFINED = "USERDEFINED"; +IfcDuctSegmentTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcDuctSilencerTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcDuctSilencerTypeEnum.FLATOVAL = "FLATOVAL"; +IfcDuctSilencerTypeEnum.RECTANGULAR = "RECTANGULAR"; +IfcDuctSilencerTypeEnum.ROUND = "ROUND"; +IfcDuctSilencerTypeEnum.USERDEFINED = "USERDEFINED"; +IfcDuctSilencerTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcElectricApplianceTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcElectricApplianceTypeEnum.DISHWASHER = "DISHWASHER"; +IfcElectricApplianceTypeEnum.ELECTRICCOOKER = "ELECTRICCOOKER"; +IfcElectricApplianceTypeEnum.FREESTANDINGELECTRICHEATER = "FREESTANDINGELECTRICHEATER"; +IfcElectricApplianceTypeEnum.FREESTANDINGFAN = "FREESTANDINGFAN"; +IfcElectricApplianceTypeEnum.FREESTANDINGWATERHEATER = "FREESTANDINGWATERHEATER"; +IfcElectricApplianceTypeEnum.FREESTANDINGWATERCOOLER = "FREESTANDINGWATERCOOLER"; +IfcElectricApplianceTypeEnum.FREEZER = "FREEZER"; +IfcElectricApplianceTypeEnum.FRIDGE_FREEZER = "FRIDGE_FREEZER"; +IfcElectricApplianceTypeEnum.HANDDRYER = "HANDDRYER"; +IfcElectricApplianceTypeEnum.KITCHENMACHINE = "KITCHENMACHINE"; +IfcElectricApplianceTypeEnum.MICROWAVE = "MICROWAVE"; +IfcElectricApplianceTypeEnum.PHOTOCOPIER = "PHOTOCOPIER"; +IfcElectricApplianceTypeEnum.REFRIGERATOR = "REFRIGERATOR"; +IfcElectricApplianceTypeEnum.TUMBLEDRYER = "TUMBLEDRYER"; +IfcElectricApplianceTypeEnum.VENDINGMACHINE = "VENDINGMACHINE"; +IfcElectricApplianceTypeEnum.WASHINGMACHINE = "WASHINGMACHINE"; +IfcElectricApplianceTypeEnum.USERDEFINED = "USERDEFINED"; +IfcElectricApplianceTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcElectricDistributionBoardTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcElectricDistributionBoardTypeEnum.CONSUMERUNIT = "CONSUMERUNIT"; +IfcElectricDistributionBoardTypeEnum.DISTRIBUTIONBOARD = "DISTRIBUTIONBOARD"; +IfcElectricDistributionBoardTypeEnum.MOTORCONTROLCENTRE = "MOTORCONTROLCENTRE"; +IfcElectricDistributionBoardTypeEnum.SWITCHBOARD = "SWITCHBOARD"; +IfcElectricDistributionBoardTypeEnum.USERDEFINED = "USERDEFINED"; +IfcElectricDistributionBoardTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcElectricFlowStorageDeviceTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcElectricFlowStorageDeviceTypeEnum.BATTERY = "BATTERY"; +IfcElectricFlowStorageDeviceTypeEnum.CAPACITORBANK = "CAPACITORBANK"; +IfcElectricFlowStorageDeviceTypeEnum.HARMONICFILTER = "HARMONICFILTER"; +IfcElectricFlowStorageDeviceTypeEnum.INDUCTORBANK = "INDUCTORBANK"; +IfcElectricFlowStorageDeviceTypeEnum.UPS = "UPS"; +IfcElectricFlowStorageDeviceTypeEnum.USERDEFINED = "USERDEFINED"; +IfcElectricFlowStorageDeviceTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcElectricGeneratorTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcElectricGeneratorTypeEnum.CHP = "CHP"; +IfcElectricGeneratorTypeEnum.ENGINEGENERATOR = "ENGINEGENERATOR"; +IfcElectricGeneratorTypeEnum.STANDALONE = "STANDALONE"; +IfcElectricGeneratorTypeEnum.USERDEFINED = "USERDEFINED"; +IfcElectricGeneratorTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcElectricMotorTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcElectricMotorTypeEnum.DC = "DC"; +IfcElectricMotorTypeEnum.INDUCTION = "INDUCTION"; +IfcElectricMotorTypeEnum.POLYPHASE = "POLYPHASE"; +IfcElectricMotorTypeEnum.RELUCTANCESYNCHRONOUS = "RELUCTANCESYNCHRONOUS"; +IfcElectricMotorTypeEnum.SYNCHRONOUS = "SYNCHRONOUS"; +IfcElectricMotorTypeEnum.USERDEFINED = "USERDEFINED"; +IfcElectricMotorTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcElectricTimeControlTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcElectricTimeControlTypeEnum.TIMECLOCK = "TIMECLOCK"; +IfcElectricTimeControlTypeEnum.TIMEDELAY = "TIMEDELAY"; +IfcElectricTimeControlTypeEnum.RELAY = "RELAY"; +IfcElectricTimeControlTypeEnum.USERDEFINED = "USERDEFINED"; +IfcElectricTimeControlTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcElementAssemblyTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcElementAssemblyTypeEnum.ACCESSORY_ASSEMBLY = "ACCESSORY_ASSEMBLY"; +IfcElementAssemblyTypeEnum.ARCH = "ARCH"; +IfcElementAssemblyTypeEnum.BEAM_GRID = "BEAM_GRID"; +IfcElementAssemblyTypeEnum.BRACED_FRAME = "BRACED_FRAME"; +IfcElementAssemblyTypeEnum.GIRDER = "GIRDER"; +IfcElementAssemblyTypeEnum.REINFORCEMENT_UNIT = "REINFORCEMENT_UNIT"; +IfcElementAssemblyTypeEnum.RIGID_FRAME = "RIGID_FRAME"; +IfcElementAssemblyTypeEnum.SLAB_FIELD = "SLAB_FIELD"; +IfcElementAssemblyTypeEnum.TRUSS = "TRUSS"; +IfcElementAssemblyTypeEnum.ABUTMENT = "ABUTMENT"; +IfcElementAssemblyTypeEnum.PIER = "PIER"; +IfcElementAssemblyTypeEnum.PYLON = "PYLON"; +IfcElementAssemblyTypeEnum.CROSS_BRACING = "CROSS_BRACING"; +IfcElementAssemblyTypeEnum.DECK = "DECK"; +IfcElementAssemblyTypeEnum.USERDEFINED = "USERDEFINED"; +IfcElementAssemblyTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcElementCompositionEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcElementCompositionEnum.COMPLEX = "COMPLEX"; +IfcElementCompositionEnum.ELEMENT = "ELEMENT"; +IfcElementCompositionEnum.PARTIAL = "PARTIAL"; +var IfcEngineTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcEngineTypeEnum.EXTERNALCOMBUSTION = "EXTERNALCOMBUSTION"; +IfcEngineTypeEnum.INTERNALCOMBUSTION = "INTERNALCOMBUSTION"; +IfcEngineTypeEnum.USERDEFINED = "USERDEFINED"; +IfcEngineTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcEvaporativeCoolerTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER = "DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER"; +IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER = "DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER"; +IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER = "DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER"; +IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER = "DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER"; +IfcEvaporativeCoolerTypeEnum.DIRECTEVAPORATIVEAIRWASHER = "DIRECTEVAPORATIVEAIRWASHER"; +IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEPACKAGEAIRCOOLER = "INDIRECTEVAPORATIVEPACKAGEAIRCOOLER"; +IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVEWETCOIL = "INDIRECTEVAPORATIVEWETCOIL"; +IfcEvaporativeCoolerTypeEnum.INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER = "INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER"; +IfcEvaporativeCoolerTypeEnum.INDIRECTDIRECTCOMBINATION = "INDIRECTDIRECTCOMBINATION"; +IfcEvaporativeCoolerTypeEnum.USERDEFINED = "USERDEFINED"; +IfcEvaporativeCoolerTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcEvaporatorTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcEvaporatorTypeEnum.DIRECTEXPANSION = "DIRECTEXPANSION"; +IfcEvaporatorTypeEnum.DIRECTEXPANSIONSHELLANDTUBE = "DIRECTEXPANSIONSHELLANDTUBE"; +IfcEvaporatorTypeEnum.DIRECTEXPANSIONTUBEINTUBE = "DIRECTEXPANSIONTUBEINTUBE"; +IfcEvaporatorTypeEnum.DIRECTEXPANSIONBRAZEDPLATE = "DIRECTEXPANSIONBRAZEDPLATE"; +IfcEvaporatorTypeEnum.FLOODEDSHELLANDTUBE = "FLOODEDSHELLANDTUBE"; +IfcEvaporatorTypeEnum.SHELLANDCOIL = "SHELLANDCOIL"; +IfcEvaporatorTypeEnum.USERDEFINED = "USERDEFINED"; +IfcEvaporatorTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcEventTriggerTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcEventTriggerTypeEnum.EVENTRULE = "EVENTRULE"; +IfcEventTriggerTypeEnum.EVENTMESSAGE = "EVENTMESSAGE"; +IfcEventTriggerTypeEnum.EVENTTIME = "EVENTTIME"; +IfcEventTriggerTypeEnum.EVENTCOMPLEX = "EVENTCOMPLEX"; +IfcEventTriggerTypeEnum.USERDEFINED = "USERDEFINED"; +IfcEventTriggerTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcEventTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcEventTypeEnum.STARTEVENT = "STARTEVENT"; +IfcEventTypeEnum.ENDEVENT = "ENDEVENT"; +IfcEventTypeEnum.INTERMEDIATEEVENT = "INTERMEDIATEEVENT"; +IfcEventTypeEnum.USERDEFINED = "USERDEFINED"; +IfcEventTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcExternalSpatialElementTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcExternalSpatialElementTypeEnum.EXTERNAL = "EXTERNAL"; +IfcExternalSpatialElementTypeEnum.EXTERNAL_EARTH = "EXTERNAL_EARTH"; +IfcExternalSpatialElementTypeEnum.EXTERNAL_WATER = "EXTERNAL_WATER"; +IfcExternalSpatialElementTypeEnum.EXTERNAL_FIRE = "EXTERNAL_FIRE"; +IfcExternalSpatialElementTypeEnum.USERDEFINED = "USERDEFINED"; +IfcExternalSpatialElementTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcFanTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcFanTypeEnum.CENTRIFUGALFORWARDCURVED = "CENTRIFUGALFORWARDCURVED"; +IfcFanTypeEnum.CENTRIFUGALRADIAL = "CENTRIFUGALRADIAL"; +IfcFanTypeEnum.CENTRIFUGALBACKWARDINCLINEDCURVED = "CENTRIFUGALBACKWARDINCLINEDCURVED"; +IfcFanTypeEnum.CENTRIFUGALAIRFOIL = "CENTRIFUGALAIRFOIL"; +IfcFanTypeEnum.TUBEAXIAL = "TUBEAXIAL"; +IfcFanTypeEnum.VANEAXIAL = "VANEAXIAL"; +IfcFanTypeEnum.PROPELLORAXIAL = "PROPELLORAXIAL"; +IfcFanTypeEnum.USERDEFINED = "USERDEFINED"; +IfcFanTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcFastenerTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcFastenerTypeEnum.GLUE = "GLUE"; +IfcFastenerTypeEnum.MORTAR = "MORTAR"; +IfcFastenerTypeEnum.WELD = "WELD"; +IfcFastenerTypeEnum.USERDEFINED = "USERDEFINED"; +IfcFastenerTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcFilterTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcFilterTypeEnum.AIRPARTICLEFILTER = "AIRPARTICLEFILTER"; +IfcFilterTypeEnum.COMPRESSEDAIRFILTER = "COMPRESSEDAIRFILTER"; +IfcFilterTypeEnum.ODORFILTER = "ODORFILTER"; +IfcFilterTypeEnum.OILFILTER = "OILFILTER"; +IfcFilterTypeEnum.STRAINER = "STRAINER"; +IfcFilterTypeEnum.WATERFILTER = "WATERFILTER"; +IfcFilterTypeEnum.USERDEFINED = "USERDEFINED"; +IfcFilterTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcFireSuppressionTerminalTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcFireSuppressionTerminalTypeEnum.BREECHINGINLET = "BREECHINGINLET"; +IfcFireSuppressionTerminalTypeEnum.FIREHYDRANT = "FIREHYDRANT"; +IfcFireSuppressionTerminalTypeEnum.HOSEREEL = "HOSEREEL"; +IfcFireSuppressionTerminalTypeEnum.SPRINKLER = "SPRINKLER"; +IfcFireSuppressionTerminalTypeEnum.SPRINKLERDEFLECTOR = "SPRINKLERDEFLECTOR"; +IfcFireSuppressionTerminalTypeEnum.USERDEFINED = "USERDEFINED"; +IfcFireSuppressionTerminalTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcFlowDirectionEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcFlowDirectionEnum.SOURCE = "SOURCE"; +IfcFlowDirectionEnum.SINK = "SINK"; +IfcFlowDirectionEnum.SOURCEANDSINK = "SOURCEANDSINK"; +IfcFlowDirectionEnum.NOTDEFINED = "NOTDEFINED"; +var IfcFlowInstrumentTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcFlowInstrumentTypeEnum.PRESSUREGAUGE = "PRESSUREGAUGE"; +IfcFlowInstrumentTypeEnum.THERMOMETER = "THERMOMETER"; +IfcFlowInstrumentTypeEnum.AMMETER = "AMMETER"; +IfcFlowInstrumentTypeEnum.FREQUENCYMETER = "FREQUENCYMETER"; +IfcFlowInstrumentTypeEnum.POWERFACTORMETER = "POWERFACTORMETER"; +IfcFlowInstrumentTypeEnum.PHASEANGLEMETER = "PHASEANGLEMETER"; +IfcFlowInstrumentTypeEnum.VOLTMETER_PEAK = "VOLTMETER_PEAK"; +IfcFlowInstrumentTypeEnum.VOLTMETER_RMS = "VOLTMETER_RMS"; +IfcFlowInstrumentTypeEnum.USERDEFINED = "USERDEFINED"; +IfcFlowInstrumentTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcFlowMeterTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcFlowMeterTypeEnum.ENERGYMETER = "ENERGYMETER"; +IfcFlowMeterTypeEnum.GASMETER = "GASMETER"; +IfcFlowMeterTypeEnum.OILMETER = "OILMETER"; +IfcFlowMeterTypeEnum.WATERMETER = "WATERMETER"; +IfcFlowMeterTypeEnum.USERDEFINED = "USERDEFINED"; +IfcFlowMeterTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcFootingTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcFootingTypeEnum.CAISSON_FOUNDATION = "CAISSON_FOUNDATION"; +IfcFootingTypeEnum.FOOTING_BEAM = "FOOTING_BEAM"; +IfcFootingTypeEnum.PAD_FOOTING = "PAD_FOOTING"; +IfcFootingTypeEnum.PILE_CAP = "PILE_CAP"; +IfcFootingTypeEnum.STRIP_FOOTING = "STRIP_FOOTING"; +IfcFootingTypeEnum.USERDEFINED = "USERDEFINED"; +IfcFootingTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcFurnitureTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcFurnitureTypeEnum.CHAIR = "CHAIR"; +IfcFurnitureTypeEnum.TABLE = "TABLE"; +IfcFurnitureTypeEnum.DESK = "DESK"; +IfcFurnitureTypeEnum.BED = "BED"; +IfcFurnitureTypeEnum.FILECABINET = "FILECABINET"; +IfcFurnitureTypeEnum.SHELF = "SHELF"; +IfcFurnitureTypeEnum.SOFA = "SOFA"; +IfcFurnitureTypeEnum.USERDEFINED = "USERDEFINED"; +IfcFurnitureTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcGeographicElementTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcGeographicElementTypeEnum.TERRAIN = "TERRAIN"; +IfcGeographicElementTypeEnum.SOIL_BORING_POINT = "SOIL_BORING_POINT"; +IfcGeographicElementTypeEnum.USERDEFINED = "USERDEFINED"; +IfcGeographicElementTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcGeometricProjectionEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcGeometricProjectionEnum.GRAPH_VIEW = "GRAPH_VIEW"; +IfcGeometricProjectionEnum.SKETCH_VIEW = "SKETCH_VIEW"; +IfcGeometricProjectionEnum.MODEL_VIEW = "MODEL_VIEW"; +IfcGeometricProjectionEnum.PLAN_VIEW = "PLAN_VIEW"; +IfcGeometricProjectionEnum.REFLECTED_PLAN_VIEW = "REFLECTED_PLAN_VIEW"; +IfcGeometricProjectionEnum.SECTION_VIEW = "SECTION_VIEW"; +IfcGeometricProjectionEnum.ELEVATION_VIEW = "ELEVATION_VIEW"; +IfcGeometricProjectionEnum.USERDEFINED = "USERDEFINED"; +IfcGeometricProjectionEnum.NOTDEFINED = "NOTDEFINED"; +var IfcGlobalOrLocalEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcGlobalOrLocalEnum.GLOBAL_COORDS = "GLOBAL_COORDS"; +IfcGlobalOrLocalEnum.LOCAL_COORDS = "LOCAL_COORDS"; +var IfcGridTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcGridTypeEnum.RECTANGULAR = "RECTANGULAR"; +IfcGridTypeEnum.RADIAL = "RADIAL"; +IfcGridTypeEnum.TRIANGULAR = "TRIANGULAR"; +IfcGridTypeEnum.IRREGULAR = "IRREGULAR"; +IfcGridTypeEnum.USERDEFINED = "USERDEFINED"; +IfcGridTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcHeatExchangerTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcHeatExchangerTypeEnum.PLATE = "PLATE"; +IfcHeatExchangerTypeEnum.SHELLANDTUBE = "SHELLANDTUBE"; +IfcHeatExchangerTypeEnum.USERDEFINED = "USERDEFINED"; +IfcHeatExchangerTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcHumidifierTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcHumidifierTypeEnum.STEAMINJECTION = "STEAMINJECTION"; +IfcHumidifierTypeEnum.ADIABATICAIRWASHER = "ADIABATICAIRWASHER"; +IfcHumidifierTypeEnum.ADIABATICPAN = "ADIABATICPAN"; +IfcHumidifierTypeEnum.ADIABATICWETTEDELEMENT = "ADIABATICWETTEDELEMENT"; +IfcHumidifierTypeEnum.ADIABATICATOMIZING = "ADIABATICATOMIZING"; +IfcHumidifierTypeEnum.ADIABATICULTRASONIC = "ADIABATICULTRASONIC"; +IfcHumidifierTypeEnum.ADIABATICRIGIDMEDIA = "ADIABATICRIGIDMEDIA"; +IfcHumidifierTypeEnum.ADIABATICCOMPRESSEDAIRNOZZLE = "ADIABATICCOMPRESSEDAIRNOZZLE"; +IfcHumidifierTypeEnum.ASSISTEDELECTRIC = "ASSISTEDELECTRIC"; +IfcHumidifierTypeEnum.ASSISTEDNATURALGAS = "ASSISTEDNATURALGAS"; +IfcHumidifierTypeEnum.ASSISTEDPROPANE = "ASSISTEDPROPANE"; +IfcHumidifierTypeEnum.ASSISTEDBUTANE = "ASSISTEDBUTANE"; +IfcHumidifierTypeEnum.ASSISTEDSTEAM = "ASSISTEDSTEAM"; +IfcHumidifierTypeEnum.USERDEFINED = "USERDEFINED"; +IfcHumidifierTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcInterceptorTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcInterceptorTypeEnum.CYCLONIC = "CYCLONIC"; +IfcInterceptorTypeEnum.GREASE = "GREASE"; +IfcInterceptorTypeEnum.OIL = "OIL"; +IfcInterceptorTypeEnum.PETROL = "PETROL"; +IfcInterceptorTypeEnum.USERDEFINED = "USERDEFINED"; +IfcInterceptorTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcInternalOrExternalEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcInternalOrExternalEnum.INTERNAL = "INTERNAL"; +IfcInternalOrExternalEnum.EXTERNAL = "EXTERNAL"; +IfcInternalOrExternalEnum.EXTERNAL_EARTH = "EXTERNAL_EARTH"; +IfcInternalOrExternalEnum.EXTERNAL_WATER = "EXTERNAL_WATER"; +IfcInternalOrExternalEnum.EXTERNAL_FIRE = "EXTERNAL_FIRE"; +IfcInternalOrExternalEnum.NOTDEFINED = "NOTDEFINED"; +var IfcInventoryTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcInventoryTypeEnum.ASSETINVENTORY = "ASSETINVENTORY"; +IfcInventoryTypeEnum.SPACEINVENTORY = "SPACEINVENTORY"; +IfcInventoryTypeEnum.FURNITUREINVENTORY = "FURNITUREINVENTORY"; +IfcInventoryTypeEnum.USERDEFINED = "USERDEFINED"; +IfcInventoryTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcJunctionBoxTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcJunctionBoxTypeEnum.DATA = "DATA"; +IfcJunctionBoxTypeEnum.POWER = "POWER"; +IfcJunctionBoxTypeEnum.USERDEFINED = "USERDEFINED"; +IfcJunctionBoxTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcKnotType = class { + constructor(v) { + this.value = v; + } +}; +IfcKnotType.UNIFORM_KNOTS = "UNIFORM_KNOTS"; +IfcKnotType.QUASI_UNIFORM_KNOTS = "QUASI_UNIFORM_KNOTS"; +IfcKnotType.PIECEWISE_BEZIER_KNOTS = "PIECEWISE_BEZIER_KNOTS"; +IfcKnotType.UNSPECIFIED = "UNSPECIFIED"; +var IfcLaborResourceTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcLaborResourceTypeEnum.ADMINISTRATION = "ADMINISTRATION"; +IfcLaborResourceTypeEnum.CARPENTRY = "CARPENTRY"; +IfcLaborResourceTypeEnum.CLEANING = "CLEANING"; +IfcLaborResourceTypeEnum.CONCRETE = "CONCRETE"; +IfcLaborResourceTypeEnum.DRYWALL = "DRYWALL"; +IfcLaborResourceTypeEnum.ELECTRIC = "ELECTRIC"; +IfcLaborResourceTypeEnum.FINISHING = "FINISHING"; +IfcLaborResourceTypeEnum.FLOORING = "FLOORING"; +IfcLaborResourceTypeEnum.GENERAL = "GENERAL"; +IfcLaborResourceTypeEnum.HVAC = "HVAC"; +IfcLaborResourceTypeEnum.LANDSCAPING = "LANDSCAPING"; +IfcLaborResourceTypeEnum.MASONRY = "MASONRY"; +IfcLaborResourceTypeEnum.PAINTING = "PAINTING"; +IfcLaborResourceTypeEnum.PAVING = "PAVING"; +IfcLaborResourceTypeEnum.PLUMBING = "PLUMBING"; +IfcLaborResourceTypeEnum.ROOFING = "ROOFING"; +IfcLaborResourceTypeEnum.SITEGRADING = "SITEGRADING"; +IfcLaborResourceTypeEnum.STEELWORK = "STEELWORK"; +IfcLaborResourceTypeEnum.SURVEYING = "SURVEYING"; +IfcLaborResourceTypeEnum.USERDEFINED = "USERDEFINED"; +IfcLaborResourceTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcLampTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcLampTypeEnum.COMPACTFLUORESCENT = "COMPACTFLUORESCENT"; +IfcLampTypeEnum.FLUORESCENT = "FLUORESCENT"; +IfcLampTypeEnum.HALOGEN = "HALOGEN"; +IfcLampTypeEnum.HIGHPRESSUREMERCURY = "HIGHPRESSUREMERCURY"; +IfcLampTypeEnum.HIGHPRESSURESODIUM = "HIGHPRESSURESODIUM"; +IfcLampTypeEnum.LED = "LED"; +IfcLampTypeEnum.METALHALIDE = "METALHALIDE"; +IfcLampTypeEnum.OLED = "OLED"; +IfcLampTypeEnum.TUNGSTENFILAMENT = "TUNGSTENFILAMENT"; +IfcLampTypeEnum.USERDEFINED = "USERDEFINED"; +IfcLampTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcLayerSetDirectionEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcLayerSetDirectionEnum.AXIS1 = "AXIS1"; +IfcLayerSetDirectionEnum.AXIS2 = "AXIS2"; +IfcLayerSetDirectionEnum.AXIS3 = "AXIS3"; +var IfcLightDistributionCurveEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcLightDistributionCurveEnum.TYPE_A = "TYPE_A"; +IfcLightDistributionCurveEnum.TYPE_B = "TYPE_B"; +IfcLightDistributionCurveEnum.TYPE_C = "TYPE_C"; +IfcLightDistributionCurveEnum.NOTDEFINED = "NOTDEFINED"; +var IfcLightEmissionSourceEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcLightEmissionSourceEnum.COMPACTFLUORESCENT = "COMPACTFLUORESCENT"; +IfcLightEmissionSourceEnum.FLUORESCENT = "FLUORESCENT"; +IfcLightEmissionSourceEnum.HIGHPRESSUREMERCURY = "HIGHPRESSUREMERCURY"; +IfcLightEmissionSourceEnum.HIGHPRESSURESODIUM = "HIGHPRESSURESODIUM"; +IfcLightEmissionSourceEnum.LIGHTEMITTINGDIODE = "LIGHTEMITTINGDIODE"; +IfcLightEmissionSourceEnum.LOWPRESSURESODIUM = "LOWPRESSURESODIUM"; +IfcLightEmissionSourceEnum.LOWVOLTAGEHALOGEN = "LOWVOLTAGEHALOGEN"; +IfcLightEmissionSourceEnum.MAINVOLTAGEHALOGEN = "MAINVOLTAGEHALOGEN"; +IfcLightEmissionSourceEnum.METALHALIDE = "METALHALIDE"; +IfcLightEmissionSourceEnum.TUNGSTENFILAMENT = "TUNGSTENFILAMENT"; +IfcLightEmissionSourceEnum.NOTDEFINED = "NOTDEFINED"; +var IfcLightFixtureTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcLightFixtureTypeEnum.POINTSOURCE = "POINTSOURCE"; +IfcLightFixtureTypeEnum.DIRECTIONSOURCE = "DIRECTIONSOURCE"; +IfcLightFixtureTypeEnum.SECURITYLIGHTING = "SECURITYLIGHTING"; +IfcLightFixtureTypeEnum.USERDEFINED = "USERDEFINED"; +IfcLightFixtureTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcLoadGroupTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcLoadGroupTypeEnum.LOAD_GROUP = "LOAD_GROUP"; +IfcLoadGroupTypeEnum.LOAD_CASE = "LOAD_CASE"; +IfcLoadGroupTypeEnum.LOAD_COMBINATION = "LOAD_COMBINATION"; +IfcLoadGroupTypeEnum.USERDEFINED = "USERDEFINED"; +IfcLoadGroupTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcLogicalOperatorEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcLogicalOperatorEnum.LOGICALAND = "LOGICALAND"; +IfcLogicalOperatorEnum.LOGICALOR = "LOGICALOR"; +IfcLogicalOperatorEnum.LOGICALXOR = "LOGICALXOR"; +IfcLogicalOperatorEnum.LOGICALNOTAND = "LOGICALNOTAND"; +IfcLogicalOperatorEnum.LOGICALNOTOR = "LOGICALNOTOR"; +var IfcMechanicalFastenerTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcMechanicalFastenerTypeEnum.ANCHORBOLT = "ANCHORBOLT"; +IfcMechanicalFastenerTypeEnum.BOLT = "BOLT"; +IfcMechanicalFastenerTypeEnum.DOWEL = "DOWEL"; +IfcMechanicalFastenerTypeEnum.NAIL = "NAIL"; +IfcMechanicalFastenerTypeEnum.NAILPLATE = "NAILPLATE"; +IfcMechanicalFastenerTypeEnum.RIVET = "RIVET"; +IfcMechanicalFastenerTypeEnum.SCREW = "SCREW"; +IfcMechanicalFastenerTypeEnum.SHEARCONNECTOR = "SHEARCONNECTOR"; +IfcMechanicalFastenerTypeEnum.STAPLE = "STAPLE"; +IfcMechanicalFastenerTypeEnum.STUDSHEARCONNECTOR = "STUDSHEARCONNECTOR"; +IfcMechanicalFastenerTypeEnum.COUPLER = "COUPLER"; +IfcMechanicalFastenerTypeEnum.USERDEFINED = "USERDEFINED"; +IfcMechanicalFastenerTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcMedicalDeviceTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcMedicalDeviceTypeEnum.AIRSTATION = "AIRSTATION"; +IfcMedicalDeviceTypeEnum.FEEDAIRUNIT = "FEEDAIRUNIT"; +IfcMedicalDeviceTypeEnum.OXYGENGENERATOR = "OXYGENGENERATOR"; +IfcMedicalDeviceTypeEnum.OXYGENPLANT = "OXYGENPLANT"; +IfcMedicalDeviceTypeEnum.VACUUMSTATION = "VACUUMSTATION"; +IfcMedicalDeviceTypeEnum.USERDEFINED = "USERDEFINED"; +IfcMedicalDeviceTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcMemberTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcMemberTypeEnum.BRACE = "BRACE"; +IfcMemberTypeEnum.CHORD = "CHORD"; +IfcMemberTypeEnum.COLLAR = "COLLAR"; +IfcMemberTypeEnum.MEMBER = "MEMBER"; +IfcMemberTypeEnum.MULLION = "MULLION"; +IfcMemberTypeEnum.PLATE = "PLATE"; +IfcMemberTypeEnum.POST = "POST"; +IfcMemberTypeEnum.PURLIN = "PURLIN"; +IfcMemberTypeEnum.RAFTER = "RAFTER"; +IfcMemberTypeEnum.STRINGER = "STRINGER"; +IfcMemberTypeEnum.STRUT = "STRUT"; +IfcMemberTypeEnum.STUD = "STUD"; +IfcMemberTypeEnum.STIFFENING_RIB = "STIFFENING_RIB"; +IfcMemberTypeEnum.ARCH_SEGMENT = "ARCH_SEGMENT"; +IfcMemberTypeEnum.SUSPENSION_CABLE = "SUSPENSION_CABLE"; +IfcMemberTypeEnum.SUSPENDER = "SUSPENDER"; +IfcMemberTypeEnum.STAY_CABLE = "STAY_CABLE"; +IfcMemberTypeEnum.USERDEFINED = "USERDEFINED"; +IfcMemberTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcMotorConnectionTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcMotorConnectionTypeEnum.BELTDRIVE = "BELTDRIVE"; +IfcMotorConnectionTypeEnum.COUPLING = "COUPLING"; +IfcMotorConnectionTypeEnum.DIRECTDRIVE = "DIRECTDRIVE"; +IfcMotorConnectionTypeEnum.USERDEFINED = "USERDEFINED"; +IfcMotorConnectionTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcNullStyle = class { + constructor(v) { + this.value = v; + } +}; +IfcNullStyle.NULL = "NULL"; +var IfcObjectTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcObjectTypeEnum.PRODUCT = "PRODUCT"; +IfcObjectTypeEnum.PROCESS = "PROCESS"; +IfcObjectTypeEnum.CONTROL = "CONTROL"; +IfcObjectTypeEnum.RESOURCE = "RESOURCE"; +IfcObjectTypeEnum.ACTOR = "ACTOR"; +IfcObjectTypeEnum.GROUP = "GROUP"; +IfcObjectTypeEnum.PROJECT = "PROJECT"; +IfcObjectTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcObjectiveEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcObjectiveEnum.CODECOMPLIANCE = "CODECOMPLIANCE"; +IfcObjectiveEnum.CODEWAIVER = "CODEWAIVER"; +IfcObjectiveEnum.DESIGNINTENT = "DESIGNINTENT"; +IfcObjectiveEnum.EXTERNAL = "EXTERNAL"; +IfcObjectiveEnum.HEALTHANDSAFETY = "HEALTHANDSAFETY"; +IfcObjectiveEnum.MERGECONFLICT = "MERGECONFLICT"; +IfcObjectiveEnum.MODELVIEW = "MODELVIEW"; +IfcObjectiveEnum.PARAMETER = "PARAMETER"; +IfcObjectiveEnum.REQUIREMENT = "REQUIREMENT"; +IfcObjectiveEnum.SPECIFICATION = "SPECIFICATION"; +IfcObjectiveEnum.TRIGGERCONDITION = "TRIGGERCONDITION"; +IfcObjectiveEnum.USERDEFINED = "USERDEFINED"; +IfcObjectiveEnum.NOTDEFINED = "NOTDEFINED"; +var IfcOccupantTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcOccupantTypeEnum.ASSIGNEE = "ASSIGNEE"; +IfcOccupantTypeEnum.ASSIGNOR = "ASSIGNOR"; +IfcOccupantTypeEnum.LESSEE = "LESSEE"; +IfcOccupantTypeEnum.LESSOR = "LESSOR"; +IfcOccupantTypeEnum.LETTINGAGENT = "LETTINGAGENT"; +IfcOccupantTypeEnum.OWNER = "OWNER"; +IfcOccupantTypeEnum.TENANT = "TENANT"; +IfcOccupantTypeEnum.USERDEFINED = "USERDEFINED"; +IfcOccupantTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcOpeningElementTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcOpeningElementTypeEnum.OPENING = "OPENING"; +IfcOpeningElementTypeEnum.RECESS = "RECESS"; +IfcOpeningElementTypeEnum.USERDEFINED = "USERDEFINED"; +IfcOpeningElementTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcOutletTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcOutletTypeEnum.AUDIOVISUALOUTLET = "AUDIOVISUALOUTLET"; +IfcOutletTypeEnum.COMMUNICATIONSOUTLET = "COMMUNICATIONSOUTLET"; +IfcOutletTypeEnum.POWEROUTLET = "POWEROUTLET"; +IfcOutletTypeEnum.DATAOUTLET = "DATAOUTLET"; +IfcOutletTypeEnum.TELEPHONEOUTLET = "TELEPHONEOUTLET"; +IfcOutletTypeEnum.USERDEFINED = "USERDEFINED"; +IfcOutletTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcPerformanceHistoryTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcPerformanceHistoryTypeEnum.USERDEFINED = "USERDEFINED"; +IfcPerformanceHistoryTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcPermeableCoveringOperationEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcPermeableCoveringOperationEnum.GRILL = "GRILL"; +IfcPermeableCoveringOperationEnum.LOUVER = "LOUVER"; +IfcPermeableCoveringOperationEnum.SCREEN = "SCREEN"; +IfcPermeableCoveringOperationEnum.USERDEFINED = "USERDEFINED"; +IfcPermeableCoveringOperationEnum.NOTDEFINED = "NOTDEFINED"; +var IfcPermitTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcPermitTypeEnum.ACCESS = "ACCESS"; +IfcPermitTypeEnum.BUILDING = "BUILDING"; +IfcPermitTypeEnum.WORK = "WORK"; +IfcPermitTypeEnum.USERDEFINED = "USERDEFINED"; +IfcPermitTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcPhysicalOrVirtualEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcPhysicalOrVirtualEnum.PHYSICAL = "PHYSICAL"; +IfcPhysicalOrVirtualEnum.VIRTUAL = "VIRTUAL"; +IfcPhysicalOrVirtualEnum.NOTDEFINED = "NOTDEFINED"; +var IfcPileConstructionEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcPileConstructionEnum.CAST_IN_PLACE = "CAST_IN_PLACE"; +IfcPileConstructionEnum.COMPOSITE = "COMPOSITE"; +IfcPileConstructionEnum.PRECAST_CONCRETE = "PRECAST_CONCRETE"; +IfcPileConstructionEnum.PREFAB_STEEL = "PREFAB_STEEL"; +IfcPileConstructionEnum.USERDEFINED = "USERDEFINED"; +IfcPileConstructionEnum.NOTDEFINED = "NOTDEFINED"; +var IfcPileTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcPileTypeEnum.BORED = "BORED"; +IfcPileTypeEnum.DRIVEN = "DRIVEN"; +IfcPileTypeEnum.JETGROUTING = "JETGROUTING"; +IfcPileTypeEnum.COHESION = "COHESION"; +IfcPileTypeEnum.FRICTION = "FRICTION"; +IfcPileTypeEnum.SUPPORT = "SUPPORT"; +IfcPileTypeEnum.USERDEFINED = "USERDEFINED"; +IfcPileTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcPipeFittingTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcPipeFittingTypeEnum.BEND = "BEND"; +IfcPipeFittingTypeEnum.CONNECTOR = "CONNECTOR"; +IfcPipeFittingTypeEnum.ENTRY = "ENTRY"; +IfcPipeFittingTypeEnum.EXIT = "EXIT"; +IfcPipeFittingTypeEnum.JUNCTION = "JUNCTION"; +IfcPipeFittingTypeEnum.OBSTRUCTION = "OBSTRUCTION"; +IfcPipeFittingTypeEnum.TRANSITION = "TRANSITION"; +IfcPipeFittingTypeEnum.USERDEFINED = "USERDEFINED"; +IfcPipeFittingTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcPipeSegmentTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcPipeSegmentTypeEnum.CULVERT = "CULVERT"; +IfcPipeSegmentTypeEnum.FLEXIBLESEGMENT = "FLEXIBLESEGMENT"; +IfcPipeSegmentTypeEnum.RIGIDSEGMENT = "RIGIDSEGMENT"; +IfcPipeSegmentTypeEnum.GUTTER = "GUTTER"; +IfcPipeSegmentTypeEnum.SPOOL = "SPOOL"; +IfcPipeSegmentTypeEnum.USERDEFINED = "USERDEFINED"; +IfcPipeSegmentTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcPlateTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcPlateTypeEnum.CURTAIN_PANEL = "CURTAIN_PANEL"; +IfcPlateTypeEnum.SHEET = "SHEET"; +IfcPlateTypeEnum.FLANGE_PLATE = "FLANGE_PLATE"; +IfcPlateTypeEnum.WEB_PLATE = "WEB_PLATE"; +IfcPlateTypeEnum.STIFFENER_PLATE = "STIFFENER_PLATE"; +IfcPlateTypeEnum.GUSSET_PLATE = "GUSSET_PLATE"; +IfcPlateTypeEnum.COVER_PLATE = "COVER_PLATE"; +IfcPlateTypeEnum.SPLICE_PLATE = "SPLICE_PLATE"; +IfcPlateTypeEnum.BASE_PLATE = "BASE_PLATE"; +IfcPlateTypeEnum.USERDEFINED = "USERDEFINED"; +IfcPlateTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcPreferredSurfaceCurveRepresentation = class { + constructor(v) { + this.value = v; + } +}; +IfcPreferredSurfaceCurveRepresentation.CURVE3D = "CURVE3D"; +IfcPreferredSurfaceCurveRepresentation.PCURVE_S1 = "PCURVE_S1"; +IfcPreferredSurfaceCurveRepresentation.PCURVE_S2 = "PCURVE_S2"; +var IfcProcedureTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcProcedureTypeEnum.ADVICE_CAUTION = "ADVICE_CAUTION"; +IfcProcedureTypeEnum.ADVICE_NOTE = "ADVICE_NOTE"; +IfcProcedureTypeEnum.ADVICE_WARNING = "ADVICE_WARNING"; +IfcProcedureTypeEnum.CALIBRATION = "CALIBRATION"; +IfcProcedureTypeEnum.DIAGNOSTIC = "DIAGNOSTIC"; +IfcProcedureTypeEnum.SHUTDOWN = "SHUTDOWN"; +IfcProcedureTypeEnum.STARTUP = "STARTUP"; +IfcProcedureTypeEnum.USERDEFINED = "USERDEFINED"; +IfcProcedureTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcProfileTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcProfileTypeEnum.CURVE = "CURVE"; +IfcProfileTypeEnum.AREA = "AREA"; +var IfcProjectOrderTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcProjectOrderTypeEnum.CHANGEORDER = "CHANGEORDER"; +IfcProjectOrderTypeEnum.MAINTENANCEWORKORDER = "MAINTENANCEWORKORDER"; +IfcProjectOrderTypeEnum.MOVEORDER = "MOVEORDER"; +IfcProjectOrderTypeEnum.PURCHASEORDER = "PURCHASEORDER"; +IfcProjectOrderTypeEnum.WORKORDER = "WORKORDER"; +IfcProjectOrderTypeEnum.USERDEFINED = "USERDEFINED"; +IfcProjectOrderTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcProjectedOrTrueLengthEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcProjectedOrTrueLengthEnum.PROJECTED_LENGTH = "PROJECTED_LENGTH"; +IfcProjectedOrTrueLengthEnum.TRUE_LENGTH = "TRUE_LENGTH"; +var IfcProjectionElementTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcProjectionElementTypeEnum.BLISTER = "BLISTER"; +IfcProjectionElementTypeEnum.DEVIATOR = "DEVIATOR"; +IfcProjectionElementTypeEnum.USERDEFINED = "USERDEFINED"; +IfcProjectionElementTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcPropertySetTemplateTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENONLY = "PSET_TYPEDRIVENONLY"; +IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENOVERRIDE = "PSET_TYPEDRIVENOVERRIDE"; +IfcPropertySetTemplateTypeEnum.PSET_OCCURRENCEDRIVEN = "PSET_OCCURRENCEDRIVEN"; +IfcPropertySetTemplateTypeEnum.PSET_PERFORMANCEDRIVEN = "PSET_PERFORMANCEDRIVEN"; +IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENONLY = "QTO_TYPEDRIVENONLY"; +IfcPropertySetTemplateTypeEnum.QTO_TYPEDRIVENOVERRIDE = "QTO_TYPEDRIVENOVERRIDE"; +IfcPropertySetTemplateTypeEnum.QTO_OCCURRENCEDRIVEN = "QTO_OCCURRENCEDRIVEN"; +IfcPropertySetTemplateTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcProtectiveDeviceTrippingUnitTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTRONIC = "ELECTRONIC"; +IfcProtectiveDeviceTrippingUnitTypeEnum.ELECTROMAGNETIC = "ELECTROMAGNETIC"; +IfcProtectiveDeviceTrippingUnitTypeEnum.RESIDUALCURRENT = "RESIDUALCURRENT"; +IfcProtectiveDeviceTrippingUnitTypeEnum.THERMAL = "THERMAL"; +IfcProtectiveDeviceTrippingUnitTypeEnum.USERDEFINED = "USERDEFINED"; +IfcProtectiveDeviceTrippingUnitTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcProtectiveDeviceTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcProtectiveDeviceTypeEnum.CIRCUITBREAKER = "CIRCUITBREAKER"; +IfcProtectiveDeviceTypeEnum.EARTHLEAKAGECIRCUITBREAKER = "EARTHLEAKAGECIRCUITBREAKER"; +IfcProtectiveDeviceTypeEnum.EARTHINGSWITCH = "EARTHINGSWITCH"; +IfcProtectiveDeviceTypeEnum.FUSEDISCONNECTOR = "FUSEDISCONNECTOR"; +IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTCIRCUITBREAKER = "RESIDUALCURRENTCIRCUITBREAKER"; +IfcProtectiveDeviceTypeEnum.RESIDUALCURRENTSWITCH = "RESIDUALCURRENTSWITCH"; +IfcProtectiveDeviceTypeEnum.VARISTOR = "VARISTOR"; +IfcProtectiveDeviceTypeEnum.USERDEFINED = "USERDEFINED"; +IfcProtectiveDeviceTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcPumpTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcPumpTypeEnum.CIRCULATOR = "CIRCULATOR"; +IfcPumpTypeEnum.ENDSUCTION = "ENDSUCTION"; +IfcPumpTypeEnum.SPLITCASE = "SPLITCASE"; +IfcPumpTypeEnum.SUBMERSIBLEPUMP = "SUBMERSIBLEPUMP"; +IfcPumpTypeEnum.SUMPPUMP = "SUMPPUMP"; +IfcPumpTypeEnum.VERTICALINLINE = "VERTICALINLINE"; +IfcPumpTypeEnum.VERTICALTURBINE = "VERTICALTURBINE"; +IfcPumpTypeEnum.USERDEFINED = "USERDEFINED"; +IfcPumpTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcRailingTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcRailingTypeEnum.HANDRAIL = "HANDRAIL"; +IfcRailingTypeEnum.GUARDRAIL = "GUARDRAIL"; +IfcRailingTypeEnum.BALUSTRADE = "BALUSTRADE"; +IfcRailingTypeEnum.USERDEFINED = "USERDEFINED"; +IfcRailingTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcRampFlightTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcRampFlightTypeEnum.STRAIGHT = "STRAIGHT"; +IfcRampFlightTypeEnum.SPIRAL = "SPIRAL"; +IfcRampFlightTypeEnum.USERDEFINED = "USERDEFINED"; +IfcRampFlightTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcRampTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcRampTypeEnum.STRAIGHT_RUN_RAMP = "STRAIGHT_RUN_RAMP"; +IfcRampTypeEnum.TWO_STRAIGHT_RUN_RAMP = "TWO_STRAIGHT_RUN_RAMP"; +IfcRampTypeEnum.QUARTER_TURN_RAMP = "QUARTER_TURN_RAMP"; +IfcRampTypeEnum.TWO_QUARTER_TURN_RAMP = "TWO_QUARTER_TURN_RAMP"; +IfcRampTypeEnum.HALF_TURN_RAMP = "HALF_TURN_RAMP"; +IfcRampTypeEnum.SPIRAL_RAMP = "SPIRAL_RAMP"; +IfcRampTypeEnum.USERDEFINED = "USERDEFINED"; +IfcRampTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcRecurrenceTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcRecurrenceTypeEnum.DAILY = "DAILY"; +IfcRecurrenceTypeEnum.WEEKLY = "WEEKLY"; +IfcRecurrenceTypeEnum.MONTHLY_BY_DAY_OF_MONTH = "MONTHLY_BY_DAY_OF_MONTH"; +IfcRecurrenceTypeEnum.MONTHLY_BY_POSITION = "MONTHLY_BY_POSITION"; +IfcRecurrenceTypeEnum.BY_DAY_COUNT = "BY_DAY_COUNT"; +IfcRecurrenceTypeEnum.BY_WEEKDAY_COUNT = "BY_WEEKDAY_COUNT"; +IfcRecurrenceTypeEnum.YEARLY_BY_DAY_OF_MONTH = "YEARLY_BY_DAY_OF_MONTH"; +IfcRecurrenceTypeEnum.YEARLY_BY_POSITION = "YEARLY_BY_POSITION"; +var IfcReferentTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcReferentTypeEnum.KILOPOINT = "KILOPOINT"; +IfcReferentTypeEnum.MILEPOINT = "MILEPOINT"; +IfcReferentTypeEnum.STATION = "STATION"; +IfcReferentTypeEnum.USERDEFINED = "USERDEFINED"; +IfcReferentTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcReflectanceMethodEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcReflectanceMethodEnum.BLINN = "BLINN"; +IfcReflectanceMethodEnum.FLAT = "FLAT"; +IfcReflectanceMethodEnum.GLASS = "GLASS"; +IfcReflectanceMethodEnum.MATT = "MATT"; +IfcReflectanceMethodEnum.METAL = "METAL"; +IfcReflectanceMethodEnum.MIRROR = "MIRROR"; +IfcReflectanceMethodEnum.PHONG = "PHONG"; +IfcReflectanceMethodEnum.PLASTIC = "PLASTIC"; +IfcReflectanceMethodEnum.STRAUSS = "STRAUSS"; +IfcReflectanceMethodEnum.NOTDEFINED = "NOTDEFINED"; +var IfcReinforcingBarRoleEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcReinforcingBarRoleEnum.MAIN = "MAIN"; +IfcReinforcingBarRoleEnum.SHEAR = "SHEAR"; +IfcReinforcingBarRoleEnum.LIGATURE = "LIGATURE"; +IfcReinforcingBarRoleEnum.STUD = "STUD"; +IfcReinforcingBarRoleEnum.PUNCHING = "PUNCHING"; +IfcReinforcingBarRoleEnum.EDGE = "EDGE"; +IfcReinforcingBarRoleEnum.RING = "RING"; +IfcReinforcingBarRoleEnum.ANCHORING = "ANCHORING"; +IfcReinforcingBarRoleEnum.USERDEFINED = "USERDEFINED"; +IfcReinforcingBarRoleEnum.NOTDEFINED = "NOTDEFINED"; +var IfcReinforcingBarSurfaceEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcReinforcingBarSurfaceEnum.PLAIN = "PLAIN"; +IfcReinforcingBarSurfaceEnum.TEXTURED = "TEXTURED"; +var IfcReinforcingBarTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcReinforcingBarTypeEnum.ANCHORING = "ANCHORING"; +IfcReinforcingBarTypeEnum.EDGE = "EDGE"; +IfcReinforcingBarTypeEnum.LIGATURE = "LIGATURE"; +IfcReinforcingBarTypeEnum.MAIN = "MAIN"; +IfcReinforcingBarTypeEnum.PUNCHING = "PUNCHING"; +IfcReinforcingBarTypeEnum.RING = "RING"; +IfcReinforcingBarTypeEnum.SHEAR = "SHEAR"; +IfcReinforcingBarTypeEnum.STUD = "STUD"; +IfcReinforcingBarTypeEnum.SPACEBAR = "SPACEBAR"; +IfcReinforcingBarTypeEnum.USERDEFINED = "USERDEFINED"; +IfcReinforcingBarTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcReinforcingMeshTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcReinforcingMeshTypeEnum.USERDEFINED = "USERDEFINED"; +IfcReinforcingMeshTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcRoleEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcRoleEnum.SUPPLIER = "SUPPLIER"; +IfcRoleEnum.MANUFACTURER = "MANUFACTURER"; +IfcRoleEnum.CONTRACTOR = "CONTRACTOR"; +IfcRoleEnum.SUBCONTRACTOR = "SUBCONTRACTOR"; +IfcRoleEnum.ARCHITECT = "ARCHITECT"; +IfcRoleEnum.STRUCTURALENGINEER = "STRUCTURALENGINEER"; +IfcRoleEnum.COSTENGINEER = "COSTENGINEER"; +IfcRoleEnum.CLIENT = "CLIENT"; +IfcRoleEnum.BUILDINGOWNER = "BUILDINGOWNER"; +IfcRoleEnum.BUILDINGOPERATOR = "BUILDINGOPERATOR"; +IfcRoleEnum.MECHANICALENGINEER = "MECHANICALENGINEER"; +IfcRoleEnum.ELECTRICALENGINEER = "ELECTRICALENGINEER"; +IfcRoleEnum.PROJECTMANAGER = "PROJECTMANAGER"; +IfcRoleEnum.FACILITIESMANAGER = "FACILITIESMANAGER"; +IfcRoleEnum.CIVILENGINEER = "CIVILENGINEER"; +IfcRoleEnum.COMMISSIONINGENGINEER = "COMMISSIONINGENGINEER"; +IfcRoleEnum.ENGINEER = "ENGINEER"; +IfcRoleEnum.OWNER = "OWNER"; +IfcRoleEnum.CONSULTANT = "CONSULTANT"; +IfcRoleEnum.CONSTRUCTIONMANAGER = "CONSTRUCTIONMANAGER"; +IfcRoleEnum.FIELDCONSTRUCTIONMANAGER = "FIELDCONSTRUCTIONMANAGER"; +IfcRoleEnum.RESELLER = "RESELLER"; +IfcRoleEnum.USERDEFINED = "USERDEFINED"; +var IfcRoofTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcRoofTypeEnum.FLAT_ROOF = "FLAT_ROOF"; +IfcRoofTypeEnum.SHED_ROOF = "SHED_ROOF"; +IfcRoofTypeEnum.GABLE_ROOF = "GABLE_ROOF"; +IfcRoofTypeEnum.HIP_ROOF = "HIP_ROOF"; +IfcRoofTypeEnum.HIPPED_GABLE_ROOF = "HIPPED_GABLE_ROOF"; +IfcRoofTypeEnum.GAMBREL_ROOF = "GAMBREL_ROOF"; +IfcRoofTypeEnum.MANSARD_ROOF = "MANSARD_ROOF"; +IfcRoofTypeEnum.BARREL_ROOF = "BARREL_ROOF"; +IfcRoofTypeEnum.RAINBOW_ROOF = "RAINBOW_ROOF"; +IfcRoofTypeEnum.BUTTERFLY_ROOF = "BUTTERFLY_ROOF"; +IfcRoofTypeEnum.PAVILION_ROOF = "PAVILION_ROOF"; +IfcRoofTypeEnum.DOME_ROOF = "DOME_ROOF"; +IfcRoofTypeEnum.FREEFORM = "FREEFORM"; +IfcRoofTypeEnum.USERDEFINED = "USERDEFINED"; +IfcRoofTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcSIPrefix = class { + constructor(v) { + this.value = v; + } +}; +IfcSIPrefix.EXA = "EXA"; +IfcSIPrefix.PETA = "PETA"; +IfcSIPrefix.TERA = "TERA"; +IfcSIPrefix.GIGA = "GIGA"; +IfcSIPrefix.MEGA = "MEGA"; +IfcSIPrefix.KILO = "KILO"; +IfcSIPrefix.HECTO = "HECTO"; +IfcSIPrefix.DECA = "DECA"; +IfcSIPrefix.DECI = "DECI"; +IfcSIPrefix.CENTI = "CENTI"; +IfcSIPrefix.MILLI = "MILLI"; +IfcSIPrefix.MICRO = "MICRO"; +IfcSIPrefix.NANO = "NANO"; +IfcSIPrefix.PICO = "PICO"; +IfcSIPrefix.FEMTO = "FEMTO"; +IfcSIPrefix.ATTO = "ATTO"; +var IfcSIUnitName = class { + constructor(v) { + this.value = v; + } +}; +IfcSIUnitName.AMPERE = "AMPERE"; +IfcSIUnitName.BECQUEREL = "BECQUEREL"; +IfcSIUnitName.CANDELA = "CANDELA"; +IfcSIUnitName.COULOMB = "COULOMB"; +IfcSIUnitName.CUBIC_METRE = "CUBIC_METRE"; +IfcSIUnitName.DEGREE_CELSIUS = "DEGREE_CELSIUS"; +IfcSIUnitName.FARAD = "FARAD"; +IfcSIUnitName.GRAM = "GRAM"; +IfcSIUnitName.GRAY = "GRAY"; +IfcSIUnitName.HENRY = "HENRY"; +IfcSIUnitName.HERTZ = "HERTZ"; +IfcSIUnitName.JOULE = "JOULE"; +IfcSIUnitName.KELVIN = "KELVIN"; +IfcSIUnitName.LUMEN = "LUMEN"; +IfcSIUnitName.LUX = "LUX"; +IfcSIUnitName.METRE = "METRE"; +IfcSIUnitName.MOLE = "MOLE"; +IfcSIUnitName.NEWTON = "NEWTON"; +IfcSIUnitName.OHM = "OHM"; +IfcSIUnitName.PASCAL = "PASCAL"; +IfcSIUnitName.RADIAN = "RADIAN"; +IfcSIUnitName.SECOND = "SECOND"; +IfcSIUnitName.SIEMENS = "SIEMENS"; +IfcSIUnitName.SIEVERT = "SIEVERT"; +IfcSIUnitName.SQUARE_METRE = "SQUARE_METRE"; +IfcSIUnitName.STERADIAN = "STERADIAN"; +IfcSIUnitName.TESLA = "TESLA"; +IfcSIUnitName.VOLT = "VOLT"; +IfcSIUnitName.WATT = "WATT"; +IfcSIUnitName.WEBER = "WEBER"; +var IfcSanitaryTerminalTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcSanitaryTerminalTypeEnum.BATH = "BATH"; +IfcSanitaryTerminalTypeEnum.BIDET = "BIDET"; +IfcSanitaryTerminalTypeEnum.CISTERN = "CISTERN"; +IfcSanitaryTerminalTypeEnum.SHOWER = "SHOWER"; +IfcSanitaryTerminalTypeEnum.SINK = "SINK"; +IfcSanitaryTerminalTypeEnum.SANITARYFOUNTAIN = "SANITARYFOUNTAIN"; +IfcSanitaryTerminalTypeEnum.TOILETPAN = "TOILETPAN"; +IfcSanitaryTerminalTypeEnum.URINAL = "URINAL"; +IfcSanitaryTerminalTypeEnum.WASHHANDBASIN = "WASHHANDBASIN"; +IfcSanitaryTerminalTypeEnum.WCSEAT = "WCSEAT"; +IfcSanitaryTerminalTypeEnum.USERDEFINED = "USERDEFINED"; +IfcSanitaryTerminalTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcSectionTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcSectionTypeEnum.UNIFORM = "UNIFORM"; +IfcSectionTypeEnum.TAPERED = "TAPERED"; +var IfcSensorTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcSensorTypeEnum.COSENSOR = "COSENSOR"; +IfcSensorTypeEnum.CO2SENSOR = "CO2SENSOR"; +IfcSensorTypeEnum.CONDUCTANCESENSOR = "CONDUCTANCESENSOR"; +IfcSensorTypeEnum.CONTACTSENSOR = "CONTACTSENSOR"; +IfcSensorTypeEnum.FIRESENSOR = "FIRESENSOR"; +IfcSensorTypeEnum.FLOWSENSOR = "FLOWSENSOR"; +IfcSensorTypeEnum.FROSTSENSOR = "FROSTSENSOR"; +IfcSensorTypeEnum.GASSENSOR = "GASSENSOR"; +IfcSensorTypeEnum.HEATSENSOR = "HEATSENSOR"; +IfcSensorTypeEnum.HUMIDITYSENSOR = "HUMIDITYSENSOR"; +IfcSensorTypeEnum.IDENTIFIERSENSOR = "IDENTIFIERSENSOR"; +IfcSensorTypeEnum.IONCONCENTRATIONSENSOR = "IONCONCENTRATIONSENSOR"; +IfcSensorTypeEnum.LEVELSENSOR = "LEVELSENSOR"; +IfcSensorTypeEnum.LIGHTSENSOR = "LIGHTSENSOR"; +IfcSensorTypeEnum.MOISTURESENSOR = "MOISTURESENSOR"; +IfcSensorTypeEnum.MOVEMENTSENSOR = "MOVEMENTSENSOR"; +IfcSensorTypeEnum.PHSENSOR = "PHSENSOR"; +IfcSensorTypeEnum.PRESSURESENSOR = "PRESSURESENSOR"; +IfcSensorTypeEnum.RADIATIONSENSOR = "RADIATIONSENSOR"; +IfcSensorTypeEnum.RADIOACTIVITYSENSOR = "RADIOACTIVITYSENSOR"; +IfcSensorTypeEnum.SMOKESENSOR = "SMOKESENSOR"; +IfcSensorTypeEnum.SOUNDSENSOR = "SOUNDSENSOR"; +IfcSensorTypeEnum.TEMPERATURESENSOR = "TEMPERATURESENSOR"; +IfcSensorTypeEnum.WINDSENSOR = "WINDSENSOR"; +IfcSensorTypeEnum.USERDEFINED = "USERDEFINED"; +IfcSensorTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcSequenceEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcSequenceEnum.START_START = "START_START"; +IfcSequenceEnum.START_FINISH = "START_FINISH"; +IfcSequenceEnum.FINISH_START = "FINISH_START"; +IfcSequenceEnum.FINISH_FINISH = "FINISH_FINISH"; +IfcSequenceEnum.USERDEFINED = "USERDEFINED"; +IfcSequenceEnum.NOTDEFINED = "NOTDEFINED"; +var IfcShadingDeviceTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcShadingDeviceTypeEnum.JALOUSIE = "JALOUSIE"; +IfcShadingDeviceTypeEnum.SHUTTER = "SHUTTER"; +IfcShadingDeviceTypeEnum.AWNING = "AWNING"; +IfcShadingDeviceTypeEnum.USERDEFINED = "USERDEFINED"; +IfcShadingDeviceTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcSimplePropertyTemplateTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcSimplePropertyTemplateTypeEnum.P_SINGLEVALUE = "P_SINGLEVALUE"; +IfcSimplePropertyTemplateTypeEnum.P_ENUMERATEDVALUE = "P_ENUMERATEDVALUE"; +IfcSimplePropertyTemplateTypeEnum.P_BOUNDEDVALUE = "P_BOUNDEDVALUE"; +IfcSimplePropertyTemplateTypeEnum.P_LISTVALUE = "P_LISTVALUE"; +IfcSimplePropertyTemplateTypeEnum.P_TABLEVALUE = "P_TABLEVALUE"; +IfcSimplePropertyTemplateTypeEnum.P_REFERENCEVALUE = "P_REFERENCEVALUE"; +IfcSimplePropertyTemplateTypeEnum.Q_LENGTH = "Q_LENGTH"; +IfcSimplePropertyTemplateTypeEnum.Q_AREA = "Q_AREA"; +IfcSimplePropertyTemplateTypeEnum.Q_VOLUME = "Q_VOLUME"; +IfcSimplePropertyTemplateTypeEnum.Q_COUNT = "Q_COUNT"; +IfcSimplePropertyTemplateTypeEnum.Q_WEIGHT = "Q_WEIGHT"; +IfcSimplePropertyTemplateTypeEnum.Q_TIME = "Q_TIME"; +var IfcSlabTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcSlabTypeEnum.FLOOR = "FLOOR"; +IfcSlabTypeEnum.ROOF = "ROOF"; +IfcSlabTypeEnum.LANDING = "LANDING"; +IfcSlabTypeEnum.BASESLAB = "BASESLAB"; +IfcSlabTypeEnum.APPROACH_SLAB = "APPROACH_SLAB"; +IfcSlabTypeEnum.PAVING = "PAVING"; +IfcSlabTypeEnum.WEARING = "WEARING"; +IfcSlabTypeEnum.SIDEWALK = "SIDEWALK"; +IfcSlabTypeEnum.USERDEFINED = "USERDEFINED"; +IfcSlabTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcSolarDeviceTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcSolarDeviceTypeEnum.SOLARCOLLECTOR = "SOLARCOLLECTOR"; +IfcSolarDeviceTypeEnum.SOLARPANEL = "SOLARPANEL"; +IfcSolarDeviceTypeEnum.USERDEFINED = "USERDEFINED"; +IfcSolarDeviceTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcSpaceHeaterTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcSpaceHeaterTypeEnum.CONVECTOR = "CONVECTOR"; +IfcSpaceHeaterTypeEnum.RADIATOR = "RADIATOR"; +IfcSpaceHeaterTypeEnum.USERDEFINED = "USERDEFINED"; +IfcSpaceHeaterTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcSpaceTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcSpaceTypeEnum.SPACE = "SPACE"; +IfcSpaceTypeEnum.PARKING = "PARKING"; +IfcSpaceTypeEnum.GFA = "GFA"; +IfcSpaceTypeEnum.INTERNAL = "INTERNAL"; +IfcSpaceTypeEnum.EXTERNAL = "EXTERNAL"; +IfcSpaceTypeEnum.USERDEFINED = "USERDEFINED"; +IfcSpaceTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcSpatialZoneTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcSpatialZoneTypeEnum.CONSTRUCTION = "CONSTRUCTION"; +IfcSpatialZoneTypeEnum.FIRESAFETY = "FIRESAFETY"; +IfcSpatialZoneTypeEnum.LIGHTING = "LIGHTING"; +IfcSpatialZoneTypeEnum.OCCUPANCY = "OCCUPANCY"; +IfcSpatialZoneTypeEnum.SECURITY = "SECURITY"; +IfcSpatialZoneTypeEnum.THERMAL = "THERMAL"; +IfcSpatialZoneTypeEnum.TRANSPORT = "TRANSPORT"; +IfcSpatialZoneTypeEnum.VENTILATION = "VENTILATION"; +IfcSpatialZoneTypeEnum.USERDEFINED = "USERDEFINED"; +IfcSpatialZoneTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcStackTerminalTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcStackTerminalTypeEnum.BIRDCAGE = "BIRDCAGE"; +IfcStackTerminalTypeEnum.COWL = "COWL"; +IfcStackTerminalTypeEnum.RAINWATERHOPPER = "RAINWATERHOPPER"; +IfcStackTerminalTypeEnum.USERDEFINED = "USERDEFINED"; +IfcStackTerminalTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcStairFlightTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcStairFlightTypeEnum.STRAIGHT = "STRAIGHT"; +IfcStairFlightTypeEnum.WINDER = "WINDER"; +IfcStairFlightTypeEnum.SPIRAL = "SPIRAL"; +IfcStairFlightTypeEnum.CURVED = "CURVED"; +IfcStairFlightTypeEnum.FREEFORM = "FREEFORM"; +IfcStairFlightTypeEnum.USERDEFINED = "USERDEFINED"; +IfcStairFlightTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcStairTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcStairTypeEnum.STRAIGHT_RUN_STAIR = "STRAIGHT_RUN_STAIR"; +IfcStairTypeEnum.TWO_STRAIGHT_RUN_STAIR = "TWO_STRAIGHT_RUN_STAIR"; +IfcStairTypeEnum.QUARTER_WINDING_STAIR = "QUARTER_WINDING_STAIR"; +IfcStairTypeEnum.QUARTER_TURN_STAIR = "QUARTER_TURN_STAIR"; +IfcStairTypeEnum.HALF_WINDING_STAIR = "HALF_WINDING_STAIR"; +IfcStairTypeEnum.HALF_TURN_STAIR = "HALF_TURN_STAIR"; +IfcStairTypeEnum.TWO_QUARTER_WINDING_STAIR = "TWO_QUARTER_WINDING_STAIR"; +IfcStairTypeEnum.TWO_QUARTER_TURN_STAIR = "TWO_QUARTER_TURN_STAIR"; +IfcStairTypeEnum.THREE_QUARTER_WINDING_STAIR = "THREE_QUARTER_WINDING_STAIR"; +IfcStairTypeEnum.THREE_QUARTER_TURN_STAIR = "THREE_QUARTER_TURN_STAIR"; +IfcStairTypeEnum.SPIRAL_STAIR = "SPIRAL_STAIR"; +IfcStairTypeEnum.DOUBLE_RETURN_STAIR = "DOUBLE_RETURN_STAIR"; +IfcStairTypeEnum.CURVED_RUN_STAIR = "CURVED_RUN_STAIR"; +IfcStairTypeEnum.TWO_CURVED_RUN_STAIR = "TWO_CURVED_RUN_STAIR"; +IfcStairTypeEnum.USERDEFINED = "USERDEFINED"; +IfcStairTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcStateEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcStateEnum.READWRITE = "READWRITE"; +IfcStateEnum.READONLY = "READONLY"; +IfcStateEnum.LOCKED = "LOCKED"; +IfcStateEnum.READWRITELOCKED = "READWRITELOCKED"; +IfcStateEnum.READONLYLOCKED = "READONLYLOCKED"; +var IfcStructuralCurveActivityTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcStructuralCurveActivityTypeEnum.CONST = "CONST"; +IfcStructuralCurveActivityTypeEnum.LINEAR = "LINEAR"; +IfcStructuralCurveActivityTypeEnum.POLYGONAL = "POLYGONAL"; +IfcStructuralCurveActivityTypeEnum.EQUIDISTANT = "EQUIDISTANT"; +IfcStructuralCurveActivityTypeEnum.SINUS = "SINUS"; +IfcStructuralCurveActivityTypeEnum.PARABOLA = "PARABOLA"; +IfcStructuralCurveActivityTypeEnum.DISCRETE = "DISCRETE"; +IfcStructuralCurveActivityTypeEnum.USERDEFINED = "USERDEFINED"; +IfcStructuralCurveActivityTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcStructuralCurveMemberTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcStructuralCurveMemberTypeEnum.RIGID_JOINED_MEMBER = "RIGID_JOINED_MEMBER"; +IfcStructuralCurveMemberTypeEnum.PIN_JOINED_MEMBER = "PIN_JOINED_MEMBER"; +IfcStructuralCurveMemberTypeEnum.CABLE = "CABLE"; +IfcStructuralCurveMemberTypeEnum.TENSION_MEMBER = "TENSION_MEMBER"; +IfcStructuralCurveMemberTypeEnum.COMPRESSION_MEMBER = "COMPRESSION_MEMBER"; +IfcStructuralCurveMemberTypeEnum.USERDEFINED = "USERDEFINED"; +IfcStructuralCurveMemberTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcStructuralSurfaceActivityTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcStructuralSurfaceActivityTypeEnum.CONST = "CONST"; +IfcStructuralSurfaceActivityTypeEnum.BILINEAR = "BILINEAR"; +IfcStructuralSurfaceActivityTypeEnum.DISCRETE = "DISCRETE"; +IfcStructuralSurfaceActivityTypeEnum.ISOCONTOUR = "ISOCONTOUR"; +IfcStructuralSurfaceActivityTypeEnum.USERDEFINED = "USERDEFINED"; +IfcStructuralSurfaceActivityTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcStructuralSurfaceMemberTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcStructuralSurfaceMemberTypeEnum.BENDING_ELEMENT = "BENDING_ELEMENT"; +IfcStructuralSurfaceMemberTypeEnum.MEMBRANE_ELEMENT = "MEMBRANE_ELEMENT"; +IfcStructuralSurfaceMemberTypeEnum.SHELL = "SHELL"; +IfcStructuralSurfaceMemberTypeEnum.USERDEFINED = "USERDEFINED"; +IfcStructuralSurfaceMemberTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcSubContractResourceTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcSubContractResourceTypeEnum.PURCHASE = "PURCHASE"; +IfcSubContractResourceTypeEnum.WORK = "WORK"; +IfcSubContractResourceTypeEnum.USERDEFINED = "USERDEFINED"; +IfcSubContractResourceTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcSurfaceFeatureTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcSurfaceFeatureTypeEnum.MARK = "MARK"; +IfcSurfaceFeatureTypeEnum.TAG = "TAG"; +IfcSurfaceFeatureTypeEnum.TREATMENT = "TREATMENT"; +IfcSurfaceFeatureTypeEnum.DEFECT = "DEFECT"; +IfcSurfaceFeatureTypeEnum.USERDEFINED = "USERDEFINED"; +IfcSurfaceFeatureTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcSurfaceSide = class { + constructor(v) { + this.value = v; + } +}; +IfcSurfaceSide.POSITIVE = "POSITIVE"; +IfcSurfaceSide.NEGATIVE = "NEGATIVE"; +IfcSurfaceSide.BOTH = "BOTH"; +var IfcSwitchingDeviceTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcSwitchingDeviceTypeEnum.CONTACTOR = "CONTACTOR"; +IfcSwitchingDeviceTypeEnum.DIMMERSWITCH = "DIMMERSWITCH"; +IfcSwitchingDeviceTypeEnum.EMERGENCYSTOP = "EMERGENCYSTOP"; +IfcSwitchingDeviceTypeEnum.KEYPAD = "KEYPAD"; +IfcSwitchingDeviceTypeEnum.MOMENTARYSWITCH = "MOMENTARYSWITCH"; +IfcSwitchingDeviceTypeEnum.SELECTORSWITCH = "SELECTORSWITCH"; +IfcSwitchingDeviceTypeEnum.STARTER = "STARTER"; +IfcSwitchingDeviceTypeEnum.SWITCHDISCONNECTOR = "SWITCHDISCONNECTOR"; +IfcSwitchingDeviceTypeEnum.TOGGLESWITCH = "TOGGLESWITCH"; +IfcSwitchingDeviceTypeEnum.USERDEFINED = "USERDEFINED"; +IfcSwitchingDeviceTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcSystemFurnitureElementTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcSystemFurnitureElementTypeEnum.PANEL = "PANEL"; +IfcSystemFurnitureElementTypeEnum.WORKSURFACE = "WORKSURFACE"; +IfcSystemFurnitureElementTypeEnum.USERDEFINED = "USERDEFINED"; +IfcSystemFurnitureElementTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcTankTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcTankTypeEnum.BASIN = "BASIN"; +IfcTankTypeEnum.BREAKPRESSURE = "BREAKPRESSURE"; +IfcTankTypeEnum.EXPANSION = "EXPANSION"; +IfcTankTypeEnum.FEEDANDEXPANSION = "FEEDANDEXPANSION"; +IfcTankTypeEnum.PRESSUREVESSEL = "PRESSUREVESSEL"; +IfcTankTypeEnum.STORAGE = "STORAGE"; +IfcTankTypeEnum.VESSEL = "VESSEL"; +IfcTankTypeEnum.USERDEFINED = "USERDEFINED"; +IfcTankTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcTaskDurationEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcTaskDurationEnum.ELAPSEDTIME = "ELAPSEDTIME"; +IfcTaskDurationEnum.WORKTIME = "WORKTIME"; +IfcTaskDurationEnum.NOTDEFINED = "NOTDEFINED"; +var IfcTaskTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcTaskTypeEnum.ATTENDANCE = "ATTENDANCE"; +IfcTaskTypeEnum.CONSTRUCTION = "CONSTRUCTION"; +IfcTaskTypeEnum.DEMOLITION = "DEMOLITION"; +IfcTaskTypeEnum.DISMANTLE = "DISMANTLE"; +IfcTaskTypeEnum.DISPOSAL = "DISPOSAL"; +IfcTaskTypeEnum.INSTALLATION = "INSTALLATION"; +IfcTaskTypeEnum.LOGISTIC = "LOGISTIC"; +IfcTaskTypeEnum.MAINTENANCE = "MAINTENANCE"; +IfcTaskTypeEnum.MOVE = "MOVE"; +IfcTaskTypeEnum.OPERATION = "OPERATION"; +IfcTaskTypeEnum.REMOVAL = "REMOVAL"; +IfcTaskTypeEnum.RENOVATION = "RENOVATION"; +IfcTaskTypeEnum.USERDEFINED = "USERDEFINED"; +IfcTaskTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcTendonAnchorTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcTendonAnchorTypeEnum.COUPLER = "COUPLER"; +IfcTendonAnchorTypeEnum.FIXED_END = "FIXED_END"; +IfcTendonAnchorTypeEnum.TENSIONING_END = "TENSIONING_END"; +IfcTendonAnchorTypeEnum.USERDEFINED = "USERDEFINED"; +IfcTendonAnchorTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcTendonConduitTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcTendonConduitTypeEnum.DUCT = "DUCT"; +IfcTendonConduitTypeEnum.COUPLER = "COUPLER"; +IfcTendonConduitTypeEnum.GROUTING_DUCT = "GROUTING_DUCT"; +IfcTendonConduitTypeEnum.TRUMPET = "TRUMPET"; +IfcTendonConduitTypeEnum.DIABOLO = "DIABOLO"; +IfcTendonConduitTypeEnum.USERDEFINED = "USERDEFINED"; +IfcTendonConduitTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcTendonTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcTendonTypeEnum.BAR = "BAR"; +IfcTendonTypeEnum.COATED = "COATED"; +IfcTendonTypeEnum.STRAND = "STRAND"; +IfcTendonTypeEnum.WIRE = "WIRE"; +IfcTendonTypeEnum.USERDEFINED = "USERDEFINED"; +IfcTendonTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcTextPath = class { + constructor(v) { + this.value = v; + } +}; +IfcTextPath.LEFT = "LEFT"; +IfcTextPath.RIGHT = "RIGHT"; +IfcTextPath.UP = "UP"; +IfcTextPath.DOWN = "DOWN"; +var IfcTimeSeriesDataTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcTimeSeriesDataTypeEnum.CONTINUOUS = "CONTINUOUS"; +IfcTimeSeriesDataTypeEnum.DISCRETE = "DISCRETE"; +IfcTimeSeriesDataTypeEnum.DISCRETEBINARY = "DISCRETEBINARY"; +IfcTimeSeriesDataTypeEnum.PIECEWISEBINARY = "PIECEWISEBINARY"; +IfcTimeSeriesDataTypeEnum.PIECEWISECONSTANT = "PIECEWISECONSTANT"; +IfcTimeSeriesDataTypeEnum.PIECEWISECONTINUOUS = "PIECEWISECONTINUOUS"; +IfcTimeSeriesDataTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcTransformerTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcTransformerTypeEnum.CURRENT = "CURRENT"; +IfcTransformerTypeEnum.FREQUENCY = "FREQUENCY"; +IfcTransformerTypeEnum.INVERTER = "INVERTER"; +IfcTransformerTypeEnum.RECTIFIER = "RECTIFIER"; +IfcTransformerTypeEnum.VOLTAGE = "VOLTAGE"; +IfcTransformerTypeEnum.USERDEFINED = "USERDEFINED"; +IfcTransformerTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcTransitionCode = class { + constructor(v) { + this.value = v; + } +}; +IfcTransitionCode.DISCONTINUOUS = "DISCONTINUOUS"; +IfcTransitionCode.CONTINUOUS = "CONTINUOUS"; +IfcTransitionCode.CONTSAMEGRADIENT = "CONTSAMEGRADIENT"; +IfcTransitionCode.CONTSAMEGRADIENTSAMECURVATURE = "CONTSAMEGRADIENTSAMECURVATURE"; +var IfcTransitionCurveType = class { + constructor(v) { + this.value = v; + } +}; +IfcTransitionCurveType.BIQUADRATICPARABOLA = "BIQUADRATICPARABOLA"; +IfcTransitionCurveType.BLOSSCURVE = "BLOSSCURVE"; +IfcTransitionCurveType.CLOTHOIDCURVE = "CLOTHOIDCURVE"; +IfcTransitionCurveType.COSINECURVE = "COSINECURVE"; +IfcTransitionCurveType.CUBICPARABOLA = "CUBICPARABOLA"; +IfcTransitionCurveType.SINECURVE = "SINECURVE"; +var IfcTransportElementTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcTransportElementTypeEnum.ELEVATOR = "ELEVATOR"; +IfcTransportElementTypeEnum.ESCALATOR = "ESCALATOR"; +IfcTransportElementTypeEnum.MOVINGWALKWAY = "MOVINGWALKWAY"; +IfcTransportElementTypeEnum.CRANEWAY = "CRANEWAY"; +IfcTransportElementTypeEnum.LIFTINGGEAR = "LIFTINGGEAR"; +IfcTransportElementTypeEnum.USERDEFINED = "USERDEFINED"; +IfcTransportElementTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcTrimmingPreference = class { + constructor(v) { + this.value = v; + } +}; +IfcTrimmingPreference.CARTESIAN = "CARTESIAN"; +IfcTrimmingPreference.PARAMETER = "PARAMETER"; +IfcTrimmingPreference.UNSPECIFIED = "UNSPECIFIED"; +var IfcTubeBundleTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcTubeBundleTypeEnum.FINNED = "FINNED"; +IfcTubeBundleTypeEnum.USERDEFINED = "USERDEFINED"; +IfcTubeBundleTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcUnitEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcUnitEnum.ABSORBEDDOSEUNIT = "ABSORBEDDOSEUNIT"; +IfcUnitEnum.AMOUNTOFSUBSTANCEUNIT = "AMOUNTOFSUBSTANCEUNIT"; +IfcUnitEnum.AREAUNIT = "AREAUNIT"; +IfcUnitEnum.DOSEEQUIVALENTUNIT = "DOSEEQUIVALENTUNIT"; +IfcUnitEnum.ELECTRICCAPACITANCEUNIT = "ELECTRICCAPACITANCEUNIT"; +IfcUnitEnum.ELECTRICCHARGEUNIT = "ELECTRICCHARGEUNIT"; +IfcUnitEnum.ELECTRICCONDUCTANCEUNIT = "ELECTRICCONDUCTANCEUNIT"; +IfcUnitEnum.ELECTRICCURRENTUNIT = "ELECTRICCURRENTUNIT"; +IfcUnitEnum.ELECTRICRESISTANCEUNIT = "ELECTRICRESISTANCEUNIT"; +IfcUnitEnum.ELECTRICVOLTAGEUNIT = "ELECTRICVOLTAGEUNIT"; +IfcUnitEnum.ENERGYUNIT = "ENERGYUNIT"; +IfcUnitEnum.FORCEUNIT = "FORCEUNIT"; +IfcUnitEnum.FREQUENCYUNIT = "FREQUENCYUNIT"; +IfcUnitEnum.ILLUMINANCEUNIT = "ILLUMINANCEUNIT"; +IfcUnitEnum.INDUCTANCEUNIT = "INDUCTANCEUNIT"; +IfcUnitEnum.LENGTHUNIT = "LENGTHUNIT"; +IfcUnitEnum.LUMINOUSFLUXUNIT = "LUMINOUSFLUXUNIT"; +IfcUnitEnum.LUMINOUSINTENSITYUNIT = "LUMINOUSINTENSITYUNIT"; +IfcUnitEnum.MAGNETICFLUXDENSITYUNIT = "MAGNETICFLUXDENSITYUNIT"; +IfcUnitEnum.MAGNETICFLUXUNIT = "MAGNETICFLUXUNIT"; +IfcUnitEnum.MASSUNIT = "MASSUNIT"; +IfcUnitEnum.PLANEANGLEUNIT = "PLANEANGLEUNIT"; +IfcUnitEnum.POWERUNIT = "POWERUNIT"; +IfcUnitEnum.PRESSUREUNIT = "PRESSUREUNIT"; +IfcUnitEnum.RADIOACTIVITYUNIT = "RADIOACTIVITYUNIT"; +IfcUnitEnum.SOLIDANGLEUNIT = "SOLIDANGLEUNIT"; +IfcUnitEnum.THERMODYNAMICTEMPERATUREUNIT = "THERMODYNAMICTEMPERATUREUNIT"; +IfcUnitEnum.TIMEUNIT = "TIMEUNIT"; +IfcUnitEnum.VOLUMEUNIT = "VOLUMEUNIT"; +IfcUnitEnum.USERDEFINED = "USERDEFINED"; +var IfcUnitaryControlElementTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcUnitaryControlElementTypeEnum.ALARMPANEL = "ALARMPANEL"; +IfcUnitaryControlElementTypeEnum.CONTROLPANEL = "CONTROLPANEL"; +IfcUnitaryControlElementTypeEnum.GASDETECTIONPANEL = "GASDETECTIONPANEL"; +IfcUnitaryControlElementTypeEnum.INDICATORPANEL = "INDICATORPANEL"; +IfcUnitaryControlElementTypeEnum.MIMICPANEL = "MIMICPANEL"; +IfcUnitaryControlElementTypeEnum.HUMIDISTAT = "HUMIDISTAT"; +IfcUnitaryControlElementTypeEnum.THERMOSTAT = "THERMOSTAT"; +IfcUnitaryControlElementTypeEnum.WEATHERSTATION = "WEATHERSTATION"; +IfcUnitaryControlElementTypeEnum.USERDEFINED = "USERDEFINED"; +IfcUnitaryControlElementTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcUnitaryEquipmentTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcUnitaryEquipmentTypeEnum.AIRHANDLER = "AIRHANDLER"; +IfcUnitaryEquipmentTypeEnum.AIRCONDITIONINGUNIT = "AIRCONDITIONINGUNIT"; +IfcUnitaryEquipmentTypeEnum.DEHUMIDIFIER = "DEHUMIDIFIER"; +IfcUnitaryEquipmentTypeEnum.SPLITSYSTEM = "SPLITSYSTEM"; +IfcUnitaryEquipmentTypeEnum.ROOFTOPUNIT = "ROOFTOPUNIT"; +IfcUnitaryEquipmentTypeEnum.USERDEFINED = "USERDEFINED"; +IfcUnitaryEquipmentTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcValveTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcValveTypeEnum.AIRRELEASE = "AIRRELEASE"; +IfcValveTypeEnum.ANTIVACUUM = "ANTIVACUUM"; +IfcValveTypeEnum.CHANGEOVER = "CHANGEOVER"; +IfcValveTypeEnum.CHECK = "CHECK"; +IfcValveTypeEnum.COMMISSIONING = "COMMISSIONING"; +IfcValveTypeEnum.DIVERTING = "DIVERTING"; +IfcValveTypeEnum.DRAWOFFCOCK = "DRAWOFFCOCK"; +IfcValveTypeEnum.DOUBLECHECK = "DOUBLECHECK"; +IfcValveTypeEnum.DOUBLEREGULATING = "DOUBLEREGULATING"; +IfcValveTypeEnum.FAUCET = "FAUCET"; +IfcValveTypeEnum.FLUSHING = "FLUSHING"; +IfcValveTypeEnum.GASCOCK = "GASCOCK"; +IfcValveTypeEnum.GASTAP = "GASTAP"; +IfcValveTypeEnum.ISOLATING = "ISOLATING"; +IfcValveTypeEnum.MIXING = "MIXING"; +IfcValveTypeEnum.PRESSUREREDUCING = "PRESSUREREDUCING"; +IfcValveTypeEnum.PRESSURERELIEF = "PRESSURERELIEF"; +IfcValveTypeEnum.REGULATING = "REGULATING"; +IfcValveTypeEnum.SAFETYCUTOFF = "SAFETYCUTOFF"; +IfcValveTypeEnum.STEAMTRAP = "STEAMTRAP"; +IfcValveTypeEnum.STOPCOCK = "STOPCOCK"; +IfcValveTypeEnum.USERDEFINED = "USERDEFINED"; +IfcValveTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcVibrationDamperTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcVibrationDamperTypeEnum.BENDING_YIELD = "BENDING_YIELD"; +IfcVibrationDamperTypeEnum.SHEAR_YIELD = "SHEAR_YIELD"; +IfcVibrationDamperTypeEnum.AXIAL_YIELD = "AXIAL_YIELD"; +IfcVibrationDamperTypeEnum.FRICTION = "FRICTION"; +IfcVibrationDamperTypeEnum.VISCOUS = "VISCOUS"; +IfcVibrationDamperTypeEnum.RUBBER = "RUBBER"; +IfcVibrationDamperTypeEnum.USERDEFINED = "USERDEFINED"; +IfcVibrationDamperTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcVibrationIsolatorTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcVibrationIsolatorTypeEnum.COMPRESSION = "COMPRESSION"; +IfcVibrationIsolatorTypeEnum.SPRING = "SPRING"; +IfcVibrationIsolatorTypeEnum.BASE = "BASE"; +IfcVibrationIsolatorTypeEnum.USERDEFINED = "USERDEFINED"; +IfcVibrationIsolatorTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcVoidingFeatureTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcVoidingFeatureTypeEnum.CUTOUT = "CUTOUT"; +IfcVoidingFeatureTypeEnum.NOTCH = "NOTCH"; +IfcVoidingFeatureTypeEnum.HOLE = "HOLE"; +IfcVoidingFeatureTypeEnum.MITER = "MITER"; +IfcVoidingFeatureTypeEnum.CHAMFER = "CHAMFER"; +IfcVoidingFeatureTypeEnum.EDGE = "EDGE"; +IfcVoidingFeatureTypeEnum.USERDEFINED = "USERDEFINED"; +IfcVoidingFeatureTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcWallTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcWallTypeEnum.MOVABLE = "MOVABLE"; +IfcWallTypeEnum.PARAPET = "PARAPET"; +IfcWallTypeEnum.PARTITIONING = "PARTITIONING"; +IfcWallTypeEnum.PLUMBINGWALL = "PLUMBINGWALL"; +IfcWallTypeEnum.SHEAR = "SHEAR"; +IfcWallTypeEnum.SOLIDWALL = "SOLIDWALL"; +IfcWallTypeEnum.STANDARD = "STANDARD"; +IfcWallTypeEnum.POLYGONAL = "POLYGONAL"; +IfcWallTypeEnum.ELEMENTEDWALL = "ELEMENTEDWALL"; +IfcWallTypeEnum.RETAININGWALL = "RETAININGWALL"; +IfcWallTypeEnum.USERDEFINED = "USERDEFINED"; +IfcWallTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcWasteTerminalTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcWasteTerminalTypeEnum.FLOORTRAP = "FLOORTRAP"; +IfcWasteTerminalTypeEnum.FLOORWASTE = "FLOORWASTE"; +IfcWasteTerminalTypeEnum.GULLYSUMP = "GULLYSUMP"; +IfcWasteTerminalTypeEnum.GULLYTRAP = "GULLYTRAP"; +IfcWasteTerminalTypeEnum.ROOFDRAIN = "ROOFDRAIN"; +IfcWasteTerminalTypeEnum.WASTEDISPOSALUNIT = "WASTEDISPOSALUNIT"; +IfcWasteTerminalTypeEnum.WASTETRAP = "WASTETRAP"; +IfcWasteTerminalTypeEnum.USERDEFINED = "USERDEFINED"; +IfcWasteTerminalTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcWindowPanelOperationEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcWindowPanelOperationEnum.SIDEHUNGRIGHTHAND = "SIDEHUNGRIGHTHAND"; +IfcWindowPanelOperationEnum.SIDEHUNGLEFTHAND = "SIDEHUNGLEFTHAND"; +IfcWindowPanelOperationEnum.TILTANDTURNRIGHTHAND = "TILTANDTURNRIGHTHAND"; +IfcWindowPanelOperationEnum.TILTANDTURNLEFTHAND = "TILTANDTURNLEFTHAND"; +IfcWindowPanelOperationEnum.TOPHUNG = "TOPHUNG"; +IfcWindowPanelOperationEnum.BOTTOMHUNG = "BOTTOMHUNG"; +IfcWindowPanelOperationEnum.PIVOTHORIZONTAL = "PIVOTHORIZONTAL"; +IfcWindowPanelOperationEnum.PIVOTVERTICAL = "PIVOTVERTICAL"; +IfcWindowPanelOperationEnum.SLIDINGHORIZONTAL = "SLIDINGHORIZONTAL"; +IfcWindowPanelOperationEnum.SLIDINGVERTICAL = "SLIDINGVERTICAL"; +IfcWindowPanelOperationEnum.REMOVABLECASEMENT = "REMOVABLECASEMENT"; +IfcWindowPanelOperationEnum.FIXEDCASEMENT = "FIXEDCASEMENT"; +IfcWindowPanelOperationEnum.OTHEROPERATION = "OTHEROPERATION"; +IfcWindowPanelOperationEnum.NOTDEFINED = "NOTDEFINED"; +var IfcWindowPanelPositionEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcWindowPanelPositionEnum.LEFT = "LEFT"; +IfcWindowPanelPositionEnum.MIDDLE = "MIDDLE"; +IfcWindowPanelPositionEnum.RIGHT = "RIGHT"; +IfcWindowPanelPositionEnum.BOTTOM = "BOTTOM"; +IfcWindowPanelPositionEnum.TOP = "TOP"; +IfcWindowPanelPositionEnum.NOTDEFINED = "NOTDEFINED"; +var IfcWindowStyleConstructionEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcWindowStyleConstructionEnum.ALUMINIUM = "ALUMINIUM"; +IfcWindowStyleConstructionEnum.HIGH_GRADE_STEEL = "HIGH_GRADE_STEEL"; +IfcWindowStyleConstructionEnum.STEEL = "STEEL"; +IfcWindowStyleConstructionEnum.WOOD = "WOOD"; +IfcWindowStyleConstructionEnum.ALUMINIUM_WOOD = "ALUMINIUM_WOOD"; +IfcWindowStyleConstructionEnum.PLASTIC = "PLASTIC"; +IfcWindowStyleConstructionEnum.OTHER_CONSTRUCTION = "OTHER_CONSTRUCTION"; +IfcWindowStyleConstructionEnum.NOTDEFINED = "NOTDEFINED"; +var IfcWindowStyleOperationEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcWindowStyleOperationEnum.SINGLE_PANEL = "SINGLE_PANEL"; +IfcWindowStyleOperationEnum.DOUBLE_PANEL_VERTICAL = "DOUBLE_PANEL_VERTICAL"; +IfcWindowStyleOperationEnum.DOUBLE_PANEL_HORIZONTAL = "DOUBLE_PANEL_HORIZONTAL"; +IfcWindowStyleOperationEnum.TRIPLE_PANEL_VERTICAL = "TRIPLE_PANEL_VERTICAL"; +IfcWindowStyleOperationEnum.TRIPLE_PANEL_BOTTOM = "TRIPLE_PANEL_BOTTOM"; +IfcWindowStyleOperationEnum.TRIPLE_PANEL_TOP = "TRIPLE_PANEL_TOP"; +IfcWindowStyleOperationEnum.TRIPLE_PANEL_LEFT = "TRIPLE_PANEL_LEFT"; +IfcWindowStyleOperationEnum.TRIPLE_PANEL_RIGHT = "TRIPLE_PANEL_RIGHT"; +IfcWindowStyleOperationEnum.TRIPLE_PANEL_HORIZONTAL = "TRIPLE_PANEL_HORIZONTAL"; +IfcWindowStyleOperationEnum.USERDEFINED = "USERDEFINED"; +IfcWindowStyleOperationEnum.NOTDEFINED = "NOTDEFINED"; +var IfcWindowTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcWindowTypeEnum.WINDOW = "WINDOW"; +IfcWindowTypeEnum.SKYLIGHT = "SKYLIGHT"; +IfcWindowTypeEnum.LIGHTDOME = "LIGHTDOME"; +IfcWindowTypeEnum.USERDEFINED = "USERDEFINED"; +IfcWindowTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcWindowTypePartitioningEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcWindowTypePartitioningEnum.SINGLE_PANEL = "SINGLE_PANEL"; +IfcWindowTypePartitioningEnum.DOUBLE_PANEL_VERTICAL = "DOUBLE_PANEL_VERTICAL"; +IfcWindowTypePartitioningEnum.DOUBLE_PANEL_HORIZONTAL = "DOUBLE_PANEL_HORIZONTAL"; +IfcWindowTypePartitioningEnum.TRIPLE_PANEL_VERTICAL = "TRIPLE_PANEL_VERTICAL"; +IfcWindowTypePartitioningEnum.TRIPLE_PANEL_BOTTOM = "TRIPLE_PANEL_BOTTOM"; +IfcWindowTypePartitioningEnum.TRIPLE_PANEL_TOP = "TRIPLE_PANEL_TOP"; +IfcWindowTypePartitioningEnum.TRIPLE_PANEL_LEFT = "TRIPLE_PANEL_LEFT"; +IfcWindowTypePartitioningEnum.TRIPLE_PANEL_RIGHT = "TRIPLE_PANEL_RIGHT"; +IfcWindowTypePartitioningEnum.TRIPLE_PANEL_HORIZONTAL = "TRIPLE_PANEL_HORIZONTAL"; +IfcWindowTypePartitioningEnum.USERDEFINED = "USERDEFINED"; +IfcWindowTypePartitioningEnum.NOTDEFINED = "NOTDEFINED"; +var IfcWorkCalendarTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcWorkCalendarTypeEnum.FIRSTSHIFT = "FIRSTSHIFT"; +IfcWorkCalendarTypeEnum.SECONDSHIFT = "SECONDSHIFT"; +IfcWorkCalendarTypeEnum.THIRDSHIFT = "THIRDSHIFT"; +IfcWorkCalendarTypeEnum.USERDEFINED = "USERDEFINED"; +IfcWorkCalendarTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcWorkPlanTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcWorkPlanTypeEnum.ACTUAL = "ACTUAL"; +IfcWorkPlanTypeEnum.BASELINE = "BASELINE"; +IfcWorkPlanTypeEnum.PLANNED = "PLANNED"; +IfcWorkPlanTypeEnum.USERDEFINED = "USERDEFINED"; +IfcWorkPlanTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcWorkScheduleTypeEnum = class { + constructor(v) { + this.value = v; + } +}; +IfcWorkScheduleTypeEnum.ACTUAL = "ACTUAL"; +IfcWorkScheduleTypeEnum.BASELINE = "BASELINE"; +IfcWorkScheduleTypeEnum.PLANNED = "PLANNED"; +IfcWorkScheduleTypeEnum.USERDEFINED = "USERDEFINED"; +IfcWorkScheduleTypeEnum.NOTDEFINED = "NOTDEFINED"; +var IfcActionRequest = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, PredefinedType, Status, LongDescription) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.PredefinedType = PredefinedType; + this.Status = Status; + this.LongDescription = LongDescription; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let Status = tape[ptr++]; + let LongDescription = tape[ptr++]; + return new IfcActionRequest(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, PredefinedType, Status, LongDescription); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.PredefinedType); + ; + args.push(this.Status); + ; + args.push(this.LongDescription); + ; + return args; + } +}; +var IfcActor = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, TheActor) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.TheActor = TheActor; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let TheActor = tape[ptr++]; + return new IfcActor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, TheActor); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.TheActor); + ; + return args; + } +}; +var IfcActorRole = class { + constructor(expressID, type, Role, UserDefinedRole, Description) { + this.expressID = expressID; + this.type = type; + this.Role = Role; + this.UserDefinedRole = UserDefinedRole; + this.Description = Description; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Role = tape[ptr++]; + let UserDefinedRole = tape[ptr++]; + let Description = tape[ptr++]; + return new IfcActorRole(expressID, type, Role, UserDefinedRole, Description); + } + ToTape() { + let args = []; + args.push(this.Role); + ; + args.push(this.UserDefinedRole); + ; + args.push(this.Description); + ; + return args; + } +}; +var IfcActuator = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcActuator(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcActuatorType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcActuatorType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcAddress = class { + constructor(expressID, type, Purpose, Description, UserDefinedPurpose) { + this.expressID = expressID; + this.type = type; + this.Purpose = Purpose; + this.Description = Description; + this.UserDefinedPurpose = UserDefinedPurpose; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Purpose = tape[ptr++]; + let Description = tape[ptr++]; + let UserDefinedPurpose = tape[ptr++]; + return new IfcAddress(expressID, type, Purpose, Description, UserDefinedPurpose); + } + ToTape() { + let args = []; + args.push(this.Purpose); + ; + args.push(this.Description); + ; + args.push(this.UserDefinedPurpose); + ; + return args; + } +}; +var IfcAdvancedBrep = class { + constructor(expressID, type, Outer) { + this.expressID = expressID; + this.type = type; + this.Outer = Outer; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Outer = tape[ptr++]; + return new IfcAdvancedBrep(expressID, type, Outer); + } + ToTape() { + let args = []; + args.push(this.Outer); + ; + return args; + } +}; +var IfcAdvancedBrepWithVoids = class { + constructor(expressID, type, Outer, Voids) { + this.expressID = expressID; + this.type = type; + this.Outer = Outer; + this.Voids = Voids; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Outer = tape[ptr++]; + let Voids = tape[ptr++]; + return new IfcAdvancedBrepWithVoids(expressID, type, Outer, Voids); + } + ToTape() { + let args = []; + args.push(this.Outer); + ; + args.push(this.Voids); + ; + return args; + } +}; +var IfcAdvancedFace = class { + constructor(expressID, type, Bounds, FaceSurface, SameSense) { + this.expressID = expressID; + this.type = type; + this.Bounds = Bounds; + this.FaceSurface = FaceSurface; + this.SameSense = SameSense; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Bounds = tape[ptr++]; + let FaceSurface = tape[ptr++]; + let SameSense = tape[ptr++]; + return new IfcAdvancedFace(expressID, type, Bounds, FaceSurface, SameSense); + } + ToTape() { + let args = []; + args.push(this.Bounds); + ; + args.push(this.FaceSurface); + ; + args.push(this.SameSense); + ; + return args; + } +}; +var IfcAirTerminal = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcAirTerminal(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcAirTerminalBox = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcAirTerminalBox(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcAirTerminalBoxType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcAirTerminalBoxType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcAirTerminalType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcAirTerminalType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcAirToAirHeatRecovery = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcAirToAirHeatRecovery(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcAirToAirHeatRecoveryType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcAirToAirHeatRecoveryType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcAlarm = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcAlarm(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcAlarmType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcAlarmType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcAlignment = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Axis, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Axis = Axis; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Axis = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcAlignment(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Axis, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Axis); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcAlignment2DHorizontal = class { + constructor(expressID, type, StartDistAlong, Segments) { + this.expressID = expressID; + this.type = type; + this.StartDistAlong = StartDistAlong; + this.Segments = Segments; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let StartDistAlong = tape[ptr++]; + let Segments = tape[ptr++]; + return new IfcAlignment2DHorizontal(expressID, type, StartDistAlong, Segments); + } + ToTape() { + let args = []; + args.push(this.StartDistAlong); + ; + args.push(this.Segments); + ; + return args; + } +}; +var IfcAlignment2DHorizontalSegment = class { + constructor(expressID, type, TangentialContinuity, StartTag, EndTag, CurveGeometry) { + this.expressID = expressID; + this.type = type; + this.TangentialContinuity = TangentialContinuity; + this.StartTag = StartTag; + this.EndTag = EndTag; + this.CurveGeometry = CurveGeometry; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let TangentialContinuity = tape[ptr++]; + let StartTag = tape[ptr++]; + let EndTag = tape[ptr++]; + let CurveGeometry = tape[ptr++]; + return new IfcAlignment2DHorizontalSegment(expressID, type, TangentialContinuity, StartTag, EndTag, CurveGeometry); + } + ToTape() { + let args = []; + args.push(this.TangentialContinuity); + ; + args.push(this.StartTag); + ; + args.push(this.EndTag); + ; + args.push(this.CurveGeometry); + ; + return args; + } +}; +var IfcAlignment2DSegment = class { + constructor(expressID, type, TangentialContinuity, StartTag, EndTag) { + this.expressID = expressID; + this.type = type; + this.TangentialContinuity = TangentialContinuity; + this.StartTag = StartTag; + this.EndTag = EndTag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let TangentialContinuity = tape[ptr++]; + let StartTag = tape[ptr++]; + let EndTag = tape[ptr++]; + return new IfcAlignment2DSegment(expressID, type, TangentialContinuity, StartTag, EndTag); + } + ToTape() { + let args = []; + args.push(this.TangentialContinuity); + ; + args.push(this.StartTag); + ; + args.push(this.EndTag); + ; + return args; + } +}; +var IfcAlignment2DVerSegCircularArc = class { + constructor(expressID, type, TangentialContinuity, StartTag, EndTag, StartDistAlong, HorizontalLength, StartHeight, StartGradient, Radius, IsConvex) { + this.expressID = expressID; + this.type = type; + this.TangentialContinuity = TangentialContinuity; + this.StartTag = StartTag; + this.EndTag = EndTag; + this.StartDistAlong = StartDistAlong; + this.HorizontalLength = HorizontalLength; + this.StartHeight = StartHeight; + this.StartGradient = StartGradient; + this.Radius = Radius; + this.IsConvex = IsConvex; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let TangentialContinuity = tape[ptr++]; + let StartTag = tape[ptr++]; + let EndTag = tape[ptr++]; + let StartDistAlong = tape[ptr++]; + let HorizontalLength = tape[ptr++]; + let StartHeight = tape[ptr++]; + let StartGradient = tape[ptr++]; + let Radius = tape[ptr++]; + let IsConvex = tape[ptr++]; + return new IfcAlignment2DVerSegCircularArc(expressID, type, TangentialContinuity, StartTag, EndTag, StartDistAlong, HorizontalLength, StartHeight, StartGradient, Radius, IsConvex); + } + ToTape() { + let args = []; + args.push(this.TangentialContinuity); + ; + args.push(this.StartTag); + ; + args.push(this.EndTag); + ; + args.push(this.StartDistAlong); + ; + args.push(this.HorizontalLength); + ; + args.push(this.StartHeight); + ; + args.push(this.StartGradient); + ; + args.push(this.Radius); + ; + args.push(this.IsConvex); + ; + return args; + } +}; +var IfcAlignment2DVerSegLine = class { + constructor(expressID, type, TangentialContinuity, StartTag, EndTag, StartDistAlong, HorizontalLength, StartHeight, StartGradient) { + this.expressID = expressID; + this.type = type; + this.TangentialContinuity = TangentialContinuity; + this.StartTag = StartTag; + this.EndTag = EndTag; + this.StartDistAlong = StartDistAlong; + this.HorizontalLength = HorizontalLength; + this.StartHeight = StartHeight; + this.StartGradient = StartGradient; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let TangentialContinuity = tape[ptr++]; + let StartTag = tape[ptr++]; + let EndTag = tape[ptr++]; + let StartDistAlong = tape[ptr++]; + let HorizontalLength = tape[ptr++]; + let StartHeight = tape[ptr++]; + let StartGradient = tape[ptr++]; + return new IfcAlignment2DVerSegLine(expressID, type, TangentialContinuity, StartTag, EndTag, StartDistAlong, HorizontalLength, StartHeight, StartGradient); + } + ToTape() { + let args = []; + args.push(this.TangentialContinuity); + ; + args.push(this.StartTag); + ; + args.push(this.EndTag); + ; + args.push(this.StartDistAlong); + ; + args.push(this.HorizontalLength); + ; + args.push(this.StartHeight); + ; + args.push(this.StartGradient); + ; + return args; + } +}; +var IfcAlignment2DVerSegParabolicArc = class { + constructor(expressID, type, TangentialContinuity, StartTag, EndTag, StartDistAlong, HorizontalLength, StartHeight, StartGradient, ParabolaConstant, IsConvex) { + this.expressID = expressID; + this.type = type; + this.TangentialContinuity = TangentialContinuity; + this.StartTag = StartTag; + this.EndTag = EndTag; + this.StartDistAlong = StartDistAlong; + this.HorizontalLength = HorizontalLength; + this.StartHeight = StartHeight; + this.StartGradient = StartGradient; + this.ParabolaConstant = ParabolaConstant; + this.IsConvex = IsConvex; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let TangentialContinuity = tape[ptr++]; + let StartTag = tape[ptr++]; + let EndTag = tape[ptr++]; + let StartDistAlong = tape[ptr++]; + let HorizontalLength = tape[ptr++]; + let StartHeight = tape[ptr++]; + let StartGradient = tape[ptr++]; + let ParabolaConstant = tape[ptr++]; + let IsConvex = tape[ptr++]; + return new IfcAlignment2DVerSegParabolicArc(expressID, type, TangentialContinuity, StartTag, EndTag, StartDistAlong, HorizontalLength, StartHeight, StartGradient, ParabolaConstant, IsConvex); + } + ToTape() { + let args = []; + args.push(this.TangentialContinuity); + ; + args.push(this.StartTag); + ; + args.push(this.EndTag); + ; + args.push(this.StartDistAlong); + ; + args.push(this.HorizontalLength); + ; + args.push(this.StartHeight); + ; + args.push(this.StartGradient); + ; + args.push(this.ParabolaConstant); + ; + args.push(this.IsConvex); + ; + return args; + } +}; +var IfcAlignment2DVertical = class { + constructor(expressID, type, Segments) { + this.expressID = expressID; + this.type = type; + this.Segments = Segments; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Segments = tape[ptr++]; + return new IfcAlignment2DVertical(expressID, type, Segments); + } + ToTape() { + let args = []; + args.push(this.Segments); + ; + return args; + } +}; +var IfcAlignment2DVerticalSegment = class { + constructor(expressID, type, TangentialContinuity, StartTag, EndTag, StartDistAlong, HorizontalLength, StartHeight, StartGradient) { + this.expressID = expressID; + this.type = type; + this.TangentialContinuity = TangentialContinuity; + this.StartTag = StartTag; + this.EndTag = EndTag; + this.StartDistAlong = StartDistAlong; + this.HorizontalLength = HorizontalLength; + this.StartHeight = StartHeight; + this.StartGradient = StartGradient; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let TangentialContinuity = tape[ptr++]; + let StartTag = tape[ptr++]; + let EndTag = tape[ptr++]; + let StartDistAlong = tape[ptr++]; + let HorizontalLength = tape[ptr++]; + let StartHeight = tape[ptr++]; + let StartGradient = tape[ptr++]; + return new IfcAlignment2DVerticalSegment(expressID, type, TangentialContinuity, StartTag, EndTag, StartDistAlong, HorizontalLength, StartHeight, StartGradient); + } + ToTape() { + let args = []; + args.push(this.TangentialContinuity); + ; + args.push(this.StartTag); + ; + args.push(this.EndTag); + ; + args.push(this.StartDistAlong); + ; + args.push(this.HorizontalLength); + ; + args.push(this.StartHeight); + ; + args.push(this.StartGradient); + ; + return args; + } +}; +var IfcAlignmentCurve = class { + constructor(expressID, type, Horizontal, Vertical, Tag) { + this.expressID = expressID; + this.type = type; + this.Horizontal = Horizontal; + this.Vertical = Vertical; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Horizontal = tape[ptr++]; + let Vertical = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcAlignmentCurve(expressID, type, Horizontal, Vertical, Tag); + } + ToTape() { + let args = []; + args.push(this.Horizontal); + ; + args.push(this.Vertical); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcAnnotation = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + return new IfcAnnotation(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + return args; + } +}; +var IfcAnnotationFillArea = class { + constructor(expressID, type, OuterBoundary, InnerBoundaries) { + this.expressID = expressID; + this.type = type; + this.OuterBoundary = OuterBoundary; + this.InnerBoundaries = InnerBoundaries; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let OuterBoundary = tape[ptr++]; + let InnerBoundaries = tape[ptr++]; + return new IfcAnnotationFillArea(expressID, type, OuterBoundary, InnerBoundaries); + } + ToTape() { + let args = []; + args.push(this.OuterBoundary); + ; + args.push(this.InnerBoundaries); + ; + return args; + } +}; +var IfcApplication = class { + constructor(expressID, type, ApplicationDeveloper, Version, ApplicationFullName, ApplicationIdentifier) { + this.expressID = expressID; + this.type = type; + this.ApplicationDeveloper = ApplicationDeveloper; + this.Version = Version; + this.ApplicationFullName = ApplicationFullName; + this.ApplicationIdentifier = ApplicationIdentifier; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ApplicationDeveloper = tape[ptr++]; + let Version = tape[ptr++]; + let ApplicationFullName = tape[ptr++]; + let ApplicationIdentifier = tape[ptr++]; + return new IfcApplication(expressID, type, ApplicationDeveloper, Version, ApplicationFullName, ApplicationIdentifier); + } + ToTape() { + let args = []; + args.push(this.ApplicationDeveloper); + ; + args.push(this.Version); + ; + args.push(this.ApplicationFullName); + ; + args.push(this.ApplicationIdentifier); + ; + return args; + } +}; +var IfcAppliedValue = class { + constructor(expressID, type, Name, Description, AppliedValue, UnitBasis, ApplicableDate, FixedUntilDate, Category, Condition, ArithmeticOperator, Components) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.AppliedValue = AppliedValue; + this.UnitBasis = UnitBasis; + this.ApplicableDate = ApplicableDate; + this.FixedUntilDate = FixedUntilDate; + this.Category = Category; + this.Condition = Condition; + this.ArithmeticOperator = ArithmeticOperator; + this.Components = Components; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let AppliedValue = tape[ptr++]; + let UnitBasis = tape[ptr++]; + let ApplicableDate = tape[ptr++]; + let FixedUntilDate = tape[ptr++]; + let Category = tape[ptr++]; + let Condition = tape[ptr++]; + let ArithmeticOperator = tape[ptr++]; + let Components = tape[ptr++]; + return new IfcAppliedValue(expressID, type, Name, Description, AppliedValue, UnitBasis, ApplicableDate, FixedUntilDate, Category, Condition, ArithmeticOperator, Components); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.AppliedValue); + ; + args.push(this.UnitBasis); + ; + args.push(this.ApplicableDate); + ; + args.push(this.FixedUntilDate); + ; + args.push(this.Category); + ; + args.push(this.Condition); + ; + args.push(this.ArithmeticOperator); + ; + args.push(this.Components); + ; + return args; + } +}; +var IfcApproval = class { + constructor(expressID, type, Identifier, Name, Description, TimeOfApproval, Status, Level, Qualifier, RequestingApproval, GivingApproval) { + this.expressID = expressID; + this.type = type; + this.Identifier = Identifier; + this.Name = Name; + this.Description = Description; + this.TimeOfApproval = TimeOfApproval; + this.Status = Status; + this.Level = Level; + this.Qualifier = Qualifier; + this.RequestingApproval = RequestingApproval; + this.GivingApproval = GivingApproval; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Identifier = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let TimeOfApproval = tape[ptr++]; + let Status = tape[ptr++]; + let Level = tape[ptr++]; + let Qualifier = tape[ptr++]; + let RequestingApproval = tape[ptr++]; + let GivingApproval = tape[ptr++]; + return new IfcApproval(expressID, type, Identifier, Name, Description, TimeOfApproval, Status, Level, Qualifier, RequestingApproval, GivingApproval); + } + ToTape() { + let args = []; + args.push(this.Identifier); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.TimeOfApproval); + ; + args.push(this.Status); + ; + args.push(this.Level); + ; + args.push(this.Qualifier); + ; + args.push(this.RequestingApproval); + ; + args.push(this.GivingApproval); + ; + return args; + } +}; +var IfcApprovalRelationship = class { + constructor(expressID, type, Name, Description, RelatingApproval, RelatedApprovals) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.RelatingApproval = RelatingApproval; + this.RelatedApprovals = RelatedApprovals; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingApproval = tape[ptr++]; + let RelatedApprovals = tape[ptr++]; + return new IfcApprovalRelationship(expressID, type, Name, Description, RelatingApproval, RelatedApprovals); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingApproval); + ; + args.push(this.RelatedApprovals); + ; + return args; + } +}; +var IfcArbitraryClosedProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, OuterCurve) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.OuterCurve = OuterCurve; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let OuterCurve = tape[ptr++]; + return new IfcArbitraryClosedProfileDef(expressID, type, ProfileType, ProfileName, OuterCurve); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.OuterCurve); + ; + return args; + } +}; +var IfcArbitraryOpenProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, Curve) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.Curve = Curve; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let Curve = tape[ptr++]; + return new IfcArbitraryOpenProfileDef(expressID, type, ProfileType, ProfileName, Curve); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.Curve); + ; + return args; + } +}; +var IfcArbitraryProfileDefWithVoids = class { + constructor(expressID, type, ProfileType, ProfileName, OuterCurve, InnerCurves) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.OuterCurve = OuterCurve; + this.InnerCurves = InnerCurves; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let OuterCurve = tape[ptr++]; + let InnerCurves = tape[ptr++]; + return new IfcArbitraryProfileDefWithVoids(expressID, type, ProfileType, ProfileName, OuterCurve, InnerCurves); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.OuterCurve); + ; + args.push(this.InnerCurves); + ; + return args; + } +}; +var IfcAsset = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, OriginalValue, CurrentValue, TotalReplacementCost, Owner, User, ResponsiblePerson, IncorporationDate, DepreciatedValue) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.OriginalValue = OriginalValue; + this.CurrentValue = CurrentValue; + this.TotalReplacementCost = TotalReplacementCost; + this.Owner = Owner; + this.User = User; + this.ResponsiblePerson = ResponsiblePerson; + this.IncorporationDate = IncorporationDate; + this.DepreciatedValue = DepreciatedValue; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let OriginalValue = tape[ptr++]; + let CurrentValue = tape[ptr++]; + let TotalReplacementCost = tape[ptr++]; + let Owner = tape[ptr++]; + let User = tape[ptr++]; + let ResponsiblePerson = tape[ptr++]; + let IncorporationDate = tape[ptr++]; + let DepreciatedValue = tape[ptr++]; + return new IfcAsset(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, OriginalValue, CurrentValue, TotalReplacementCost, Owner, User, ResponsiblePerson, IncorporationDate, DepreciatedValue); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.OriginalValue); + ; + args.push(this.CurrentValue); + ; + args.push(this.TotalReplacementCost); + ; + args.push(this.Owner); + ; + args.push(this.User); + ; + args.push(this.ResponsiblePerson); + ; + args.push(this.IncorporationDate); + ; + args.push(this.DepreciatedValue); + ; + return args; + } +}; +var IfcAsymmetricIShapeProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, Position, BottomFlangeWidth, OverallDepth, WebThickness, BottomFlangeThickness, BottomFlangeFilletRadius, TopFlangeWidth, TopFlangeThickness, TopFlangeFilletRadius, BottomFlangeEdgeRadius, BottomFlangeSlope, TopFlangeEdgeRadius, TopFlangeSlope) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.Position = Position; + this.BottomFlangeWidth = BottomFlangeWidth; + this.OverallDepth = OverallDepth; + this.WebThickness = WebThickness; + this.BottomFlangeThickness = BottomFlangeThickness; + this.BottomFlangeFilletRadius = BottomFlangeFilletRadius; + this.TopFlangeWidth = TopFlangeWidth; + this.TopFlangeThickness = TopFlangeThickness; + this.TopFlangeFilletRadius = TopFlangeFilletRadius; + this.BottomFlangeEdgeRadius = BottomFlangeEdgeRadius; + this.BottomFlangeSlope = BottomFlangeSlope; + this.TopFlangeEdgeRadius = TopFlangeEdgeRadius; + this.TopFlangeSlope = TopFlangeSlope; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let Position = tape[ptr++]; + let BottomFlangeWidth = tape[ptr++]; + let OverallDepth = tape[ptr++]; + let WebThickness = tape[ptr++]; + let BottomFlangeThickness = tape[ptr++]; + let BottomFlangeFilletRadius = tape[ptr++]; + let TopFlangeWidth = tape[ptr++]; + let TopFlangeThickness = tape[ptr++]; + let TopFlangeFilletRadius = tape[ptr++]; + let BottomFlangeEdgeRadius = tape[ptr++]; + let BottomFlangeSlope = tape[ptr++]; + let TopFlangeEdgeRadius = tape[ptr++]; + let TopFlangeSlope = tape[ptr++]; + return new IfcAsymmetricIShapeProfileDef(expressID, type, ProfileType, ProfileName, Position, BottomFlangeWidth, OverallDepth, WebThickness, BottomFlangeThickness, BottomFlangeFilletRadius, TopFlangeWidth, TopFlangeThickness, TopFlangeFilletRadius, BottomFlangeEdgeRadius, BottomFlangeSlope, TopFlangeEdgeRadius, TopFlangeSlope); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.Position); + ; + args.push(this.BottomFlangeWidth); + ; + args.push(this.OverallDepth); + ; + args.push(this.WebThickness); + ; + args.push(this.BottomFlangeThickness); + ; + args.push(this.BottomFlangeFilletRadius); + ; + args.push(this.TopFlangeWidth); + ; + args.push(this.TopFlangeThickness); + ; + args.push(this.TopFlangeFilletRadius); + ; + args.push(this.BottomFlangeEdgeRadius); + ; + args.push(this.BottomFlangeSlope); + ; + args.push(this.TopFlangeEdgeRadius); + ; + args.push(this.TopFlangeSlope); + ; + return args; + } +}; +var IfcAudioVisualAppliance = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcAudioVisualAppliance(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcAudioVisualApplianceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcAudioVisualApplianceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcAxis1Placement = class { + constructor(expressID, type, Location, Axis) { + this.expressID = expressID; + this.type = type; + this.Location = Location; + this.Axis = Axis; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Location = tape[ptr++]; + let Axis = tape[ptr++]; + return new IfcAxis1Placement(expressID, type, Location, Axis); + } + ToTape() { + let args = []; + args.push(this.Location); + ; + args.push(this.Axis); + ; + return args; + } +}; +var IfcAxis2Placement2D = class { + constructor(expressID, type, Location, RefDirection) { + this.expressID = expressID; + this.type = type; + this.Location = Location; + this.RefDirection = RefDirection; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Location = tape[ptr++]; + let RefDirection = tape[ptr++]; + return new IfcAxis2Placement2D(expressID, type, Location, RefDirection); + } + ToTape() { + let args = []; + args.push(this.Location); + ; + args.push(this.RefDirection); + ; + return args; + } +}; +var IfcAxis2Placement3D = class { + constructor(expressID, type, Location, Axis, RefDirection) { + this.expressID = expressID; + this.type = type; + this.Location = Location; + this.Axis = Axis; + this.RefDirection = RefDirection; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Location = tape[ptr++]; + let Axis = tape[ptr++]; + let RefDirection = tape[ptr++]; + return new IfcAxis2Placement3D(expressID, type, Location, Axis, RefDirection); + } + ToTape() { + let args = []; + args.push(this.Location); + ; + args.push(this.Axis); + ; + args.push(this.RefDirection); + ; + return args; + } +}; +var IfcBSplineCurve = class { + constructor(expressID, type, Degree, ControlPointsList, CurveForm, ClosedCurve, SelfIntersect) { + this.expressID = expressID; + this.type = type; + this.Degree = Degree; + this.ControlPointsList = ControlPointsList; + this.CurveForm = CurveForm; + this.ClosedCurve = ClosedCurve; + this.SelfIntersect = SelfIntersect; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Degree = tape[ptr++]; + let ControlPointsList = tape[ptr++]; + let CurveForm = tape[ptr++]; + let ClosedCurve = tape[ptr++]; + let SelfIntersect = tape[ptr++]; + return new IfcBSplineCurve(expressID, type, Degree, ControlPointsList, CurveForm, ClosedCurve, SelfIntersect); + } + ToTape() { + let args = []; + args.push(this.Degree); + ; + args.push(this.ControlPointsList); + ; + args.push(this.CurveForm); + ; + args.push(this.ClosedCurve); + ; + args.push(this.SelfIntersect); + ; + return args; + } +}; +var IfcBSplineCurveWithKnots = class { + constructor(expressID, type, Degree, ControlPointsList, CurveForm, ClosedCurve, SelfIntersect, KnotMultiplicities, Knots, KnotSpec) { + this.expressID = expressID; + this.type = type; + this.Degree = Degree; + this.ControlPointsList = ControlPointsList; + this.CurveForm = CurveForm; + this.ClosedCurve = ClosedCurve; + this.SelfIntersect = SelfIntersect; + this.KnotMultiplicities = KnotMultiplicities; + this.Knots = Knots; + this.KnotSpec = KnotSpec; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Degree = tape[ptr++]; + let ControlPointsList = tape[ptr++]; + let CurveForm = tape[ptr++]; + let ClosedCurve = tape[ptr++]; + let SelfIntersect = tape[ptr++]; + let KnotMultiplicities = tape[ptr++]; + let Knots = tape[ptr++]; + let KnotSpec = tape[ptr++]; + return new IfcBSplineCurveWithKnots(expressID, type, Degree, ControlPointsList, CurveForm, ClosedCurve, SelfIntersect, KnotMultiplicities, Knots, KnotSpec); + } + ToTape() { + let args = []; + args.push(this.Degree); + ; + args.push(this.ControlPointsList); + ; + args.push(this.CurveForm); + ; + args.push(this.ClosedCurve); + ; + args.push(this.SelfIntersect); + ; + args.push(this.KnotMultiplicities); + ; + args.push(this.Knots); + ; + args.push(this.KnotSpec); + ; + return args; + } +}; +var IfcBSplineSurface = class { + constructor(expressID, type, UDegree, VDegree, ControlPointsList, SurfaceForm, UClosed, VClosed, SelfIntersect) { + this.expressID = expressID; + this.type = type; + this.UDegree = UDegree; + this.VDegree = VDegree; + this.ControlPointsList = ControlPointsList; + this.SurfaceForm = SurfaceForm; + this.UClosed = UClosed; + this.VClosed = VClosed; + this.SelfIntersect = SelfIntersect; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let UDegree = tape[ptr++]; + let VDegree = tape[ptr++]; + let ControlPointsList = tape[ptr++]; + let SurfaceForm = tape[ptr++]; + let UClosed = tape[ptr++]; + let VClosed = tape[ptr++]; + let SelfIntersect = tape[ptr++]; + return new IfcBSplineSurface(expressID, type, UDegree, VDegree, ControlPointsList, SurfaceForm, UClosed, VClosed, SelfIntersect); + } + ToTape() { + let args = []; + args.push(this.UDegree); + ; + args.push(this.VDegree); + ; + args.push(this.ControlPointsList); + ; + args.push(this.SurfaceForm); + ; + args.push(this.UClosed); + ; + args.push(this.VClosed); + ; + args.push(this.SelfIntersect); + ; + return args; + } +}; +var IfcBSplineSurfaceWithKnots = class { + constructor(expressID, type, UDegree, VDegree, ControlPointsList, SurfaceForm, UClosed, VClosed, SelfIntersect, UMultiplicities, VMultiplicities, UKnots, VKnots, KnotSpec) { + this.expressID = expressID; + this.type = type; + this.UDegree = UDegree; + this.VDegree = VDegree; + this.ControlPointsList = ControlPointsList; + this.SurfaceForm = SurfaceForm; + this.UClosed = UClosed; + this.VClosed = VClosed; + this.SelfIntersect = SelfIntersect; + this.UMultiplicities = UMultiplicities; + this.VMultiplicities = VMultiplicities; + this.UKnots = UKnots; + this.VKnots = VKnots; + this.KnotSpec = KnotSpec; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let UDegree = tape[ptr++]; + let VDegree = tape[ptr++]; + let ControlPointsList = tape[ptr++]; + let SurfaceForm = tape[ptr++]; + let UClosed = tape[ptr++]; + let VClosed = tape[ptr++]; + let SelfIntersect = tape[ptr++]; + let UMultiplicities = tape[ptr++]; + let VMultiplicities = tape[ptr++]; + let UKnots = tape[ptr++]; + let VKnots = tape[ptr++]; + let KnotSpec = tape[ptr++]; + return new IfcBSplineSurfaceWithKnots(expressID, type, UDegree, VDegree, ControlPointsList, SurfaceForm, UClosed, VClosed, SelfIntersect, UMultiplicities, VMultiplicities, UKnots, VKnots, KnotSpec); + } + ToTape() { + let args = []; + args.push(this.UDegree); + ; + args.push(this.VDegree); + ; + args.push(this.ControlPointsList); + ; + args.push(this.SurfaceForm); + ; + args.push(this.UClosed); + ; + args.push(this.VClosed); + ; + args.push(this.SelfIntersect); + ; + args.push(this.UMultiplicities); + ; + args.push(this.VMultiplicities); + ; + args.push(this.UKnots); + ; + args.push(this.VKnots); + ; + args.push(this.KnotSpec); + ; + return args; + } +}; +var IfcBeam = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcBeam(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcBeamStandardCase = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcBeamStandardCase(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcBeamType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcBeamType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcBearing = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcBearing(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcBearingType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcBearingType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcBlobTexture = class { + constructor(expressID, type, RepeatS, RepeatT, Mode, TextureTransform, Parameter, RasterFormat, RasterCode) { + this.expressID = expressID; + this.type = type; + this.RepeatS = RepeatS; + this.RepeatT = RepeatT; + this.Mode = Mode; + this.TextureTransform = TextureTransform; + this.Parameter = Parameter; + this.RasterFormat = RasterFormat; + this.RasterCode = RasterCode; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let RepeatS = tape[ptr++]; + let RepeatT = tape[ptr++]; + let Mode = tape[ptr++]; + let TextureTransform = tape[ptr++]; + let Parameter = tape[ptr++]; + let RasterFormat = tape[ptr++]; + let RasterCode = tape[ptr++]; + return new IfcBlobTexture(expressID, type, RepeatS, RepeatT, Mode, TextureTransform, Parameter, RasterFormat, RasterCode); + } + ToTape() { + let args = []; + args.push(this.RepeatS); + ; + args.push(this.RepeatT); + ; + args.push(this.Mode); + ; + args.push(this.TextureTransform); + ; + args.push(this.Parameter); + ; + args.push(this.RasterFormat); + ; + args.push(this.RasterCode); + ; + return args; + } +}; +var IfcBlock = class { + constructor(expressID, type, Position, XLength, YLength, ZLength) { + this.expressID = expressID; + this.type = type; + this.Position = Position; + this.XLength = XLength; + this.YLength = YLength; + this.ZLength = ZLength; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Position = tape[ptr++]; + let XLength = tape[ptr++]; + let YLength = tape[ptr++]; + let ZLength = tape[ptr++]; + return new IfcBlock(expressID, type, Position, XLength, YLength, ZLength); + } + ToTape() { + let args = []; + args.push(this.Position); + ; + args.push(this.XLength); + ; + args.push(this.YLength); + ; + args.push(this.ZLength); + ; + return args; + } +}; +var IfcBoiler = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcBoiler(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcBoilerType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcBoilerType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcBooleanClippingResult = class { + constructor(expressID, type, Operator, FirstOperand, SecondOperand) { + this.expressID = expressID; + this.type = type; + this.Operator = Operator; + this.FirstOperand = FirstOperand; + this.SecondOperand = SecondOperand; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Operator = tape[ptr++]; + let FirstOperand = tape[ptr++]; + let SecondOperand = tape[ptr++]; + return new IfcBooleanClippingResult(expressID, type, Operator, FirstOperand, SecondOperand); + } + ToTape() { + let args = []; + args.push(this.Operator); + ; + args.push(this.FirstOperand); + ; + args.push(this.SecondOperand); + ; + return args; + } +}; +var IfcBooleanResult = class { + constructor(expressID, type, Operator, FirstOperand, SecondOperand) { + this.expressID = expressID; + this.type = type; + this.Operator = Operator; + this.FirstOperand = FirstOperand; + this.SecondOperand = SecondOperand; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Operator = tape[ptr++]; + let FirstOperand = tape[ptr++]; + let SecondOperand = tape[ptr++]; + return new IfcBooleanResult(expressID, type, Operator, FirstOperand, SecondOperand); + } + ToTape() { + let args = []; + args.push(this.Operator); + ; + args.push(this.FirstOperand); + ; + args.push(this.SecondOperand); + ; + return args; + } +}; +var IfcBoundaryCondition = class { + constructor(expressID, type, Name) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + return new IfcBoundaryCondition(expressID, type, Name); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + return args; + } +}; +var IfcBoundaryCurve = class { + constructor(expressID, type, Segments, SelfIntersect) { + this.expressID = expressID; + this.type = type; + this.Segments = Segments; + this.SelfIntersect = SelfIntersect; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Segments = tape[ptr++]; + let SelfIntersect = tape[ptr++]; + return new IfcBoundaryCurve(expressID, type, Segments, SelfIntersect); + } + ToTape() { + let args = []; + args.push(this.Segments); + ; + args.push(this.SelfIntersect); + ; + return args; + } +}; +var IfcBoundaryEdgeCondition = class { + constructor(expressID, type, Name, TranslationalStiffnessByLengthX, TranslationalStiffnessByLengthY, TranslationalStiffnessByLengthZ, RotationalStiffnessByLengthX, RotationalStiffnessByLengthY, RotationalStiffnessByLengthZ) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.TranslationalStiffnessByLengthX = TranslationalStiffnessByLengthX; + this.TranslationalStiffnessByLengthY = TranslationalStiffnessByLengthY; + this.TranslationalStiffnessByLengthZ = TranslationalStiffnessByLengthZ; + this.RotationalStiffnessByLengthX = RotationalStiffnessByLengthX; + this.RotationalStiffnessByLengthY = RotationalStiffnessByLengthY; + this.RotationalStiffnessByLengthZ = RotationalStiffnessByLengthZ; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let TranslationalStiffnessByLengthX = tape[ptr++]; + let TranslationalStiffnessByLengthY = tape[ptr++]; + let TranslationalStiffnessByLengthZ = tape[ptr++]; + let RotationalStiffnessByLengthX = tape[ptr++]; + let RotationalStiffnessByLengthY = tape[ptr++]; + let RotationalStiffnessByLengthZ = tape[ptr++]; + return new IfcBoundaryEdgeCondition(expressID, type, Name, TranslationalStiffnessByLengthX, TranslationalStiffnessByLengthY, TranslationalStiffnessByLengthZ, RotationalStiffnessByLengthX, RotationalStiffnessByLengthY, RotationalStiffnessByLengthZ); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.TranslationalStiffnessByLengthX); + ; + args.push(this.TranslationalStiffnessByLengthY); + ; + args.push(this.TranslationalStiffnessByLengthZ); + ; + args.push(this.RotationalStiffnessByLengthX); + ; + args.push(this.RotationalStiffnessByLengthY); + ; + args.push(this.RotationalStiffnessByLengthZ); + ; + return args; + } +}; +var IfcBoundaryFaceCondition = class { + constructor(expressID, type, Name, TranslationalStiffnessByAreaX, TranslationalStiffnessByAreaY, TranslationalStiffnessByAreaZ) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.TranslationalStiffnessByAreaX = TranslationalStiffnessByAreaX; + this.TranslationalStiffnessByAreaY = TranslationalStiffnessByAreaY; + this.TranslationalStiffnessByAreaZ = TranslationalStiffnessByAreaZ; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let TranslationalStiffnessByAreaX = tape[ptr++]; + let TranslationalStiffnessByAreaY = tape[ptr++]; + let TranslationalStiffnessByAreaZ = tape[ptr++]; + return new IfcBoundaryFaceCondition(expressID, type, Name, TranslationalStiffnessByAreaX, TranslationalStiffnessByAreaY, TranslationalStiffnessByAreaZ); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.TranslationalStiffnessByAreaX); + ; + args.push(this.TranslationalStiffnessByAreaY); + ; + args.push(this.TranslationalStiffnessByAreaZ); + ; + return args; + } +}; +var IfcBoundaryNodeCondition = class { + constructor(expressID, type, Name, TranslationalStiffnessX, TranslationalStiffnessY, TranslationalStiffnessZ, RotationalStiffnessX, RotationalStiffnessY, RotationalStiffnessZ) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.TranslationalStiffnessX = TranslationalStiffnessX; + this.TranslationalStiffnessY = TranslationalStiffnessY; + this.TranslationalStiffnessZ = TranslationalStiffnessZ; + this.RotationalStiffnessX = RotationalStiffnessX; + this.RotationalStiffnessY = RotationalStiffnessY; + this.RotationalStiffnessZ = RotationalStiffnessZ; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let TranslationalStiffnessX = tape[ptr++]; + let TranslationalStiffnessY = tape[ptr++]; + let TranslationalStiffnessZ = tape[ptr++]; + let RotationalStiffnessX = tape[ptr++]; + let RotationalStiffnessY = tape[ptr++]; + let RotationalStiffnessZ = tape[ptr++]; + return new IfcBoundaryNodeCondition(expressID, type, Name, TranslationalStiffnessX, TranslationalStiffnessY, TranslationalStiffnessZ, RotationalStiffnessX, RotationalStiffnessY, RotationalStiffnessZ); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.TranslationalStiffnessX); + ; + args.push(this.TranslationalStiffnessY); + ; + args.push(this.TranslationalStiffnessZ); + ; + args.push(this.RotationalStiffnessX); + ; + args.push(this.RotationalStiffnessY); + ; + args.push(this.RotationalStiffnessZ); + ; + return args; + } +}; +var IfcBoundaryNodeConditionWarping = class { + constructor(expressID, type, Name, TranslationalStiffnessX, TranslationalStiffnessY, TranslationalStiffnessZ, RotationalStiffnessX, RotationalStiffnessY, RotationalStiffnessZ, WarpingStiffness) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.TranslationalStiffnessX = TranslationalStiffnessX; + this.TranslationalStiffnessY = TranslationalStiffnessY; + this.TranslationalStiffnessZ = TranslationalStiffnessZ; + this.RotationalStiffnessX = RotationalStiffnessX; + this.RotationalStiffnessY = RotationalStiffnessY; + this.RotationalStiffnessZ = RotationalStiffnessZ; + this.WarpingStiffness = WarpingStiffness; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let TranslationalStiffnessX = tape[ptr++]; + let TranslationalStiffnessY = tape[ptr++]; + let TranslationalStiffnessZ = tape[ptr++]; + let RotationalStiffnessX = tape[ptr++]; + let RotationalStiffnessY = tape[ptr++]; + let RotationalStiffnessZ = tape[ptr++]; + let WarpingStiffness = tape[ptr++]; + return new IfcBoundaryNodeConditionWarping(expressID, type, Name, TranslationalStiffnessX, TranslationalStiffnessY, TranslationalStiffnessZ, RotationalStiffnessX, RotationalStiffnessY, RotationalStiffnessZ, WarpingStiffness); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.TranslationalStiffnessX); + ; + args.push(this.TranslationalStiffnessY); + ; + args.push(this.TranslationalStiffnessZ); + ; + args.push(this.RotationalStiffnessX); + ; + args.push(this.RotationalStiffnessY); + ; + args.push(this.RotationalStiffnessZ); + ; + args.push(this.WarpingStiffness); + ; + return args; + } +}; +var IfcBoundedCurve = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcBoundedCurve(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcBoundedSurface = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcBoundedSurface(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcBoundingBox = class { + constructor(expressID, type, Corner, XDim, YDim, ZDim) { + this.expressID = expressID; + this.type = type; + this.Corner = Corner; + this.XDim = XDim; + this.YDim = YDim; + this.ZDim = ZDim; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Corner = tape[ptr++]; + let XDim = tape[ptr++]; + let YDim = tape[ptr++]; + let ZDim = tape[ptr++]; + return new IfcBoundingBox(expressID, type, Corner, XDim, YDim, ZDim); + } + ToTape() { + let args = []; + args.push(this.Corner); + ; + args.push(this.XDim); + ; + args.push(this.YDim); + ; + args.push(this.ZDim); + ; + return args; + } +}; +var IfcBoxedHalfSpace = class { + constructor(expressID, type, BaseSurface, AgreementFlag, Enclosure) { + this.expressID = expressID; + this.type = type; + this.BaseSurface = BaseSurface; + this.AgreementFlag = AgreementFlag; + this.Enclosure = Enclosure; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let BaseSurface = tape[ptr++]; + let AgreementFlag = tape[ptr++]; + let Enclosure = tape[ptr++]; + return new IfcBoxedHalfSpace(expressID, type, BaseSurface, AgreementFlag, Enclosure); + } + ToTape() { + let args = []; + args.push(this.BaseSurface); + ; + args.push(this.AgreementFlag); + ; + args.push(this.Enclosure); + ; + return args; + } +}; +var IfcBridge = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, CompositionType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.LongName = LongName; + this.CompositionType = CompositionType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let LongName = tape[ptr++]; + let CompositionType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcBridge(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, CompositionType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.LongName); + ; + args.push(this.CompositionType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcBridgePart = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, CompositionType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.LongName = LongName; + this.CompositionType = CompositionType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let LongName = tape[ptr++]; + let CompositionType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcBridgePart(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, CompositionType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.LongName); + ; + args.push(this.CompositionType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcBuilding = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, CompositionType, ElevationOfRefHeight, ElevationOfTerrain, BuildingAddress) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.LongName = LongName; + this.CompositionType = CompositionType; + this.ElevationOfRefHeight = ElevationOfRefHeight; + this.ElevationOfTerrain = ElevationOfTerrain; + this.BuildingAddress = BuildingAddress; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let LongName = tape[ptr++]; + let CompositionType = tape[ptr++]; + let ElevationOfRefHeight = tape[ptr++]; + let ElevationOfTerrain = tape[ptr++]; + let BuildingAddress = tape[ptr++]; + return new IfcBuilding(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, CompositionType, ElevationOfRefHeight, ElevationOfTerrain, BuildingAddress); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.LongName); + ; + args.push(this.CompositionType); + ; + args.push(this.ElevationOfRefHeight); + ; + args.push(this.ElevationOfTerrain); + ; + args.push(this.BuildingAddress); + ; + return args; + } +}; +var IfcBuildingElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcBuildingElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcBuildingElementPart = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcBuildingElementPart(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcBuildingElementPartType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcBuildingElementPartType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcBuildingElementProxy = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcBuildingElementProxy(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcBuildingElementProxyType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcBuildingElementProxyType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcBuildingElementType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcBuildingElementType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcBuildingStorey = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, CompositionType, Elevation) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.LongName = LongName; + this.CompositionType = CompositionType; + this.Elevation = Elevation; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let LongName = tape[ptr++]; + let CompositionType = tape[ptr++]; + let Elevation = tape[ptr++]; + return new IfcBuildingStorey(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, CompositionType, Elevation); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.LongName); + ; + args.push(this.CompositionType); + ; + args.push(this.Elevation); + ; + return args; + } +}; +var IfcBuildingSystem = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, PredefinedType, LongName) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.PredefinedType = PredefinedType; + this.LongName = LongName; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let LongName = tape[ptr++]; + return new IfcBuildingSystem(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, PredefinedType, LongName); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.PredefinedType); + ; + args.push(this.LongName); + ; + return args; + } +}; +var IfcBurner = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcBurner(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcBurnerType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcBurnerType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCShapeProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, Position, Depth, Width, WallThickness, Girth, InternalFilletRadius) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.Position = Position; + this.Depth = Depth; + this.Width = Width; + this.WallThickness = WallThickness; + this.Girth = Girth; + this.InternalFilletRadius = InternalFilletRadius; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let Position = tape[ptr++]; + let Depth = tape[ptr++]; + let Width = tape[ptr++]; + let WallThickness = tape[ptr++]; + let Girth = tape[ptr++]; + let InternalFilletRadius = tape[ptr++]; + return new IfcCShapeProfileDef(expressID, type, ProfileType, ProfileName, Position, Depth, Width, WallThickness, Girth, InternalFilletRadius); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.Position); + ; + args.push(this.Depth); + ; + args.push(this.Width); + ; + args.push(this.WallThickness); + ; + args.push(this.Girth); + ; + args.push(this.InternalFilletRadius); + ; + return args; + } +}; +var IfcCableCarrierFitting = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCableCarrierFitting(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCableCarrierFittingType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCableCarrierFittingType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCableCarrierSegment = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCableCarrierSegment(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCableCarrierSegmentType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCableCarrierSegmentType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCableFitting = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCableFitting(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCableFittingType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCableFittingType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCableSegment = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCableSegment(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCableSegmentType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCableSegmentType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCaissonFoundation = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCaissonFoundation(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCaissonFoundationType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCaissonFoundationType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCartesianPoint = class { + constructor(expressID, type, Coordinates) { + this.expressID = expressID; + this.type = type; + this.Coordinates = Coordinates; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Coordinates = tape[ptr++]; + return new IfcCartesianPoint(expressID, type, Coordinates); + } + ToTape() { + let args = []; + args.push(this.Coordinates); + ; + return args; + } +}; +var IfcCartesianPointList = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcCartesianPointList(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcCartesianPointList2D = class { + constructor(expressID, type, CoordList, TagList) { + this.expressID = expressID; + this.type = type; + this.CoordList = CoordList; + this.TagList = TagList; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let CoordList = tape[ptr++]; + let TagList = tape[ptr++]; + return new IfcCartesianPointList2D(expressID, type, CoordList, TagList); + } + ToTape() { + let args = []; + args.push(this.CoordList); + ; + args.push(this.TagList); + ; + return args; + } +}; +var IfcCartesianPointList3D = class { + constructor(expressID, type, CoordList, TagList) { + this.expressID = expressID; + this.type = type; + this.CoordList = CoordList; + this.TagList = TagList; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let CoordList = tape[ptr++]; + let TagList = tape[ptr++]; + return new IfcCartesianPointList3D(expressID, type, CoordList, TagList); + } + ToTape() { + let args = []; + args.push(this.CoordList); + ; + args.push(this.TagList); + ; + return args; + } +}; +var IfcCartesianTransformationOperator = class { + constructor(expressID, type, Axis1, Axis2, LocalOrigin, Scale) { + this.expressID = expressID; + this.type = type; + this.Axis1 = Axis1; + this.Axis2 = Axis2; + this.LocalOrigin = LocalOrigin; + this.Scale = Scale; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Axis1 = tape[ptr++]; + let Axis2 = tape[ptr++]; + let LocalOrigin = tape[ptr++]; + let Scale = tape[ptr++]; + return new IfcCartesianTransformationOperator(expressID, type, Axis1, Axis2, LocalOrigin, Scale); + } + ToTape() { + let args = []; + args.push(this.Axis1); + ; + args.push(this.Axis2); + ; + args.push(this.LocalOrigin); + ; + args.push(this.Scale); + ; + return args; + } +}; +var IfcCartesianTransformationOperator2D = class { + constructor(expressID, type, Axis1, Axis2, LocalOrigin, Scale) { + this.expressID = expressID; + this.type = type; + this.Axis1 = Axis1; + this.Axis2 = Axis2; + this.LocalOrigin = LocalOrigin; + this.Scale = Scale; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Axis1 = tape[ptr++]; + let Axis2 = tape[ptr++]; + let LocalOrigin = tape[ptr++]; + let Scale = tape[ptr++]; + return new IfcCartesianTransformationOperator2D(expressID, type, Axis1, Axis2, LocalOrigin, Scale); + } + ToTape() { + let args = []; + args.push(this.Axis1); + ; + args.push(this.Axis2); + ; + args.push(this.LocalOrigin); + ; + args.push(this.Scale); + ; + return args; + } +}; +var IfcCartesianTransformationOperator2DnonUniform = class { + constructor(expressID, type, Axis1, Axis2, LocalOrigin, Scale, Scale2) { + this.expressID = expressID; + this.type = type; + this.Axis1 = Axis1; + this.Axis2 = Axis2; + this.LocalOrigin = LocalOrigin; + this.Scale = Scale; + this.Scale2 = Scale2; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Axis1 = tape[ptr++]; + let Axis2 = tape[ptr++]; + let LocalOrigin = tape[ptr++]; + let Scale = tape[ptr++]; + let Scale2 = tape[ptr++]; + return new IfcCartesianTransformationOperator2DnonUniform(expressID, type, Axis1, Axis2, LocalOrigin, Scale, Scale2); + } + ToTape() { + let args = []; + args.push(this.Axis1); + ; + args.push(this.Axis2); + ; + args.push(this.LocalOrigin); + ; + args.push(this.Scale); + ; + args.push(this.Scale2); + ; + return args; + } +}; +var IfcCartesianTransformationOperator3D = class { + constructor(expressID, type, Axis1, Axis2, LocalOrigin, Scale, Axis3) { + this.expressID = expressID; + this.type = type; + this.Axis1 = Axis1; + this.Axis2 = Axis2; + this.LocalOrigin = LocalOrigin; + this.Scale = Scale; + this.Axis3 = Axis3; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Axis1 = tape[ptr++]; + let Axis2 = tape[ptr++]; + let LocalOrigin = tape[ptr++]; + let Scale = tape[ptr++]; + let Axis3 = tape[ptr++]; + return new IfcCartesianTransformationOperator3D(expressID, type, Axis1, Axis2, LocalOrigin, Scale, Axis3); + } + ToTape() { + let args = []; + args.push(this.Axis1); + ; + args.push(this.Axis2); + ; + args.push(this.LocalOrigin); + ; + args.push(this.Scale); + ; + args.push(this.Axis3); + ; + return args; + } +}; +var IfcCartesianTransformationOperator3DnonUniform = class { + constructor(expressID, type, Axis1, Axis2, LocalOrigin, Scale, Axis3, Scale2, Scale3) { + this.expressID = expressID; + this.type = type; + this.Axis1 = Axis1; + this.Axis2 = Axis2; + this.LocalOrigin = LocalOrigin; + this.Scale = Scale; + this.Axis3 = Axis3; + this.Scale2 = Scale2; + this.Scale3 = Scale3; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Axis1 = tape[ptr++]; + let Axis2 = tape[ptr++]; + let LocalOrigin = tape[ptr++]; + let Scale = tape[ptr++]; + let Axis3 = tape[ptr++]; + let Scale2 = tape[ptr++]; + let Scale3 = tape[ptr++]; + return new IfcCartesianTransformationOperator3DnonUniform(expressID, type, Axis1, Axis2, LocalOrigin, Scale, Axis3, Scale2, Scale3); + } + ToTape() { + let args = []; + args.push(this.Axis1); + ; + args.push(this.Axis2); + ; + args.push(this.LocalOrigin); + ; + args.push(this.Scale); + ; + args.push(this.Axis3); + ; + args.push(this.Scale2); + ; + args.push(this.Scale3); + ; + return args; + } +}; +var IfcCenterLineProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, Curve, Thickness) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.Curve = Curve; + this.Thickness = Thickness; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let Curve = tape[ptr++]; + let Thickness = tape[ptr++]; + return new IfcCenterLineProfileDef(expressID, type, ProfileType, ProfileName, Curve, Thickness); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.Curve); + ; + args.push(this.Thickness); + ; + return args; + } +}; +var IfcChiller = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcChiller(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcChillerType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcChillerType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcChimney = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcChimney(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcChimneyType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcChimneyType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCircle = class { + constructor(expressID, type, Position, Radius) { + this.expressID = expressID; + this.type = type; + this.Position = Position; + this.Radius = Radius; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Position = tape[ptr++]; + let Radius = tape[ptr++]; + return new IfcCircle(expressID, type, Position, Radius); + } + ToTape() { + let args = []; + args.push(this.Position); + ; + args.push(this.Radius); + ; + return args; + } +}; +var IfcCircleHollowProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, Position, Radius, WallThickness) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.Position = Position; + this.Radius = Radius; + this.WallThickness = WallThickness; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let Position = tape[ptr++]; + let Radius = tape[ptr++]; + let WallThickness = tape[ptr++]; + return new IfcCircleHollowProfileDef(expressID, type, ProfileType, ProfileName, Position, Radius, WallThickness); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.Position); + ; + args.push(this.Radius); + ; + args.push(this.WallThickness); + ; + return args; + } +}; +var IfcCircleProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, Position, Radius) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.Position = Position; + this.Radius = Radius; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let Position = tape[ptr++]; + let Radius = tape[ptr++]; + return new IfcCircleProfileDef(expressID, type, ProfileType, ProfileName, Position, Radius); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.Position); + ; + args.push(this.Radius); + ; + return args; + } +}; +var IfcCircularArcSegment2D = class { + constructor(expressID, type, StartPoint, StartDirection, SegmentLength, Radius, IsCCW) { + this.expressID = expressID; + this.type = type; + this.StartPoint = StartPoint; + this.StartDirection = StartDirection; + this.SegmentLength = SegmentLength; + this.Radius = Radius; + this.IsCCW = IsCCW; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let StartPoint = tape[ptr++]; + let StartDirection = tape[ptr++]; + let SegmentLength = tape[ptr++]; + let Radius = tape[ptr++]; + let IsCCW = tape[ptr++]; + return new IfcCircularArcSegment2D(expressID, type, StartPoint, StartDirection, SegmentLength, Radius, IsCCW); + } + ToTape() { + let args = []; + args.push(this.StartPoint); + ; + args.push(this.StartDirection); + ; + args.push(this.SegmentLength); + ; + args.push(this.Radius); + ; + args.push(this.IsCCW); + ; + return args; + } +}; +var IfcCivilElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcCivilElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcCivilElementType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcCivilElementType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcClassification = class { + constructor(expressID, type, Source, Edition, EditionDate, Name, Description, Location, ReferenceTokens) { + this.expressID = expressID; + this.type = type; + this.Source = Source; + this.Edition = Edition; + this.EditionDate = EditionDate; + this.Name = Name; + this.Description = Description; + this.Location = Location; + this.ReferenceTokens = ReferenceTokens; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Source = tape[ptr++]; + let Edition = tape[ptr++]; + let EditionDate = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Location = tape[ptr++]; + let ReferenceTokens = tape[ptr++]; + return new IfcClassification(expressID, type, Source, Edition, EditionDate, Name, Description, Location, ReferenceTokens); + } + ToTape() { + let args = []; + args.push(this.Source); + ; + args.push(this.Edition); + ; + args.push(this.EditionDate); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Location); + ; + args.push(this.ReferenceTokens); + ; + return args; + } +}; +var IfcClassificationReference = class { + constructor(expressID, type, Location, Identification, Name, ReferencedSource, Description, Sort) { + this.expressID = expressID; + this.type = type; + this.Location = Location; + this.Identification = Identification; + this.Name = Name; + this.ReferencedSource = ReferencedSource; + this.Description = Description; + this.Sort = Sort; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Location = tape[ptr++]; + let Identification = tape[ptr++]; + let Name = tape[ptr++]; + let ReferencedSource = tape[ptr++]; + let Description = tape[ptr++]; + let Sort = tape[ptr++]; + return new IfcClassificationReference(expressID, type, Location, Identification, Name, ReferencedSource, Description, Sort); + } + ToTape() { + let args = []; + args.push(this.Location); + ; + args.push(this.Identification); + ; + args.push(this.Name); + ; + args.push(this.ReferencedSource); + ; + args.push(this.Description); + ; + args.push(this.Sort); + ; + return args; + } +}; +var IfcClosedShell = class { + constructor(expressID, type, CfsFaces) { + this.expressID = expressID; + this.type = type; + this.CfsFaces = CfsFaces; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let CfsFaces = tape[ptr++]; + return new IfcClosedShell(expressID, type, CfsFaces); + } + ToTape() { + let args = []; + args.push(this.CfsFaces); + ; + return args; + } +}; +var IfcCoil = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCoil(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCoilType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCoilType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcColourRgb = class { + constructor(expressID, type, Name, Red, Green, Blue) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Red = Red; + this.Green = Green; + this.Blue = Blue; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Red = tape[ptr++]; + let Green = tape[ptr++]; + let Blue = tape[ptr++]; + return new IfcColourRgb(expressID, type, Name, Red, Green, Blue); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Red); + ; + args.push(this.Green); + ; + args.push(this.Blue); + ; + return args; + } +}; +var IfcColourRgbList = class { + constructor(expressID, type, ColourList) { + this.expressID = expressID; + this.type = type; + this.ColourList = ColourList; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ColourList = tape[ptr++]; + return new IfcColourRgbList(expressID, type, ColourList); + } + ToTape() { + let args = []; + args.push(this.ColourList); + ; + return args; + } +}; +var IfcColourSpecification = class { + constructor(expressID, type, Name) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + return new IfcColourSpecification(expressID, type, Name); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + return args; + } +}; +var IfcColumn = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcColumn(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcColumnStandardCase = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcColumnStandardCase(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcColumnType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcColumnType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCommunicationsAppliance = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCommunicationsAppliance(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCommunicationsApplianceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCommunicationsApplianceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcComplexProperty = class { + constructor(expressID, type, Name, Description, UsageName, HasProperties) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.UsageName = UsageName; + this.HasProperties = HasProperties; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let UsageName = tape[ptr++]; + let HasProperties = tape[ptr++]; + return new IfcComplexProperty(expressID, type, Name, Description, UsageName, HasProperties); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.UsageName); + ; + args.push(this.HasProperties); + ; + return args; + } +}; +var IfcComplexPropertyTemplate = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, UsageName, TemplateType, HasPropertyTemplates) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.UsageName = UsageName; + this.TemplateType = TemplateType; + this.HasPropertyTemplates = HasPropertyTemplates; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let UsageName = tape[ptr++]; + let TemplateType = tape[ptr++]; + let HasPropertyTemplates = tape[ptr++]; + return new IfcComplexPropertyTemplate(expressID, type, GlobalId, OwnerHistory, Name, Description, UsageName, TemplateType, HasPropertyTemplates); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.UsageName); + ; + args.push(this.TemplateType); + ; + args.push(this.HasPropertyTemplates); + ; + return args; + } +}; +var IfcCompositeCurve = class { + constructor(expressID, type, Segments, SelfIntersect) { + this.expressID = expressID; + this.type = type; + this.Segments = Segments; + this.SelfIntersect = SelfIntersect; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Segments = tape[ptr++]; + let SelfIntersect = tape[ptr++]; + return new IfcCompositeCurve(expressID, type, Segments, SelfIntersect); + } + ToTape() { + let args = []; + args.push(this.Segments); + ; + args.push(this.SelfIntersect); + ; + return args; + } +}; +var IfcCompositeCurveOnSurface = class { + constructor(expressID, type, Segments, SelfIntersect) { + this.expressID = expressID; + this.type = type; + this.Segments = Segments; + this.SelfIntersect = SelfIntersect; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Segments = tape[ptr++]; + let SelfIntersect = tape[ptr++]; + return new IfcCompositeCurveOnSurface(expressID, type, Segments, SelfIntersect); + } + ToTape() { + let args = []; + args.push(this.Segments); + ; + args.push(this.SelfIntersect); + ; + return args; + } +}; +var IfcCompositeCurveSegment = class { + constructor(expressID, type, Transition, SameSense, ParentCurve) { + this.expressID = expressID; + this.type = type; + this.Transition = Transition; + this.SameSense = SameSense; + this.ParentCurve = ParentCurve; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Transition = tape[ptr++]; + let SameSense = tape[ptr++]; + let ParentCurve = tape[ptr++]; + return new IfcCompositeCurveSegment(expressID, type, Transition, SameSense, ParentCurve); + } + ToTape() { + let args = []; + args.push(this.Transition); + ; + args.push(this.SameSense); + ; + args.push(this.ParentCurve); + ; + return args; + } +}; +var IfcCompositeProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, Profiles, Label) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.Profiles = Profiles; + this.Label = Label; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let Profiles = tape[ptr++]; + let Label = tape[ptr++]; + return new IfcCompositeProfileDef(expressID, type, ProfileType, ProfileName, Profiles, Label); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.Profiles); + ; + args.push(this.Label); + ; + return args; + } +}; +var IfcCompressor = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCompressor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCompressorType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCompressorType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCondenser = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCondenser(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCondenserType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCondenserType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcConic = class { + constructor(expressID, type, Position) { + this.expressID = expressID; + this.type = type; + this.Position = Position; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Position = tape[ptr++]; + return new IfcConic(expressID, type, Position); + } + ToTape() { + let args = []; + args.push(this.Position); + ; + return args; + } +}; +var IfcConnectedFaceSet = class { + constructor(expressID, type, CfsFaces) { + this.expressID = expressID; + this.type = type; + this.CfsFaces = CfsFaces; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let CfsFaces = tape[ptr++]; + return new IfcConnectedFaceSet(expressID, type, CfsFaces); + } + ToTape() { + let args = []; + args.push(this.CfsFaces); + ; + return args; + } +}; +var IfcConnectionCurveGeometry = class { + constructor(expressID, type, CurveOnRelatingElement, CurveOnRelatedElement) { + this.expressID = expressID; + this.type = type; + this.CurveOnRelatingElement = CurveOnRelatingElement; + this.CurveOnRelatedElement = CurveOnRelatedElement; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let CurveOnRelatingElement = tape[ptr++]; + let CurveOnRelatedElement = tape[ptr++]; + return new IfcConnectionCurveGeometry(expressID, type, CurveOnRelatingElement, CurveOnRelatedElement); + } + ToTape() { + let args = []; + args.push(this.CurveOnRelatingElement); + ; + args.push(this.CurveOnRelatedElement); + ; + return args; + } +}; +var IfcConnectionGeometry = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcConnectionGeometry(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcConnectionPointEccentricity = class { + constructor(expressID, type, PointOnRelatingElement, PointOnRelatedElement, EccentricityInX, EccentricityInY, EccentricityInZ) { + this.expressID = expressID; + this.type = type; + this.PointOnRelatingElement = PointOnRelatingElement; + this.PointOnRelatedElement = PointOnRelatedElement; + this.EccentricityInX = EccentricityInX; + this.EccentricityInY = EccentricityInY; + this.EccentricityInZ = EccentricityInZ; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let PointOnRelatingElement = tape[ptr++]; + let PointOnRelatedElement = tape[ptr++]; + let EccentricityInX = tape[ptr++]; + let EccentricityInY = tape[ptr++]; + let EccentricityInZ = tape[ptr++]; + return new IfcConnectionPointEccentricity(expressID, type, PointOnRelatingElement, PointOnRelatedElement, EccentricityInX, EccentricityInY, EccentricityInZ); + } + ToTape() { + let args = []; + args.push(this.PointOnRelatingElement); + ; + args.push(this.PointOnRelatedElement); + ; + args.push(this.EccentricityInX); + ; + args.push(this.EccentricityInY); + ; + args.push(this.EccentricityInZ); + ; + return args; + } +}; +var IfcConnectionPointGeometry = class { + constructor(expressID, type, PointOnRelatingElement, PointOnRelatedElement) { + this.expressID = expressID; + this.type = type; + this.PointOnRelatingElement = PointOnRelatingElement; + this.PointOnRelatedElement = PointOnRelatedElement; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let PointOnRelatingElement = tape[ptr++]; + let PointOnRelatedElement = tape[ptr++]; + return new IfcConnectionPointGeometry(expressID, type, PointOnRelatingElement, PointOnRelatedElement); + } + ToTape() { + let args = []; + args.push(this.PointOnRelatingElement); + ; + args.push(this.PointOnRelatedElement); + ; + return args; + } +}; +var IfcConnectionSurfaceGeometry = class { + constructor(expressID, type, SurfaceOnRelatingElement, SurfaceOnRelatedElement) { + this.expressID = expressID; + this.type = type; + this.SurfaceOnRelatingElement = SurfaceOnRelatingElement; + this.SurfaceOnRelatedElement = SurfaceOnRelatedElement; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SurfaceOnRelatingElement = tape[ptr++]; + let SurfaceOnRelatedElement = tape[ptr++]; + return new IfcConnectionSurfaceGeometry(expressID, type, SurfaceOnRelatingElement, SurfaceOnRelatedElement); + } + ToTape() { + let args = []; + args.push(this.SurfaceOnRelatingElement); + ; + args.push(this.SurfaceOnRelatedElement); + ; + return args; + } +}; +var IfcConnectionVolumeGeometry = class { + constructor(expressID, type, VolumeOnRelatingElement, VolumeOnRelatedElement) { + this.expressID = expressID; + this.type = type; + this.VolumeOnRelatingElement = VolumeOnRelatingElement; + this.VolumeOnRelatedElement = VolumeOnRelatedElement; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let VolumeOnRelatingElement = tape[ptr++]; + let VolumeOnRelatedElement = tape[ptr++]; + return new IfcConnectionVolumeGeometry(expressID, type, VolumeOnRelatingElement, VolumeOnRelatedElement); + } + ToTape() { + let args = []; + args.push(this.VolumeOnRelatingElement); + ; + args.push(this.VolumeOnRelatedElement); + ; + return args; + } +}; +var IfcConstraint = class { + constructor(expressID, type, Name, Description, ConstraintGrade, ConstraintSource, CreatingActor, CreationTime, UserDefinedGrade) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.ConstraintGrade = ConstraintGrade; + this.ConstraintSource = ConstraintSource; + this.CreatingActor = CreatingActor; + this.CreationTime = CreationTime; + this.UserDefinedGrade = UserDefinedGrade; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ConstraintGrade = tape[ptr++]; + let ConstraintSource = tape[ptr++]; + let CreatingActor = tape[ptr++]; + let CreationTime = tape[ptr++]; + let UserDefinedGrade = tape[ptr++]; + return new IfcConstraint(expressID, type, Name, Description, ConstraintGrade, ConstraintSource, CreatingActor, CreationTime, UserDefinedGrade); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ConstraintGrade); + ; + args.push(this.ConstraintSource); + ; + args.push(this.CreatingActor); + ; + args.push(this.CreationTime); + ; + args.push(this.UserDefinedGrade); + ; + return args; + } +}; +var IfcConstructionEquipmentResource = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, Usage, BaseCosts, BaseQuantity, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.Usage = Usage; + this.BaseCosts = BaseCosts; + this.BaseQuantity = BaseQuantity; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let Usage = tape[ptr++]; + let BaseCosts = tape[ptr++]; + let BaseQuantity = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcConstructionEquipmentResource(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, Usage, BaseCosts, BaseQuantity, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.Usage); + ; + args.push(this.BaseCosts); + ; + args.push(this.BaseQuantity); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcConstructionEquipmentResourceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ResourceType, BaseCosts, BaseQuantity, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.ResourceType = ResourceType; + this.BaseCosts = BaseCosts; + this.BaseQuantity = BaseQuantity; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let ResourceType = tape[ptr++]; + let BaseCosts = tape[ptr++]; + let BaseQuantity = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcConstructionEquipmentResourceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ResourceType, BaseCosts, BaseQuantity, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.ResourceType); + ; + args.push(this.BaseCosts); + ; + args.push(this.BaseQuantity); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcConstructionMaterialResource = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, Usage, BaseCosts, BaseQuantity, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.Usage = Usage; + this.BaseCosts = BaseCosts; + this.BaseQuantity = BaseQuantity; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let Usage = tape[ptr++]; + let BaseCosts = tape[ptr++]; + let BaseQuantity = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcConstructionMaterialResource(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, Usage, BaseCosts, BaseQuantity, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.Usage); + ; + args.push(this.BaseCosts); + ; + args.push(this.BaseQuantity); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcConstructionMaterialResourceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ResourceType, BaseCosts, BaseQuantity, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.ResourceType = ResourceType; + this.BaseCosts = BaseCosts; + this.BaseQuantity = BaseQuantity; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let ResourceType = tape[ptr++]; + let BaseCosts = tape[ptr++]; + let BaseQuantity = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcConstructionMaterialResourceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ResourceType, BaseCosts, BaseQuantity, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.ResourceType); + ; + args.push(this.BaseCosts); + ; + args.push(this.BaseQuantity); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcConstructionProductResource = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, Usage, BaseCosts, BaseQuantity, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.Usage = Usage; + this.BaseCosts = BaseCosts; + this.BaseQuantity = BaseQuantity; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let Usage = tape[ptr++]; + let BaseCosts = tape[ptr++]; + let BaseQuantity = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcConstructionProductResource(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, Usage, BaseCosts, BaseQuantity, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.Usage); + ; + args.push(this.BaseCosts); + ; + args.push(this.BaseQuantity); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcConstructionProductResourceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ResourceType, BaseCosts, BaseQuantity, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.ResourceType = ResourceType; + this.BaseCosts = BaseCosts; + this.BaseQuantity = BaseQuantity; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let ResourceType = tape[ptr++]; + let BaseCosts = tape[ptr++]; + let BaseQuantity = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcConstructionProductResourceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ResourceType, BaseCosts, BaseQuantity, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.ResourceType); + ; + args.push(this.BaseCosts); + ; + args.push(this.BaseQuantity); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcConstructionResource = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, Usage, BaseCosts, BaseQuantity) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.Usage = Usage; + this.BaseCosts = BaseCosts; + this.BaseQuantity = BaseQuantity; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let Usage = tape[ptr++]; + let BaseCosts = tape[ptr++]; + let BaseQuantity = tape[ptr++]; + return new IfcConstructionResource(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, Usage, BaseCosts, BaseQuantity); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.Usage); + ; + args.push(this.BaseCosts); + ; + args.push(this.BaseQuantity); + ; + return args; + } +}; +var IfcConstructionResourceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ResourceType, BaseCosts, BaseQuantity) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.ResourceType = ResourceType; + this.BaseCosts = BaseCosts; + this.BaseQuantity = BaseQuantity; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let ResourceType = tape[ptr++]; + let BaseCosts = tape[ptr++]; + let BaseQuantity = tape[ptr++]; + return new IfcConstructionResourceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ResourceType, BaseCosts, BaseQuantity); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.ResourceType); + ; + args.push(this.BaseCosts); + ; + args.push(this.BaseQuantity); + ; + return args; + } +}; +var IfcContext = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, LongName, Phase, RepresentationContexts, UnitsInContext) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.LongName = LongName; + this.Phase = Phase; + this.RepresentationContexts = RepresentationContexts; + this.UnitsInContext = UnitsInContext; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let LongName = tape[ptr++]; + let Phase = tape[ptr++]; + let RepresentationContexts = tape[ptr++]; + let UnitsInContext = tape[ptr++]; + return new IfcContext(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, LongName, Phase, RepresentationContexts, UnitsInContext); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.LongName); + ; + args.push(this.Phase); + ; + args.push(this.RepresentationContexts); + ; + args.push(this.UnitsInContext); + ; + return args; + } +}; +var IfcContextDependentUnit = class { + constructor(expressID, type, Dimensions, UnitType, Name) { + this.expressID = expressID; + this.type = type; + this.Dimensions = Dimensions; + this.UnitType = UnitType; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Dimensions = tape[ptr++]; + let UnitType = tape[ptr++]; + let Name = tape[ptr++]; + return new IfcContextDependentUnit(expressID, type, Dimensions, UnitType, Name); + } + ToTape() { + let args = []; + args.push(this.Dimensions); + ; + args.push(this.UnitType); + ; + args.push(this.Name); + ; + return args; + } +}; +var IfcControl = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + return new IfcControl(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + return args; + } +}; +var IfcController = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcController(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcControllerType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcControllerType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcConversionBasedUnit = class { + constructor(expressID, type, Dimensions, UnitType, Name, ConversionFactor) { + this.expressID = expressID; + this.type = type; + this.Dimensions = Dimensions; + this.UnitType = UnitType; + this.Name = Name; + this.ConversionFactor = ConversionFactor; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Dimensions = tape[ptr++]; + let UnitType = tape[ptr++]; + let Name = tape[ptr++]; + let ConversionFactor = tape[ptr++]; + return new IfcConversionBasedUnit(expressID, type, Dimensions, UnitType, Name, ConversionFactor); + } + ToTape() { + let args = []; + args.push(this.Dimensions); + ; + args.push(this.UnitType); + ; + args.push(this.Name); + ; + args.push(this.ConversionFactor); + ; + return args; + } +}; +var IfcConversionBasedUnitWithOffset = class { + constructor(expressID, type, Dimensions, UnitType, Name, ConversionFactor, ConversionOffset) { + this.expressID = expressID; + this.type = type; + this.Dimensions = Dimensions; + this.UnitType = UnitType; + this.Name = Name; + this.ConversionFactor = ConversionFactor; + this.ConversionOffset = ConversionOffset; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Dimensions = tape[ptr++]; + let UnitType = tape[ptr++]; + let Name = tape[ptr++]; + let ConversionFactor = tape[ptr++]; + let ConversionOffset = tape[ptr++]; + return new IfcConversionBasedUnitWithOffset(expressID, type, Dimensions, UnitType, Name, ConversionFactor, ConversionOffset); + } + ToTape() { + let args = []; + args.push(this.Dimensions); + ; + args.push(this.UnitType); + ; + args.push(this.Name); + ; + args.push(this.ConversionFactor); + ; + args.push(this.ConversionOffset); + ; + return args; + } +}; +var IfcCooledBeam = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCooledBeam(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCooledBeamType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCooledBeamType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCoolingTower = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCoolingTower(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCoolingTowerType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCoolingTowerType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCoordinateOperation = class { + constructor(expressID, type, SourceCRS, TargetCRS) { + this.expressID = expressID; + this.type = type; + this.SourceCRS = SourceCRS; + this.TargetCRS = TargetCRS; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SourceCRS = tape[ptr++]; + let TargetCRS = tape[ptr++]; + return new IfcCoordinateOperation(expressID, type, SourceCRS, TargetCRS); + } + ToTape() { + let args = []; + args.push(this.SourceCRS); + ; + args.push(this.TargetCRS); + ; + return args; + } +}; +var IfcCoordinateReferenceSystem = class { + constructor(expressID, type, Name, Description, GeodeticDatum, VerticalDatum) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.GeodeticDatum = GeodeticDatum; + this.VerticalDatum = VerticalDatum; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let GeodeticDatum = tape[ptr++]; + let VerticalDatum = tape[ptr++]; + return new IfcCoordinateReferenceSystem(expressID, type, Name, Description, GeodeticDatum, VerticalDatum); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.GeodeticDatum); + ; + args.push(this.VerticalDatum); + ; + return args; + } +}; +var IfcCostItem = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, PredefinedType, CostValues, CostQuantities) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.PredefinedType = PredefinedType; + this.CostValues = CostValues; + this.CostQuantities = CostQuantities; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let CostValues = tape[ptr++]; + let CostQuantities = tape[ptr++]; + return new IfcCostItem(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, PredefinedType, CostValues, CostQuantities); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.PredefinedType); + ; + args.push(this.CostValues); + ; + args.push(this.CostQuantities); + ; + return args; + } +}; +var IfcCostSchedule = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, PredefinedType, Status, SubmittedOn, UpdateDate) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.PredefinedType = PredefinedType; + this.Status = Status; + this.SubmittedOn = SubmittedOn; + this.UpdateDate = UpdateDate; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let Status = tape[ptr++]; + let SubmittedOn = tape[ptr++]; + let UpdateDate = tape[ptr++]; + return new IfcCostSchedule(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, PredefinedType, Status, SubmittedOn, UpdateDate); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.PredefinedType); + ; + args.push(this.Status); + ; + args.push(this.SubmittedOn); + ; + args.push(this.UpdateDate); + ; + return args; + } +}; +var IfcCostValue = class { + constructor(expressID, type, Name, Description, AppliedValue, UnitBasis, ApplicableDate, FixedUntilDate, Category, Condition, ArithmeticOperator, Components) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.AppliedValue = AppliedValue; + this.UnitBasis = UnitBasis; + this.ApplicableDate = ApplicableDate; + this.FixedUntilDate = FixedUntilDate; + this.Category = Category; + this.Condition = Condition; + this.ArithmeticOperator = ArithmeticOperator; + this.Components = Components; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let AppliedValue = tape[ptr++]; + let UnitBasis = tape[ptr++]; + let ApplicableDate = tape[ptr++]; + let FixedUntilDate = tape[ptr++]; + let Category = tape[ptr++]; + let Condition = tape[ptr++]; + let ArithmeticOperator = tape[ptr++]; + let Components = tape[ptr++]; + return new IfcCostValue(expressID, type, Name, Description, AppliedValue, UnitBasis, ApplicableDate, FixedUntilDate, Category, Condition, ArithmeticOperator, Components); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.AppliedValue); + ; + args.push(this.UnitBasis); + ; + args.push(this.ApplicableDate); + ; + args.push(this.FixedUntilDate); + ; + args.push(this.Category); + ; + args.push(this.Condition); + ; + args.push(this.ArithmeticOperator); + ; + args.push(this.Components); + ; + return args; + } +}; +var IfcCovering = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCovering(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCoveringType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCoveringType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCrewResource = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, Usage, BaseCosts, BaseQuantity, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.Usage = Usage; + this.BaseCosts = BaseCosts; + this.BaseQuantity = BaseQuantity; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let Usage = tape[ptr++]; + let BaseCosts = tape[ptr++]; + let BaseQuantity = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCrewResource(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, Usage, BaseCosts, BaseQuantity, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.Usage); + ; + args.push(this.BaseCosts); + ; + args.push(this.BaseQuantity); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCrewResourceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ResourceType, BaseCosts, BaseQuantity, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.ResourceType = ResourceType; + this.BaseCosts = BaseCosts; + this.BaseQuantity = BaseQuantity; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let ResourceType = tape[ptr++]; + let BaseCosts = tape[ptr++]; + let BaseQuantity = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCrewResourceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ResourceType, BaseCosts, BaseQuantity, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.ResourceType); + ; + args.push(this.BaseCosts); + ; + args.push(this.BaseQuantity); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCsgPrimitive3D = class { + constructor(expressID, type, Position) { + this.expressID = expressID; + this.type = type; + this.Position = Position; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Position = tape[ptr++]; + return new IfcCsgPrimitive3D(expressID, type, Position); + } + ToTape() { + let args = []; + args.push(this.Position); + ; + return args; + } +}; +var IfcCsgSolid = class { + constructor(expressID, type, TreeRootExpression) { + this.expressID = expressID; + this.type = type; + this.TreeRootExpression = TreeRootExpression; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let TreeRootExpression = tape[ptr++]; + return new IfcCsgSolid(expressID, type, TreeRootExpression); + } + ToTape() { + let args = []; + args.push(this.TreeRootExpression); + ; + return args; + } +}; +var IfcCurrencyRelationship = class { + constructor(expressID, type, Name, Description, RelatingMonetaryUnit, RelatedMonetaryUnit, ExchangeRate, RateDateTime, RateSource) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.RelatingMonetaryUnit = RelatingMonetaryUnit; + this.RelatedMonetaryUnit = RelatedMonetaryUnit; + this.ExchangeRate = ExchangeRate; + this.RateDateTime = RateDateTime; + this.RateSource = RateSource; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingMonetaryUnit = tape[ptr++]; + let RelatedMonetaryUnit = tape[ptr++]; + let ExchangeRate = tape[ptr++]; + let RateDateTime = tape[ptr++]; + let RateSource = tape[ptr++]; + return new IfcCurrencyRelationship(expressID, type, Name, Description, RelatingMonetaryUnit, RelatedMonetaryUnit, ExchangeRate, RateDateTime, RateSource); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingMonetaryUnit); + ; + args.push(this.RelatedMonetaryUnit); + ; + args.push(this.ExchangeRate); + ; + args.push(this.RateDateTime); + ; + args.push(this.RateSource); + ; + return args; + } +}; +var IfcCurtainWall = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCurtainWall(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCurtainWallType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcCurtainWallType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcCurve = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcCurve(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcCurveBoundedPlane = class { + constructor(expressID, type, BasisSurface, OuterBoundary, InnerBoundaries) { + this.expressID = expressID; + this.type = type; + this.BasisSurface = BasisSurface; + this.OuterBoundary = OuterBoundary; + this.InnerBoundaries = InnerBoundaries; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let BasisSurface = tape[ptr++]; + let OuterBoundary = tape[ptr++]; + let InnerBoundaries = tape[ptr++]; + return new IfcCurveBoundedPlane(expressID, type, BasisSurface, OuterBoundary, InnerBoundaries); + } + ToTape() { + let args = []; + args.push(this.BasisSurface); + ; + args.push(this.OuterBoundary); + ; + args.push(this.InnerBoundaries); + ; + return args; + } +}; +var IfcCurveBoundedSurface = class { + constructor(expressID, type, BasisSurface, Boundaries, ImplicitOuter) { + this.expressID = expressID; + this.type = type; + this.BasisSurface = BasisSurface; + this.Boundaries = Boundaries; + this.ImplicitOuter = ImplicitOuter; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let BasisSurface = tape[ptr++]; + let Boundaries = tape[ptr++]; + let ImplicitOuter = tape[ptr++]; + return new IfcCurveBoundedSurface(expressID, type, BasisSurface, Boundaries, ImplicitOuter); + } + ToTape() { + let args = []; + args.push(this.BasisSurface); + ; + args.push(this.Boundaries); + ; + args.push(this.ImplicitOuter); + ; + return args; + } +}; +var IfcCurveSegment2D = class { + constructor(expressID, type, StartPoint, StartDirection, SegmentLength) { + this.expressID = expressID; + this.type = type; + this.StartPoint = StartPoint; + this.StartDirection = StartDirection; + this.SegmentLength = SegmentLength; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let StartPoint = tape[ptr++]; + let StartDirection = tape[ptr++]; + let SegmentLength = tape[ptr++]; + return new IfcCurveSegment2D(expressID, type, StartPoint, StartDirection, SegmentLength); + } + ToTape() { + let args = []; + args.push(this.StartPoint); + ; + args.push(this.StartDirection); + ; + args.push(this.SegmentLength); + ; + return args; + } +}; +var IfcCurveStyle = class { + constructor(expressID, type, Name, CurveFont, CurveWidth, CurveColour, ModelOrDraughting) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.CurveFont = CurveFont; + this.CurveWidth = CurveWidth; + this.CurveColour = CurveColour; + this.ModelOrDraughting = ModelOrDraughting; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let CurveFont = tape[ptr++]; + let CurveWidth = tape[ptr++]; + let CurveColour = tape[ptr++]; + let ModelOrDraughting = tape[ptr++]; + return new IfcCurveStyle(expressID, type, Name, CurveFont, CurveWidth, CurveColour, ModelOrDraughting); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.CurveFont); + ; + args.push(this.CurveWidth); + ; + args.push(this.CurveColour); + ; + args.push(this.ModelOrDraughting); + ; + return args; + } +}; +var IfcCurveStyleFont = class { + constructor(expressID, type, Name, PatternList) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.PatternList = PatternList; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let PatternList = tape[ptr++]; + return new IfcCurveStyleFont(expressID, type, Name, PatternList); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.PatternList); + ; + return args; + } +}; +var IfcCurveStyleFontAndScaling = class { + constructor(expressID, type, Name, CurveFont, CurveFontScaling) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.CurveFont = CurveFont; + this.CurveFontScaling = CurveFontScaling; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let CurveFont = tape[ptr++]; + let CurveFontScaling = tape[ptr++]; + return new IfcCurveStyleFontAndScaling(expressID, type, Name, CurveFont, CurveFontScaling); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.CurveFont); + ; + args.push(this.CurveFontScaling); + ; + return args; + } +}; +var IfcCurveStyleFontPattern = class { + constructor(expressID, type, VisibleSegmentLength, InvisibleSegmentLength) { + this.expressID = expressID; + this.type = type; + this.VisibleSegmentLength = VisibleSegmentLength; + this.InvisibleSegmentLength = InvisibleSegmentLength; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let VisibleSegmentLength = tape[ptr++]; + let InvisibleSegmentLength = tape[ptr++]; + return new IfcCurveStyleFontPattern(expressID, type, VisibleSegmentLength, InvisibleSegmentLength); + } + ToTape() { + let args = []; + args.push(this.VisibleSegmentLength); + ; + args.push(this.InvisibleSegmentLength); + ; + return args; + } +}; +var IfcCylindricalSurface = class { + constructor(expressID, type, Position, Radius) { + this.expressID = expressID; + this.type = type; + this.Position = Position; + this.Radius = Radius; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Position = tape[ptr++]; + let Radius = tape[ptr++]; + return new IfcCylindricalSurface(expressID, type, Position, Radius); + } + ToTape() { + let args = []; + args.push(this.Position); + ; + args.push(this.Radius); + ; + return args; + } +}; +var IfcDamper = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcDamper(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcDamperType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcDamperType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcDeepFoundation = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcDeepFoundation(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcDeepFoundationType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcDeepFoundationType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcDerivedProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, ParentProfile, Operator, Label) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.ParentProfile = ParentProfile; + this.Operator = Operator; + this.Label = Label; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let ParentProfile = tape[ptr++]; + let Operator = tape[ptr++]; + let Label = tape[ptr++]; + return new IfcDerivedProfileDef(expressID, type, ProfileType, ProfileName, ParentProfile, Operator, Label); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.ParentProfile); + ; + args.push(this.Operator); + ; + args.push(this.Label); + ; + return args; + } +}; +var IfcDerivedUnit = class { + constructor(expressID, type, Elements, UnitType, UserDefinedType) { + this.expressID = expressID; + this.type = type; + this.Elements = Elements; + this.UnitType = UnitType; + this.UserDefinedType = UserDefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Elements = tape[ptr++]; + let UnitType = tape[ptr++]; + let UserDefinedType = tape[ptr++]; + return new IfcDerivedUnit(expressID, type, Elements, UnitType, UserDefinedType); + } + ToTape() { + let args = []; + args.push(this.Elements); + ; + args.push(this.UnitType); + ; + args.push(this.UserDefinedType); + ; + return args; + } +}; +var IfcDerivedUnitElement = class { + constructor(expressID, type, Unit, Exponent) { + this.expressID = expressID; + this.type = type; + this.Unit = Unit; + this.Exponent = Exponent; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Unit = tape[ptr++]; + let Exponent = tape[ptr++]; + return new IfcDerivedUnitElement(expressID, type, Unit, Exponent); + } + ToTape() { + let args = []; + args.push(this.Unit); + ; + args.push(this.Exponent); + ; + return args; + } +}; +var IfcDimensionalExponents = class { + constructor(expressID, type, LengthExponent, MassExponent, TimeExponent, ElectricCurrentExponent, ThermodynamicTemperatureExponent, AmountOfSubstanceExponent, LuminousIntensityExponent) { + this.expressID = expressID; + this.type = type; + this.LengthExponent = LengthExponent; + this.MassExponent = MassExponent; + this.TimeExponent = TimeExponent; + this.ElectricCurrentExponent = ElectricCurrentExponent; + this.ThermodynamicTemperatureExponent = ThermodynamicTemperatureExponent; + this.AmountOfSubstanceExponent = AmountOfSubstanceExponent; + this.LuminousIntensityExponent = LuminousIntensityExponent; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let LengthExponent = tape[ptr++]; + let MassExponent = tape[ptr++]; + let TimeExponent = tape[ptr++]; + let ElectricCurrentExponent = tape[ptr++]; + let ThermodynamicTemperatureExponent = tape[ptr++]; + let AmountOfSubstanceExponent = tape[ptr++]; + let LuminousIntensityExponent = tape[ptr++]; + return new IfcDimensionalExponents(expressID, type, LengthExponent, MassExponent, TimeExponent, ElectricCurrentExponent, ThermodynamicTemperatureExponent, AmountOfSubstanceExponent, LuminousIntensityExponent); + } + ToTape() { + let args = []; + args.push(this.LengthExponent); + ; + args.push(this.MassExponent); + ; + args.push(this.TimeExponent); + ; + args.push(this.ElectricCurrentExponent); + ; + args.push(this.ThermodynamicTemperatureExponent); + ; + args.push(this.AmountOfSubstanceExponent); + ; + args.push(this.LuminousIntensityExponent); + ; + return args; + } +}; +var IfcDirection = class { + constructor(expressID, type, DirectionRatios) { + this.expressID = expressID; + this.type = type; + this.DirectionRatios = DirectionRatios; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let DirectionRatios = tape[ptr++]; + return new IfcDirection(expressID, type, DirectionRatios); + } + ToTape() { + let args = []; + args.push(this.DirectionRatios); + ; + return args; + } +}; +var IfcDiscreteAccessory = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcDiscreteAccessory(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcDiscreteAccessoryType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcDiscreteAccessoryType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcDistanceExpression = class { + constructor(expressID, type, DistanceAlong, OffsetLateral, OffsetVertical, OffsetLongitudinal, AlongHorizontal) { + this.expressID = expressID; + this.type = type; + this.DistanceAlong = DistanceAlong; + this.OffsetLateral = OffsetLateral; + this.OffsetVertical = OffsetVertical; + this.OffsetLongitudinal = OffsetLongitudinal; + this.AlongHorizontal = AlongHorizontal; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let DistanceAlong = tape[ptr++]; + let OffsetLateral = tape[ptr++]; + let OffsetVertical = tape[ptr++]; + let OffsetLongitudinal = tape[ptr++]; + let AlongHorizontal = tape[ptr++]; + return new IfcDistanceExpression(expressID, type, DistanceAlong, OffsetLateral, OffsetVertical, OffsetLongitudinal, AlongHorizontal); + } + ToTape() { + let args = []; + args.push(this.DistanceAlong); + ; + args.push(this.OffsetLateral); + ; + args.push(this.OffsetVertical); + ; + args.push(this.OffsetLongitudinal); + ; + args.push(this.AlongHorizontal); + ; + return args; + } +}; +var IfcDistributionChamberElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcDistributionChamberElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcDistributionChamberElementType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcDistributionChamberElementType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcDistributionCircuit = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, LongName, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.LongName = LongName; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let LongName = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcDistributionCircuit(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, LongName, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.LongName); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcDistributionControlElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcDistributionControlElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcDistributionControlElementType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcDistributionControlElementType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcDistributionElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcDistributionElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcDistributionElementType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcDistributionElementType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcDistributionFlowElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcDistributionFlowElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcDistributionFlowElementType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcDistributionFlowElementType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcDistributionPort = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, FlowDirection, PredefinedType, SystemType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.FlowDirection = FlowDirection; + this.PredefinedType = PredefinedType; + this.SystemType = SystemType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let FlowDirection = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let SystemType = tape[ptr++]; + return new IfcDistributionPort(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, FlowDirection, PredefinedType, SystemType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.FlowDirection); + ; + args.push(this.PredefinedType); + ; + args.push(this.SystemType); + ; + return args; + } +}; +var IfcDistributionSystem = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, LongName, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.LongName = LongName; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let LongName = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcDistributionSystem(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, LongName, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.LongName); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcDocumentInformation = class { + constructor(expressID, type, Identification, Name, Description, Location, Purpose, IntendedUse, Scope, Revision, DocumentOwner, Editors, CreationTime, LastRevisionTime, ElectronicFormat, ValidFrom, ValidUntil, Confidentiality, Status) { + this.expressID = expressID; + this.type = type; + this.Identification = Identification; + this.Name = Name; + this.Description = Description; + this.Location = Location; + this.Purpose = Purpose; + this.IntendedUse = IntendedUse; + this.Scope = Scope; + this.Revision = Revision; + this.DocumentOwner = DocumentOwner; + this.Editors = Editors; + this.CreationTime = CreationTime; + this.LastRevisionTime = LastRevisionTime; + this.ElectronicFormat = ElectronicFormat; + this.ValidFrom = ValidFrom; + this.ValidUntil = ValidUntil; + this.Confidentiality = Confidentiality; + this.Status = Status; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Identification = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Location = tape[ptr++]; + let Purpose = tape[ptr++]; + let IntendedUse = tape[ptr++]; + let Scope = tape[ptr++]; + let Revision = tape[ptr++]; + let DocumentOwner = tape[ptr++]; + let Editors = tape[ptr++]; + let CreationTime = tape[ptr++]; + let LastRevisionTime = tape[ptr++]; + let ElectronicFormat = tape[ptr++]; + let ValidFrom = tape[ptr++]; + let ValidUntil = tape[ptr++]; + let Confidentiality = tape[ptr++]; + let Status = tape[ptr++]; + return new IfcDocumentInformation(expressID, type, Identification, Name, Description, Location, Purpose, IntendedUse, Scope, Revision, DocumentOwner, Editors, CreationTime, LastRevisionTime, ElectronicFormat, ValidFrom, ValidUntil, Confidentiality, Status); + } + ToTape() { + let args = []; + args.push(this.Identification); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Location); + ; + args.push(this.Purpose); + ; + args.push(this.IntendedUse); + ; + args.push(this.Scope); + ; + args.push(this.Revision); + ; + args.push(this.DocumentOwner); + ; + args.push(this.Editors); + ; + args.push(this.CreationTime); + ; + args.push(this.LastRevisionTime); + ; + args.push(this.ElectronicFormat); + ; + args.push(this.ValidFrom); + ; + args.push(this.ValidUntil); + ; + args.push(this.Confidentiality); + ; + args.push(this.Status); + ; + return args; + } +}; +var IfcDocumentInformationRelationship = class { + constructor(expressID, type, Name, Description, RelatingDocument, RelatedDocuments, RelationshipType) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.RelatingDocument = RelatingDocument; + this.RelatedDocuments = RelatedDocuments; + this.RelationshipType = RelationshipType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingDocument = tape[ptr++]; + let RelatedDocuments = tape[ptr++]; + let RelationshipType = tape[ptr++]; + return new IfcDocumentInformationRelationship(expressID, type, Name, Description, RelatingDocument, RelatedDocuments, RelationshipType); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingDocument); + ; + args.push(this.RelatedDocuments); + ; + args.push(this.RelationshipType); + ; + return args; + } +}; +var IfcDocumentReference = class { + constructor(expressID, type, Location, Identification, Name, Description, ReferencedDocument) { + this.expressID = expressID; + this.type = type; + this.Location = Location; + this.Identification = Identification; + this.Name = Name; + this.Description = Description; + this.ReferencedDocument = ReferencedDocument; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Location = tape[ptr++]; + let Identification = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ReferencedDocument = tape[ptr++]; + return new IfcDocumentReference(expressID, type, Location, Identification, Name, Description, ReferencedDocument); + } + ToTape() { + let args = []; + args.push(this.Location); + ; + args.push(this.Identification); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ReferencedDocument); + ; + return args; + } +}; +var IfcDoor = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, OverallHeight, OverallWidth, PredefinedType, OperationType, UserDefinedOperationType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.OverallHeight = OverallHeight; + this.OverallWidth = OverallWidth; + this.PredefinedType = PredefinedType; + this.OperationType = OperationType; + this.UserDefinedOperationType = UserDefinedOperationType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let OverallHeight = tape[ptr++]; + let OverallWidth = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let OperationType = tape[ptr++]; + let UserDefinedOperationType = tape[ptr++]; + return new IfcDoor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, OverallHeight, OverallWidth, PredefinedType, OperationType, UserDefinedOperationType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.OverallHeight); + ; + args.push(this.OverallWidth); + ; + args.push(this.PredefinedType); + ; + args.push(this.OperationType); + ; + args.push(this.UserDefinedOperationType); + ; + return args; + } +}; +var IfcDoorLiningProperties = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, LiningDepth, LiningThickness, ThresholdDepth, ThresholdThickness, TransomThickness, TransomOffset, LiningOffset, ThresholdOffset, CasingThickness, CasingDepth, ShapeAspectStyle, LiningToPanelOffsetX, LiningToPanelOffsetY) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.LiningDepth = LiningDepth; + this.LiningThickness = LiningThickness; + this.ThresholdDepth = ThresholdDepth; + this.ThresholdThickness = ThresholdThickness; + this.TransomThickness = TransomThickness; + this.TransomOffset = TransomOffset; + this.LiningOffset = LiningOffset; + this.ThresholdOffset = ThresholdOffset; + this.CasingThickness = CasingThickness; + this.CasingDepth = CasingDepth; + this.ShapeAspectStyle = ShapeAspectStyle; + this.LiningToPanelOffsetX = LiningToPanelOffsetX; + this.LiningToPanelOffsetY = LiningToPanelOffsetY; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let LiningDepth = tape[ptr++]; + let LiningThickness = tape[ptr++]; + let ThresholdDepth = tape[ptr++]; + let ThresholdThickness = tape[ptr++]; + let TransomThickness = tape[ptr++]; + let TransomOffset = tape[ptr++]; + let LiningOffset = tape[ptr++]; + let ThresholdOffset = tape[ptr++]; + let CasingThickness = tape[ptr++]; + let CasingDepth = tape[ptr++]; + let ShapeAspectStyle = tape[ptr++]; + let LiningToPanelOffsetX = tape[ptr++]; + let LiningToPanelOffsetY = tape[ptr++]; + return new IfcDoorLiningProperties(expressID, type, GlobalId, OwnerHistory, Name, Description, LiningDepth, LiningThickness, ThresholdDepth, ThresholdThickness, TransomThickness, TransomOffset, LiningOffset, ThresholdOffset, CasingThickness, CasingDepth, ShapeAspectStyle, LiningToPanelOffsetX, LiningToPanelOffsetY); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.LiningDepth); + ; + args.push(this.LiningThickness); + ; + args.push(this.ThresholdDepth); + ; + args.push(this.ThresholdThickness); + ; + args.push(this.TransomThickness); + ; + args.push(this.TransomOffset); + ; + args.push(this.LiningOffset); + ; + args.push(this.ThresholdOffset); + ; + args.push(this.CasingThickness); + ; + args.push(this.CasingDepth); + ; + args.push(this.ShapeAspectStyle); + ; + args.push(this.LiningToPanelOffsetX); + ; + args.push(this.LiningToPanelOffsetY); + ; + return args; + } +}; +var IfcDoorPanelProperties = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, PanelDepth, PanelOperation, PanelWidth, PanelPosition, ShapeAspectStyle) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.PanelDepth = PanelDepth; + this.PanelOperation = PanelOperation; + this.PanelWidth = PanelWidth; + this.PanelPosition = PanelPosition; + this.ShapeAspectStyle = ShapeAspectStyle; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let PanelDepth = tape[ptr++]; + let PanelOperation = tape[ptr++]; + let PanelWidth = tape[ptr++]; + let PanelPosition = tape[ptr++]; + let ShapeAspectStyle = tape[ptr++]; + return new IfcDoorPanelProperties(expressID, type, GlobalId, OwnerHistory, Name, Description, PanelDepth, PanelOperation, PanelWidth, PanelPosition, ShapeAspectStyle); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.PanelDepth); + ; + args.push(this.PanelOperation); + ; + args.push(this.PanelWidth); + ; + args.push(this.PanelPosition); + ; + args.push(this.ShapeAspectStyle); + ; + return args; + } +}; +var IfcDoorStandardCase = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, OverallHeight, OverallWidth, PredefinedType, OperationType, UserDefinedOperationType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.OverallHeight = OverallHeight; + this.OverallWidth = OverallWidth; + this.PredefinedType = PredefinedType; + this.OperationType = OperationType; + this.UserDefinedOperationType = UserDefinedOperationType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let OverallHeight = tape[ptr++]; + let OverallWidth = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let OperationType = tape[ptr++]; + let UserDefinedOperationType = tape[ptr++]; + return new IfcDoorStandardCase(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, OverallHeight, OverallWidth, PredefinedType, OperationType, UserDefinedOperationType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.OverallHeight); + ; + args.push(this.OverallWidth); + ; + args.push(this.PredefinedType); + ; + args.push(this.OperationType); + ; + args.push(this.UserDefinedOperationType); + ; + return args; + } +}; +var IfcDoorStyle = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, OperationType, ConstructionType, ParameterTakesPrecedence, Sizeable) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.OperationType = OperationType; + this.ConstructionType = ConstructionType; + this.ParameterTakesPrecedence = ParameterTakesPrecedence; + this.Sizeable = Sizeable; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let OperationType = tape[ptr++]; + let ConstructionType = tape[ptr++]; + let ParameterTakesPrecedence = tape[ptr++]; + let Sizeable = tape[ptr++]; + return new IfcDoorStyle(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, OperationType, ConstructionType, ParameterTakesPrecedence, Sizeable); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.OperationType); + ; + args.push(this.ConstructionType); + ; + args.push(this.ParameterTakesPrecedence); + ; + args.push(this.Sizeable); + ; + return args; + } +}; +var IfcDoorType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType, OperationType, ParameterTakesPrecedence, UserDefinedOperationType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + this.OperationType = OperationType; + this.ParameterTakesPrecedence = ParameterTakesPrecedence; + this.UserDefinedOperationType = UserDefinedOperationType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let OperationType = tape[ptr++]; + let ParameterTakesPrecedence = tape[ptr++]; + let UserDefinedOperationType = tape[ptr++]; + return new IfcDoorType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType, OperationType, ParameterTakesPrecedence, UserDefinedOperationType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + args.push(this.OperationType); + ; + args.push(this.ParameterTakesPrecedence); + ; + args.push(this.UserDefinedOperationType); + ; + return args; + } +}; +var IfcDraughtingPreDefinedColour = class { + constructor(expressID, type, Name) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + return new IfcDraughtingPreDefinedColour(expressID, type, Name); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + return args; + } +}; +var IfcDraughtingPreDefinedCurveFont = class { + constructor(expressID, type, Name) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + return new IfcDraughtingPreDefinedCurveFont(expressID, type, Name); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + return args; + } +}; +var IfcDuctFitting = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcDuctFitting(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcDuctFittingType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcDuctFittingType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcDuctSegment = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcDuctSegment(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcDuctSegmentType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcDuctSegmentType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcDuctSilencer = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcDuctSilencer(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcDuctSilencerType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcDuctSilencerType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcEdge = class { + constructor(expressID, type, EdgeStart, EdgeEnd) { + this.expressID = expressID; + this.type = type; + this.EdgeStart = EdgeStart; + this.EdgeEnd = EdgeEnd; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let EdgeStart = tape[ptr++]; + let EdgeEnd = tape[ptr++]; + return new IfcEdge(expressID, type, EdgeStart, EdgeEnd); + } + ToTape() { + let args = []; + args.push(this.EdgeStart); + ; + args.push(this.EdgeEnd); + ; + return args; + } +}; +var IfcEdgeCurve = class { + constructor(expressID, type, EdgeStart, EdgeEnd, EdgeGeometry, SameSense) { + this.expressID = expressID; + this.type = type; + this.EdgeStart = EdgeStart; + this.EdgeEnd = EdgeEnd; + this.EdgeGeometry = EdgeGeometry; + this.SameSense = SameSense; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let EdgeStart = tape[ptr++]; + let EdgeEnd = tape[ptr++]; + let EdgeGeometry = tape[ptr++]; + let SameSense = tape[ptr++]; + return new IfcEdgeCurve(expressID, type, EdgeStart, EdgeEnd, EdgeGeometry, SameSense); + } + ToTape() { + let args = []; + args.push(this.EdgeStart); + ; + args.push(this.EdgeEnd); + ; + args.push(this.EdgeGeometry); + ; + args.push(this.SameSense); + ; + return args; + } +}; +var IfcEdgeLoop = class { + constructor(expressID, type, EdgeList) { + this.expressID = expressID; + this.type = type; + this.EdgeList = EdgeList; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let EdgeList = tape[ptr++]; + return new IfcEdgeLoop(expressID, type, EdgeList); + } + ToTape() { + let args = []; + args.push(this.EdgeList); + ; + return args; + } +}; +var IfcElectricAppliance = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcElectricAppliance(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcElectricApplianceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcElectricApplianceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcElectricDistributionBoard = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcElectricDistributionBoard(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcElectricDistributionBoardType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcElectricDistributionBoardType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcElectricFlowStorageDevice = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcElectricFlowStorageDevice(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcElectricFlowStorageDeviceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcElectricFlowStorageDeviceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcElectricGenerator = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcElectricGenerator(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcElectricGeneratorType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcElectricGeneratorType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcElectricMotor = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcElectricMotor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcElectricMotorType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcElectricMotorType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcElectricTimeControl = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcElectricTimeControl(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcElectricTimeControlType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcElectricTimeControlType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcElementAssembly = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, AssemblyPlace, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.AssemblyPlace = AssemblyPlace; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let AssemblyPlace = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcElementAssembly(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, AssemblyPlace, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.AssemblyPlace); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcElementAssemblyType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcElementAssemblyType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcElementComponent = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcElementComponent(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcElementComponentType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcElementComponentType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcElementQuantity = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, MethodOfMeasurement, Quantities) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.MethodOfMeasurement = MethodOfMeasurement; + this.Quantities = Quantities; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let MethodOfMeasurement = tape[ptr++]; + let Quantities = tape[ptr++]; + return new IfcElementQuantity(expressID, type, GlobalId, OwnerHistory, Name, Description, MethodOfMeasurement, Quantities); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.MethodOfMeasurement); + ; + args.push(this.Quantities); + ; + return args; + } +}; +var IfcElementType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcElementType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcElementarySurface = class { + constructor(expressID, type, Position) { + this.expressID = expressID; + this.type = type; + this.Position = Position; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Position = tape[ptr++]; + return new IfcElementarySurface(expressID, type, Position); + } + ToTape() { + let args = []; + args.push(this.Position); + ; + return args; + } +}; +var IfcEllipse = class { + constructor(expressID, type, Position, SemiAxis1, SemiAxis2) { + this.expressID = expressID; + this.type = type; + this.Position = Position; + this.SemiAxis1 = SemiAxis1; + this.SemiAxis2 = SemiAxis2; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Position = tape[ptr++]; + let SemiAxis1 = tape[ptr++]; + let SemiAxis2 = tape[ptr++]; + return new IfcEllipse(expressID, type, Position, SemiAxis1, SemiAxis2); + } + ToTape() { + let args = []; + args.push(this.Position); + ; + args.push(this.SemiAxis1); + ; + args.push(this.SemiAxis2); + ; + return args; + } +}; +var IfcEllipseProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, Position, SemiAxis1, SemiAxis2) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.Position = Position; + this.SemiAxis1 = SemiAxis1; + this.SemiAxis2 = SemiAxis2; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let Position = tape[ptr++]; + let SemiAxis1 = tape[ptr++]; + let SemiAxis2 = tape[ptr++]; + return new IfcEllipseProfileDef(expressID, type, ProfileType, ProfileName, Position, SemiAxis1, SemiAxis2); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.Position); + ; + args.push(this.SemiAxis1); + ; + args.push(this.SemiAxis2); + ; + return args; + } +}; +var IfcEnergyConversionDevice = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcEnergyConversionDevice(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcEnergyConversionDeviceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcEnergyConversionDeviceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcEngine = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcEngine(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcEngineType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcEngineType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcEvaporativeCooler = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcEvaporativeCooler(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcEvaporativeCoolerType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcEvaporativeCoolerType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcEvaporator = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcEvaporator(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcEvaporatorType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcEvaporatorType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcEvent = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, PredefinedType, EventTriggerType, UserDefinedEventTriggerType, EventOccurenceTime) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.PredefinedType = PredefinedType; + this.EventTriggerType = EventTriggerType; + this.UserDefinedEventTriggerType = UserDefinedEventTriggerType; + this.EventOccurenceTime = EventOccurenceTime; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let EventTriggerType = tape[ptr++]; + let UserDefinedEventTriggerType = tape[ptr++]; + let EventOccurenceTime = tape[ptr++]; + return new IfcEvent(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, PredefinedType, EventTriggerType, UserDefinedEventTriggerType, EventOccurenceTime); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.PredefinedType); + ; + args.push(this.EventTriggerType); + ; + args.push(this.UserDefinedEventTriggerType); + ; + args.push(this.EventOccurenceTime); + ; + return args; + } +}; +var IfcEventTime = class { + constructor(expressID, type, Name, DataOrigin, UserDefinedDataOrigin, ActualDate, EarlyDate, LateDate, ScheduleDate) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.DataOrigin = DataOrigin; + this.UserDefinedDataOrigin = UserDefinedDataOrigin; + this.ActualDate = ActualDate; + this.EarlyDate = EarlyDate; + this.LateDate = LateDate; + this.ScheduleDate = ScheduleDate; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let DataOrigin = tape[ptr++]; + let UserDefinedDataOrigin = tape[ptr++]; + let ActualDate = tape[ptr++]; + let EarlyDate = tape[ptr++]; + let LateDate = tape[ptr++]; + let ScheduleDate = tape[ptr++]; + return new IfcEventTime(expressID, type, Name, DataOrigin, UserDefinedDataOrigin, ActualDate, EarlyDate, LateDate, ScheduleDate); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.DataOrigin); + ; + args.push(this.UserDefinedDataOrigin); + ; + args.push(this.ActualDate); + ; + args.push(this.EarlyDate); + ; + args.push(this.LateDate); + ; + args.push(this.ScheduleDate); + ; + return args; + } +}; +var IfcEventType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ProcessType, PredefinedType, EventTriggerType, UserDefinedEventTriggerType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.ProcessType = ProcessType; + this.PredefinedType = PredefinedType; + this.EventTriggerType = EventTriggerType; + this.UserDefinedEventTriggerType = UserDefinedEventTriggerType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let ProcessType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let EventTriggerType = tape[ptr++]; + let UserDefinedEventTriggerType = tape[ptr++]; + return new IfcEventType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ProcessType, PredefinedType, EventTriggerType, UserDefinedEventTriggerType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.ProcessType); + ; + args.push(this.PredefinedType); + ; + args.push(this.EventTriggerType); + ; + args.push(this.UserDefinedEventTriggerType); + ; + return args; + } +}; +var IfcExtendedProperties = class { + constructor(expressID, type, Name, Description, Properties) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.Properties = Properties; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Properties = tape[ptr++]; + return new IfcExtendedProperties(expressID, type, Name, Description, Properties); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Properties); + ; + return args; + } +}; +var IfcExternalInformation = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcExternalInformation(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcExternalReference = class { + constructor(expressID, type, Location, Identification, Name) { + this.expressID = expressID; + this.type = type; + this.Location = Location; + this.Identification = Identification; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Location = tape[ptr++]; + let Identification = tape[ptr++]; + let Name = tape[ptr++]; + return new IfcExternalReference(expressID, type, Location, Identification, Name); + } + ToTape() { + let args = []; + args.push(this.Location); + ; + args.push(this.Identification); + ; + args.push(this.Name); + ; + return args; + } +}; +var IfcExternalReferenceRelationship = class { + constructor(expressID, type, Name, Description, RelatingReference, RelatedResourceObjects) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.RelatingReference = RelatingReference; + this.RelatedResourceObjects = RelatedResourceObjects; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingReference = tape[ptr++]; + let RelatedResourceObjects = tape[ptr++]; + return new IfcExternalReferenceRelationship(expressID, type, Name, Description, RelatingReference, RelatedResourceObjects); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingReference); + ; + args.push(this.RelatedResourceObjects); + ; + return args; + } +}; +var IfcExternalSpatialElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.LongName = LongName; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let LongName = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcExternalSpatialElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.LongName); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcExternalSpatialStructureElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.LongName = LongName; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let LongName = tape[ptr++]; + return new IfcExternalSpatialStructureElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.LongName); + ; + return args; + } +}; +var IfcExternallyDefinedHatchStyle = class { + constructor(expressID, type, Location, Identification, Name) { + this.expressID = expressID; + this.type = type; + this.Location = Location; + this.Identification = Identification; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Location = tape[ptr++]; + let Identification = tape[ptr++]; + let Name = tape[ptr++]; + return new IfcExternallyDefinedHatchStyle(expressID, type, Location, Identification, Name); + } + ToTape() { + let args = []; + args.push(this.Location); + ; + args.push(this.Identification); + ; + args.push(this.Name); + ; + return args; + } +}; +var IfcExternallyDefinedSurfaceStyle = class { + constructor(expressID, type, Location, Identification, Name) { + this.expressID = expressID; + this.type = type; + this.Location = Location; + this.Identification = Identification; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Location = tape[ptr++]; + let Identification = tape[ptr++]; + let Name = tape[ptr++]; + return new IfcExternallyDefinedSurfaceStyle(expressID, type, Location, Identification, Name); + } + ToTape() { + let args = []; + args.push(this.Location); + ; + args.push(this.Identification); + ; + args.push(this.Name); + ; + return args; + } +}; +var IfcExternallyDefinedTextFont = class { + constructor(expressID, type, Location, Identification, Name) { + this.expressID = expressID; + this.type = type; + this.Location = Location; + this.Identification = Identification; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Location = tape[ptr++]; + let Identification = tape[ptr++]; + let Name = tape[ptr++]; + return new IfcExternallyDefinedTextFont(expressID, type, Location, Identification, Name); + } + ToTape() { + let args = []; + args.push(this.Location); + ; + args.push(this.Identification); + ; + args.push(this.Name); + ; + return args; + } +}; +var IfcExtrudedAreaSolid = class { + constructor(expressID, type, SweptArea, Position, ExtrudedDirection, Depth) { + this.expressID = expressID; + this.type = type; + this.SweptArea = SweptArea; + this.Position = Position; + this.ExtrudedDirection = ExtrudedDirection; + this.Depth = Depth; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SweptArea = tape[ptr++]; + let Position = tape[ptr++]; + let ExtrudedDirection = tape[ptr++]; + let Depth = tape[ptr++]; + return new IfcExtrudedAreaSolid(expressID, type, SweptArea, Position, ExtrudedDirection, Depth); + } + ToTape() { + let args = []; + args.push(this.SweptArea); + ; + args.push(this.Position); + ; + args.push(this.ExtrudedDirection); + ; + args.push(this.Depth); + ; + return args; + } +}; +var IfcExtrudedAreaSolidTapered = class { + constructor(expressID, type, SweptArea, Position, ExtrudedDirection, Depth, EndSweptArea) { + this.expressID = expressID; + this.type = type; + this.SweptArea = SweptArea; + this.Position = Position; + this.ExtrudedDirection = ExtrudedDirection; + this.Depth = Depth; + this.EndSweptArea = EndSweptArea; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SweptArea = tape[ptr++]; + let Position = tape[ptr++]; + let ExtrudedDirection = tape[ptr++]; + let Depth = tape[ptr++]; + let EndSweptArea = tape[ptr++]; + return new IfcExtrudedAreaSolidTapered(expressID, type, SweptArea, Position, ExtrudedDirection, Depth, EndSweptArea); + } + ToTape() { + let args = []; + args.push(this.SweptArea); + ; + args.push(this.Position); + ; + args.push(this.ExtrudedDirection); + ; + args.push(this.Depth); + ; + args.push(this.EndSweptArea); + ; + return args; + } +}; +var IfcFace = class { + constructor(expressID, type, Bounds) { + this.expressID = expressID; + this.type = type; + this.Bounds = Bounds; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Bounds = tape[ptr++]; + return new IfcFace(expressID, type, Bounds); + } + ToTape() { + let args = []; + args.push(this.Bounds); + ; + return args; + } +}; +var IfcFaceBasedSurfaceModel = class { + constructor(expressID, type, FbsmFaces) { + this.expressID = expressID; + this.type = type; + this.FbsmFaces = FbsmFaces; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let FbsmFaces = tape[ptr++]; + return new IfcFaceBasedSurfaceModel(expressID, type, FbsmFaces); + } + ToTape() { + let args = []; + args.push(this.FbsmFaces); + ; + return args; + } +}; +var IfcFaceBound = class { + constructor(expressID, type, Bound, Orientation) { + this.expressID = expressID; + this.type = type; + this.Bound = Bound; + this.Orientation = Orientation; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Bound = tape[ptr++]; + let Orientation = tape[ptr++]; + return new IfcFaceBound(expressID, type, Bound, Orientation); + } + ToTape() { + let args = []; + args.push(this.Bound); + ; + args.push(this.Orientation); + ; + return args; + } +}; +var IfcFaceOuterBound = class { + constructor(expressID, type, Bound, Orientation) { + this.expressID = expressID; + this.type = type; + this.Bound = Bound; + this.Orientation = Orientation; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Bound = tape[ptr++]; + let Orientation = tape[ptr++]; + return new IfcFaceOuterBound(expressID, type, Bound, Orientation); + } + ToTape() { + let args = []; + args.push(this.Bound); + ; + args.push(this.Orientation); + ; + return args; + } +}; +var IfcFaceSurface = class { + constructor(expressID, type, Bounds, FaceSurface, SameSense) { + this.expressID = expressID; + this.type = type; + this.Bounds = Bounds; + this.FaceSurface = FaceSurface; + this.SameSense = SameSense; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Bounds = tape[ptr++]; + let FaceSurface = tape[ptr++]; + let SameSense = tape[ptr++]; + return new IfcFaceSurface(expressID, type, Bounds, FaceSurface, SameSense); + } + ToTape() { + let args = []; + args.push(this.Bounds); + ; + args.push(this.FaceSurface); + ; + args.push(this.SameSense); + ; + return args; + } +}; +var IfcFacetedBrep = class { + constructor(expressID, type, Outer) { + this.expressID = expressID; + this.type = type; + this.Outer = Outer; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Outer = tape[ptr++]; + return new IfcFacetedBrep(expressID, type, Outer); + } + ToTape() { + let args = []; + args.push(this.Outer); + ; + return args; + } +}; +var IfcFacetedBrepWithVoids = class { + constructor(expressID, type, Outer, Voids) { + this.expressID = expressID; + this.type = type; + this.Outer = Outer; + this.Voids = Voids; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Outer = tape[ptr++]; + let Voids = tape[ptr++]; + return new IfcFacetedBrepWithVoids(expressID, type, Outer, Voids); + } + ToTape() { + let args = []; + args.push(this.Outer); + ; + args.push(this.Voids); + ; + return args; + } +}; +var IfcFacility = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, CompositionType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.LongName = LongName; + this.CompositionType = CompositionType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let LongName = tape[ptr++]; + let CompositionType = tape[ptr++]; + return new IfcFacility(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, CompositionType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.LongName); + ; + args.push(this.CompositionType); + ; + return args; + } +}; +var IfcFacilityPart = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, CompositionType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.LongName = LongName; + this.CompositionType = CompositionType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let LongName = tape[ptr++]; + let CompositionType = tape[ptr++]; + return new IfcFacilityPart(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, CompositionType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.LongName); + ; + args.push(this.CompositionType); + ; + return args; + } +}; +var IfcFailureConnectionCondition = class { + constructor(expressID, type, Name, TensionFailureX, TensionFailureY, TensionFailureZ, CompressionFailureX, CompressionFailureY, CompressionFailureZ) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.TensionFailureX = TensionFailureX; + this.TensionFailureY = TensionFailureY; + this.TensionFailureZ = TensionFailureZ; + this.CompressionFailureX = CompressionFailureX; + this.CompressionFailureY = CompressionFailureY; + this.CompressionFailureZ = CompressionFailureZ; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let TensionFailureX = tape[ptr++]; + let TensionFailureY = tape[ptr++]; + let TensionFailureZ = tape[ptr++]; + let CompressionFailureX = tape[ptr++]; + let CompressionFailureY = tape[ptr++]; + let CompressionFailureZ = tape[ptr++]; + return new IfcFailureConnectionCondition(expressID, type, Name, TensionFailureX, TensionFailureY, TensionFailureZ, CompressionFailureX, CompressionFailureY, CompressionFailureZ); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.TensionFailureX); + ; + args.push(this.TensionFailureY); + ; + args.push(this.TensionFailureZ); + ; + args.push(this.CompressionFailureX); + ; + args.push(this.CompressionFailureY); + ; + args.push(this.CompressionFailureZ); + ; + return args; + } +}; +var IfcFan = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcFan(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcFanType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcFanType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcFastener = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcFastener(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcFastenerType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcFastenerType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcFeatureElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcFeatureElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcFeatureElementAddition = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcFeatureElementAddition(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcFeatureElementSubtraction = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcFeatureElementSubtraction(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcFillAreaStyle = class { + constructor(expressID, type, Name, FillStyles, ModelorDraughting) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.FillStyles = FillStyles; + this.ModelorDraughting = ModelorDraughting; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let FillStyles = tape[ptr++]; + let ModelorDraughting = tape[ptr++]; + return new IfcFillAreaStyle(expressID, type, Name, FillStyles, ModelorDraughting); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.FillStyles); + ; + args.push(this.ModelorDraughting); + ; + return args; + } +}; +var IfcFillAreaStyleHatching = class { + constructor(expressID, type, HatchLineAppearance, StartOfNextHatchLine, PointOfReferenceHatchLine, PatternStart, HatchLineAngle) { + this.expressID = expressID; + this.type = type; + this.HatchLineAppearance = HatchLineAppearance; + this.StartOfNextHatchLine = StartOfNextHatchLine; + this.PointOfReferenceHatchLine = PointOfReferenceHatchLine; + this.PatternStart = PatternStart; + this.HatchLineAngle = HatchLineAngle; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let HatchLineAppearance = tape[ptr++]; + let StartOfNextHatchLine = tape[ptr++]; + let PointOfReferenceHatchLine = tape[ptr++]; + let PatternStart = tape[ptr++]; + let HatchLineAngle = tape[ptr++]; + return new IfcFillAreaStyleHatching(expressID, type, HatchLineAppearance, StartOfNextHatchLine, PointOfReferenceHatchLine, PatternStart, HatchLineAngle); + } + ToTape() { + let args = []; + args.push(this.HatchLineAppearance); + ; + args.push(this.StartOfNextHatchLine); + ; + args.push(this.PointOfReferenceHatchLine); + ; + args.push(this.PatternStart); + ; + args.push(this.HatchLineAngle); + ; + return args; + } +}; +var IfcFillAreaStyleTiles = class { + constructor(expressID, type, TilingPattern, Tiles, TilingScale) { + this.expressID = expressID; + this.type = type; + this.TilingPattern = TilingPattern; + this.Tiles = Tiles; + this.TilingScale = TilingScale; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let TilingPattern = tape[ptr++]; + let Tiles = tape[ptr++]; + let TilingScale = tape[ptr++]; + return new IfcFillAreaStyleTiles(expressID, type, TilingPattern, Tiles, TilingScale); + } + ToTape() { + let args = []; + args.push(this.TilingPattern); + ; + args.push(this.Tiles); + ; + args.push(this.TilingScale); + ; + return args; + } +}; +var IfcFilter = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcFilter(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcFilterType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcFilterType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcFireSuppressionTerminal = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcFireSuppressionTerminal(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcFireSuppressionTerminalType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcFireSuppressionTerminalType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcFixedReferenceSweptAreaSolid = class { + constructor(expressID, type, SweptArea, Position, Directrix, StartParam, EndParam, FixedReference) { + this.expressID = expressID; + this.type = type; + this.SweptArea = SweptArea; + this.Position = Position; + this.Directrix = Directrix; + this.StartParam = StartParam; + this.EndParam = EndParam; + this.FixedReference = FixedReference; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SweptArea = tape[ptr++]; + let Position = tape[ptr++]; + let Directrix = tape[ptr++]; + let StartParam = tape[ptr++]; + let EndParam = tape[ptr++]; + let FixedReference = tape[ptr++]; + return new IfcFixedReferenceSweptAreaSolid(expressID, type, SweptArea, Position, Directrix, StartParam, EndParam, FixedReference); + } + ToTape() { + let args = []; + args.push(this.SweptArea); + ; + args.push(this.Position); + ; + args.push(this.Directrix); + ; + args.push(this.StartParam); + ; + args.push(this.EndParam); + ; + args.push(this.FixedReference); + ; + return args; + } +}; +var IfcFlowController = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcFlowController(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcFlowControllerType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcFlowControllerType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcFlowFitting = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcFlowFitting(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcFlowFittingType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcFlowFittingType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcFlowInstrument = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcFlowInstrument(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcFlowInstrumentType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcFlowInstrumentType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcFlowMeter = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcFlowMeter(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcFlowMeterType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcFlowMeterType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcFlowMovingDevice = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcFlowMovingDevice(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcFlowMovingDeviceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcFlowMovingDeviceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcFlowSegment = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcFlowSegment(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcFlowSegmentType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcFlowSegmentType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcFlowStorageDevice = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcFlowStorageDevice(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcFlowStorageDeviceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcFlowStorageDeviceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcFlowTerminal = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcFlowTerminal(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcFlowTerminalType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcFlowTerminalType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcFlowTreatmentDevice = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcFlowTreatmentDevice(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcFlowTreatmentDeviceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcFlowTreatmentDeviceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcFooting = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcFooting(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcFootingType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcFootingType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcFurnishingElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcFurnishingElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcFurnishingElementType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcFurnishingElementType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcFurniture = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcFurniture(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcFurnitureType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, AssemblyPlace, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.AssemblyPlace = AssemblyPlace; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let AssemblyPlace = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcFurnitureType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, AssemblyPlace, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.AssemblyPlace); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcGeographicElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcGeographicElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcGeographicElementType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcGeographicElementType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcGeometricCurveSet = class { + constructor(expressID, type, Elements) { + this.expressID = expressID; + this.type = type; + this.Elements = Elements; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Elements = tape[ptr++]; + return new IfcGeometricCurveSet(expressID, type, Elements); + } + ToTape() { + let args = []; + args.push(this.Elements); + ; + return args; + } +}; +var IfcGeometricRepresentationContext = class { + constructor(expressID, type, ContextIdentifier, ContextType, CoordinateSpaceDimension, Precision, WorldCoordinateSystem, TrueNorth) { + this.expressID = expressID; + this.type = type; + this.ContextIdentifier = ContextIdentifier; + this.ContextType = ContextType; + this.CoordinateSpaceDimension = CoordinateSpaceDimension; + this.Precision = Precision; + this.WorldCoordinateSystem = WorldCoordinateSystem; + this.TrueNorth = TrueNorth; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ContextIdentifier = tape[ptr++]; + let ContextType = tape[ptr++]; + let CoordinateSpaceDimension = tape[ptr++]; + let Precision = tape[ptr++]; + let WorldCoordinateSystem = tape[ptr++]; + let TrueNorth = tape[ptr++]; + return new IfcGeometricRepresentationContext(expressID, type, ContextIdentifier, ContextType, CoordinateSpaceDimension, Precision, WorldCoordinateSystem, TrueNorth); + } + ToTape() { + let args = []; + args.push(this.ContextIdentifier); + ; + args.push(this.ContextType); + ; + args.push(this.CoordinateSpaceDimension); + ; + args.push(this.Precision); + ; + args.push(this.WorldCoordinateSystem); + ; + args.push(this.TrueNorth); + ; + return args; + } +}; +var IfcGeometricRepresentationItem = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcGeometricRepresentationItem(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcGeometricRepresentationSubContext = class { + constructor(expressID, type, ContextIdentifier, ContextType, CoordinateSpaceDimension, Precision, WorldCoordinateSystem, TrueNorth, ParentContext, TargetScale, TargetView, UserDefinedTargetView) { + this.expressID = expressID; + this.type = type; + this.ContextIdentifier = ContextIdentifier; + this.ContextType = ContextType; + this.CoordinateSpaceDimension = CoordinateSpaceDimension; + this.Precision = Precision; + this.WorldCoordinateSystem = WorldCoordinateSystem; + this.TrueNorth = TrueNorth; + this.ParentContext = ParentContext; + this.TargetScale = TargetScale; + this.TargetView = TargetView; + this.UserDefinedTargetView = UserDefinedTargetView; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ContextIdentifier = tape[ptr++]; + let ContextType = tape[ptr++]; + let CoordinateSpaceDimension = tape[ptr++]; + let Precision = tape[ptr++]; + let WorldCoordinateSystem = tape[ptr++]; + let TrueNorth = tape[ptr++]; + let ParentContext = tape[ptr++]; + let TargetScale = tape[ptr++]; + let TargetView = tape[ptr++]; + let UserDefinedTargetView = tape[ptr++]; + return new IfcGeometricRepresentationSubContext(expressID, type, ContextIdentifier, ContextType, CoordinateSpaceDimension, Precision, WorldCoordinateSystem, TrueNorth, ParentContext, TargetScale, TargetView, UserDefinedTargetView); + } + ToTape() { + let args = []; + args.push(this.ContextIdentifier); + ; + args.push(this.ContextType); + ; + args.push(this.CoordinateSpaceDimension); + ; + args.push(this.Precision); + ; + args.push(this.WorldCoordinateSystem); + ; + args.push(this.TrueNorth); + ; + args.push(this.ParentContext); + ; + args.push(this.TargetScale); + ; + args.push(this.TargetView); + ; + args.push(this.UserDefinedTargetView); + ; + return args; + } +}; +var IfcGeometricSet = class { + constructor(expressID, type, Elements) { + this.expressID = expressID; + this.type = type; + this.Elements = Elements; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Elements = tape[ptr++]; + return new IfcGeometricSet(expressID, type, Elements); + } + ToTape() { + let args = []; + args.push(this.Elements); + ; + return args; + } +}; +var IfcGrid = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, UAxes, VAxes, WAxes, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.UAxes = UAxes; + this.VAxes = VAxes; + this.WAxes = WAxes; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let UAxes = tape[ptr++]; + let VAxes = tape[ptr++]; + let WAxes = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcGrid(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, UAxes, VAxes, WAxes, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.UAxes); + ; + args.push(this.VAxes); + ; + args.push(this.WAxes); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcGridAxis = class { + constructor(expressID, type, AxisTag, AxisCurve, SameSense) { + this.expressID = expressID; + this.type = type; + this.AxisTag = AxisTag; + this.AxisCurve = AxisCurve; + this.SameSense = SameSense; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let AxisTag = tape[ptr++]; + let AxisCurve = tape[ptr++]; + let SameSense = tape[ptr++]; + return new IfcGridAxis(expressID, type, AxisTag, AxisCurve, SameSense); + } + ToTape() { + let args = []; + args.push(this.AxisTag); + ; + args.push(this.AxisCurve); + ; + args.push(this.SameSense); + ; + return args; + } +}; +var IfcGridPlacement = class { + constructor(expressID, type, PlacementRelTo, PlacementLocation, PlacementRefDirection) { + this.expressID = expressID; + this.type = type; + this.PlacementRelTo = PlacementRelTo; + this.PlacementLocation = PlacementLocation; + this.PlacementRefDirection = PlacementRefDirection; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let PlacementRelTo = tape[ptr++]; + let PlacementLocation = tape[ptr++]; + let PlacementRefDirection = tape[ptr++]; + return new IfcGridPlacement(expressID, type, PlacementRelTo, PlacementLocation, PlacementRefDirection); + } + ToTape() { + let args = []; + args.push(this.PlacementRelTo); + ; + args.push(this.PlacementLocation); + ; + args.push(this.PlacementRefDirection); + ; + return args; + } +}; +var IfcGroup = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + return new IfcGroup(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + return args; + } +}; +var IfcHalfSpaceSolid = class { + constructor(expressID, type, BaseSurface, AgreementFlag) { + this.expressID = expressID; + this.type = type; + this.BaseSurface = BaseSurface; + this.AgreementFlag = AgreementFlag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let BaseSurface = tape[ptr++]; + let AgreementFlag = tape[ptr++]; + return new IfcHalfSpaceSolid(expressID, type, BaseSurface, AgreementFlag); + } + ToTape() { + let args = []; + args.push(this.BaseSurface); + ; + args.push(this.AgreementFlag); + ; + return args; + } +}; +var IfcHeatExchanger = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcHeatExchanger(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcHeatExchangerType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcHeatExchangerType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcHumidifier = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcHumidifier(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcHumidifierType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcHumidifierType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcIShapeProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, Position, OverallWidth, OverallDepth, WebThickness, FlangeThickness, FilletRadius, FlangeEdgeRadius, FlangeSlope) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.Position = Position; + this.OverallWidth = OverallWidth; + this.OverallDepth = OverallDepth; + this.WebThickness = WebThickness; + this.FlangeThickness = FlangeThickness; + this.FilletRadius = FilletRadius; + this.FlangeEdgeRadius = FlangeEdgeRadius; + this.FlangeSlope = FlangeSlope; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let Position = tape[ptr++]; + let OverallWidth = tape[ptr++]; + let OverallDepth = tape[ptr++]; + let WebThickness = tape[ptr++]; + let FlangeThickness = tape[ptr++]; + let FilletRadius = tape[ptr++]; + let FlangeEdgeRadius = tape[ptr++]; + let FlangeSlope = tape[ptr++]; + return new IfcIShapeProfileDef(expressID, type, ProfileType, ProfileName, Position, OverallWidth, OverallDepth, WebThickness, FlangeThickness, FilletRadius, FlangeEdgeRadius, FlangeSlope); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.Position); + ; + args.push(this.OverallWidth); + ; + args.push(this.OverallDepth); + ; + args.push(this.WebThickness); + ; + args.push(this.FlangeThickness); + ; + args.push(this.FilletRadius); + ; + args.push(this.FlangeEdgeRadius); + ; + args.push(this.FlangeSlope); + ; + return args; + } +}; +var IfcImageTexture = class { + constructor(expressID, type, RepeatS, RepeatT, Mode, TextureTransform, Parameter, URLReference) { + this.expressID = expressID; + this.type = type; + this.RepeatS = RepeatS; + this.RepeatT = RepeatT; + this.Mode = Mode; + this.TextureTransform = TextureTransform; + this.Parameter = Parameter; + this.URLReference = URLReference; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let RepeatS = tape[ptr++]; + let RepeatT = tape[ptr++]; + let Mode = tape[ptr++]; + let TextureTransform = tape[ptr++]; + let Parameter = tape[ptr++]; + let URLReference = tape[ptr++]; + return new IfcImageTexture(expressID, type, RepeatS, RepeatT, Mode, TextureTransform, Parameter, URLReference); + } + ToTape() { + let args = []; + args.push(this.RepeatS); + ; + args.push(this.RepeatT); + ; + args.push(this.Mode); + ; + args.push(this.TextureTransform); + ; + args.push(this.Parameter); + ; + args.push(this.URLReference); + ; + return args; + } +}; +var IfcIndexedColourMap = class { + constructor(expressID, type, MappedTo, Opacity, Colours, ColourIndex) { + this.expressID = expressID; + this.type = type; + this.MappedTo = MappedTo; + this.Opacity = Opacity; + this.Colours = Colours; + this.ColourIndex = ColourIndex; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let MappedTo = tape[ptr++]; + let Opacity = tape[ptr++]; + let Colours = tape[ptr++]; + let ColourIndex = tape[ptr++]; + return new IfcIndexedColourMap(expressID, type, MappedTo, Opacity, Colours, ColourIndex); + } + ToTape() { + let args = []; + args.push(this.MappedTo); + ; + args.push(this.Opacity); + ; + args.push(this.Colours); + ; + args.push(this.ColourIndex); + ; + return args; + } +}; +var IfcIndexedPolyCurve = class { + constructor(expressID, type, Points, Segments, SelfIntersect) { + this.expressID = expressID; + this.type = type; + this.Points = Points; + this.Segments = Segments; + this.SelfIntersect = SelfIntersect; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Points = tape[ptr++]; + let Segments = tape[ptr++]; + let SelfIntersect = tape[ptr++]; + return new IfcIndexedPolyCurve(expressID, type, Points, Segments, SelfIntersect); + } + ToTape() { + let args = []; + args.push(this.Points); + ; + args.push(this.Segments); + ; + args.push(this.SelfIntersect); + ; + return args; + } +}; +var IfcIndexedPolygonalFace = class { + constructor(expressID, type, CoordIndex) { + this.expressID = expressID; + this.type = type; + this.CoordIndex = CoordIndex; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let CoordIndex = tape[ptr++]; + return new IfcIndexedPolygonalFace(expressID, type, CoordIndex); + } + ToTape() { + let args = []; + args.push(this.CoordIndex); + ; + return args; + } +}; +var IfcIndexedPolygonalFaceWithVoids = class { + constructor(expressID, type, CoordIndex, InnerCoordIndices) { + this.expressID = expressID; + this.type = type; + this.CoordIndex = CoordIndex; + this.InnerCoordIndices = InnerCoordIndices; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let CoordIndex = tape[ptr++]; + let InnerCoordIndices = tape[ptr++]; + return new IfcIndexedPolygonalFaceWithVoids(expressID, type, CoordIndex, InnerCoordIndices); + } + ToTape() { + let args = []; + args.push(this.CoordIndex); + ; + args.push(this.InnerCoordIndices); + ; + return args; + } +}; +var IfcIndexedTextureMap = class { + constructor(expressID, type, Maps, MappedTo, TexCoords) { + this.expressID = expressID; + this.type = type; + this.Maps = Maps; + this.MappedTo = MappedTo; + this.TexCoords = TexCoords; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Maps = tape[ptr++]; + let MappedTo = tape[ptr++]; + let TexCoords = tape[ptr++]; + return new IfcIndexedTextureMap(expressID, type, Maps, MappedTo, TexCoords); + } + ToTape() { + let args = []; + args.push(this.Maps); + ; + args.push(this.MappedTo); + ; + args.push(this.TexCoords); + ; + return args; + } +}; +var IfcIndexedTriangleTextureMap = class { + constructor(expressID, type, Maps, MappedTo, TexCoords, TexCoordIndex) { + this.expressID = expressID; + this.type = type; + this.Maps = Maps; + this.MappedTo = MappedTo; + this.TexCoords = TexCoords; + this.TexCoordIndex = TexCoordIndex; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Maps = tape[ptr++]; + let MappedTo = tape[ptr++]; + let TexCoords = tape[ptr++]; + let TexCoordIndex = tape[ptr++]; + return new IfcIndexedTriangleTextureMap(expressID, type, Maps, MappedTo, TexCoords, TexCoordIndex); + } + ToTape() { + let args = []; + args.push(this.Maps); + ; + args.push(this.MappedTo); + ; + args.push(this.TexCoords); + ; + args.push(this.TexCoordIndex); + ; + return args; + } +}; +var IfcInterceptor = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcInterceptor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcInterceptorType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcInterceptorType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcIntersectionCurve = class { + constructor(expressID, type, Curve3D, AssociatedGeometry, MasterRepresentation) { + this.expressID = expressID; + this.type = type; + this.Curve3D = Curve3D; + this.AssociatedGeometry = AssociatedGeometry; + this.MasterRepresentation = MasterRepresentation; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Curve3D = tape[ptr++]; + let AssociatedGeometry = tape[ptr++]; + let MasterRepresentation = tape[ptr++]; + return new IfcIntersectionCurve(expressID, type, Curve3D, AssociatedGeometry, MasterRepresentation); + } + ToTape() { + let args = []; + args.push(this.Curve3D); + ; + args.push(this.AssociatedGeometry); + ; + args.push(this.MasterRepresentation); + ; + return args; + } +}; +var IfcInventory = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, PredefinedType, Jurisdiction, ResponsiblePersons, LastUpdateDate, CurrentValue, OriginalValue) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.PredefinedType = PredefinedType; + this.Jurisdiction = Jurisdiction; + this.ResponsiblePersons = ResponsiblePersons; + this.LastUpdateDate = LastUpdateDate; + this.CurrentValue = CurrentValue; + this.OriginalValue = OriginalValue; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let Jurisdiction = tape[ptr++]; + let ResponsiblePersons = tape[ptr++]; + let LastUpdateDate = tape[ptr++]; + let CurrentValue = tape[ptr++]; + let OriginalValue = tape[ptr++]; + return new IfcInventory(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, PredefinedType, Jurisdiction, ResponsiblePersons, LastUpdateDate, CurrentValue, OriginalValue); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.PredefinedType); + ; + args.push(this.Jurisdiction); + ; + args.push(this.ResponsiblePersons); + ; + args.push(this.LastUpdateDate); + ; + args.push(this.CurrentValue); + ; + args.push(this.OriginalValue); + ; + return args; + } +}; +var IfcIrregularTimeSeries = class { + constructor(expressID, type, Name, Description, StartTime, EndTime, TimeSeriesDataType, DataOrigin, UserDefinedDataOrigin, Unit, Values) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.StartTime = StartTime; + this.EndTime = EndTime; + this.TimeSeriesDataType = TimeSeriesDataType; + this.DataOrigin = DataOrigin; + this.UserDefinedDataOrigin = UserDefinedDataOrigin; + this.Unit = Unit; + this.Values = Values; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let StartTime = tape[ptr++]; + let EndTime = tape[ptr++]; + let TimeSeriesDataType = tape[ptr++]; + let DataOrigin = tape[ptr++]; + let UserDefinedDataOrigin = tape[ptr++]; + let Unit = tape[ptr++]; + let Values = tape[ptr++]; + return new IfcIrregularTimeSeries(expressID, type, Name, Description, StartTime, EndTime, TimeSeriesDataType, DataOrigin, UserDefinedDataOrigin, Unit, Values); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.StartTime); + ; + args.push(this.EndTime); + ; + args.push(this.TimeSeriesDataType); + ; + args.push(this.DataOrigin); + ; + args.push(this.UserDefinedDataOrigin); + ; + args.push(this.Unit); + ; + args.push(this.Values); + ; + return args; + } +}; +var IfcIrregularTimeSeriesValue = class { + constructor(expressID, type, TimeStamp, ListValues) { + this.expressID = expressID; + this.type = type; + this.TimeStamp = TimeStamp; + this.ListValues = ListValues; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let TimeStamp = tape[ptr++]; + let ListValues = tape[ptr++]; + return new IfcIrregularTimeSeriesValue(expressID, type, TimeStamp, ListValues); + } + ToTape() { + let args = []; + args.push(this.TimeStamp); + ; + args.push(this.ListValues); + ; + return args; + } +}; +var IfcJunctionBox = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcJunctionBox(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcJunctionBoxType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcJunctionBoxType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcLShapeProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, Position, Depth, Width, Thickness, FilletRadius, EdgeRadius, LegSlope) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.Position = Position; + this.Depth = Depth; + this.Width = Width; + this.Thickness = Thickness; + this.FilletRadius = FilletRadius; + this.EdgeRadius = EdgeRadius; + this.LegSlope = LegSlope; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let Position = tape[ptr++]; + let Depth = tape[ptr++]; + let Width = tape[ptr++]; + let Thickness = tape[ptr++]; + let FilletRadius = tape[ptr++]; + let EdgeRadius = tape[ptr++]; + let LegSlope = tape[ptr++]; + return new IfcLShapeProfileDef(expressID, type, ProfileType, ProfileName, Position, Depth, Width, Thickness, FilletRadius, EdgeRadius, LegSlope); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.Position); + ; + args.push(this.Depth); + ; + args.push(this.Width); + ; + args.push(this.Thickness); + ; + args.push(this.FilletRadius); + ; + args.push(this.EdgeRadius); + ; + args.push(this.LegSlope); + ; + return args; + } +}; +var IfcLaborResource = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, Usage, BaseCosts, BaseQuantity, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.Usage = Usage; + this.BaseCosts = BaseCosts; + this.BaseQuantity = BaseQuantity; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let Usage = tape[ptr++]; + let BaseCosts = tape[ptr++]; + let BaseQuantity = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcLaborResource(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, Usage, BaseCosts, BaseQuantity, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.Usage); + ; + args.push(this.BaseCosts); + ; + args.push(this.BaseQuantity); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcLaborResourceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ResourceType, BaseCosts, BaseQuantity, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.ResourceType = ResourceType; + this.BaseCosts = BaseCosts; + this.BaseQuantity = BaseQuantity; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let ResourceType = tape[ptr++]; + let BaseCosts = tape[ptr++]; + let BaseQuantity = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcLaborResourceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ResourceType, BaseCosts, BaseQuantity, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.ResourceType); + ; + args.push(this.BaseCosts); + ; + args.push(this.BaseQuantity); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcLagTime = class { + constructor(expressID, type, Name, DataOrigin, UserDefinedDataOrigin, LagValue, DurationType) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.DataOrigin = DataOrigin; + this.UserDefinedDataOrigin = UserDefinedDataOrigin; + this.LagValue = LagValue; + this.DurationType = DurationType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let DataOrigin = tape[ptr++]; + let UserDefinedDataOrigin = tape[ptr++]; + let LagValue = tape[ptr++]; + let DurationType = tape[ptr++]; + return new IfcLagTime(expressID, type, Name, DataOrigin, UserDefinedDataOrigin, LagValue, DurationType); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.DataOrigin); + ; + args.push(this.UserDefinedDataOrigin); + ; + args.push(this.LagValue); + ; + args.push(this.DurationType); + ; + return args; + } +}; +var IfcLamp = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcLamp(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcLampType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcLampType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcLibraryInformation = class { + constructor(expressID, type, Name, Version, Publisher, VersionDate, Location, Description) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Version = Version; + this.Publisher = Publisher; + this.VersionDate = VersionDate; + this.Location = Location; + this.Description = Description; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Version = tape[ptr++]; + let Publisher = tape[ptr++]; + let VersionDate = tape[ptr++]; + let Location = tape[ptr++]; + let Description = tape[ptr++]; + return new IfcLibraryInformation(expressID, type, Name, Version, Publisher, VersionDate, Location, Description); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Version); + ; + args.push(this.Publisher); + ; + args.push(this.VersionDate); + ; + args.push(this.Location); + ; + args.push(this.Description); + ; + return args; + } +}; +var IfcLibraryReference = class { + constructor(expressID, type, Location, Identification, Name, Description, Language, ReferencedLibrary) { + this.expressID = expressID; + this.type = type; + this.Location = Location; + this.Identification = Identification; + this.Name = Name; + this.Description = Description; + this.Language = Language; + this.ReferencedLibrary = ReferencedLibrary; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Location = tape[ptr++]; + let Identification = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Language = tape[ptr++]; + let ReferencedLibrary = tape[ptr++]; + return new IfcLibraryReference(expressID, type, Location, Identification, Name, Description, Language, ReferencedLibrary); + } + ToTape() { + let args = []; + args.push(this.Location); + ; + args.push(this.Identification); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Language); + ; + args.push(this.ReferencedLibrary); + ; + return args; + } +}; +var IfcLightDistributionData = class { + constructor(expressID, type, MainPlaneAngle, SecondaryPlaneAngle, LuminousIntensity) { + this.expressID = expressID; + this.type = type; + this.MainPlaneAngle = MainPlaneAngle; + this.SecondaryPlaneAngle = SecondaryPlaneAngle; + this.LuminousIntensity = LuminousIntensity; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let MainPlaneAngle = tape[ptr++]; + let SecondaryPlaneAngle = tape[ptr++]; + let LuminousIntensity = tape[ptr++]; + return new IfcLightDistributionData(expressID, type, MainPlaneAngle, SecondaryPlaneAngle, LuminousIntensity); + } + ToTape() { + let args = []; + args.push(this.MainPlaneAngle); + ; + args.push(this.SecondaryPlaneAngle); + ; + args.push(this.LuminousIntensity); + ; + return args; + } +}; +var IfcLightFixture = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcLightFixture(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcLightFixtureType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcLightFixtureType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcLightIntensityDistribution = class { + constructor(expressID, type, LightDistributionCurve, DistributionData) { + this.expressID = expressID; + this.type = type; + this.LightDistributionCurve = LightDistributionCurve; + this.DistributionData = DistributionData; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let LightDistributionCurve = tape[ptr++]; + let DistributionData = tape[ptr++]; + return new IfcLightIntensityDistribution(expressID, type, LightDistributionCurve, DistributionData); + } + ToTape() { + let args = []; + args.push(this.LightDistributionCurve); + ; + args.push(this.DistributionData); + ; + return args; + } +}; +var IfcLightSource = class { + constructor(expressID, type, Name, LightColour, AmbientIntensity, Intensity) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.LightColour = LightColour; + this.AmbientIntensity = AmbientIntensity; + this.Intensity = Intensity; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let LightColour = tape[ptr++]; + let AmbientIntensity = tape[ptr++]; + let Intensity = tape[ptr++]; + return new IfcLightSource(expressID, type, Name, LightColour, AmbientIntensity, Intensity); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.LightColour); + ; + args.push(this.AmbientIntensity); + ; + args.push(this.Intensity); + ; + return args; + } +}; +var IfcLightSourceAmbient = class { + constructor(expressID, type, Name, LightColour, AmbientIntensity, Intensity) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.LightColour = LightColour; + this.AmbientIntensity = AmbientIntensity; + this.Intensity = Intensity; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let LightColour = tape[ptr++]; + let AmbientIntensity = tape[ptr++]; + let Intensity = tape[ptr++]; + return new IfcLightSourceAmbient(expressID, type, Name, LightColour, AmbientIntensity, Intensity); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.LightColour); + ; + args.push(this.AmbientIntensity); + ; + args.push(this.Intensity); + ; + return args; + } +}; +var IfcLightSourceDirectional = class { + constructor(expressID, type, Name, LightColour, AmbientIntensity, Intensity, Orientation) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.LightColour = LightColour; + this.AmbientIntensity = AmbientIntensity; + this.Intensity = Intensity; + this.Orientation = Orientation; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let LightColour = tape[ptr++]; + let AmbientIntensity = tape[ptr++]; + let Intensity = tape[ptr++]; + let Orientation = tape[ptr++]; + return new IfcLightSourceDirectional(expressID, type, Name, LightColour, AmbientIntensity, Intensity, Orientation); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.LightColour); + ; + args.push(this.AmbientIntensity); + ; + args.push(this.Intensity); + ; + args.push(this.Orientation); + ; + return args; + } +}; +var IfcLightSourceGoniometric = class { + constructor(expressID, type, Name, LightColour, AmbientIntensity, Intensity, Position, ColourAppearance, ColourTemperature, LuminousFlux, LightEmissionSource, LightDistributionDataSource) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.LightColour = LightColour; + this.AmbientIntensity = AmbientIntensity; + this.Intensity = Intensity; + this.Position = Position; + this.ColourAppearance = ColourAppearance; + this.ColourTemperature = ColourTemperature; + this.LuminousFlux = LuminousFlux; + this.LightEmissionSource = LightEmissionSource; + this.LightDistributionDataSource = LightDistributionDataSource; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let LightColour = tape[ptr++]; + let AmbientIntensity = tape[ptr++]; + let Intensity = tape[ptr++]; + let Position = tape[ptr++]; + let ColourAppearance = tape[ptr++]; + let ColourTemperature = tape[ptr++]; + let LuminousFlux = tape[ptr++]; + let LightEmissionSource = tape[ptr++]; + let LightDistributionDataSource = tape[ptr++]; + return new IfcLightSourceGoniometric(expressID, type, Name, LightColour, AmbientIntensity, Intensity, Position, ColourAppearance, ColourTemperature, LuminousFlux, LightEmissionSource, LightDistributionDataSource); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.LightColour); + ; + args.push(this.AmbientIntensity); + ; + args.push(this.Intensity); + ; + args.push(this.Position); + ; + args.push(this.ColourAppearance); + ; + args.push(this.ColourTemperature); + ; + args.push(this.LuminousFlux); + ; + args.push(this.LightEmissionSource); + ; + args.push(this.LightDistributionDataSource); + ; + return args; + } +}; +var IfcLightSourcePositional = class { + constructor(expressID, type, Name, LightColour, AmbientIntensity, Intensity, Position, Radius, ConstantAttenuation, DistanceAttenuation, QuadricAttenuation) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.LightColour = LightColour; + this.AmbientIntensity = AmbientIntensity; + this.Intensity = Intensity; + this.Position = Position; + this.Radius = Radius; + this.ConstantAttenuation = ConstantAttenuation; + this.DistanceAttenuation = DistanceAttenuation; + this.QuadricAttenuation = QuadricAttenuation; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let LightColour = tape[ptr++]; + let AmbientIntensity = tape[ptr++]; + let Intensity = tape[ptr++]; + let Position = tape[ptr++]; + let Radius = tape[ptr++]; + let ConstantAttenuation = tape[ptr++]; + let DistanceAttenuation = tape[ptr++]; + let QuadricAttenuation = tape[ptr++]; + return new IfcLightSourcePositional(expressID, type, Name, LightColour, AmbientIntensity, Intensity, Position, Radius, ConstantAttenuation, DistanceAttenuation, QuadricAttenuation); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.LightColour); + ; + args.push(this.AmbientIntensity); + ; + args.push(this.Intensity); + ; + args.push(this.Position); + ; + args.push(this.Radius); + ; + args.push(this.ConstantAttenuation); + ; + args.push(this.DistanceAttenuation); + ; + args.push(this.QuadricAttenuation); + ; + return args; + } +}; +var IfcLightSourceSpot = class { + constructor(expressID, type, Name, LightColour, AmbientIntensity, Intensity, Position, Radius, ConstantAttenuation, DistanceAttenuation, QuadricAttenuation, Orientation, ConcentrationExponent, SpreadAngle, BeamWidthAngle) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.LightColour = LightColour; + this.AmbientIntensity = AmbientIntensity; + this.Intensity = Intensity; + this.Position = Position; + this.Radius = Radius; + this.ConstantAttenuation = ConstantAttenuation; + this.DistanceAttenuation = DistanceAttenuation; + this.QuadricAttenuation = QuadricAttenuation; + this.Orientation = Orientation; + this.ConcentrationExponent = ConcentrationExponent; + this.SpreadAngle = SpreadAngle; + this.BeamWidthAngle = BeamWidthAngle; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let LightColour = tape[ptr++]; + let AmbientIntensity = tape[ptr++]; + let Intensity = tape[ptr++]; + let Position = tape[ptr++]; + let Radius = tape[ptr++]; + let ConstantAttenuation = tape[ptr++]; + let DistanceAttenuation = tape[ptr++]; + let QuadricAttenuation = tape[ptr++]; + let Orientation = tape[ptr++]; + let ConcentrationExponent = tape[ptr++]; + let SpreadAngle = tape[ptr++]; + let BeamWidthAngle = tape[ptr++]; + return new IfcLightSourceSpot(expressID, type, Name, LightColour, AmbientIntensity, Intensity, Position, Radius, ConstantAttenuation, DistanceAttenuation, QuadricAttenuation, Orientation, ConcentrationExponent, SpreadAngle, BeamWidthAngle); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.LightColour); + ; + args.push(this.AmbientIntensity); + ; + args.push(this.Intensity); + ; + args.push(this.Position); + ; + args.push(this.Radius); + ; + args.push(this.ConstantAttenuation); + ; + args.push(this.DistanceAttenuation); + ; + args.push(this.QuadricAttenuation); + ; + args.push(this.Orientation); + ; + args.push(this.ConcentrationExponent); + ; + args.push(this.SpreadAngle); + ; + args.push(this.BeamWidthAngle); + ; + return args; + } +}; +var IfcLine = class { + constructor(expressID, type, Pnt, Dir) { + this.expressID = expressID; + this.type = type; + this.Pnt = Pnt; + this.Dir = Dir; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Pnt = tape[ptr++]; + let Dir = tape[ptr++]; + return new IfcLine(expressID, type, Pnt, Dir); + } + ToTape() { + let args = []; + args.push(this.Pnt); + ; + args.push(this.Dir); + ; + return args; + } +}; +var IfcLineSegment2D = class { + constructor(expressID, type, StartPoint, StartDirection, SegmentLength) { + this.expressID = expressID; + this.type = type; + this.StartPoint = StartPoint; + this.StartDirection = StartDirection; + this.SegmentLength = SegmentLength; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let StartPoint = tape[ptr++]; + let StartDirection = tape[ptr++]; + let SegmentLength = tape[ptr++]; + return new IfcLineSegment2D(expressID, type, StartPoint, StartDirection, SegmentLength); + } + ToTape() { + let args = []; + args.push(this.StartPoint); + ; + args.push(this.StartDirection); + ; + args.push(this.SegmentLength); + ; + return args; + } +}; +var IfcLinearPlacement = class { + constructor(expressID, type, PlacementRelTo, PlacementMeasuredAlong, Distance, Orientation, CartesianPosition) { + this.expressID = expressID; + this.type = type; + this.PlacementRelTo = PlacementRelTo; + this.PlacementMeasuredAlong = PlacementMeasuredAlong; + this.Distance = Distance; + this.Orientation = Orientation; + this.CartesianPosition = CartesianPosition; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let PlacementRelTo = tape[ptr++]; + let PlacementMeasuredAlong = tape[ptr++]; + let Distance = tape[ptr++]; + let Orientation = tape[ptr++]; + let CartesianPosition = tape[ptr++]; + return new IfcLinearPlacement(expressID, type, PlacementRelTo, PlacementMeasuredAlong, Distance, Orientation, CartesianPosition); + } + ToTape() { + let args = []; + args.push(this.PlacementRelTo); + ; + args.push(this.PlacementMeasuredAlong); + ; + args.push(this.Distance); + ; + args.push(this.Orientation); + ; + args.push(this.CartesianPosition); + ; + return args; + } +}; +var IfcLinearPositioningElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Axis) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Axis = Axis; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Axis = tape[ptr++]; + return new IfcLinearPositioningElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Axis); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Axis); + ; + return args; + } +}; +var IfcLocalPlacement = class { + constructor(expressID, type, PlacementRelTo, RelativePlacement) { + this.expressID = expressID; + this.type = type; + this.PlacementRelTo = PlacementRelTo; + this.RelativePlacement = RelativePlacement; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let PlacementRelTo = tape[ptr++]; + let RelativePlacement = tape[ptr++]; + return new IfcLocalPlacement(expressID, type, PlacementRelTo, RelativePlacement); + } + ToTape() { + let args = []; + args.push(this.PlacementRelTo); + ; + args.push(this.RelativePlacement); + ; + return args; + } +}; +var IfcLoop = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcLoop(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcManifoldSolidBrep = class { + constructor(expressID, type, Outer) { + this.expressID = expressID; + this.type = type; + this.Outer = Outer; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Outer = tape[ptr++]; + return new IfcManifoldSolidBrep(expressID, type, Outer); + } + ToTape() { + let args = []; + args.push(this.Outer); + ; + return args; + } +}; +var IfcMapConversion = class { + constructor(expressID, type, SourceCRS, TargetCRS, Eastings, Northings, OrthogonalHeight, XAxisAbscissa, XAxisOrdinate, Scale) { + this.expressID = expressID; + this.type = type; + this.SourceCRS = SourceCRS; + this.TargetCRS = TargetCRS; + this.Eastings = Eastings; + this.Northings = Northings; + this.OrthogonalHeight = OrthogonalHeight; + this.XAxisAbscissa = XAxisAbscissa; + this.XAxisOrdinate = XAxisOrdinate; + this.Scale = Scale; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SourceCRS = tape[ptr++]; + let TargetCRS = tape[ptr++]; + let Eastings = tape[ptr++]; + let Northings = tape[ptr++]; + let OrthogonalHeight = tape[ptr++]; + let XAxisAbscissa = tape[ptr++]; + let XAxisOrdinate = tape[ptr++]; + let Scale = tape[ptr++]; + return new IfcMapConversion(expressID, type, SourceCRS, TargetCRS, Eastings, Northings, OrthogonalHeight, XAxisAbscissa, XAxisOrdinate, Scale); + } + ToTape() { + let args = []; + args.push(this.SourceCRS); + ; + args.push(this.TargetCRS); + ; + args.push(this.Eastings); + ; + args.push(this.Northings); + ; + args.push(this.OrthogonalHeight); + ; + args.push(this.XAxisAbscissa); + ; + args.push(this.XAxisOrdinate); + ; + args.push(this.Scale); + ; + return args; + } +}; +var IfcMappedItem = class { + constructor(expressID, type, MappingSource, MappingTarget) { + this.expressID = expressID; + this.type = type; + this.MappingSource = MappingSource; + this.MappingTarget = MappingTarget; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let MappingSource = tape[ptr++]; + let MappingTarget = tape[ptr++]; + return new IfcMappedItem(expressID, type, MappingSource, MappingTarget); + } + ToTape() { + let args = []; + args.push(this.MappingSource); + ; + args.push(this.MappingTarget); + ; + return args; + } +}; +var IfcMaterial = class { + constructor(expressID, type, Name, Description, Category) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.Category = Category; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Category = tape[ptr++]; + return new IfcMaterial(expressID, type, Name, Description, Category); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Category); + ; + return args; + } +}; +var IfcMaterialClassificationRelationship = class { + constructor(expressID, type, MaterialClassifications, ClassifiedMaterial) { + this.expressID = expressID; + this.type = type; + this.MaterialClassifications = MaterialClassifications; + this.ClassifiedMaterial = ClassifiedMaterial; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let MaterialClassifications = tape[ptr++]; + let ClassifiedMaterial = tape[ptr++]; + return new IfcMaterialClassificationRelationship(expressID, type, MaterialClassifications, ClassifiedMaterial); + } + ToTape() { + let args = []; + args.push(this.MaterialClassifications); + ; + args.push(this.ClassifiedMaterial); + ; + return args; + } +}; +var IfcMaterialConstituent = class { + constructor(expressID, type, Name, Description, Material, Fraction, Category) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.Material = Material; + this.Fraction = Fraction; + this.Category = Category; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Material = tape[ptr++]; + let Fraction = tape[ptr++]; + let Category = tape[ptr++]; + return new IfcMaterialConstituent(expressID, type, Name, Description, Material, Fraction, Category); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Material); + ; + args.push(this.Fraction); + ; + args.push(this.Category); + ; + return args; + } +}; +var IfcMaterialConstituentSet = class { + constructor(expressID, type, Name, Description, MaterialConstituents) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.MaterialConstituents = MaterialConstituents; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let MaterialConstituents = tape[ptr++]; + return new IfcMaterialConstituentSet(expressID, type, Name, Description, MaterialConstituents); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.MaterialConstituents); + ; + return args; + } +}; +var IfcMaterialDefinition = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcMaterialDefinition(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcMaterialDefinitionRepresentation = class { + constructor(expressID, type, Name, Description, Representations, RepresentedMaterial) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.Representations = Representations; + this.RepresentedMaterial = RepresentedMaterial; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Representations = tape[ptr++]; + let RepresentedMaterial = tape[ptr++]; + return new IfcMaterialDefinitionRepresentation(expressID, type, Name, Description, Representations, RepresentedMaterial); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Representations); + ; + args.push(this.RepresentedMaterial); + ; + return args; + } +}; +var IfcMaterialLayer = class { + constructor(expressID, type, Material, LayerThickness, IsVentilated, Name, Description, Category, Priority) { + this.expressID = expressID; + this.type = type; + this.Material = Material; + this.LayerThickness = LayerThickness; + this.IsVentilated = IsVentilated; + this.Name = Name; + this.Description = Description; + this.Category = Category; + this.Priority = Priority; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Material = tape[ptr++]; + let LayerThickness = tape[ptr++]; + let IsVentilated = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Category = tape[ptr++]; + let Priority = tape[ptr++]; + return new IfcMaterialLayer(expressID, type, Material, LayerThickness, IsVentilated, Name, Description, Category, Priority); + } + ToTape() { + let args = []; + args.push(this.Material); + ; + args.push(this.LayerThickness); + ; + args.push(this.IsVentilated); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Category); + ; + args.push(this.Priority); + ; + return args; + } +}; +var IfcMaterialLayerSet = class { + constructor(expressID, type, MaterialLayers, LayerSetName, Description) { + this.expressID = expressID; + this.type = type; + this.MaterialLayers = MaterialLayers; + this.LayerSetName = LayerSetName; + this.Description = Description; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let MaterialLayers = tape[ptr++]; + let LayerSetName = tape[ptr++]; + let Description = tape[ptr++]; + return new IfcMaterialLayerSet(expressID, type, MaterialLayers, LayerSetName, Description); + } + ToTape() { + let args = []; + args.push(this.MaterialLayers); + ; + args.push(this.LayerSetName); + ; + args.push(this.Description); + ; + return args; + } +}; +var IfcMaterialLayerSetUsage = class { + constructor(expressID, type, ForLayerSet, LayerSetDirection, DirectionSense, OffsetFromReferenceLine, ReferenceExtent) { + this.expressID = expressID; + this.type = type; + this.ForLayerSet = ForLayerSet; + this.LayerSetDirection = LayerSetDirection; + this.DirectionSense = DirectionSense; + this.OffsetFromReferenceLine = OffsetFromReferenceLine; + this.ReferenceExtent = ReferenceExtent; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ForLayerSet = tape[ptr++]; + let LayerSetDirection = tape[ptr++]; + let DirectionSense = tape[ptr++]; + let OffsetFromReferenceLine = tape[ptr++]; + let ReferenceExtent = tape[ptr++]; + return new IfcMaterialLayerSetUsage(expressID, type, ForLayerSet, LayerSetDirection, DirectionSense, OffsetFromReferenceLine, ReferenceExtent); + } + ToTape() { + let args = []; + args.push(this.ForLayerSet); + ; + args.push(this.LayerSetDirection); + ; + args.push(this.DirectionSense); + ; + args.push(this.OffsetFromReferenceLine); + ; + args.push(this.ReferenceExtent); + ; + return args; + } +}; +var IfcMaterialLayerWithOffsets = class { + constructor(expressID, type, Material, LayerThickness, IsVentilated, Name, Description, Category, Priority, OffsetDirection, OffsetValues) { + this.expressID = expressID; + this.type = type; + this.Material = Material; + this.LayerThickness = LayerThickness; + this.IsVentilated = IsVentilated; + this.Name = Name; + this.Description = Description; + this.Category = Category; + this.Priority = Priority; + this.OffsetDirection = OffsetDirection; + this.OffsetValues = OffsetValues; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Material = tape[ptr++]; + let LayerThickness = tape[ptr++]; + let IsVentilated = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Category = tape[ptr++]; + let Priority = tape[ptr++]; + let OffsetDirection = tape[ptr++]; + let OffsetValues = tape[ptr++]; + return new IfcMaterialLayerWithOffsets(expressID, type, Material, LayerThickness, IsVentilated, Name, Description, Category, Priority, OffsetDirection, OffsetValues); + } + ToTape() { + let args = []; + args.push(this.Material); + ; + args.push(this.LayerThickness); + ; + args.push(this.IsVentilated); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Category); + ; + args.push(this.Priority); + ; + args.push(this.OffsetDirection); + ; + args.push(this.OffsetValues); + ; + return args; + } +}; +var IfcMaterialList = class { + constructor(expressID, type, Materials) { + this.expressID = expressID; + this.type = type; + this.Materials = Materials; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Materials = tape[ptr++]; + return new IfcMaterialList(expressID, type, Materials); + } + ToTape() { + let args = []; + args.push(this.Materials); + ; + return args; + } +}; +var IfcMaterialProfile = class { + constructor(expressID, type, Name, Description, Material, Profile, Priority, Category) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.Material = Material; + this.Profile = Profile; + this.Priority = Priority; + this.Category = Category; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Material = tape[ptr++]; + let Profile = tape[ptr++]; + let Priority = tape[ptr++]; + let Category = tape[ptr++]; + return new IfcMaterialProfile(expressID, type, Name, Description, Material, Profile, Priority, Category); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Material); + ; + args.push(this.Profile); + ; + args.push(this.Priority); + ; + args.push(this.Category); + ; + return args; + } +}; +var IfcMaterialProfileSet = class { + constructor(expressID, type, Name, Description, MaterialProfiles, CompositeProfile) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.MaterialProfiles = MaterialProfiles; + this.CompositeProfile = CompositeProfile; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let MaterialProfiles = tape[ptr++]; + let CompositeProfile = tape[ptr++]; + return new IfcMaterialProfileSet(expressID, type, Name, Description, MaterialProfiles, CompositeProfile); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.MaterialProfiles); + ; + args.push(this.CompositeProfile); + ; + return args; + } +}; +var IfcMaterialProfileSetUsage = class { + constructor(expressID, type, ForProfileSet, CardinalPoint, ReferenceExtent) { + this.expressID = expressID; + this.type = type; + this.ForProfileSet = ForProfileSet; + this.CardinalPoint = CardinalPoint; + this.ReferenceExtent = ReferenceExtent; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ForProfileSet = tape[ptr++]; + let CardinalPoint = tape[ptr++]; + let ReferenceExtent = tape[ptr++]; + return new IfcMaterialProfileSetUsage(expressID, type, ForProfileSet, CardinalPoint, ReferenceExtent); + } + ToTape() { + let args = []; + args.push(this.ForProfileSet); + ; + args.push(this.CardinalPoint); + ; + args.push(this.ReferenceExtent); + ; + return args; + } +}; +var IfcMaterialProfileSetUsageTapering = class { + constructor(expressID, type, ForProfileSet, CardinalPoint, ReferenceExtent, ForProfileEndSet, CardinalEndPoint) { + this.expressID = expressID; + this.type = type; + this.ForProfileSet = ForProfileSet; + this.CardinalPoint = CardinalPoint; + this.ReferenceExtent = ReferenceExtent; + this.ForProfileEndSet = ForProfileEndSet; + this.CardinalEndPoint = CardinalEndPoint; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ForProfileSet = tape[ptr++]; + let CardinalPoint = tape[ptr++]; + let ReferenceExtent = tape[ptr++]; + let ForProfileEndSet = tape[ptr++]; + let CardinalEndPoint = tape[ptr++]; + return new IfcMaterialProfileSetUsageTapering(expressID, type, ForProfileSet, CardinalPoint, ReferenceExtent, ForProfileEndSet, CardinalEndPoint); + } + ToTape() { + let args = []; + args.push(this.ForProfileSet); + ; + args.push(this.CardinalPoint); + ; + args.push(this.ReferenceExtent); + ; + args.push(this.ForProfileEndSet); + ; + args.push(this.CardinalEndPoint); + ; + return args; + } +}; +var IfcMaterialProfileWithOffsets = class { + constructor(expressID, type, Name, Description, Material, Profile, Priority, Category, OffsetValues) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.Material = Material; + this.Profile = Profile; + this.Priority = Priority; + this.Category = Category; + this.OffsetValues = OffsetValues; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Material = tape[ptr++]; + let Profile = tape[ptr++]; + let Priority = tape[ptr++]; + let Category = tape[ptr++]; + let OffsetValues = tape[ptr++]; + return new IfcMaterialProfileWithOffsets(expressID, type, Name, Description, Material, Profile, Priority, Category, OffsetValues); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Material); + ; + args.push(this.Profile); + ; + args.push(this.Priority); + ; + args.push(this.Category); + ; + args.push(this.OffsetValues); + ; + return args; + } +}; +var IfcMaterialProperties = class { + constructor(expressID, type, Name, Description, Properties, Material) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.Properties = Properties; + this.Material = Material; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Properties = tape[ptr++]; + let Material = tape[ptr++]; + return new IfcMaterialProperties(expressID, type, Name, Description, Properties, Material); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Properties); + ; + args.push(this.Material); + ; + return args; + } +}; +var IfcMaterialRelationship = class { + constructor(expressID, type, Name, Description, RelatingMaterial, RelatedMaterials, Expression) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.RelatingMaterial = RelatingMaterial; + this.RelatedMaterials = RelatedMaterials; + this.Expression = Expression; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingMaterial = tape[ptr++]; + let RelatedMaterials = tape[ptr++]; + let Expression = tape[ptr++]; + return new IfcMaterialRelationship(expressID, type, Name, Description, RelatingMaterial, RelatedMaterials, Expression); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingMaterial); + ; + args.push(this.RelatedMaterials); + ; + args.push(this.Expression); + ; + return args; + } +}; +var IfcMaterialUsageDefinition = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcMaterialUsageDefinition(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcMeasureWithUnit = class { + constructor(expressID, type, ValueComponent, UnitComponent) { + this.expressID = expressID; + this.type = type; + this.ValueComponent = ValueComponent; + this.UnitComponent = UnitComponent; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ValueComponent = tape[ptr++]; + let UnitComponent = tape[ptr++]; + return new IfcMeasureWithUnit(expressID, type, ValueComponent, UnitComponent); + } + ToTape() { + let args = []; + args.push(this.ValueComponent); + ; + args.push(this.UnitComponent); + ; + return args; + } +}; +var IfcMechanicalFastener = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, NominalDiameter, NominalLength, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.NominalDiameter = NominalDiameter; + this.NominalLength = NominalLength; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let NominalDiameter = tape[ptr++]; + let NominalLength = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcMechanicalFastener(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, NominalDiameter, NominalLength, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.NominalDiameter); + ; + args.push(this.NominalLength); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcMechanicalFastenerType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType, NominalDiameter, NominalLength) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + this.NominalDiameter = NominalDiameter; + this.NominalLength = NominalLength; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let NominalDiameter = tape[ptr++]; + let NominalLength = tape[ptr++]; + return new IfcMechanicalFastenerType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType, NominalDiameter, NominalLength); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + args.push(this.NominalDiameter); + ; + args.push(this.NominalLength); + ; + return args; + } +}; +var IfcMedicalDevice = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcMedicalDevice(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcMedicalDeviceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcMedicalDeviceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcMember = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcMember(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcMemberStandardCase = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcMemberStandardCase(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcMemberType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcMemberType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcMetric = class { + constructor(expressID, type, Name, Description, ConstraintGrade, ConstraintSource, CreatingActor, CreationTime, UserDefinedGrade, Benchmark, ValueSource, DataValue, ReferencePath) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.ConstraintGrade = ConstraintGrade; + this.ConstraintSource = ConstraintSource; + this.CreatingActor = CreatingActor; + this.CreationTime = CreationTime; + this.UserDefinedGrade = UserDefinedGrade; + this.Benchmark = Benchmark; + this.ValueSource = ValueSource; + this.DataValue = DataValue; + this.ReferencePath = ReferencePath; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ConstraintGrade = tape[ptr++]; + let ConstraintSource = tape[ptr++]; + let CreatingActor = tape[ptr++]; + let CreationTime = tape[ptr++]; + let UserDefinedGrade = tape[ptr++]; + let Benchmark = tape[ptr++]; + let ValueSource = tape[ptr++]; + let DataValue = tape[ptr++]; + let ReferencePath = tape[ptr++]; + return new IfcMetric(expressID, type, Name, Description, ConstraintGrade, ConstraintSource, CreatingActor, CreationTime, UserDefinedGrade, Benchmark, ValueSource, DataValue, ReferencePath); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ConstraintGrade); + ; + args.push(this.ConstraintSource); + ; + args.push(this.CreatingActor); + ; + args.push(this.CreationTime); + ; + args.push(this.UserDefinedGrade); + ; + args.push(this.Benchmark); + ; + args.push(this.ValueSource); + ; + args.push(this.DataValue); + ; + args.push(this.ReferencePath); + ; + return args; + } +}; +var IfcMirroredProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, ParentProfile, Operator, Label) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.ParentProfile = ParentProfile; + this.Operator = Operator; + this.Label = Label; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let ParentProfile = tape[ptr++]; + let Operator = tape[ptr++]; + let Label = tape[ptr++]; + return new IfcMirroredProfileDef(expressID, type, ProfileType, ProfileName, ParentProfile, Operator, Label); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.ParentProfile); + ; + args.push(this.Operator); + ; + args.push(this.Label); + ; + return args; + } +}; +var IfcMonetaryUnit = class { + constructor(expressID, type, Currency) { + this.expressID = expressID; + this.type = type; + this.Currency = Currency; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Currency = tape[ptr++]; + return new IfcMonetaryUnit(expressID, type, Currency); + } + ToTape() { + let args = []; + args.push(this.Currency); + ; + return args; + } +}; +var IfcMotorConnection = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcMotorConnection(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcMotorConnectionType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcMotorConnectionType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcNamedUnit = class { + constructor(expressID, type, Dimensions, UnitType) { + this.expressID = expressID; + this.type = type; + this.Dimensions = Dimensions; + this.UnitType = UnitType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Dimensions = tape[ptr++]; + let UnitType = tape[ptr++]; + return new IfcNamedUnit(expressID, type, Dimensions, UnitType); + } + ToTape() { + let args = []; + args.push(this.Dimensions); + ; + args.push(this.UnitType); + ; + return args; + } +}; +var IfcObject = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + return new IfcObject(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + return args; + } +}; +var IfcObjectDefinition = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + return new IfcObjectDefinition(expressID, type, GlobalId, OwnerHistory, Name, Description); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + return args; + } +}; +var IfcObjectPlacement = class { + constructor(expressID, type, PlacementRelTo) { + this.expressID = expressID; + this.type = type; + this.PlacementRelTo = PlacementRelTo; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let PlacementRelTo = tape[ptr++]; + return new IfcObjectPlacement(expressID, type, PlacementRelTo); + } + ToTape() { + let args = []; + args.push(this.PlacementRelTo); + ; + return args; + } +}; +var IfcObjective = class { + constructor(expressID, type, Name, Description, ConstraintGrade, ConstraintSource, CreatingActor, CreationTime, UserDefinedGrade, BenchmarkValues, LogicalAggregator, ObjectiveQualifier, UserDefinedQualifier) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.ConstraintGrade = ConstraintGrade; + this.ConstraintSource = ConstraintSource; + this.CreatingActor = CreatingActor; + this.CreationTime = CreationTime; + this.UserDefinedGrade = UserDefinedGrade; + this.BenchmarkValues = BenchmarkValues; + this.LogicalAggregator = LogicalAggregator; + this.ObjectiveQualifier = ObjectiveQualifier; + this.UserDefinedQualifier = UserDefinedQualifier; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ConstraintGrade = tape[ptr++]; + let ConstraintSource = tape[ptr++]; + let CreatingActor = tape[ptr++]; + let CreationTime = tape[ptr++]; + let UserDefinedGrade = tape[ptr++]; + let BenchmarkValues = tape[ptr++]; + let LogicalAggregator = tape[ptr++]; + let ObjectiveQualifier = tape[ptr++]; + let UserDefinedQualifier = tape[ptr++]; + return new IfcObjective(expressID, type, Name, Description, ConstraintGrade, ConstraintSource, CreatingActor, CreationTime, UserDefinedGrade, BenchmarkValues, LogicalAggregator, ObjectiveQualifier, UserDefinedQualifier); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ConstraintGrade); + ; + args.push(this.ConstraintSource); + ; + args.push(this.CreatingActor); + ; + args.push(this.CreationTime); + ; + args.push(this.UserDefinedGrade); + ; + args.push(this.BenchmarkValues); + ; + args.push(this.LogicalAggregator); + ; + args.push(this.ObjectiveQualifier); + ; + args.push(this.UserDefinedQualifier); + ; + return args; + } +}; +var IfcOccupant = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, TheActor, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.TheActor = TheActor; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let TheActor = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcOccupant(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, TheActor, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.TheActor); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcOffsetCurve = class { + constructor(expressID, type, BasisCurve) { + this.expressID = expressID; + this.type = type; + this.BasisCurve = BasisCurve; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let BasisCurve = tape[ptr++]; + return new IfcOffsetCurve(expressID, type, BasisCurve); + } + ToTape() { + let args = []; + args.push(this.BasisCurve); + ; + return args; + } +}; +var IfcOffsetCurve2D = class { + constructor(expressID, type, BasisCurve, Distance, SelfIntersect) { + this.expressID = expressID; + this.type = type; + this.BasisCurve = BasisCurve; + this.Distance = Distance; + this.SelfIntersect = SelfIntersect; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let BasisCurve = tape[ptr++]; + let Distance = tape[ptr++]; + let SelfIntersect = tape[ptr++]; + return new IfcOffsetCurve2D(expressID, type, BasisCurve, Distance, SelfIntersect); + } + ToTape() { + let args = []; + args.push(this.BasisCurve); + ; + args.push(this.Distance); + ; + args.push(this.SelfIntersect); + ; + return args; + } +}; +var IfcOffsetCurve3D = class { + constructor(expressID, type, BasisCurve, Distance, SelfIntersect, RefDirection) { + this.expressID = expressID; + this.type = type; + this.BasisCurve = BasisCurve; + this.Distance = Distance; + this.SelfIntersect = SelfIntersect; + this.RefDirection = RefDirection; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let BasisCurve = tape[ptr++]; + let Distance = tape[ptr++]; + let SelfIntersect = tape[ptr++]; + let RefDirection = tape[ptr++]; + return new IfcOffsetCurve3D(expressID, type, BasisCurve, Distance, SelfIntersect, RefDirection); + } + ToTape() { + let args = []; + args.push(this.BasisCurve); + ; + args.push(this.Distance); + ; + args.push(this.SelfIntersect); + ; + args.push(this.RefDirection); + ; + return args; + } +}; +var IfcOffsetCurveByDistances = class { + constructor(expressID, type, BasisCurve, OffsetValues, Tag) { + this.expressID = expressID; + this.type = type; + this.BasisCurve = BasisCurve; + this.OffsetValues = OffsetValues; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let BasisCurve = tape[ptr++]; + let OffsetValues = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcOffsetCurveByDistances(expressID, type, BasisCurve, OffsetValues, Tag); + } + ToTape() { + let args = []; + args.push(this.BasisCurve); + ; + args.push(this.OffsetValues); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcOpenShell = class { + constructor(expressID, type, CfsFaces) { + this.expressID = expressID; + this.type = type; + this.CfsFaces = CfsFaces; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let CfsFaces = tape[ptr++]; + return new IfcOpenShell(expressID, type, CfsFaces); + } + ToTape() { + let args = []; + args.push(this.CfsFaces); + ; + return args; + } +}; +var IfcOpeningElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcOpeningElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcOpeningStandardCase = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcOpeningStandardCase(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcOrganization = class { + constructor(expressID, type, Identification, Name, Description, Roles, Addresses) { + this.expressID = expressID; + this.type = type; + this.Identification = Identification; + this.Name = Name; + this.Description = Description; + this.Roles = Roles; + this.Addresses = Addresses; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Identification = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Roles = tape[ptr++]; + let Addresses = tape[ptr++]; + return new IfcOrganization(expressID, type, Identification, Name, Description, Roles, Addresses); + } + ToTape() { + let args = []; + args.push(this.Identification); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Roles); + ; + args.push(this.Addresses); + ; + return args; + } +}; +var IfcOrganizationRelationship = class { + constructor(expressID, type, Name, Description, RelatingOrganization, RelatedOrganizations) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.RelatingOrganization = RelatingOrganization; + this.RelatedOrganizations = RelatedOrganizations; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingOrganization = tape[ptr++]; + let RelatedOrganizations = tape[ptr++]; + return new IfcOrganizationRelationship(expressID, type, Name, Description, RelatingOrganization, RelatedOrganizations); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingOrganization); + ; + args.push(this.RelatedOrganizations); + ; + return args; + } +}; +var IfcOrientationExpression = class { + constructor(expressID, type, LateralAxisDirection, VerticalAxisDirection) { + this.expressID = expressID; + this.type = type; + this.LateralAxisDirection = LateralAxisDirection; + this.VerticalAxisDirection = VerticalAxisDirection; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let LateralAxisDirection = tape[ptr++]; + let VerticalAxisDirection = tape[ptr++]; + return new IfcOrientationExpression(expressID, type, LateralAxisDirection, VerticalAxisDirection); + } + ToTape() { + let args = []; + args.push(this.LateralAxisDirection); + ; + args.push(this.VerticalAxisDirection); + ; + return args; + } +}; +var IfcOrientedEdge = class { + constructor(expressID, type, EdgeStart, EdgeEnd, EdgeElement, Orientation) { + this.expressID = expressID; + this.type = type; + this.EdgeStart = EdgeStart; + this.EdgeEnd = EdgeEnd; + this.EdgeElement = EdgeElement; + this.Orientation = Orientation; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let EdgeStart = tape[ptr++]; + let EdgeEnd = tape[ptr++]; + let EdgeElement = tape[ptr++]; + let Orientation = tape[ptr++]; + return new IfcOrientedEdge(expressID, type, EdgeStart, EdgeEnd, EdgeElement, Orientation); + } + ToTape() { + let args = []; + args.push(this.EdgeStart); + ; + args.push(this.EdgeEnd); + ; + args.push(this.EdgeElement); + ; + args.push(this.Orientation); + ; + return args; + } +}; +var IfcOuterBoundaryCurve = class { + constructor(expressID, type, Segments, SelfIntersect) { + this.expressID = expressID; + this.type = type; + this.Segments = Segments; + this.SelfIntersect = SelfIntersect; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Segments = tape[ptr++]; + let SelfIntersect = tape[ptr++]; + return new IfcOuterBoundaryCurve(expressID, type, Segments, SelfIntersect); + } + ToTape() { + let args = []; + args.push(this.Segments); + ; + args.push(this.SelfIntersect); + ; + return args; + } +}; +var IfcOutlet = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcOutlet(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcOutletType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcOutletType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcOwnerHistory = class { + constructor(expressID, type, OwningUser, OwningApplication, State, ChangeAction, LastModifiedDate, LastModifyingUser, LastModifyingApplication, CreationDate) { + this.expressID = expressID; + this.type = type; + this.OwningUser = OwningUser; + this.OwningApplication = OwningApplication; + this.State = State; + this.ChangeAction = ChangeAction; + this.LastModifiedDate = LastModifiedDate; + this.LastModifyingUser = LastModifyingUser; + this.LastModifyingApplication = LastModifyingApplication; + this.CreationDate = CreationDate; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let OwningUser = tape[ptr++]; + let OwningApplication = tape[ptr++]; + let State = tape[ptr++]; + let ChangeAction = tape[ptr++]; + let LastModifiedDate = tape[ptr++]; + let LastModifyingUser = tape[ptr++]; + let LastModifyingApplication = tape[ptr++]; + let CreationDate = tape[ptr++]; + return new IfcOwnerHistory(expressID, type, OwningUser, OwningApplication, State, ChangeAction, LastModifiedDate, LastModifyingUser, LastModifyingApplication, CreationDate); + } + ToTape() { + let args = []; + args.push(this.OwningUser); + ; + args.push(this.OwningApplication); + ; + args.push(this.State); + ; + args.push(this.ChangeAction); + ; + args.push(this.LastModifiedDate); + ; + args.push(this.LastModifyingUser); + ; + args.push(this.LastModifyingApplication); + ; + args.push(this.CreationDate); + ; + return args; + } +}; +var IfcParameterizedProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, Position) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.Position = Position; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let Position = tape[ptr++]; + return new IfcParameterizedProfileDef(expressID, type, ProfileType, ProfileName, Position); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.Position); + ; + return args; + } +}; +var IfcPath = class { + constructor(expressID, type, EdgeList) { + this.expressID = expressID; + this.type = type; + this.EdgeList = EdgeList; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let EdgeList = tape[ptr++]; + return new IfcPath(expressID, type, EdgeList); + } + ToTape() { + let args = []; + args.push(this.EdgeList); + ; + return args; + } +}; +var IfcPcurve = class { + constructor(expressID, type, BasisSurface, ReferenceCurve) { + this.expressID = expressID; + this.type = type; + this.BasisSurface = BasisSurface; + this.ReferenceCurve = ReferenceCurve; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let BasisSurface = tape[ptr++]; + let ReferenceCurve = tape[ptr++]; + return new IfcPcurve(expressID, type, BasisSurface, ReferenceCurve); + } + ToTape() { + let args = []; + args.push(this.BasisSurface); + ; + args.push(this.ReferenceCurve); + ; + return args; + } +}; +var IfcPerformanceHistory = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LifeCyclePhase, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.LifeCyclePhase = LifeCyclePhase; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let LifeCyclePhase = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcPerformanceHistory(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LifeCyclePhase, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.LifeCyclePhase); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcPermeableCoveringProperties = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, OperationType, PanelPosition, FrameDepth, FrameThickness, ShapeAspectStyle) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.OperationType = OperationType; + this.PanelPosition = PanelPosition; + this.FrameDepth = FrameDepth; + this.FrameThickness = FrameThickness; + this.ShapeAspectStyle = ShapeAspectStyle; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let OperationType = tape[ptr++]; + let PanelPosition = tape[ptr++]; + let FrameDepth = tape[ptr++]; + let FrameThickness = tape[ptr++]; + let ShapeAspectStyle = tape[ptr++]; + return new IfcPermeableCoveringProperties(expressID, type, GlobalId, OwnerHistory, Name, Description, OperationType, PanelPosition, FrameDepth, FrameThickness, ShapeAspectStyle); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.OperationType); + ; + args.push(this.PanelPosition); + ; + args.push(this.FrameDepth); + ; + args.push(this.FrameThickness); + ; + args.push(this.ShapeAspectStyle); + ; + return args; + } +}; +var IfcPermit = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, PredefinedType, Status, LongDescription) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.PredefinedType = PredefinedType; + this.Status = Status; + this.LongDescription = LongDescription; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let Status = tape[ptr++]; + let LongDescription = tape[ptr++]; + return new IfcPermit(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, PredefinedType, Status, LongDescription); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.PredefinedType); + ; + args.push(this.Status); + ; + args.push(this.LongDescription); + ; + return args; + } +}; +var IfcPerson = class { + constructor(expressID, type, Identification, FamilyName, GivenName, MiddleNames, PrefixTitles, SuffixTitles, Roles, Addresses) { + this.expressID = expressID; + this.type = type; + this.Identification = Identification; + this.FamilyName = FamilyName; + this.GivenName = GivenName; + this.MiddleNames = MiddleNames; + this.PrefixTitles = PrefixTitles; + this.SuffixTitles = SuffixTitles; + this.Roles = Roles; + this.Addresses = Addresses; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Identification = tape[ptr++]; + let FamilyName = tape[ptr++]; + let GivenName = tape[ptr++]; + let MiddleNames = tape[ptr++]; + let PrefixTitles = tape[ptr++]; + let SuffixTitles = tape[ptr++]; + let Roles = tape[ptr++]; + let Addresses = tape[ptr++]; + return new IfcPerson(expressID, type, Identification, FamilyName, GivenName, MiddleNames, PrefixTitles, SuffixTitles, Roles, Addresses); + } + ToTape() { + let args = []; + args.push(this.Identification); + ; + args.push(this.FamilyName); + ; + args.push(this.GivenName); + ; + args.push(this.MiddleNames); + ; + args.push(this.PrefixTitles); + ; + args.push(this.SuffixTitles); + ; + args.push(this.Roles); + ; + args.push(this.Addresses); + ; + return args; + } +}; +var IfcPersonAndOrganization = class { + constructor(expressID, type, ThePerson, TheOrganization, Roles) { + this.expressID = expressID; + this.type = type; + this.ThePerson = ThePerson; + this.TheOrganization = TheOrganization; + this.Roles = Roles; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ThePerson = tape[ptr++]; + let TheOrganization = tape[ptr++]; + let Roles = tape[ptr++]; + return new IfcPersonAndOrganization(expressID, type, ThePerson, TheOrganization, Roles); + } + ToTape() { + let args = []; + args.push(this.ThePerson); + ; + args.push(this.TheOrganization); + ; + args.push(this.Roles); + ; + return args; + } +}; +var IfcPhysicalComplexQuantity = class { + constructor(expressID, type, Name, Description, HasQuantities, Discrimination, Quality, Usage) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.HasQuantities = HasQuantities; + this.Discrimination = Discrimination; + this.Quality = Quality; + this.Usage = Usage; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let HasQuantities = tape[ptr++]; + let Discrimination = tape[ptr++]; + let Quality = tape[ptr++]; + let Usage = tape[ptr++]; + return new IfcPhysicalComplexQuantity(expressID, type, Name, Description, HasQuantities, Discrimination, Quality, Usage); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.HasQuantities); + ; + args.push(this.Discrimination); + ; + args.push(this.Quality); + ; + args.push(this.Usage); + ; + return args; + } +}; +var IfcPhysicalQuantity = class { + constructor(expressID, type, Name, Description) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + return new IfcPhysicalQuantity(expressID, type, Name, Description); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + return args; + } +}; +var IfcPhysicalSimpleQuantity = class { + constructor(expressID, type, Name, Description, Unit) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.Unit = Unit; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Unit = tape[ptr++]; + return new IfcPhysicalSimpleQuantity(expressID, type, Name, Description, Unit); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Unit); + ; + return args; + } +}; +var IfcPile = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType, ConstructionType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + this.ConstructionType = ConstructionType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let ConstructionType = tape[ptr++]; + return new IfcPile(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType, ConstructionType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + args.push(this.ConstructionType); + ; + return args; + } +}; +var IfcPileType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcPileType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcPipeFitting = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcPipeFitting(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcPipeFittingType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcPipeFittingType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcPipeSegment = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcPipeSegment(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcPipeSegmentType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcPipeSegmentType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcPixelTexture = class { + constructor(expressID, type, RepeatS, RepeatT, Mode, TextureTransform, Parameter, Width, Height, ColourComponents, Pixel) { + this.expressID = expressID; + this.type = type; + this.RepeatS = RepeatS; + this.RepeatT = RepeatT; + this.Mode = Mode; + this.TextureTransform = TextureTransform; + this.Parameter = Parameter; + this.Width = Width; + this.Height = Height; + this.ColourComponents = ColourComponents; + this.Pixel = Pixel; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let RepeatS = tape[ptr++]; + let RepeatT = tape[ptr++]; + let Mode = tape[ptr++]; + let TextureTransform = tape[ptr++]; + let Parameter = tape[ptr++]; + let Width = tape[ptr++]; + let Height = tape[ptr++]; + let ColourComponents = tape[ptr++]; + let Pixel = tape[ptr++]; + return new IfcPixelTexture(expressID, type, RepeatS, RepeatT, Mode, TextureTransform, Parameter, Width, Height, ColourComponents, Pixel); + } + ToTape() { + let args = []; + args.push(this.RepeatS); + ; + args.push(this.RepeatT); + ; + args.push(this.Mode); + ; + args.push(this.TextureTransform); + ; + args.push(this.Parameter); + ; + args.push(this.Width); + ; + args.push(this.Height); + ; + args.push(this.ColourComponents); + ; + args.push(this.Pixel); + ; + return args; + } +}; +var IfcPlacement = class { + constructor(expressID, type, Location) { + this.expressID = expressID; + this.type = type; + this.Location = Location; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Location = tape[ptr++]; + return new IfcPlacement(expressID, type, Location); + } + ToTape() { + let args = []; + args.push(this.Location); + ; + return args; + } +}; +var IfcPlanarBox = class { + constructor(expressID, type, SizeInX, SizeInY, Placement) { + this.expressID = expressID; + this.type = type; + this.SizeInX = SizeInX; + this.SizeInY = SizeInY; + this.Placement = Placement; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SizeInX = tape[ptr++]; + let SizeInY = tape[ptr++]; + let Placement = tape[ptr++]; + return new IfcPlanarBox(expressID, type, SizeInX, SizeInY, Placement); + } + ToTape() { + let args = []; + args.push(this.SizeInX); + ; + args.push(this.SizeInY); + ; + args.push(this.Placement); + ; + return args; + } +}; +var IfcPlanarExtent = class { + constructor(expressID, type, SizeInX, SizeInY) { + this.expressID = expressID; + this.type = type; + this.SizeInX = SizeInX; + this.SizeInY = SizeInY; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SizeInX = tape[ptr++]; + let SizeInY = tape[ptr++]; + return new IfcPlanarExtent(expressID, type, SizeInX, SizeInY); + } + ToTape() { + let args = []; + args.push(this.SizeInX); + ; + args.push(this.SizeInY); + ; + return args; + } +}; +var IfcPlane = class { + constructor(expressID, type, Position) { + this.expressID = expressID; + this.type = type; + this.Position = Position; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Position = tape[ptr++]; + return new IfcPlane(expressID, type, Position); + } + ToTape() { + let args = []; + args.push(this.Position); + ; + return args; + } +}; +var IfcPlate = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcPlate(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcPlateStandardCase = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcPlateStandardCase(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcPlateType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcPlateType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcPoint = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcPoint(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcPointOnCurve = class { + constructor(expressID, type, BasisCurve, PointParameter) { + this.expressID = expressID; + this.type = type; + this.BasisCurve = BasisCurve; + this.PointParameter = PointParameter; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let BasisCurve = tape[ptr++]; + let PointParameter = tape[ptr++]; + return new IfcPointOnCurve(expressID, type, BasisCurve, PointParameter); + } + ToTape() { + let args = []; + args.push(this.BasisCurve); + ; + args.push(this.PointParameter); + ; + return args; + } +}; +var IfcPointOnSurface = class { + constructor(expressID, type, BasisSurface, PointParameterU, PointParameterV) { + this.expressID = expressID; + this.type = type; + this.BasisSurface = BasisSurface; + this.PointParameterU = PointParameterU; + this.PointParameterV = PointParameterV; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let BasisSurface = tape[ptr++]; + let PointParameterU = tape[ptr++]; + let PointParameterV = tape[ptr++]; + return new IfcPointOnSurface(expressID, type, BasisSurface, PointParameterU, PointParameterV); + } + ToTape() { + let args = []; + args.push(this.BasisSurface); + ; + args.push(this.PointParameterU); + ; + args.push(this.PointParameterV); + ; + return args; + } +}; +var IfcPolyLoop = class { + constructor(expressID, type, Polygon) { + this.expressID = expressID; + this.type = type; + this.Polygon = Polygon; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Polygon = tape[ptr++]; + return new IfcPolyLoop(expressID, type, Polygon); + } + ToTape() { + let args = []; + args.push(this.Polygon); + ; + return args; + } +}; +var IfcPolygonalBoundedHalfSpace = class { + constructor(expressID, type, BaseSurface, AgreementFlag, Position, PolygonalBoundary) { + this.expressID = expressID; + this.type = type; + this.BaseSurface = BaseSurface; + this.AgreementFlag = AgreementFlag; + this.Position = Position; + this.PolygonalBoundary = PolygonalBoundary; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let BaseSurface = tape[ptr++]; + let AgreementFlag = tape[ptr++]; + let Position = tape[ptr++]; + let PolygonalBoundary = tape[ptr++]; + return new IfcPolygonalBoundedHalfSpace(expressID, type, BaseSurface, AgreementFlag, Position, PolygonalBoundary); + } + ToTape() { + let args = []; + args.push(this.BaseSurface); + ; + args.push(this.AgreementFlag); + ; + args.push(this.Position); + ; + args.push(this.PolygonalBoundary); + ; + return args; + } +}; +var IfcPolygonalFaceSet = class { + constructor(expressID, type, Coordinates, Closed, Faces, PnIndex) { + this.expressID = expressID; + this.type = type; + this.Coordinates = Coordinates; + this.Closed = Closed; + this.Faces = Faces; + this.PnIndex = PnIndex; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Coordinates = tape[ptr++]; + let Closed = tape[ptr++]; + let Faces = tape[ptr++]; + let PnIndex = tape[ptr++]; + return new IfcPolygonalFaceSet(expressID, type, Coordinates, Closed, Faces, PnIndex); + } + ToTape() { + let args = []; + args.push(this.Coordinates); + ; + args.push(this.Closed); + ; + args.push(this.Faces); + ; + args.push(this.PnIndex); + ; + return args; + } +}; +var IfcPolyline = class { + constructor(expressID, type, Points) { + this.expressID = expressID; + this.type = type; + this.Points = Points; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Points = tape[ptr++]; + return new IfcPolyline(expressID, type, Points); + } + ToTape() { + let args = []; + args.push(this.Points); + ; + return args; + } +}; +var IfcPort = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + return new IfcPort(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + return args; + } +}; +var IfcPositioningElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + return new IfcPositioningElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + return args; + } +}; +var IfcPostalAddress = class { + constructor(expressID, type, Purpose, Description, UserDefinedPurpose, InternalLocation, AddressLines, PostalBox, Town, Region, PostalCode, Country) { + this.expressID = expressID; + this.type = type; + this.Purpose = Purpose; + this.Description = Description; + this.UserDefinedPurpose = UserDefinedPurpose; + this.InternalLocation = InternalLocation; + this.AddressLines = AddressLines; + this.PostalBox = PostalBox; + this.Town = Town; + this.Region = Region; + this.PostalCode = PostalCode; + this.Country = Country; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Purpose = tape[ptr++]; + let Description = tape[ptr++]; + let UserDefinedPurpose = tape[ptr++]; + let InternalLocation = tape[ptr++]; + let AddressLines = tape[ptr++]; + let PostalBox = tape[ptr++]; + let Town = tape[ptr++]; + let Region = tape[ptr++]; + let PostalCode = tape[ptr++]; + let Country = tape[ptr++]; + return new IfcPostalAddress(expressID, type, Purpose, Description, UserDefinedPurpose, InternalLocation, AddressLines, PostalBox, Town, Region, PostalCode, Country); + } + ToTape() { + let args = []; + args.push(this.Purpose); + ; + args.push(this.Description); + ; + args.push(this.UserDefinedPurpose); + ; + args.push(this.InternalLocation); + ; + args.push(this.AddressLines); + ; + args.push(this.PostalBox); + ; + args.push(this.Town); + ; + args.push(this.Region); + ; + args.push(this.PostalCode); + ; + args.push(this.Country); + ; + return args; + } +}; +var IfcPreDefinedColour = class { + constructor(expressID, type, Name) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + return new IfcPreDefinedColour(expressID, type, Name); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + return args; + } +}; +var IfcPreDefinedCurveFont = class { + constructor(expressID, type, Name) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + return new IfcPreDefinedCurveFont(expressID, type, Name); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + return args; + } +}; +var IfcPreDefinedItem = class { + constructor(expressID, type, Name) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + return new IfcPreDefinedItem(expressID, type, Name); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + return args; + } +}; +var IfcPreDefinedProperties = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcPreDefinedProperties(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcPreDefinedPropertySet = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + return new IfcPreDefinedPropertySet(expressID, type, GlobalId, OwnerHistory, Name, Description); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + return args; + } +}; +var IfcPreDefinedTextFont = class { + constructor(expressID, type, Name) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + return new IfcPreDefinedTextFont(expressID, type, Name); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + return args; + } +}; +var IfcPresentationItem = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcPresentationItem(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcPresentationLayerAssignment = class { + constructor(expressID, type, Name, Description, AssignedItems, Identifier) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.AssignedItems = AssignedItems; + this.Identifier = Identifier; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let AssignedItems = tape[ptr++]; + let Identifier = tape[ptr++]; + return new IfcPresentationLayerAssignment(expressID, type, Name, Description, AssignedItems, Identifier); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.AssignedItems); + ; + args.push(this.Identifier); + ; + return args; + } +}; +var IfcPresentationLayerWithStyle = class { + constructor(expressID, type, Name, Description, AssignedItems, Identifier, LayerOn, LayerFrozen, LayerBlocked, LayerStyles) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.AssignedItems = AssignedItems; + this.Identifier = Identifier; + this.LayerOn = LayerOn; + this.LayerFrozen = LayerFrozen; + this.LayerBlocked = LayerBlocked; + this.LayerStyles = LayerStyles; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let AssignedItems = tape[ptr++]; + let Identifier = tape[ptr++]; + let LayerOn = tape[ptr++]; + let LayerFrozen = tape[ptr++]; + let LayerBlocked = tape[ptr++]; + let LayerStyles = tape[ptr++]; + return new IfcPresentationLayerWithStyle(expressID, type, Name, Description, AssignedItems, Identifier, LayerOn, LayerFrozen, LayerBlocked, LayerStyles); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.AssignedItems); + ; + args.push(this.Identifier); + ; + args.push(this.LayerOn); + ; + args.push(this.LayerFrozen); + ; + args.push(this.LayerBlocked); + ; + args.push(this.LayerStyles); + ; + return args; + } +}; +var IfcPresentationStyle = class { + constructor(expressID, type, Name) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + return new IfcPresentationStyle(expressID, type, Name); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + return args; + } +}; +var IfcPresentationStyleAssignment = class { + constructor(expressID, type, Styles) { + this.expressID = expressID; + this.type = type; + this.Styles = Styles; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Styles = tape[ptr++]; + return new IfcPresentationStyleAssignment(expressID, type, Styles); + } + ToTape() { + let args = []; + args.push(this.Styles); + ; + return args; + } +}; +var IfcProcedure = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcProcedure(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcProcedureType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ProcessType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.ProcessType = ProcessType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let ProcessType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcProcedureType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ProcessType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.ProcessType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcProcess = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.LongDescription = LongDescription; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + return new IfcProcess(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + return args; + } +}; +var IfcProduct = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + return new IfcProduct(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + return args; + } +}; +var IfcProductDefinitionShape = class { + constructor(expressID, type, Name, Description, Representations) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.Representations = Representations; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Representations = tape[ptr++]; + return new IfcProductDefinitionShape(expressID, type, Name, Description, Representations); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Representations); + ; + return args; + } +}; +var IfcProductRepresentation = class { + constructor(expressID, type, Name, Description, Representations) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.Representations = Representations; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Representations = tape[ptr++]; + return new IfcProductRepresentation(expressID, type, Name, Description, Representations); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Representations); + ; + return args; + } +}; +var IfcProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + return new IfcProfileDef(expressID, type, ProfileType, ProfileName); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + return args; + } +}; +var IfcProfileProperties = class { + constructor(expressID, type, Name, Description, Properties, ProfileDefinition) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.Properties = Properties; + this.ProfileDefinition = ProfileDefinition; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Properties = tape[ptr++]; + let ProfileDefinition = tape[ptr++]; + return new IfcProfileProperties(expressID, type, Name, Description, Properties, ProfileDefinition); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Properties); + ; + args.push(this.ProfileDefinition); + ; + return args; + } +}; +var IfcProject = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, LongName, Phase, RepresentationContexts, UnitsInContext) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.LongName = LongName; + this.Phase = Phase; + this.RepresentationContexts = RepresentationContexts; + this.UnitsInContext = UnitsInContext; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let LongName = tape[ptr++]; + let Phase = tape[ptr++]; + let RepresentationContexts = tape[ptr++]; + let UnitsInContext = tape[ptr++]; + return new IfcProject(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, LongName, Phase, RepresentationContexts, UnitsInContext); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.LongName); + ; + args.push(this.Phase); + ; + args.push(this.RepresentationContexts); + ; + args.push(this.UnitsInContext); + ; + return args; + } +}; +var IfcProjectLibrary = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, LongName, Phase, RepresentationContexts, UnitsInContext) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.LongName = LongName; + this.Phase = Phase; + this.RepresentationContexts = RepresentationContexts; + this.UnitsInContext = UnitsInContext; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let LongName = tape[ptr++]; + let Phase = tape[ptr++]; + let RepresentationContexts = tape[ptr++]; + let UnitsInContext = tape[ptr++]; + return new IfcProjectLibrary(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, LongName, Phase, RepresentationContexts, UnitsInContext); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.LongName); + ; + args.push(this.Phase); + ; + args.push(this.RepresentationContexts); + ; + args.push(this.UnitsInContext); + ; + return args; + } +}; +var IfcProjectOrder = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, PredefinedType, Status, LongDescription) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.PredefinedType = PredefinedType; + this.Status = Status; + this.LongDescription = LongDescription; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let Status = tape[ptr++]; + let LongDescription = tape[ptr++]; + return new IfcProjectOrder(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, PredefinedType, Status, LongDescription); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.PredefinedType); + ; + args.push(this.Status); + ; + args.push(this.LongDescription); + ; + return args; + } +}; +var IfcProjectedCRS = class { + constructor(expressID, type, Name, Description, GeodeticDatum, VerticalDatum, MapProjection, MapZone, MapUnit) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.GeodeticDatum = GeodeticDatum; + this.VerticalDatum = VerticalDatum; + this.MapProjection = MapProjection; + this.MapZone = MapZone; + this.MapUnit = MapUnit; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let GeodeticDatum = tape[ptr++]; + let VerticalDatum = tape[ptr++]; + let MapProjection = tape[ptr++]; + let MapZone = tape[ptr++]; + let MapUnit = tape[ptr++]; + return new IfcProjectedCRS(expressID, type, Name, Description, GeodeticDatum, VerticalDatum, MapProjection, MapZone, MapUnit); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.GeodeticDatum); + ; + args.push(this.VerticalDatum); + ; + args.push(this.MapProjection); + ; + args.push(this.MapZone); + ; + args.push(this.MapUnit); + ; + return args; + } +}; +var IfcProjectionElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcProjectionElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcProperty = class { + constructor(expressID, type, Name, Description) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + return new IfcProperty(expressID, type, Name, Description); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + return args; + } +}; +var IfcPropertyAbstraction = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcPropertyAbstraction(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcPropertyBoundedValue = class { + constructor(expressID, type, Name, Description, UpperBoundValue, LowerBoundValue, Unit, SetPointValue) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.UpperBoundValue = UpperBoundValue; + this.LowerBoundValue = LowerBoundValue; + this.Unit = Unit; + this.SetPointValue = SetPointValue; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let UpperBoundValue = tape[ptr++]; + let LowerBoundValue = tape[ptr++]; + let Unit = tape[ptr++]; + let SetPointValue = tape[ptr++]; + return new IfcPropertyBoundedValue(expressID, type, Name, Description, UpperBoundValue, LowerBoundValue, Unit, SetPointValue); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.UpperBoundValue); + ; + args.push(this.LowerBoundValue); + ; + args.push(this.Unit); + ; + args.push(this.SetPointValue); + ; + return args; + } +}; +var IfcPropertyDefinition = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + return new IfcPropertyDefinition(expressID, type, GlobalId, OwnerHistory, Name, Description); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + return args; + } +}; +var IfcPropertyDependencyRelationship = class { + constructor(expressID, type, Name, Description, DependingProperty, DependantProperty, Expression) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.DependingProperty = DependingProperty; + this.DependantProperty = DependantProperty; + this.Expression = Expression; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let DependingProperty = tape[ptr++]; + let DependantProperty = tape[ptr++]; + let Expression = tape[ptr++]; + return new IfcPropertyDependencyRelationship(expressID, type, Name, Description, DependingProperty, DependantProperty, Expression); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.DependingProperty); + ; + args.push(this.DependantProperty); + ; + args.push(this.Expression); + ; + return args; + } +}; +var IfcPropertyEnumeratedValue = class { + constructor(expressID, type, Name, Description, EnumerationValues, EnumerationReference) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.EnumerationValues = EnumerationValues; + this.EnumerationReference = EnumerationReference; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let EnumerationValues = tape[ptr++]; + let EnumerationReference = tape[ptr++]; + return new IfcPropertyEnumeratedValue(expressID, type, Name, Description, EnumerationValues, EnumerationReference); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.EnumerationValues); + ; + args.push(this.EnumerationReference); + ; + return args; + } +}; +var IfcPropertyEnumeration = class { + constructor(expressID, type, Name, EnumerationValues, Unit) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.EnumerationValues = EnumerationValues; + this.Unit = Unit; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let EnumerationValues = tape[ptr++]; + let Unit = tape[ptr++]; + return new IfcPropertyEnumeration(expressID, type, Name, EnumerationValues, Unit); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.EnumerationValues); + ; + args.push(this.Unit); + ; + return args; + } +}; +var IfcPropertyListValue = class { + constructor(expressID, type, Name, Description, ListValues, Unit) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.ListValues = ListValues; + this.Unit = Unit; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ListValues = tape[ptr++]; + let Unit = tape[ptr++]; + return new IfcPropertyListValue(expressID, type, Name, Description, ListValues, Unit); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ListValues); + ; + args.push(this.Unit); + ; + return args; + } +}; +var IfcPropertyReferenceValue = class { + constructor(expressID, type, Name, Description, UsageName, PropertyReference) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.UsageName = UsageName; + this.PropertyReference = PropertyReference; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let UsageName = tape[ptr++]; + let PropertyReference = tape[ptr++]; + return new IfcPropertyReferenceValue(expressID, type, Name, Description, UsageName, PropertyReference); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.UsageName); + ; + args.push(this.PropertyReference); + ; + return args; + } +}; +var IfcPropertySet = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, HasProperties) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.HasProperties = HasProperties; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let HasProperties = tape[ptr++]; + return new IfcPropertySet(expressID, type, GlobalId, OwnerHistory, Name, Description, HasProperties); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.HasProperties); + ; + return args; + } +}; +var IfcPropertySetDefinition = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + return new IfcPropertySetDefinition(expressID, type, GlobalId, OwnerHistory, Name, Description); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + return args; + } +}; +var IfcPropertySetTemplate = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, TemplateType, ApplicableEntity, HasPropertyTemplates) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.TemplateType = TemplateType; + this.ApplicableEntity = ApplicableEntity; + this.HasPropertyTemplates = HasPropertyTemplates; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let TemplateType = tape[ptr++]; + let ApplicableEntity = tape[ptr++]; + let HasPropertyTemplates = tape[ptr++]; + return new IfcPropertySetTemplate(expressID, type, GlobalId, OwnerHistory, Name, Description, TemplateType, ApplicableEntity, HasPropertyTemplates); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.TemplateType); + ; + args.push(this.ApplicableEntity); + ; + args.push(this.HasPropertyTemplates); + ; + return args; + } +}; +var IfcPropertySingleValue = class { + constructor(expressID, type, Name, Description, NominalValue, Unit) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.NominalValue = NominalValue; + this.Unit = Unit; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let NominalValue = tape[ptr++]; + let Unit = tape[ptr++]; + return new IfcPropertySingleValue(expressID, type, Name, Description, NominalValue, Unit); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.NominalValue); + ; + args.push(this.Unit); + ; + return args; + } +}; +var IfcPropertyTableValue = class { + constructor(expressID, type, Name, Description, DefiningValues, DefinedValues, Expression, DefiningUnit, DefinedUnit, CurveInterpolation) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.DefiningValues = DefiningValues; + this.DefinedValues = DefinedValues; + this.Expression = Expression; + this.DefiningUnit = DefiningUnit; + this.DefinedUnit = DefinedUnit; + this.CurveInterpolation = CurveInterpolation; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let DefiningValues = tape[ptr++]; + let DefinedValues = tape[ptr++]; + let Expression = tape[ptr++]; + let DefiningUnit = tape[ptr++]; + let DefinedUnit = tape[ptr++]; + let CurveInterpolation = tape[ptr++]; + return new IfcPropertyTableValue(expressID, type, Name, Description, DefiningValues, DefinedValues, Expression, DefiningUnit, DefinedUnit, CurveInterpolation); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.DefiningValues); + ; + args.push(this.DefinedValues); + ; + args.push(this.Expression); + ; + args.push(this.DefiningUnit); + ; + args.push(this.DefinedUnit); + ; + args.push(this.CurveInterpolation); + ; + return args; + } +}; +var IfcPropertyTemplate = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + return new IfcPropertyTemplate(expressID, type, GlobalId, OwnerHistory, Name, Description); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + return args; + } +}; +var IfcPropertyTemplateDefinition = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + return new IfcPropertyTemplateDefinition(expressID, type, GlobalId, OwnerHistory, Name, Description); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + return args; + } +}; +var IfcProtectiveDevice = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcProtectiveDevice(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcProtectiveDeviceTrippingUnit = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcProtectiveDeviceTrippingUnit(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcProtectiveDeviceTrippingUnitType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcProtectiveDeviceTrippingUnitType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcProtectiveDeviceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcProtectiveDeviceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcProxy = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, ProxyType, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.ProxyType = ProxyType; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let ProxyType = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcProxy(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, ProxyType, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.ProxyType); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcPump = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcPump(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcPumpType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcPumpType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcQuantityArea = class { + constructor(expressID, type, Name, Description, Unit, AreaValue, Formula) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.Unit = Unit; + this.AreaValue = AreaValue; + this.Formula = Formula; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Unit = tape[ptr++]; + let AreaValue = tape[ptr++]; + let Formula = tape[ptr++]; + return new IfcQuantityArea(expressID, type, Name, Description, Unit, AreaValue, Formula); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Unit); + ; + args.push(this.AreaValue); + ; + args.push(this.Formula); + ; + return args; + } +}; +var IfcQuantityCount = class { + constructor(expressID, type, Name, Description, Unit, CountValue, Formula) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.Unit = Unit; + this.CountValue = CountValue; + this.Formula = Formula; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Unit = tape[ptr++]; + let CountValue = tape[ptr++]; + let Formula = tape[ptr++]; + return new IfcQuantityCount(expressID, type, Name, Description, Unit, CountValue, Formula); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Unit); + ; + args.push(this.CountValue); + ; + args.push(this.Formula); + ; + return args; + } +}; +var IfcQuantityLength = class { + constructor(expressID, type, Name, Description, Unit, LengthValue, Formula) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.Unit = Unit; + this.LengthValue = LengthValue; + this.Formula = Formula; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Unit = tape[ptr++]; + let LengthValue = tape[ptr++]; + let Formula = tape[ptr++]; + return new IfcQuantityLength(expressID, type, Name, Description, Unit, LengthValue, Formula); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Unit); + ; + args.push(this.LengthValue); + ; + args.push(this.Formula); + ; + return args; + } +}; +var IfcQuantitySet = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + return new IfcQuantitySet(expressID, type, GlobalId, OwnerHistory, Name, Description); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + return args; + } +}; +var IfcQuantityTime = class { + constructor(expressID, type, Name, Description, Unit, TimeValue, Formula) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.Unit = Unit; + this.TimeValue = TimeValue; + this.Formula = Formula; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Unit = tape[ptr++]; + let TimeValue = tape[ptr++]; + let Formula = tape[ptr++]; + return new IfcQuantityTime(expressID, type, Name, Description, Unit, TimeValue, Formula); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Unit); + ; + args.push(this.TimeValue); + ; + args.push(this.Formula); + ; + return args; + } +}; +var IfcQuantityVolume = class { + constructor(expressID, type, Name, Description, Unit, VolumeValue, Formula) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.Unit = Unit; + this.VolumeValue = VolumeValue; + this.Formula = Formula; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Unit = tape[ptr++]; + let VolumeValue = tape[ptr++]; + let Formula = tape[ptr++]; + return new IfcQuantityVolume(expressID, type, Name, Description, Unit, VolumeValue, Formula); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Unit); + ; + args.push(this.VolumeValue); + ; + args.push(this.Formula); + ; + return args; + } +}; +var IfcQuantityWeight = class { + constructor(expressID, type, Name, Description, Unit, WeightValue, Formula) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.Unit = Unit; + this.WeightValue = WeightValue; + this.Formula = Formula; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Unit = tape[ptr++]; + let WeightValue = tape[ptr++]; + let Formula = tape[ptr++]; + return new IfcQuantityWeight(expressID, type, Name, Description, Unit, WeightValue, Formula); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Unit); + ; + args.push(this.WeightValue); + ; + args.push(this.Formula); + ; + return args; + } +}; +var IfcRailing = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcRailing(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcRailingType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcRailingType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcRamp = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcRamp(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcRampFlight = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcRampFlight(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcRampFlightType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcRampFlightType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcRampType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcRampType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcRationalBSplineCurveWithKnots = class { + constructor(expressID, type, Degree, ControlPointsList, CurveForm, ClosedCurve, SelfIntersect, KnotMultiplicities, Knots, KnotSpec, WeightsData) { + this.expressID = expressID; + this.type = type; + this.Degree = Degree; + this.ControlPointsList = ControlPointsList; + this.CurveForm = CurveForm; + this.ClosedCurve = ClosedCurve; + this.SelfIntersect = SelfIntersect; + this.KnotMultiplicities = KnotMultiplicities; + this.Knots = Knots; + this.KnotSpec = KnotSpec; + this.WeightsData = WeightsData; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Degree = tape[ptr++]; + let ControlPointsList = tape[ptr++]; + let CurveForm = tape[ptr++]; + let ClosedCurve = tape[ptr++]; + let SelfIntersect = tape[ptr++]; + let KnotMultiplicities = tape[ptr++]; + let Knots = tape[ptr++]; + let KnotSpec = tape[ptr++]; + let WeightsData = tape[ptr++]; + return new IfcRationalBSplineCurveWithKnots(expressID, type, Degree, ControlPointsList, CurveForm, ClosedCurve, SelfIntersect, KnotMultiplicities, Knots, KnotSpec, WeightsData); + } + ToTape() { + let args = []; + args.push(this.Degree); + ; + args.push(this.ControlPointsList); + ; + args.push(this.CurveForm); + ; + args.push(this.ClosedCurve); + ; + args.push(this.SelfIntersect); + ; + args.push(this.KnotMultiplicities); + ; + args.push(this.Knots); + ; + args.push(this.KnotSpec); + ; + args.push(this.WeightsData); + ; + return args; + } +}; +var IfcRationalBSplineSurfaceWithKnots = class { + constructor(expressID, type, UDegree, VDegree, ControlPointsList, SurfaceForm, UClosed, VClosed, SelfIntersect, UMultiplicities, VMultiplicities, UKnots, VKnots, KnotSpec, WeightsData) { + this.expressID = expressID; + this.type = type; + this.UDegree = UDegree; + this.VDegree = VDegree; + this.ControlPointsList = ControlPointsList; + this.SurfaceForm = SurfaceForm; + this.UClosed = UClosed; + this.VClosed = VClosed; + this.SelfIntersect = SelfIntersect; + this.UMultiplicities = UMultiplicities; + this.VMultiplicities = VMultiplicities; + this.UKnots = UKnots; + this.VKnots = VKnots; + this.KnotSpec = KnotSpec; + this.WeightsData = WeightsData; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let UDegree = tape[ptr++]; + let VDegree = tape[ptr++]; + let ControlPointsList = tape[ptr++]; + let SurfaceForm = tape[ptr++]; + let UClosed = tape[ptr++]; + let VClosed = tape[ptr++]; + let SelfIntersect = tape[ptr++]; + let UMultiplicities = tape[ptr++]; + let VMultiplicities = tape[ptr++]; + let UKnots = tape[ptr++]; + let VKnots = tape[ptr++]; + let KnotSpec = tape[ptr++]; + let WeightsData = tape[ptr++]; + return new IfcRationalBSplineSurfaceWithKnots(expressID, type, UDegree, VDegree, ControlPointsList, SurfaceForm, UClosed, VClosed, SelfIntersect, UMultiplicities, VMultiplicities, UKnots, VKnots, KnotSpec, WeightsData); + } + ToTape() { + let args = []; + args.push(this.UDegree); + ; + args.push(this.VDegree); + ; + args.push(this.ControlPointsList); + ; + args.push(this.SurfaceForm); + ; + args.push(this.UClosed); + ; + args.push(this.VClosed); + ; + args.push(this.SelfIntersect); + ; + args.push(this.UMultiplicities); + ; + args.push(this.VMultiplicities); + ; + args.push(this.UKnots); + ; + args.push(this.VKnots); + ; + args.push(this.KnotSpec); + ; + args.push(this.WeightsData); + ; + return args; + } +}; +var IfcRectangleHollowProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, Position, XDim, YDim, WallThickness, InnerFilletRadius, OuterFilletRadius) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.Position = Position; + this.XDim = XDim; + this.YDim = YDim; + this.WallThickness = WallThickness; + this.InnerFilletRadius = InnerFilletRadius; + this.OuterFilletRadius = OuterFilletRadius; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let Position = tape[ptr++]; + let XDim = tape[ptr++]; + let YDim = tape[ptr++]; + let WallThickness = tape[ptr++]; + let InnerFilletRadius = tape[ptr++]; + let OuterFilletRadius = tape[ptr++]; + return new IfcRectangleHollowProfileDef(expressID, type, ProfileType, ProfileName, Position, XDim, YDim, WallThickness, InnerFilletRadius, OuterFilletRadius); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.Position); + ; + args.push(this.XDim); + ; + args.push(this.YDim); + ; + args.push(this.WallThickness); + ; + args.push(this.InnerFilletRadius); + ; + args.push(this.OuterFilletRadius); + ; + return args; + } +}; +var IfcRectangleProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, Position, XDim, YDim) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.Position = Position; + this.XDim = XDim; + this.YDim = YDim; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let Position = tape[ptr++]; + let XDim = tape[ptr++]; + let YDim = tape[ptr++]; + return new IfcRectangleProfileDef(expressID, type, ProfileType, ProfileName, Position, XDim, YDim); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.Position); + ; + args.push(this.XDim); + ; + args.push(this.YDim); + ; + return args; + } +}; +var IfcRectangularPyramid = class { + constructor(expressID, type, Position, XLength, YLength, Height) { + this.expressID = expressID; + this.type = type; + this.Position = Position; + this.XLength = XLength; + this.YLength = YLength; + this.Height = Height; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Position = tape[ptr++]; + let XLength = tape[ptr++]; + let YLength = tape[ptr++]; + let Height = tape[ptr++]; + return new IfcRectangularPyramid(expressID, type, Position, XLength, YLength, Height); + } + ToTape() { + let args = []; + args.push(this.Position); + ; + args.push(this.XLength); + ; + args.push(this.YLength); + ; + args.push(this.Height); + ; + return args; + } +}; +var IfcRectangularTrimmedSurface = class { + constructor(expressID, type, BasisSurface, U1, V1, U2, V2, Usense, Vsense) { + this.expressID = expressID; + this.type = type; + this.BasisSurface = BasisSurface; + this.U1 = U1; + this.V1 = V1; + this.U2 = U2; + this.V2 = V2; + this.Usense = Usense; + this.Vsense = Vsense; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let BasisSurface = tape[ptr++]; + let U1 = tape[ptr++]; + let V1 = tape[ptr++]; + let U2 = tape[ptr++]; + let V2 = tape[ptr++]; + let Usense = tape[ptr++]; + let Vsense = tape[ptr++]; + return new IfcRectangularTrimmedSurface(expressID, type, BasisSurface, U1, V1, U2, V2, Usense, Vsense); + } + ToTape() { + let args = []; + args.push(this.BasisSurface); + ; + args.push(this.U1); + ; + args.push(this.V1); + ; + args.push(this.U2); + ; + args.push(this.V2); + ; + args.push(this.Usense); + ; + args.push(this.Vsense); + ; + return args; + } +}; +var IfcRecurrencePattern = class { + constructor(expressID, type, RecurrenceType, DayComponent, WeekdayComponent, MonthComponent, Position, Interval, Occurrences, TimePeriods) { + this.expressID = expressID; + this.type = type; + this.RecurrenceType = RecurrenceType; + this.DayComponent = DayComponent; + this.WeekdayComponent = WeekdayComponent; + this.MonthComponent = MonthComponent; + this.Position = Position; + this.Interval = Interval; + this.Occurrences = Occurrences; + this.TimePeriods = TimePeriods; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let RecurrenceType = tape[ptr++]; + let DayComponent = tape[ptr++]; + let WeekdayComponent = tape[ptr++]; + let MonthComponent = tape[ptr++]; + let Position = tape[ptr++]; + let Interval = tape[ptr++]; + let Occurrences = tape[ptr++]; + let TimePeriods = tape[ptr++]; + return new IfcRecurrencePattern(expressID, type, RecurrenceType, DayComponent, WeekdayComponent, MonthComponent, Position, Interval, Occurrences, TimePeriods); + } + ToTape() { + let args = []; + args.push(this.RecurrenceType); + ; + args.push(this.DayComponent); + ; + args.push(this.WeekdayComponent); + ; + args.push(this.MonthComponent); + ; + args.push(this.Position); + ; + args.push(this.Interval); + ; + args.push(this.Occurrences); + ; + args.push(this.TimePeriods); + ; + return args; + } +}; +var IfcReference = class { + constructor(expressID, type, TypeIdentifier, AttributeIdentifier, InstanceName, ListPositions, InnerReference) { + this.expressID = expressID; + this.type = type; + this.TypeIdentifier = TypeIdentifier; + this.AttributeIdentifier = AttributeIdentifier; + this.InstanceName = InstanceName; + this.ListPositions = ListPositions; + this.InnerReference = InnerReference; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let TypeIdentifier = tape[ptr++]; + let AttributeIdentifier = tape[ptr++]; + let InstanceName = tape[ptr++]; + let ListPositions = tape[ptr++]; + let InnerReference = tape[ptr++]; + return new IfcReference(expressID, type, TypeIdentifier, AttributeIdentifier, InstanceName, ListPositions, InnerReference); + } + ToTape() { + let args = []; + args.push(this.TypeIdentifier); + ; + args.push(this.AttributeIdentifier); + ; + args.push(this.InstanceName); + ; + args.push(this.ListPositions); + ; + args.push(this.InnerReference); + ; + return args; + } +}; +var IfcReferent = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, PredefinedType, RestartDistance) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.PredefinedType = PredefinedType; + this.RestartDistance = RestartDistance; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let RestartDistance = tape[ptr++]; + return new IfcReferent(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, PredefinedType, RestartDistance); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.PredefinedType); + ; + args.push(this.RestartDistance); + ; + return args; + } +}; +var IfcRegularTimeSeries = class { + constructor(expressID, type, Name, Description, StartTime, EndTime, TimeSeriesDataType, DataOrigin, UserDefinedDataOrigin, Unit, TimeStep, Values) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.StartTime = StartTime; + this.EndTime = EndTime; + this.TimeSeriesDataType = TimeSeriesDataType; + this.DataOrigin = DataOrigin; + this.UserDefinedDataOrigin = UserDefinedDataOrigin; + this.Unit = Unit; + this.TimeStep = TimeStep; + this.Values = Values; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let StartTime = tape[ptr++]; + let EndTime = tape[ptr++]; + let TimeSeriesDataType = tape[ptr++]; + let DataOrigin = tape[ptr++]; + let UserDefinedDataOrigin = tape[ptr++]; + let Unit = tape[ptr++]; + let TimeStep = tape[ptr++]; + let Values = tape[ptr++]; + return new IfcRegularTimeSeries(expressID, type, Name, Description, StartTime, EndTime, TimeSeriesDataType, DataOrigin, UserDefinedDataOrigin, Unit, TimeStep, Values); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.StartTime); + ; + args.push(this.EndTime); + ; + args.push(this.TimeSeriesDataType); + ; + args.push(this.DataOrigin); + ; + args.push(this.UserDefinedDataOrigin); + ; + args.push(this.Unit); + ; + args.push(this.TimeStep); + ; + args.push(this.Values); + ; + return args; + } +}; +var IfcReinforcementBarProperties = class { + constructor(expressID, type, TotalCrossSectionArea, SteelGrade, BarSurface, EffectiveDepth, NominalBarDiameter, BarCount) { + this.expressID = expressID; + this.type = type; + this.TotalCrossSectionArea = TotalCrossSectionArea; + this.SteelGrade = SteelGrade; + this.BarSurface = BarSurface; + this.EffectiveDepth = EffectiveDepth; + this.NominalBarDiameter = NominalBarDiameter; + this.BarCount = BarCount; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let TotalCrossSectionArea = tape[ptr++]; + let SteelGrade = tape[ptr++]; + let BarSurface = tape[ptr++]; + let EffectiveDepth = tape[ptr++]; + let NominalBarDiameter = tape[ptr++]; + let BarCount = tape[ptr++]; + return new IfcReinforcementBarProperties(expressID, type, TotalCrossSectionArea, SteelGrade, BarSurface, EffectiveDepth, NominalBarDiameter, BarCount); + } + ToTape() { + let args = []; + args.push(this.TotalCrossSectionArea); + ; + args.push(this.SteelGrade); + ; + args.push(this.BarSurface); + ; + args.push(this.EffectiveDepth); + ; + args.push(this.NominalBarDiameter); + ; + args.push(this.BarCount); + ; + return args; + } +}; +var IfcReinforcementDefinitionProperties = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, DefinitionType, ReinforcementSectionDefinitions) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.DefinitionType = DefinitionType; + this.ReinforcementSectionDefinitions = ReinforcementSectionDefinitions; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let DefinitionType = tape[ptr++]; + let ReinforcementSectionDefinitions = tape[ptr++]; + return new IfcReinforcementDefinitionProperties(expressID, type, GlobalId, OwnerHistory, Name, Description, DefinitionType, ReinforcementSectionDefinitions); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.DefinitionType); + ; + args.push(this.ReinforcementSectionDefinitions); + ; + return args; + } +}; +var IfcReinforcingBar = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, SteelGrade, NominalDiameter, CrossSectionArea, BarLength, PredefinedType, BarSurface) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.SteelGrade = SteelGrade; + this.NominalDiameter = NominalDiameter; + this.CrossSectionArea = CrossSectionArea; + this.BarLength = BarLength; + this.PredefinedType = PredefinedType; + this.BarSurface = BarSurface; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let SteelGrade = tape[ptr++]; + let NominalDiameter = tape[ptr++]; + let CrossSectionArea = tape[ptr++]; + let BarLength = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let BarSurface = tape[ptr++]; + return new IfcReinforcingBar(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, SteelGrade, NominalDiameter, CrossSectionArea, BarLength, PredefinedType, BarSurface); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.SteelGrade); + ; + args.push(this.NominalDiameter); + ; + args.push(this.CrossSectionArea); + ; + args.push(this.BarLength); + ; + args.push(this.PredefinedType); + ; + args.push(this.BarSurface); + ; + return args; + } +}; +var IfcReinforcingBarType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType, NominalDiameter, CrossSectionArea, BarLength, BarSurface, BendingShapeCode, BendingParameters) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + this.NominalDiameter = NominalDiameter; + this.CrossSectionArea = CrossSectionArea; + this.BarLength = BarLength; + this.BarSurface = BarSurface; + this.BendingShapeCode = BendingShapeCode; + this.BendingParameters = BendingParameters; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let NominalDiameter = tape[ptr++]; + let CrossSectionArea = tape[ptr++]; + let BarLength = tape[ptr++]; + let BarSurface = tape[ptr++]; + let BendingShapeCode = tape[ptr++]; + let BendingParameters = tape[ptr++]; + return new IfcReinforcingBarType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType, NominalDiameter, CrossSectionArea, BarLength, BarSurface, BendingShapeCode, BendingParameters); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + args.push(this.NominalDiameter); + ; + args.push(this.CrossSectionArea); + ; + args.push(this.BarLength); + ; + args.push(this.BarSurface); + ; + args.push(this.BendingShapeCode); + ; + args.push(this.BendingParameters); + ; + return args; + } +}; +var IfcReinforcingElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, SteelGrade) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.SteelGrade = SteelGrade; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let SteelGrade = tape[ptr++]; + return new IfcReinforcingElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, SteelGrade); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.SteelGrade); + ; + return args; + } +}; +var IfcReinforcingElementType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcReinforcingElementType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcReinforcingMesh = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, SteelGrade, MeshLength, MeshWidth, LongitudinalBarNominalDiameter, TransverseBarNominalDiameter, LongitudinalBarCrossSectionArea, TransverseBarCrossSectionArea, LongitudinalBarSpacing, TransverseBarSpacing, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.SteelGrade = SteelGrade; + this.MeshLength = MeshLength; + this.MeshWidth = MeshWidth; + this.LongitudinalBarNominalDiameter = LongitudinalBarNominalDiameter; + this.TransverseBarNominalDiameter = TransverseBarNominalDiameter; + this.LongitudinalBarCrossSectionArea = LongitudinalBarCrossSectionArea; + this.TransverseBarCrossSectionArea = TransverseBarCrossSectionArea; + this.LongitudinalBarSpacing = LongitudinalBarSpacing; + this.TransverseBarSpacing = TransverseBarSpacing; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let SteelGrade = tape[ptr++]; + let MeshLength = tape[ptr++]; + let MeshWidth = tape[ptr++]; + let LongitudinalBarNominalDiameter = tape[ptr++]; + let TransverseBarNominalDiameter = tape[ptr++]; + let LongitudinalBarCrossSectionArea = tape[ptr++]; + let TransverseBarCrossSectionArea = tape[ptr++]; + let LongitudinalBarSpacing = tape[ptr++]; + let TransverseBarSpacing = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcReinforcingMesh(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, SteelGrade, MeshLength, MeshWidth, LongitudinalBarNominalDiameter, TransverseBarNominalDiameter, LongitudinalBarCrossSectionArea, TransverseBarCrossSectionArea, LongitudinalBarSpacing, TransverseBarSpacing, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.SteelGrade); + ; + args.push(this.MeshLength); + ; + args.push(this.MeshWidth); + ; + args.push(this.LongitudinalBarNominalDiameter); + ; + args.push(this.TransverseBarNominalDiameter); + ; + args.push(this.LongitudinalBarCrossSectionArea); + ; + args.push(this.TransverseBarCrossSectionArea); + ; + args.push(this.LongitudinalBarSpacing); + ; + args.push(this.TransverseBarSpacing); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcReinforcingMeshType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType, MeshLength, MeshWidth, LongitudinalBarNominalDiameter, TransverseBarNominalDiameter, LongitudinalBarCrossSectionArea, TransverseBarCrossSectionArea, LongitudinalBarSpacing, TransverseBarSpacing, BendingShapeCode, BendingParameters) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + this.MeshLength = MeshLength; + this.MeshWidth = MeshWidth; + this.LongitudinalBarNominalDiameter = LongitudinalBarNominalDiameter; + this.TransverseBarNominalDiameter = TransverseBarNominalDiameter; + this.LongitudinalBarCrossSectionArea = LongitudinalBarCrossSectionArea; + this.TransverseBarCrossSectionArea = TransverseBarCrossSectionArea; + this.LongitudinalBarSpacing = LongitudinalBarSpacing; + this.TransverseBarSpacing = TransverseBarSpacing; + this.BendingShapeCode = BendingShapeCode; + this.BendingParameters = BendingParameters; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let MeshLength = tape[ptr++]; + let MeshWidth = tape[ptr++]; + let LongitudinalBarNominalDiameter = tape[ptr++]; + let TransverseBarNominalDiameter = tape[ptr++]; + let LongitudinalBarCrossSectionArea = tape[ptr++]; + let TransverseBarCrossSectionArea = tape[ptr++]; + let LongitudinalBarSpacing = tape[ptr++]; + let TransverseBarSpacing = tape[ptr++]; + let BendingShapeCode = tape[ptr++]; + let BendingParameters = tape[ptr++]; + return new IfcReinforcingMeshType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType, MeshLength, MeshWidth, LongitudinalBarNominalDiameter, TransverseBarNominalDiameter, LongitudinalBarCrossSectionArea, TransverseBarCrossSectionArea, LongitudinalBarSpacing, TransverseBarSpacing, BendingShapeCode, BendingParameters); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + args.push(this.MeshLength); + ; + args.push(this.MeshWidth); + ; + args.push(this.LongitudinalBarNominalDiameter); + ; + args.push(this.TransverseBarNominalDiameter); + ; + args.push(this.LongitudinalBarCrossSectionArea); + ; + args.push(this.TransverseBarCrossSectionArea); + ; + args.push(this.LongitudinalBarSpacing); + ; + args.push(this.TransverseBarSpacing); + ; + args.push(this.BendingShapeCode); + ; + args.push(this.BendingParameters); + ; + return args; + } +}; +var IfcRelAggregates = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingObject, RelatedObjects) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingObject = RelatingObject; + this.RelatedObjects = RelatedObjects; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingObject = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + return new IfcRelAggregates(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingObject, RelatedObjects); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingObject); + ; + args.push(this.RelatedObjects); + ; + return args; + } +}; +var IfcRelAssigns = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatedObjectsType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedObjects = RelatedObjects; + this.RelatedObjectsType = RelatedObjectsType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + let RelatedObjectsType = tape[ptr++]; + return new IfcRelAssigns(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatedObjectsType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedObjects); + ; + args.push(this.RelatedObjectsType); + ; + return args; + } +}; +var IfcRelAssignsToActor = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatedObjectsType, RelatingActor, ActingRole) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedObjects = RelatedObjects; + this.RelatedObjectsType = RelatedObjectsType; + this.RelatingActor = RelatingActor; + this.ActingRole = ActingRole; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + let RelatedObjectsType = tape[ptr++]; + let RelatingActor = tape[ptr++]; + let ActingRole = tape[ptr++]; + return new IfcRelAssignsToActor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatedObjectsType, RelatingActor, ActingRole); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedObjects); + ; + args.push(this.RelatedObjectsType); + ; + args.push(this.RelatingActor); + ; + args.push(this.ActingRole); + ; + return args; + } +}; +var IfcRelAssignsToControl = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatedObjectsType, RelatingControl) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedObjects = RelatedObjects; + this.RelatedObjectsType = RelatedObjectsType; + this.RelatingControl = RelatingControl; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + let RelatedObjectsType = tape[ptr++]; + let RelatingControl = tape[ptr++]; + return new IfcRelAssignsToControl(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatedObjectsType, RelatingControl); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedObjects); + ; + args.push(this.RelatedObjectsType); + ; + args.push(this.RelatingControl); + ; + return args; + } +}; +var IfcRelAssignsToGroup = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatedObjectsType, RelatingGroup) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedObjects = RelatedObjects; + this.RelatedObjectsType = RelatedObjectsType; + this.RelatingGroup = RelatingGroup; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + let RelatedObjectsType = tape[ptr++]; + let RelatingGroup = tape[ptr++]; + return new IfcRelAssignsToGroup(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatedObjectsType, RelatingGroup); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedObjects); + ; + args.push(this.RelatedObjectsType); + ; + args.push(this.RelatingGroup); + ; + return args; + } +}; +var IfcRelAssignsToGroupByFactor = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatedObjectsType, RelatingGroup, Factor) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedObjects = RelatedObjects; + this.RelatedObjectsType = RelatedObjectsType; + this.RelatingGroup = RelatingGroup; + this.Factor = Factor; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + let RelatedObjectsType = tape[ptr++]; + let RelatingGroup = tape[ptr++]; + let Factor = tape[ptr++]; + return new IfcRelAssignsToGroupByFactor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatedObjectsType, RelatingGroup, Factor); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedObjects); + ; + args.push(this.RelatedObjectsType); + ; + args.push(this.RelatingGroup); + ; + args.push(this.Factor); + ; + return args; + } +}; +var IfcRelAssignsToProcess = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatedObjectsType, RelatingProcess, QuantityInProcess) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedObjects = RelatedObjects; + this.RelatedObjectsType = RelatedObjectsType; + this.RelatingProcess = RelatingProcess; + this.QuantityInProcess = QuantityInProcess; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + let RelatedObjectsType = tape[ptr++]; + let RelatingProcess = tape[ptr++]; + let QuantityInProcess = tape[ptr++]; + return new IfcRelAssignsToProcess(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatedObjectsType, RelatingProcess, QuantityInProcess); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedObjects); + ; + args.push(this.RelatedObjectsType); + ; + args.push(this.RelatingProcess); + ; + args.push(this.QuantityInProcess); + ; + return args; + } +}; +var IfcRelAssignsToProduct = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatedObjectsType, RelatingProduct) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedObjects = RelatedObjects; + this.RelatedObjectsType = RelatedObjectsType; + this.RelatingProduct = RelatingProduct; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + let RelatedObjectsType = tape[ptr++]; + let RelatingProduct = tape[ptr++]; + return new IfcRelAssignsToProduct(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatedObjectsType, RelatingProduct); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedObjects); + ; + args.push(this.RelatedObjectsType); + ; + args.push(this.RelatingProduct); + ; + return args; + } +}; +var IfcRelAssignsToResource = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatedObjectsType, RelatingResource) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedObjects = RelatedObjects; + this.RelatedObjectsType = RelatedObjectsType; + this.RelatingResource = RelatingResource; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + let RelatedObjectsType = tape[ptr++]; + let RelatingResource = tape[ptr++]; + return new IfcRelAssignsToResource(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatedObjectsType, RelatingResource); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedObjects); + ; + args.push(this.RelatedObjectsType); + ; + args.push(this.RelatingResource); + ; + return args; + } +}; +var IfcRelAssociates = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedObjects = RelatedObjects; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + return new IfcRelAssociates(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedObjects); + ; + return args; + } +}; +var IfcRelAssociatesApproval = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatingApproval) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedObjects = RelatedObjects; + this.RelatingApproval = RelatingApproval; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + let RelatingApproval = tape[ptr++]; + return new IfcRelAssociatesApproval(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatingApproval); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedObjects); + ; + args.push(this.RelatingApproval); + ; + return args; + } +}; +var IfcRelAssociatesClassification = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatingClassification) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedObjects = RelatedObjects; + this.RelatingClassification = RelatingClassification; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + let RelatingClassification = tape[ptr++]; + return new IfcRelAssociatesClassification(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatingClassification); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedObjects); + ; + args.push(this.RelatingClassification); + ; + return args; + } +}; +var IfcRelAssociatesConstraint = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, Intent, RelatingConstraint) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedObjects = RelatedObjects; + this.Intent = Intent; + this.RelatingConstraint = RelatingConstraint; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + let Intent = tape[ptr++]; + let RelatingConstraint = tape[ptr++]; + return new IfcRelAssociatesConstraint(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, Intent, RelatingConstraint); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedObjects); + ; + args.push(this.Intent); + ; + args.push(this.RelatingConstraint); + ; + return args; + } +}; +var IfcRelAssociatesDocument = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatingDocument) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedObjects = RelatedObjects; + this.RelatingDocument = RelatingDocument; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + let RelatingDocument = tape[ptr++]; + return new IfcRelAssociatesDocument(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatingDocument); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedObjects); + ; + args.push(this.RelatingDocument); + ; + return args; + } +}; +var IfcRelAssociatesLibrary = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatingLibrary) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedObjects = RelatedObjects; + this.RelatingLibrary = RelatingLibrary; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + let RelatingLibrary = tape[ptr++]; + return new IfcRelAssociatesLibrary(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatingLibrary); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedObjects); + ; + args.push(this.RelatingLibrary); + ; + return args; + } +}; +var IfcRelAssociatesMaterial = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatingMaterial) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedObjects = RelatedObjects; + this.RelatingMaterial = RelatingMaterial; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + let RelatingMaterial = tape[ptr++]; + return new IfcRelAssociatesMaterial(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatingMaterial); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedObjects); + ; + args.push(this.RelatingMaterial); + ; + return args; + } +}; +var IfcRelConnects = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + return new IfcRelConnects(expressID, type, GlobalId, OwnerHistory, Name, Description); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + return args; + } +}; +var IfcRelConnectsElements = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ConnectionGeometry, RelatingElement, RelatedElement) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ConnectionGeometry = ConnectionGeometry; + this.RelatingElement = RelatingElement; + this.RelatedElement = RelatedElement; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ConnectionGeometry = tape[ptr++]; + let RelatingElement = tape[ptr++]; + let RelatedElement = tape[ptr++]; + return new IfcRelConnectsElements(expressID, type, GlobalId, OwnerHistory, Name, Description, ConnectionGeometry, RelatingElement, RelatedElement); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ConnectionGeometry); + ; + args.push(this.RelatingElement); + ; + args.push(this.RelatedElement); + ; + return args; + } +}; +var IfcRelConnectsPathElements = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ConnectionGeometry, RelatingElement, RelatedElement, RelatingPriorities, RelatedPriorities, RelatedConnectionType, RelatingConnectionType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ConnectionGeometry = ConnectionGeometry; + this.RelatingElement = RelatingElement; + this.RelatedElement = RelatedElement; + this.RelatingPriorities = RelatingPriorities; + this.RelatedPriorities = RelatedPriorities; + this.RelatedConnectionType = RelatedConnectionType; + this.RelatingConnectionType = RelatingConnectionType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ConnectionGeometry = tape[ptr++]; + let RelatingElement = tape[ptr++]; + let RelatedElement = tape[ptr++]; + let RelatingPriorities = tape[ptr++]; + let RelatedPriorities = tape[ptr++]; + let RelatedConnectionType = tape[ptr++]; + let RelatingConnectionType = tape[ptr++]; + return new IfcRelConnectsPathElements(expressID, type, GlobalId, OwnerHistory, Name, Description, ConnectionGeometry, RelatingElement, RelatedElement, RelatingPriorities, RelatedPriorities, RelatedConnectionType, RelatingConnectionType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ConnectionGeometry); + ; + args.push(this.RelatingElement); + ; + args.push(this.RelatedElement); + ; + args.push(this.RelatingPriorities); + ; + args.push(this.RelatedPriorities); + ; + args.push(this.RelatedConnectionType); + ; + args.push(this.RelatingConnectionType); + ; + return args; + } +}; +var IfcRelConnectsPortToElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingPort, RelatedElement) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingPort = RelatingPort; + this.RelatedElement = RelatedElement; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingPort = tape[ptr++]; + let RelatedElement = tape[ptr++]; + return new IfcRelConnectsPortToElement(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingPort, RelatedElement); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingPort); + ; + args.push(this.RelatedElement); + ; + return args; + } +}; +var IfcRelConnectsPorts = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingPort, RelatedPort, RealizingElement) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingPort = RelatingPort; + this.RelatedPort = RelatedPort; + this.RealizingElement = RealizingElement; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingPort = tape[ptr++]; + let RelatedPort = tape[ptr++]; + let RealizingElement = tape[ptr++]; + return new IfcRelConnectsPorts(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingPort, RelatedPort, RealizingElement); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingPort); + ; + args.push(this.RelatedPort); + ; + args.push(this.RealizingElement); + ; + return args; + } +}; +var IfcRelConnectsStructuralActivity = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingElement, RelatedStructuralActivity) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingElement = RelatingElement; + this.RelatedStructuralActivity = RelatedStructuralActivity; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingElement = tape[ptr++]; + let RelatedStructuralActivity = tape[ptr++]; + return new IfcRelConnectsStructuralActivity(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingElement, RelatedStructuralActivity); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingElement); + ; + args.push(this.RelatedStructuralActivity); + ; + return args; + } +}; +var IfcRelConnectsStructuralMember = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingStructuralMember, RelatedStructuralConnection, AppliedCondition, AdditionalConditions, SupportedLength, ConditionCoordinateSystem) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingStructuralMember = RelatingStructuralMember; + this.RelatedStructuralConnection = RelatedStructuralConnection; + this.AppliedCondition = AppliedCondition; + this.AdditionalConditions = AdditionalConditions; + this.SupportedLength = SupportedLength; + this.ConditionCoordinateSystem = ConditionCoordinateSystem; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingStructuralMember = tape[ptr++]; + let RelatedStructuralConnection = tape[ptr++]; + let AppliedCondition = tape[ptr++]; + let AdditionalConditions = tape[ptr++]; + let SupportedLength = tape[ptr++]; + let ConditionCoordinateSystem = tape[ptr++]; + return new IfcRelConnectsStructuralMember(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingStructuralMember, RelatedStructuralConnection, AppliedCondition, AdditionalConditions, SupportedLength, ConditionCoordinateSystem); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingStructuralMember); + ; + args.push(this.RelatedStructuralConnection); + ; + args.push(this.AppliedCondition); + ; + args.push(this.AdditionalConditions); + ; + args.push(this.SupportedLength); + ; + args.push(this.ConditionCoordinateSystem); + ; + return args; + } +}; +var IfcRelConnectsWithEccentricity = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingStructuralMember, RelatedStructuralConnection, AppliedCondition, AdditionalConditions, SupportedLength, ConditionCoordinateSystem, ConnectionConstraint) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingStructuralMember = RelatingStructuralMember; + this.RelatedStructuralConnection = RelatedStructuralConnection; + this.AppliedCondition = AppliedCondition; + this.AdditionalConditions = AdditionalConditions; + this.SupportedLength = SupportedLength; + this.ConditionCoordinateSystem = ConditionCoordinateSystem; + this.ConnectionConstraint = ConnectionConstraint; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingStructuralMember = tape[ptr++]; + let RelatedStructuralConnection = tape[ptr++]; + let AppliedCondition = tape[ptr++]; + let AdditionalConditions = tape[ptr++]; + let SupportedLength = tape[ptr++]; + let ConditionCoordinateSystem = tape[ptr++]; + let ConnectionConstraint = tape[ptr++]; + return new IfcRelConnectsWithEccentricity(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingStructuralMember, RelatedStructuralConnection, AppliedCondition, AdditionalConditions, SupportedLength, ConditionCoordinateSystem, ConnectionConstraint); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingStructuralMember); + ; + args.push(this.RelatedStructuralConnection); + ; + args.push(this.AppliedCondition); + ; + args.push(this.AdditionalConditions); + ; + args.push(this.SupportedLength); + ; + args.push(this.ConditionCoordinateSystem); + ; + args.push(this.ConnectionConstraint); + ; + return args; + } +}; +var IfcRelConnectsWithRealizingElements = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ConnectionGeometry, RelatingElement, RelatedElement, RealizingElements, ConnectionType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ConnectionGeometry = ConnectionGeometry; + this.RelatingElement = RelatingElement; + this.RelatedElement = RelatedElement; + this.RealizingElements = RealizingElements; + this.ConnectionType = ConnectionType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ConnectionGeometry = tape[ptr++]; + let RelatingElement = tape[ptr++]; + let RelatedElement = tape[ptr++]; + let RealizingElements = tape[ptr++]; + let ConnectionType = tape[ptr++]; + return new IfcRelConnectsWithRealizingElements(expressID, type, GlobalId, OwnerHistory, Name, Description, ConnectionGeometry, RelatingElement, RelatedElement, RealizingElements, ConnectionType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ConnectionGeometry); + ; + args.push(this.RelatingElement); + ; + args.push(this.RelatedElement); + ; + args.push(this.RealizingElements); + ; + args.push(this.ConnectionType); + ; + return args; + } +}; +var IfcRelContainedInSpatialStructure = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedElements, RelatingStructure) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedElements = RelatedElements; + this.RelatingStructure = RelatingStructure; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedElements = tape[ptr++]; + let RelatingStructure = tape[ptr++]; + return new IfcRelContainedInSpatialStructure(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedElements, RelatingStructure); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedElements); + ; + args.push(this.RelatingStructure); + ; + return args; + } +}; +var IfcRelCoversBldgElements = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingBuildingElement, RelatedCoverings) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingBuildingElement = RelatingBuildingElement; + this.RelatedCoverings = RelatedCoverings; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingBuildingElement = tape[ptr++]; + let RelatedCoverings = tape[ptr++]; + return new IfcRelCoversBldgElements(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingBuildingElement, RelatedCoverings); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingBuildingElement); + ; + args.push(this.RelatedCoverings); + ; + return args; + } +}; +var IfcRelCoversSpaces = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingSpace, RelatedCoverings) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingSpace = RelatingSpace; + this.RelatedCoverings = RelatedCoverings; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingSpace = tape[ptr++]; + let RelatedCoverings = tape[ptr++]; + return new IfcRelCoversSpaces(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingSpace, RelatedCoverings); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingSpace); + ; + args.push(this.RelatedCoverings); + ; + return args; + } +}; +var IfcRelDeclares = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingContext, RelatedDefinitions) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingContext = RelatingContext; + this.RelatedDefinitions = RelatedDefinitions; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingContext = tape[ptr++]; + let RelatedDefinitions = tape[ptr++]; + return new IfcRelDeclares(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingContext, RelatedDefinitions); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingContext); + ; + args.push(this.RelatedDefinitions); + ; + return args; + } +}; +var IfcRelDecomposes = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + return new IfcRelDecomposes(expressID, type, GlobalId, OwnerHistory, Name, Description); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + return args; + } +}; +var IfcRelDefines = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + return new IfcRelDefines(expressID, type, GlobalId, OwnerHistory, Name, Description); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + return args; + } +}; +var IfcRelDefinesByObject = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatingObject) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedObjects = RelatedObjects; + this.RelatingObject = RelatingObject; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + let RelatingObject = tape[ptr++]; + return new IfcRelDefinesByObject(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatingObject); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedObjects); + ; + args.push(this.RelatingObject); + ; + return args; + } +}; +var IfcRelDefinesByProperties = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatingPropertyDefinition) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedObjects = RelatedObjects; + this.RelatingPropertyDefinition = RelatingPropertyDefinition; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + let RelatingPropertyDefinition = tape[ptr++]; + return new IfcRelDefinesByProperties(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatingPropertyDefinition); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedObjects); + ; + args.push(this.RelatingPropertyDefinition); + ; + return args; + } +}; +var IfcRelDefinesByTemplate = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedPropertySets, RelatingTemplate) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedPropertySets = RelatedPropertySets; + this.RelatingTemplate = RelatingTemplate; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedPropertySets = tape[ptr++]; + let RelatingTemplate = tape[ptr++]; + return new IfcRelDefinesByTemplate(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedPropertySets, RelatingTemplate); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedPropertySets); + ; + args.push(this.RelatingTemplate); + ; + return args; + } +}; +var IfcRelDefinesByType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatingType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedObjects = RelatedObjects; + this.RelatingType = RelatingType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + let RelatingType = tape[ptr++]; + return new IfcRelDefinesByType(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedObjects, RelatingType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedObjects); + ; + args.push(this.RelatingType); + ; + return args; + } +}; +var IfcRelFillsElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingOpeningElement, RelatedBuildingElement) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingOpeningElement = RelatingOpeningElement; + this.RelatedBuildingElement = RelatedBuildingElement; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingOpeningElement = tape[ptr++]; + let RelatedBuildingElement = tape[ptr++]; + return new IfcRelFillsElement(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingOpeningElement, RelatedBuildingElement); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingOpeningElement); + ; + args.push(this.RelatedBuildingElement); + ; + return args; + } +}; +var IfcRelFlowControlElements = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedControlElements, RelatingFlowElement) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedControlElements = RelatedControlElements; + this.RelatingFlowElement = RelatingFlowElement; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedControlElements = tape[ptr++]; + let RelatingFlowElement = tape[ptr++]; + return new IfcRelFlowControlElements(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedControlElements, RelatingFlowElement); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedControlElements); + ; + args.push(this.RelatingFlowElement); + ; + return args; + } +}; +var IfcRelInterferesElements = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingElement, RelatedElement, InterferenceGeometry, InterferenceType, ImpliedOrder) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingElement = RelatingElement; + this.RelatedElement = RelatedElement; + this.InterferenceGeometry = InterferenceGeometry; + this.InterferenceType = InterferenceType; + this.ImpliedOrder = ImpliedOrder; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingElement = tape[ptr++]; + let RelatedElement = tape[ptr++]; + let InterferenceGeometry = tape[ptr++]; + let InterferenceType = tape[ptr++]; + let ImpliedOrder = tape[ptr++]; + return new IfcRelInterferesElements(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingElement, RelatedElement, InterferenceGeometry, InterferenceType, ImpliedOrder); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingElement); + ; + args.push(this.RelatedElement); + ; + args.push(this.InterferenceGeometry); + ; + args.push(this.InterferenceType); + ; + args.push(this.ImpliedOrder); + ; + return args; + } +}; +var IfcRelNests = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingObject, RelatedObjects) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingObject = RelatingObject; + this.RelatedObjects = RelatedObjects; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingObject = tape[ptr++]; + let RelatedObjects = tape[ptr++]; + return new IfcRelNests(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingObject, RelatedObjects); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingObject); + ; + args.push(this.RelatedObjects); + ; + return args; + } +}; +var IfcRelPositions = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingPositioningElement, RelatedProducts) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingPositioningElement = RelatingPositioningElement; + this.RelatedProducts = RelatedProducts; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingPositioningElement = tape[ptr++]; + let RelatedProducts = tape[ptr++]; + return new IfcRelPositions(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingPositioningElement, RelatedProducts); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingPositioningElement); + ; + args.push(this.RelatedProducts); + ; + return args; + } +}; +var IfcRelProjectsElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingElement, RelatedFeatureElement) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingElement = RelatingElement; + this.RelatedFeatureElement = RelatedFeatureElement; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingElement = tape[ptr++]; + let RelatedFeatureElement = tape[ptr++]; + return new IfcRelProjectsElement(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingElement, RelatedFeatureElement); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingElement); + ; + args.push(this.RelatedFeatureElement); + ; + return args; + } +}; +var IfcRelReferencedInSpatialStructure = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedElements, RelatingStructure) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatedElements = RelatedElements; + this.RelatingStructure = RelatingStructure; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedElements = tape[ptr++]; + let RelatingStructure = tape[ptr++]; + return new IfcRelReferencedInSpatialStructure(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatedElements, RelatingStructure); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedElements); + ; + args.push(this.RelatingStructure); + ; + return args; + } +}; +var IfcRelSequence = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingProcess, RelatedProcess, TimeLag, SequenceType, UserDefinedSequenceType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingProcess = RelatingProcess; + this.RelatedProcess = RelatedProcess; + this.TimeLag = TimeLag; + this.SequenceType = SequenceType; + this.UserDefinedSequenceType = UserDefinedSequenceType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingProcess = tape[ptr++]; + let RelatedProcess = tape[ptr++]; + let TimeLag = tape[ptr++]; + let SequenceType = tape[ptr++]; + let UserDefinedSequenceType = tape[ptr++]; + return new IfcRelSequence(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingProcess, RelatedProcess, TimeLag, SequenceType, UserDefinedSequenceType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingProcess); + ; + args.push(this.RelatedProcess); + ; + args.push(this.TimeLag); + ; + args.push(this.SequenceType); + ; + args.push(this.UserDefinedSequenceType); + ; + return args; + } +}; +var IfcRelServicesBuildings = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingSystem, RelatedBuildings) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingSystem = RelatingSystem; + this.RelatedBuildings = RelatedBuildings; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingSystem = tape[ptr++]; + let RelatedBuildings = tape[ptr++]; + return new IfcRelServicesBuildings(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingSystem, RelatedBuildings); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingSystem); + ; + args.push(this.RelatedBuildings); + ; + return args; + } +}; +var IfcRelSpaceBoundary = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingSpace, RelatedBuildingElement, ConnectionGeometry, PhysicalOrVirtualBoundary, InternalOrExternalBoundary) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingSpace = RelatingSpace; + this.RelatedBuildingElement = RelatedBuildingElement; + this.ConnectionGeometry = ConnectionGeometry; + this.PhysicalOrVirtualBoundary = PhysicalOrVirtualBoundary; + this.InternalOrExternalBoundary = InternalOrExternalBoundary; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingSpace = tape[ptr++]; + let RelatedBuildingElement = tape[ptr++]; + let ConnectionGeometry = tape[ptr++]; + let PhysicalOrVirtualBoundary = tape[ptr++]; + let InternalOrExternalBoundary = tape[ptr++]; + return new IfcRelSpaceBoundary(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingSpace, RelatedBuildingElement, ConnectionGeometry, PhysicalOrVirtualBoundary, InternalOrExternalBoundary); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingSpace); + ; + args.push(this.RelatedBuildingElement); + ; + args.push(this.ConnectionGeometry); + ; + args.push(this.PhysicalOrVirtualBoundary); + ; + args.push(this.InternalOrExternalBoundary); + ; + return args; + } +}; +var IfcRelSpaceBoundary1stLevel = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingSpace, RelatedBuildingElement, ConnectionGeometry, PhysicalOrVirtualBoundary, InternalOrExternalBoundary, ParentBoundary) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingSpace = RelatingSpace; + this.RelatedBuildingElement = RelatedBuildingElement; + this.ConnectionGeometry = ConnectionGeometry; + this.PhysicalOrVirtualBoundary = PhysicalOrVirtualBoundary; + this.InternalOrExternalBoundary = InternalOrExternalBoundary; + this.ParentBoundary = ParentBoundary; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingSpace = tape[ptr++]; + let RelatedBuildingElement = tape[ptr++]; + let ConnectionGeometry = tape[ptr++]; + let PhysicalOrVirtualBoundary = tape[ptr++]; + let InternalOrExternalBoundary = tape[ptr++]; + let ParentBoundary = tape[ptr++]; + return new IfcRelSpaceBoundary1stLevel(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingSpace, RelatedBuildingElement, ConnectionGeometry, PhysicalOrVirtualBoundary, InternalOrExternalBoundary, ParentBoundary); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingSpace); + ; + args.push(this.RelatedBuildingElement); + ; + args.push(this.ConnectionGeometry); + ; + args.push(this.PhysicalOrVirtualBoundary); + ; + args.push(this.InternalOrExternalBoundary); + ; + args.push(this.ParentBoundary); + ; + return args; + } +}; +var IfcRelSpaceBoundary2ndLevel = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingSpace, RelatedBuildingElement, ConnectionGeometry, PhysicalOrVirtualBoundary, InternalOrExternalBoundary, ParentBoundary, CorrespondingBoundary) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingSpace = RelatingSpace; + this.RelatedBuildingElement = RelatedBuildingElement; + this.ConnectionGeometry = ConnectionGeometry; + this.PhysicalOrVirtualBoundary = PhysicalOrVirtualBoundary; + this.InternalOrExternalBoundary = InternalOrExternalBoundary; + this.ParentBoundary = ParentBoundary; + this.CorrespondingBoundary = CorrespondingBoundary; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingSpace = tape[ptr++]; + let RelatedBuildingElement = tape[ptr++]; + let ConnectionGeometry = tape[ptr++]; + let PhysicalOrVirtualBoundary = tape[ptr++]; + let InternalOrExternalBoundary = tape[ptr++]; + let ParentBoundary = tape[ptr++]; + let CorrespondingBoundary = tape[ptr++]; + return new IfcRelSpaceBoundary2ndLevel(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingSpace, RelatedBuildingElement, ConnectionGeometry, PhysicalOrVirtualBoundary, InternalOrExternalBoundary, ParentBoundary, CorrespondingBoundary); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingSpace); + ; + args.push(this.RelatedBuildingElement); + ; + args.push(this.ConnectionGeometry); + ; + args.push(this.PhysicalOrVirtualBoundary); + ; + args.push(this.InternalOrExternalBoundary); + ; + args.push(this.ParentBoundary); + ; + args.push(this.CorrespondingBoundary); + ; + return args; + } +}; +var IfcRelVoidsElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingBuildingElement, RelatedOpeningElement) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.RelatingBuildingElement = RelatingBuildingElement; + this.RelatedOpeningElement = RelatedOpeningElement; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingBuildingElement = tape[ptr++]; + let RelatedOpeningElement = tape[ptr++]; + return new IfcRelVoidsElement(expressID, type, GlobalId, OwnerHistory, Name, Description, RelatingBuildingElement, RelatedOpeningElement); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingBuildingElement); + ; + args.push(this.RelatedOpeningElement); + ; + return args; + } +}; +var IfcRelationship = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + return new IfcRelationship(expressID, type, GlobalId, OwnerHistory, Name, Description); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + return args; + } +}; +var IfcReparametrisedCompositeCurveSegment = class { + constructor(expressID, type, Transition, SameSense, ParentCurve, ParamLength) { + this.expressID = expressID; + this.type = type; + this.Transition = Transition; + this.SameSense = SameSense; + this.ParentCurve = ParentCurve; + this.ParamLength = ParamLength; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Transition = tape[ptr++]; + let SameSense = tape[ptr++]; + let ParentCurve = tape[ptr++]; + let ParamLength = tape[ptr++]; + return new IfcReparametrisedCompositeCurveSegment(expressID, type, Transition, SameSense, ParentCurve, ParamLength); + } + ToTape() { + let args = []; + args.push(this.Transition); + ; + args.push(this.SameSense); + ; + args.push(this.ParentCurve); + ; + args.push(this.ParamLength); + ; + return args; + } +}; +var IfcRepresentation = class { + constructor(expressID, type, ContextOfItems, RepresentationIdentifier, RepresentationType, Items) { + this.expressID = expressID; + this.type = type; + this.ContextOfItems = ContextOfItems; + this.RepresentationIdentifier = RepresentationIdentifier; + this.RepresentationType = RepresentationType; + this.Items = Items; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ContextOfItems = tape[ptr++]; + let RepresentationIdentifier = tape[ptr++]; + let RepresentationType = tape[ptr++]; + let Items = tape[ptr++]; + return new IfcRepresentation(expressID, type, ContextOfItems, RepresentationIdentifier, RepresentationType, Items); + } + ToTape() { + let args = []; + args.push(this.ContextOfItems); + ; + args.push(this.RepresentationIdentifier); + ; + args.push(this.RepresentationType); + ; + args.push(this.Items); + ; + return args; + } +}; +var IfcRepresentationContext = class { + constructor(expressID, type, ContextIdentifier, ContextType) { + this.expressID = expressID; + this.type = type; + this.ContextIdentifier = ContextIdentifier; + this.ContextType = ContextType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ContextIdentifier = tape[ptr++]; + let ContextType = tape[ptr++]; + return new IfcRepresentationContext(expressID, type, ContextIdentifier, ContextType); + } + ToTape() { + let args = []; + args.push(this.ContextIdentifier); + ; + args.push(this.ContextType); + ; + return args; + } +}; +var IfcRepresentationItem = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcRepresentationItem(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcRepresentationMap = class { + constructor(expressID, type, MappingOrigin, MappedRepresentation) { + this.expressID = expressID; + this.type = type; + this.MappingOrigin = MappingOrigin; + this.MappedRepresentation = MappedRepresentation; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let MappingOrigin = tape[ptr++]; + let MappedRepresentation = tape[ptr++]; + return new IfcRepresentationMap(expressID, type, MappingOrigin, MappedRepresentation); + } + ToTape() { + let args = []; + args.push(this.MappingOrigin); + ; + args.push(this.MappedRepresentation); + ; + return args; + } +}; +var IfcResource = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.LongDescription = LongDescription; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + return new IfcResource(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + return args; + } +}; +var IfcResourceApprovalRelationship = class { + constructor(expressID, type, Name, Description, RelatedResourceObjects, RelatingApproval) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.RelatedResourceObjects = RelatedResourceObjects; + this.RelatingApproval = RelatingApproval; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatedResourceObjects = tape[ptr++]; + let RelatingApproval = tape[ptr++]; + return new IfcResourceApprovalRelationship(expressID, type, Name, Description, RelatedResourceObjects, RelatingApproval); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatedResourceObjects); + ; + args.push(this.RelatingApproval); + ; + return args; + } +}; +var IfcResourceConstraintRelationship = class { + constructor(expressID, type, Name, Description, RelatingConstraint, RelatedResourceObjects) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.RelatingConstraint = RelatingConstraint; + this.RelatedResourceObjects = RelatedResourceObjects; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let RelatingConstraint = tape[ptr++]; + let RelatedResourceObjects = tape[ptr++]; + return new IfcResourceConstraintRelationship(expressID, type, Name, Description, RelatingConstraint, RelatedResourceObjects); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.RelatingConstraint); + ; + args.push(this.RelatedResourceObjects); + ; + return args; + } +}; +var IfcResourceLevelRelationship = class { + constructor(expressID, type, Name, Description) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + return new IfcResourceLevelRelationship(expressID, type, Name, Description); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + return args; + } +}; +var IfcResourceTime = class { + constructor(expressID, type, Name, DataOrigin, UserDefinedDataOrigin, ScheduleWork, ScheduleUsage, ScheduleStart, ScheduleFinish, ScheduleContour, LevelingDelay, IsOverAllocated, StatusTime, ActualWork, ActualUsage, ActualStart, ActualFinish, RemainingWork, RemainingUsage, Completion) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.DataOrigin = DataOrigin; + this.UserDefinedDataOrigin = UserDefinedDataOrigin; + this.ScheduleWork = ScheduleWork; + this.ScheduleUsage = ScheduleUsage; + this.ScheduleStart = ScheduleStart; + this.ScheduleFinish = ScheduleFinish; + this.ScheduleContour = ScheduleContour; + this.LevelingDelay = LevelingDelay; + this.IsOverAllocated = IsOverAllocated; + this.StatusTime = StatusTime; + this.ActualWork = ActualWork; + this.ActualUsage = ActualUsage; + this.ActualStart = ActualStart; + this.ActualFinish = ActualFinish; + this.RemainingWork = RemainingWork; + this.RemainingUsage = RemainingUsage; + this.Completion = Completion; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let DataOrigin = tape[ptr++]; + let UserDefinedDataOrigin = tape[ptr++]; + let ScheduleWork = tape[ptr++]; + let ScheduleUsage = tape[ptr++]; + let ScheduleStart = tape[ptr++]; + let ScheduleFinish = tape[ptr++]; + let ScheduleContour = tape[ptr++]; + let LevelingDelay = tape[ptr++]; + let IsOverAllocated = tape[ptr++]; + let StatusTime = tape[ptr++]; + let ActualWork = tape[ptr++]; + let ActualUsage = tape[ptr++]; + let ActualStart = tape[ptr++]; + let ActualFinish = tape[ptr++]; + let RemainingWork = tape[ptr++]; + let RemainingUsage = tape[ptr++]; + let Completion = tape[ptr++]; + return new IfcResourceTime(expressID, type, Name, DataOrigin, UserDefinedDataOrigin, ScheduleWork, ScheduleUsage, ScheduleStart, ScheduleFinish, ScheduleContour, LevelingDelay, IsOverAllocated, StatusTime, ActualWork, ActualUsage, ActualStart, ActualFinish, RemainingWork, RemainingUsage, Completion); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.DataOrigin); + ; + args.push(this.UserDefinedDataOrigin); + ; + args.push(this.ScheduleWork); + ; + args.push(this.ScheduleUsage); + ; + args.push(this.ScheduleStart); + ; + args.push(this.ScheduleFinish); + ; + args.push(this.ScheduleContour); + ; + args.push(this.LevelingDelay); + ; + args.push(this.IsOverAllocated); + ; + args.push(this.StatusTime); + ; + args.push(this.ActualWork); + ; + args.push(this.ActualUsage); + ; + args.push(this.ActualStart); + ; + args.push(this.ActualFinish); + ; + args.push(this.RemainingWork); + ; + args.push(this.RemainingUsage); + ; + args.push(this.Completion); + ; + return args; + } +}; +var IfcRevolvedAreaSolid = class { + constructor(expressID, type, SweptArea, Position, Axis, Angle) { + this.expressID = expressID; + this.type = type; + this.SweptArea = SweptArea; + this.Position = Position; + this.Axis = Axis; + this.Angle = Angle; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SweptArea = tape[ptr++]; + let Position = tape[ptr++]; + let Axis = tape[ptr++]; + let Angle = tape[ptr++]; + return new IfcRevolvedAreaSolid(expressID, type, SweptArea, Position, Axis, Angle); + } + ToTape() { + let args = []; + args.push(this.SweptArea); + ; + args.push(this.Position); + ; + args.push(this.Axis); + ; + args.push(this.Angle); + ; + return args; + } +}; +var IfcRevolvedAreaSolidTapered = class { + constructor(expressID, type, SweptArea, Position, Axis, Angle, EndSweptArea) { + this.expressID = expressID; + this.type = type; + this.SweptArea = SweptArea; + this.Position = Position; + this.Axis = Axis; + this.Angle = Angle; + this.EndSweptArea = EndSweptArea; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SweptArea = tape[ptr++]; + let Position = tape[ptr++]; + let Axis = tape[ptr++]; + let Angle = tape[ptr++]; + let EndSweptArea = tape[ptr++]; + return new IfcRevolvedAreaSolidTapered(expressID, type, SweptArea, Position, Axis, Angle, EndSweptArea); + } + ToTape() { + let args = []; + args.push(this.SweptArea); + ; + args.push(this.Position); + ; + args.push(this.Axis); + ; + args.push(this.Angle); + ; + args.push(this.EndSweptArea); + ; + return args; + } +}; +var IfcRightCircularCone = class { + constructor(expressID, type, Position, Height, BottomRadius) { + this.expressID = expressID; + this.type = type; + this.Position = Position; + this.Height = Height; + this.BottomRadius = BottomRadius; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Position = tape[ptr++]; + let Height = tape[ptr++]; + let BottomRadius = tape[ptr++]; + return new IfcRightCircularCone(expressID, type, Position, Height, BottomRadius); + } + ToTape() { + let args = []; + args.push(this.Position); + ; + args.push(this.Height); + ; + args.push(this.BottomRadius); + ; + return args; + } +}; +var IfcRightCircularCylinder = class { + constructor(expressID, type, Position, Height, Radius) { + this.expressID = expressID; + this.type = type; + this.Position = Position; + this.Height = Height; + this.Radius = Radius; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Position = tape[ptr++]; + let Height = tape[ptr++]; + let Radius = tape[ptr++]; + return new IfcRightCircularCylinder(expressID, type, Position, Height, Radius); + } + ToTape() { + let args = []; + args.push(this.Position); + ; + args.push(this.Height); + ; + args.push(this.Radius); + ; + return args; + } +}; +var IfcRoof = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcRoof(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcRoofType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcRoofType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcRoot = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + return new IfcRoot(expressID, type, GlobalId, OwnerHistory, Name, Description); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + return args; + } +}; +var IfcRoundedRectangleProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, Position, XDim, YDim, RoundingRadius) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.Position = Position; + this.XDim = XDim; + this.YDim = YDim; + this.RoundingRadius = RoundingRadius; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let Position = tape[ptr++]; + let XDim = tape[ptr++]; + let YDim = tape[ptr++]; + let RoundingRadius = tape[ptr++]; + return new IfcRoundedRectangleProfileDef(expressID, type, ProfileType, ProfileName, Position, XDim, YDim, RoundingRadius); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.Position); + ; + args.push(this.XDim); + ; + args.push(this.YDim); + ; + args.push(this.RoundingRadius); + ; + return args; + } +}; +var IfcSIUnit = class { + constructor(expressID, type, Dimensions, UnitType, Prefix, Name) { + this.expressID = expressID; + this.type = type; + this.Dimensions = Dimensions; + this.UnitType = UnitType; + this.Prefix = Prefix; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Dimensions = tape[ptr++]; + let UnitType = tape[ptr++]; + let Prefix = tape[ptr++]; + let Name = tape[ptr++]; + return new IfcSIUnit(expressID, type, Dimensions, UnitType, Prefix, Name); + } + ToTape() { + let args = []; + args.push(this.Dimensions); + ; + args.push(this.UnitType); + ; + args.push(this.Prefix); + ; + args.push(this.Name); + ; + return args; + } +}; +var IfcSanitaryTerminal = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSanitaryTerminal(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcSanitaryTerminalType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSanitaryTerminalType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcSchedulingTime = class { + constructor(expressID, type, Name, DataOrigin, UserDefinedDataOrigin) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.DataOrigin = DataOrigin; + this.UserDefinedDataOrigin = UserDefinedDataOrigin; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let DataOrigin = tape[ptr++]; + let UserDefinedDataOrigin = tape[ptr++]; + return new IfcSchedulingTime(expressID, type, Name, DataOrigin, UserDefinedDataOrigin); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.DataOrigin); + ; + args.push(this.UserDefinedDataOrigin); + ; + return args; + } +}; +var IfcSeamCurve = class { + constructor(expressID, type, Curve3D, AssociatedGeometry, MasterRepresentation) { + this.expressID = expressID; + this.type = type; + this.Curve3D = Curve3D; + this.AssociatedGeometry = AssociatedGeometry; + this.MasterRepresentation = MasterRepresentation; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Curve3D = tape[ptr++]; + let AssociatedGeometry = tape[ptr++]; + let MasterRepresentation = tape[ptr++]; + return new IfcSeamCurve(expressID, type, Curve3D, AssociatedGeometry, MasterRepresentation); + } + ToTape() { + let args = []; + args.push(this.Curve3D); + ; + args.push(this.AssociatedGeometry); + ; + args.push(this.MasterRepresentation); + ; + return args; + } +}; +var IfcSectionProperties = class { + constructor(expressID, type, SectionType, StartProfile, EndProfile) { + this.expressID = expressID; + this.type = type; + this.SectionType = SectionType; + this.StartProfile = StartProfile; + this.EndProfile = EndProfile; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SectionType = tape[ptr++]; + let StartProfile = tape[ptr++]; + let EndProfile = tape[ptr++]; + return new IfcSectionProperties(expressID, type, SectionType, StartProfile, EndProfile); + } + ToTape() { + let args = []; + args.push(this.SectionType); + ; + args.push(this.StartProfile); + ; + args.push(this.EndProfile); + ; + return args; + } +}; +var IfcSectionReinforcementProperties = class { + constructor(expressID, type, LongitudinalStartPosition, LongitudinalEndPosition, TransversePosition, ReinforcementRole, SectionDefinition, CrossSectionReinforcementDefinitions) { + this.expressID = expressID; + this.type = type; + this.LongitudinalStartPosition = LongitudinalStartPosition; + this.LongitudinalEndPosition = LongitudinalEndPosition; + this.TransversePosition = TransversePosition; + this.ReinforcementRole = ReinforcementRole; + this.SectionDefinition = SectionDefinition; + this.CrossSectionReinforcementDefinitions = CrossSectionReinforcementDefinitions; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let LongitudinalStartPosition = tape[ptr++]; + let LongitudinalEndPosition = tape[ptr++]; + let TransversePosition = tape[ptr++]; + let ReinforcementRole = tape[ptr++]; + let SectionDefinition = tape[ptr++]; + let CrossSectionReinforcementDefinitions = tape[ptr++]; + return new IfcSectionReinforcementProperties(expressID, type, LongitudinalStartPosition, LongitudinalEndPosition, TransversePosition, ReinforcementRole, SectionDefinition, CrossSectionReinforcementDefinitions); + } + ToTape() { + let args = []; + args.push(this.LongitudinalStartPosition); + ; + args.push(this.LongitudinalEndPosition); + ; + args.push(this.TransversePosition); + ; + args.push(this.ReinforcementRole); + ; + args.push(this.SectionDefinition); + ; + args.push(this.CrossSectionReinforcementDefinitions); + ; + return args; + } +}; +var IfcSectionedSolid = class { + constructor(expressID, type, Directrix, CrossSections) { + this.expressID = expressID; + this.type = type; + this.Directrix = Directrix; + this.CrossSections = CrossSections; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Directrix = tape[ptr++]; + let CrossSections = tape[ptr++]; + return new IfcSectionedSolid(expressID, type, Directrix, CrossSections); + } + ToTape() { + let args = []; + args.push(this.Directrix); + ; + args.push(this.CrossSections); + ; + return args; + } +}; +var IfcSectionedSolidHorizontal = class { + constructor(expressID, type, Directrix, CrossSections, CrossSectionPositions, FixedAxisVertical) { + this.expressID = expressID; + this.type = type; + this.Directrix = Directrix; + this.CrossSections = CrossSections; + this.CrossSectionPositions = CrossSectionPositions; + this.FixedAxisVertical = FixedAxisVertical; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Directrix = tape[ptr++]; + let CrossSections = tape[ptr++]; + let CrossSectionPositions = tape[ptr++]; + let FixedAxisVertical = tape[ptr++]; + return new IfcSectionedSolidHorizontal(expressID, type, Directrix, CrossSections, CrossSectionPositions, FixedAxisVertical); + } + ToTape() { + let args = []; + args.push(this.Directrix); + ; + args.push(this.CrossSections); + ; + args.push(this.CrossSectionPositions); + ; + args.push(this.FixedAxisVertical); + ; + return args; + } +}; +var IfcSectionedSpine = class { + constructor(expressID, type, SpineCurve, CrossSections, CrossSectionPositions) { + this.expressID = expressID; + this.type = type; + this.SpineCurve = SpineCurve; + this.CrossSections = CrossSections; + this.CrossSectionPositions = CrossSectionPositions; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SpineCurve = tape[ptr++]; + let CrossSections = tape[ptr++]; + let CrossSectionPositions = tape[ptr++]; + return new IfcSectionedSpine(expressID, type, SpineCurve, CrossSections, CrossSectionPositions); + } + ToTape() { + let args = []; + args.push(this.SpineCurve); + ; + args.push(this.CrossSections); + ; + args.push(this.CrossSectionPositions); + ; + return args; + } +}; +var IfcSensor = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSensor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcSensorType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSensorType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcShadingDevice = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcShadingDevice(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcShadingDeviceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcShadingDeviceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcShapeAspect = class { + constructor(expressID, type, ShapeRepresentations, Name, Description, ProductDefinitional, PartOfProductDefinitionShape) { + this.expressID = expressID; + this.type = type; + this.ShapeRepresentations = ShapeRepresentations; + this.Name = Name; + this.Description = Description; + this.ProductDefinitional = ProductDefinitional; + this.PartOfProductDefinitionShape = PartOfProductDefinitionShape; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ShapeRepresentations = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ProductDefinitional = tape[ptr++]; + let PartOfProductDefinitionShape = tape[ptr++]; + return new IfcShapeAspect(expressID, type, ShapeRepresentations, Name, Description, ProductDefinitional, PartOfProductDefinitionShape); + } + ToTape() { + let args = []; + args.push(this.ShapeRepresentations); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ProductDefinitional); + ; + args.push(this.PartOfProductDefinitionShape); + ; + return args; + } +}; +var IfcShapeModel = class { + constructor(expressID, type, ContextOfItems, RepresentationIdentifier, RepresentationType, Items) { + this.expressID = expressID; + this.type = type; + this.ContextOfItems = ContextOfItems; + this.RepresentationIdentifier = RepresentationIdentifier; + this.RepresentationType = RepresentationType; + this.Items = Items; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ContextOfItems = tape[ptr++]; + let RepresentationIdentifier = tape[ptr++]; + let RepresentationType = tape[ptr++]; + let Items = tape[ptr++]; + return new IfcShapeModel(expressID, type, ContextOfItems, RepresentationIdentifier, RepresentationType, Items); + } + ToTape() { + let args = []; + args.push(this.ContextOfItems); + ; + args.push(this.RepresentationIdentifier); + ; + args.push(this.RepresentationType); + ; + args.push(this.Items); + ; + return args; + } +}; +var IfcShapeRepresentation = class { + constructor(expressID, type, ContextOfItems, RepresentationIdentifier, RepresentationType, Items) { + this.expressID = expressID; + this.type = type; + this.ContextOfItems = ContextOfItems; + this.RepresentationIdentifier = RepresentationIdentifier; + this.RepresentationType = RepresentationType; + this.Items = Items; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ContextOfItems = tape[ptr++]; + let RepresentationIdentifier = tape[ptr++]; + let RepresentationType = tape[ptr++]; + let Items = tape[ptr++]; + return new IfcShapeRepresentation(expressID, type, ContextOfItems, RepresentationIdentifier, RepresentationType, Items); + } + ToTape() { + let args = []; + args.push(this.ContextOfItems); + ; + args.push(this.RepresentationIdentifier); + ; + args.push(this.RepresentationType); + ; + args.push(this.Items); + ; + return args; + } +}; +var IfcShellBasedSurfaceModel = class { + constructor(expressID, type, SbsmBoundary) { + this.expressID = expressID; + this.type = type; + this.SbsmBoundary = SbsmBoundary; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SbsmBoundary = tape[ptr++]; + return new IfcShellBasedSurfaceModel(expressID, type, SbsmBoundary); + } + ToTape() { + let args = []; + args.push(this.SbsmBoundary); + ; + return args; + } +}; +var IfcSimpleProperty = class { + constructor(expressID, type, Name, Description) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + return new IfcSimpleProperty(expressID, type, Name, Description); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + return args; + } +}; +var IfcSimplePropertyTemplate = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, TemplateType, PrimaryMeasureType, SecondaryMeasureType, Enumerators, PrimaryUnit, SecondaryUnit, Expression, AccessState) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.TemplateType = TemplateType; + this.PrimaryMeasureType = PrimaryMeasureType; + this.SecondaryMeasureType = SecondaryMeasureType; + this.Enumerators = Enumerators; + this.PrimaryUnit = PrimaryUnit; + this.SecondaryUnit = SecondaryUnit; + this.Expression = Expression; + this.AccessState = AccessState; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let TemplateType = tape[ptr++]; + let PrimaryMeasureType = tape[ptr++]; + let SecondaryMeasureType = tape[ptr++]; + let Enumerators = tape[ptr++]; + let PrimaryUnit = tape[ptr++]; + let SecondaryUnit = tape[ptr++]; + let Expression = tape[ptr++]; + let AccessState = tape[ptr++]; + return new IfcSimplePropertyTemplate(expressID, type, GlobalId, OwnerHistory, Name, Description, TemplateType, PrimaryMeasureType, SecondaryMeasureType, Enumerators, PrimaryUnit, SecondaryUnit, Expression, AccessState); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.TemplateType); + ; + args.push(this.PrimaryMeasureType); + ; + args.push(this.SecondaryMeasureType); + ; + args.push(this.Enumerators); + ; + args.push(this.PrimaryUnit); + ; + args.push(this.SecondaryUnit); + ; + args.push(this.Expression); + ; + args.push(this.AccessState); + ; + return args; + } +}; +var IfcSite = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, CompositionType, RefLatitude, RefLongitude, RefElevation, LandTitleNumber, SiteAddress) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.LongName = LongName; + this.CompositionType = CompositionType; + this.RefLatitude = RefLatitude; + this.RefLongitude = RefLongitude; + this.RefElevation = RefElevation; + this.LandTitleNumber = LandTitleNumber; + this.SiteAddress = SiteAddress; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let LongName = tape[ptr++]; + let CompositionType = tape[ptr++]; + let RefLatitude = tape[ptr++]; + let RefLongitude = tape[ptr++]; + let RefElevation = tape[ptr++]; + let LandTitleNumber = tape[ptr++]; + let SiteAddress = tape[ptr++]; + return new IfcSite(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, CompositionType, RefLatitude, RefLongitude, RefElevation, LandTitleNumber, SiteAddress); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.LongName); + ; + args.push(this.CompositionType); + ; + args.push(this.RefLatitude); + ; + args.push(this.RefLongitude); + ; + args.push(this.RefElevation); + ; + args.push(this.LandTitleNumber); + ; + args.push(this.SiteAddress); + ; + return args; + } +}; +var IfcSlab = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSlab(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcSlabElementedCase = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSlabElementedCase(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcSlabStandardCase = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSlabStandardCase(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcSlabType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSlabType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcSlippageConnectionCondition = class { + constructor(expressID, type, Name, SlippageX, SlippageY, SlippageZ) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.SlippageX = SlippageX; + this.SlippageY = SlippageY; + this.SlippageZ = SlippageZ; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let SlippageX = tape[ptr++]; + let SlippageY = tape[ptr++]; + let SlippageZ = tape[ptr++]; + return new IfcSlippageConnectionCondition(expressID, type, Name, SlippageX, SlippageY, SlippageZ); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.SlippageX); + ; + args.push(this.SlippageY); + ; + args.push(this.SlippageZ); + ; + return args; + } +}; +var IfcSolarDevice = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSolarDevice(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcSolarDeviceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSolarDeviceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcSolidModel = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcSolidModel(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcSpace = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, CompositionType, PredefinedType, ElevationWithFlooring) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.LongName = LongName; + this.CompositionType = CompositionType; + this.PredefinedType = PredefinedType; + this.ElevationWithFlooring = ElevationWithFlooring; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let LongName = tape[ptr++]; + let CompositionType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let ElevationWithFlooring = tape[ptr++]; + return new IfcSpace(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, CompositionType, PredefinedType, ElevationWithFlooring); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.LongName); + ; + args.push(this.CompositionType); + ; + args.push(this.PredefinedType); + ; + args.push(this.ElevationWithFlooring); + ; + return args; + } +}; +var IfcSpaceHeater = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSpaceHeater(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcSpaceHeaterType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSpaceHeaterType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcSpaceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType, LongName) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + this.LongName = LongName; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let LongName = tape[ptr++]; + return new IfcSpaceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType, LongName); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + args.push(this.LongName); + ; + return args; + } +}; +var IfcSpatialElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.LongName = LongName; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let LongName = tape[ptr++]; + return new IfcSpatialElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.LongName); + ; + return args; + } +}; +var IfcSpatialElementType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcSpatialElementType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcSpatialStructureElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, CompositionType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.LongName = LongName; + this.CompositionType = CompositionType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let LongName = tape[ptr++]; + let CompositionType = tape[ptr++]; + return new IfcSpatialStructureElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, CompositionType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.LongName); + ; + args.push(this.CompositionType); + ; + return args; + } +}; +var IfcSpatialStructureElementType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + return new IfcSpatialStructureElementType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + return args; + } +}; +var IfcSpatialZone = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.LongName = LongName; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let LongName = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSpatialZone(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, LongName, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.LongName); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcSpatialZoneType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType, LongName) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + this.LongName = LongName; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let LongName = tape[ptr++]; + return new IfcSpatialZoneType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType, LongName); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + args.push(this.LongName); + ; + return args; + } +}; +var IfcSphere = class { + constructor(expressID, type, Position, Radius) { + this.expressID = expressID; + this.type = type; + this.Position = Position; + this.Radius = Radius; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Position = tape[ptr++]; + let Radius = tape[ptr++]; + return new IfcSphere(expressID, type, Position, Radius); + } + ToTape() { + let args = []; + args.push(this.Position); + ; + args.push(this.Radius); + ; + return args; + } +}; +var IfcSphericalSurface = class { + constructor(expressID, type, Position, Radius) { + this.expressID = expressID; + this.type = type; + this.Position = Position; + this.Radius = Radius; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Position = tape[ptr++]; + let Radius = tape[ptr++]; + return new IfcSphericalSurface(expressID, type, Position, Radius); + } + ToTape() { + let args = []; + args.push(this.Position); + ; + args.push(this.Radius); + ; + return args; + } +}; +var IfcStackTerminal = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcStackTerminal(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcStackTerminalType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcStackTerminalType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcStair = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcStair(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcStairFlight = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, NumberOfRisers, NumberOfTreads, RiserHeight, TreadLength, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.NumberOfRisers = NumberOfRisers; + this.NumberOfTreads = NumberOfTreads; + this.RiserHeight = RiserHeight; + this.TreadLength = TreadLength; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let NumberOfRisers = tape[ptr++]; + let NumberOfTreads = tape[ptr++]; + let RiserHeight = tape[ptr++]; + let TreadLength = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcStairFlight(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, NumberOfRisers, NumberOfTreads, RiserHeight, TreadLength, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.NumberOfRisers); + ; + args.push(this.NumberOfTreads); + ; + args.push(this.RiserHeight); + ; + args.push(this.TreadLength); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcStairFlightType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcStairFlightType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcStairType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcStairType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcStructuralAction = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal, DestabilizingLoad) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.AppliedLoad = AppliedLoad; + this.GlobalOrLocal = GlobalOrLocal; + this.DestabilizingLoad = DestabilizingLoad; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let AppliedLoad = tape[ptr++]; + let GlobalOrLocal = tape[ptr++]; + let DestabilizingLoad = tape[ptr++]; + return new IfcStructuralAction(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal, DestabilizingLoad); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.AppliedLoad); + ; + args.push(this.GlobalOrLocal); + ; + args.push(this.DestabilizingLoad); + ; + return args; + } +}; +var IfcStructuralActivity = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.AppliedLoad = AppliedLoad; + this.GlobalOrLocal = GlobalOrLocal; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let AppliedLoad = tape[ptr++]; + let GlobalOrLocal = tape[ptr++]; + return new IfcStructuralActivity(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.AppliedLoad); + ; + args.push(this.GlobalOrLocal); + ; + return args; + } +}; +var IfcStructuralAnalysisModel = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, PredefinedType, OrientationOf2DPlane, LoadedBy, HasResults, SharedPlacement) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.PredefinedType = PredefinedType; + this.OrientationOf2DPlane = OrientationOf2DPlane; + this.LoadedBy = LoadedBy; + this.HasResults = HasResults; + this.SharedPlacement = SharedPlacement; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let OrientationOf2DPlane = tape[ptr++]; + let LoadedBy = tape[ptr++]; + let HasResults = tape[ptr++]; + let SharedPlacement = tape[ptr++]; + return new IfcStructuralAnalysisModel(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, PredefinedType, OrientationOf2DPlane, LoadedBy, HasResults, SharedPlacement); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.PredefinedType); + ; + args.push(this.OrientationOf2DPlane); + ; + args.push(this.LoadedBy); + ; + args.push(this.HasResults); + ; + args.push(this.SharedPlacement); + ; + return args; + } +}; +var IfcStructuralConnection = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedCondition) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.AppliedCondition = AppliedCondition; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let AppliedCondition = tape[ptr++]; + return new IfcStructuralConnection(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedCondition); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.AppliedCondition); + ; + return args; + } +}; +var IfcStructuralConnectionCondition = class { + constructor(expressID, type, Name) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + return new IfcStructuralConnectionCondition(expressID, type, Name); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + return args; + } +}; +var IfcStructuralCurveAction = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal, DestabilizingLoad, ProjectedOrTrue, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.AppliedLoad = AppliedLoad; + this.GlobalOrLocal = GlobalOrLocal; + this.DestabilizingLoad = DestabilizingLoad; + this.ProjectedOrTrue = ProjectedOrTrue; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let AppliedLoad = tape[ptr++]; + let GlobalOrLocal = tape[ptr++]; + let DestabilizingLoad = tape[ptr++]; + let ProjectedOrTrue = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcStructuralCurveAction(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal, DestabilizingLoad, ProjectedOrTrue, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.AppliedLoad); + ; + args.push(this.GlobalOrLocal); + ; + args.push(this.DestabilizingLoad); + ; + args.push(this.ProjectedOrTrue); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcStructuralCurveConnection = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedCondition, Axis) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.AppliedCondition = AppliedCondition; + this.Axis = Axis; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let AppliedCondition = tape[ptr++]; + let Axis = tape[ptr++]; + return new IfcStructuralCurveConnection(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedCondition, Axis); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.AppliedCondition); + ; + args.push(this.Axis); + ; + return args; + } +}; +var IfcStructuralCurveMember = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, PredefinedType, Axis) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.PredefinedType = PredefinedType; + this.Axis = Axis; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let Axis = tape[ptr++]; + return new IfcStructuralCurveMember(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, PredefinedType, Axis); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.PredefinedType); + ; + args.push(this.Axis); + ; + return args; + } +}; +var IfcStructuralCurveMemberVarying = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, PredefinedType, Axis) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.PredefinedType = PredefinedType; + this.Axis = Axis; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let Axis = tape[ptr++]; + return new IfcStructuralCurveMemberVarying(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, PredefinedType, Axis); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.PredefinedType); + ; + args.push(this.Axis); + ; + return args; + } +}; +var IfcStructuralCurveReaction = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.AppliedLoad = AppliedLoad; + this.GlobalOrLocal = GlobalOrLocal; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let AppliedLoad = tape[ptr++]; + let GlobalOrLocal = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcStructuralCurveReaction(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.AppliedLoad); + ; + args.push(this.GlobalOrLocal); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcStructuralItem = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + return new IfcStructuralItem(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + return args; + } +}; +var IfcStructuralLinearAction = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal, DestabilizingLoad, ProjectedOrTrue, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.AppliedLoad = AppliedLoad; + this.GlobalOrLocal = GlobalOrLocal; + this.DestabilizingLoad = DestabilizingLoad; + this.ProjectedOrTrue = ProjectedOrTrue; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let AppliedLoad = tape[ptr++]; + let GlobalOrLocal = tape[ptr++]; + let DestabilizingLoad = tape[ptr++]; + let ProjectedOrTrue = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcStructuralLinearAction(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal, DestabilizingLoad, ProjectedOrTrue, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.AppliedLoad); + ; + args.push(this.GlobalOrLocal); + ; + args.push(this.DestabilizingLoad); + ; + args.push(this.ProjectedOrTrue); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcStructuralLoad = class { + constructor(expressID, type, Name) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + return new IfcStructuralLoad(expressID, type, Name); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + return args; + } +}; +var IfcStructuralLoadCase = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, PredefinedType, ActionType, ActionSource, Coefficient, Purpose, SelfWeightCoefficients) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.PredefinedType = PredefinedType; + this.ActionType = ActionType; + this.ActionSource = ActionSource; + this.Coefficient = Coefficient; + this.Purpose = Purpose; + this.SelfWeightCoefficients = SelfWeightCoefficients; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let ActionType = tape[ptr++]; + let ActionSource = tape[ptr++]; + let Coefficient = tape[ptr++]; + let Purpose = tape[ptr++]; + let SelfWeightCoefficients = tape[ptr++]; + return new IfcStructuralLoadCase(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, PredefinedType, ActionType, ActionSource, Coefficient, Purpose, SelfWeightCoefficients); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.PredefinedType); + ; + args.push(this.ActionType); + ; + args.push(this.ActionSource); + ; + args.push(this.Coefficient); + ; + args.push(this.Purpose); + ; + args.push(this.SelfWeightCoefficients); + ; + return args; + } +}; +var IfcStructuralLoadConfiguration = class { + constructor(expressID, type, Name, Values, Locations) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Values = Values; + this.Locations = Locations; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Values = tape[ptr++]; + let Locations = tape[ptr++]; + return new IfcStructuralLoadConfiguration(expressID, type, Name, Values, Locations); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Values); + ; + args.push(this.Locations); + ; + return args; + } +}; +var IfcStructuralLoadGroup = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, PredefinedType, ActionType, ActionSource, Coefficient, Purpose) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.PredefinedType = PredefinedType; + this.ActionType = ActionType; + this.ActionSource = ActionSource; + this.Coefficient = Coefficient; + this.Purpose = Purpose; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let ActionType = tape[ptr++]; + let ActionSource = tape[ptr++]; + let Coefficient = tape[ptr++]; + let Purpose = tape[ptr++]; + return new IfcStructuralLoadGroup(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, PredefinedType, ActionType, ActionSource, Coefficient, Purpose); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.PredefinedType); + ; + args.push(this.ActionType); + ; + args.push(this.ActionSource); + ; + args.push(this.Coefficient); + ; + args.push(this.Purpose); + ; + return args; + } +}; +var IfcStructuralLoadLinearForce = class { + constructor(expressID, type, Name, LinearForceX, LinearForceY, LinearForceZ, LinearMomentX, LinearMomentY, LinearMomentZ) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.LinearForceX = LinearForceX; + this.LinearForceY = LinearForceY; + this.LinearForceZ = LinearForceZ; + this.LinearMomentX = LinearMomentX; + this.LinearMomentY = LinearMomentY; + this.LinearMomentZ = LinearMomentZ; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let LinearForceX = tape[ptr++]; + let LinearForceY = tape[ptr++]; + let LinearForceZ = tape[ptr++]; + let LinearMomentX = tape[ptr++]; + let LinearMomentY = tape[ptr++]; + let LinearMomentZ = tape[ptr++]; + return new IfcStructuralLoadLinearForce(expressID, type, Name, LinearForceX, LinearForceY, LinearForceZ, LinearMomentX, LinearMomentY, LinearMomentZ); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.LinearForceX); + ; + args.push(this.LinearForceY); + ; + args.push(this.LinearForceZ); + ; + args.push(this.LinearMomentX); + ; + args.push(this.LinearMomentY); + ; + args.push(this.LinearMomentZ); + ; + return args; + } +}; +var IfcStructuralLoadOrResult = class { + constructor(expressID, type, Name) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + return new IfcStructuralLoadOrResult(expressID, type, Name); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + return args; + } +}; +var IfcStructuralLoadPlanarForce = class { + constructor(expressID, type, Name, PlanarForceX, PlanarForceY, PlanarForceZ) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.PlanarForceX = PlanarForceX; + this.PlanarForceY = PlanarForceY; + this.PlanarForceZ = PlanarForceZ; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let PlanarForceX = tape[ptr++]; + let PlanarForceY = tape[ptr++]; + let PlanarForceZ = tape[ptr++]; + return new IfcStructuralLoadPlanarForce(expressID, type, Name, PlanarForceX, PlanarForceY, PlanarForceZ); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.PlanarForceX); + ; + args.push(this.PlanarForceY); + ; + args.push(this.PlanarForceZ); + ; + return args; + } +}; +var IfcStructuralLoadSingleDisplacement = class { + constructor(expressID, type, Name, DisplacementX, DisplacementY, DisplacementZ, RotationalDisplacementRX, RotationalDisplacementRY, RotationalDisplacementRZ) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.DisplacementX = DisplacementX; + this.DisplacementY = DisplacementY; + this.DisplacementZ = DisplacementZ; + this.RotationalDisplacementRX = RotationalDisplacementRX; + this.RotationalDisplacementRY = RotationalDisplacementRY; + this.RotationalDisplacementRZ = RotationalDisplacementRZ; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let DisplacementX = tape[ptr++]; + let DisplacementY = tape[ptr++]; + let DisplacementZ = tape[ptr++]; + let RotationalDisplacementRX = tape[ptr++]; + let RotationalDisplacementRY = tape[ptr++]; + let RotationalDisplacementRZ = tape[ptr++]; + return new IfcStructuralLoadSingleDisplacement(expressID, type, Name, DisplacementX, DisplacementY, DisplacementZ, RotationalDisplacementRX, RotationalDisplacementRY, RotationalDisplacementRZ); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.DisplacementX); + ; + args.push(this.DisplacementY); + ; + args.push(this.DisplacementZ); + ; + args.push(this.RotationalDisplacementRX); + ; + args.push(this.RotationalDisplacementRY); + ; + args.push(this.RotationalDisplacementRZ); + ; + return args; + } +}; +var IfcStructuralLoadSingleDisplacementDistortion = class { + constructor(expressID, type, Name, DisplacementX, DisplacementY, DisplacementZ, RotationalDisplacementRX, RotationalDisplacementRY, RotationalDisplacementRZ, Distortion) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.DisplacementX = DisplacementX; + this.DisplacementY = DisplacementY; + this.DisplacementZ = DisplacementZ; + this.RotationalDisplacementRX = RotationalDisplacementRX; + this.RotationalDisplacementRY = RotationalDisplacementRY; + this.RotationalDisplacementRZ = RotationalDisplacementRZ; + this.Distortion = Distortion; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let DisplacementX = tape[ptr++]; + let DisplacementY = tape[ptr++]; + let DisplacementZ = tape[ptr++]; + let RotationalDisplacementRX = tape[ptr++]; + let RotationalDisplacementRY = tape[ptr++]; + let RotationalDisplacementRZ = tape[ptr++]; + let Distortion = tape[ptr++]; + return new IfcStructuralLoadSingleDisplacementDistortion(expressID, type, Name, DisplacementX, DisplacementY, DisplacementZ, RotationalDisplacementRX, RotationalDisplacementRY, RotationalDisplacementRZ, Distortion); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.DisplacementX); + ; + args.push(this.DisplacementY); + ; + args.push(this.DisplacementZ); + ; + args.push(this.RotationalDisplacementRX); + ; + args.push(this.RotationalDisplacementRY); + ; + args.push(this.RotationalDisplacementRZ); + ; + args.push(this.Distortion); + ; + return args; + } +}; +var IfcStructuralLoadSingleForce = class { + constructor(expressID, type, Name, ForceX, ForceY, ForceZ, MomentX, MomentY, MomentZ) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.ForceX = ForceX; + this.ForceY = ForceY; + this.ForceZ = ForceZ; + this.MomentX = MomentX; + this.MomentY = MomentY; + this.MomentZ = MomentZ; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let ForceX = tape[ptr++]; + let ForceY = tape[ptr++]; + let ForceZ = tape[ptr++]; + let MomentX = tape[ptr++]; + let MomentY = tape[ptr++]; + let MomentZ = tape[ptr++]; + return new IfcStructuralLoadSingleForce(expressID, type, Name, ForceX, ForceY, ForceZ, MomentX, MomentY, MomentZ); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.ForceX); + ; + args.push(this.ForceY); + ; + args.push(this.ForceZ); + ; + args.push(this.MomentX); + ; + args.push(this.MomentY); + ; + args.push(this.MomentZ); + ; + return args; + } +}; +var IfcStructuralLoadSingleForceWarping = class { + constructor(expressID, type, Name, ForceX, ForceY, ForceZ, MomentX, MomentY, MomentZ, WarpingMoment) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.ForceX = ForceX; + this.ForceY = ForceY; + this.ForceZ = ForceZ; + this.MomentX = MomentX; + this.MomentY = MomentY; + this.MomentZ = MomentZ; + this.WarpingMoment = WarpingMoment; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let ForceX = tape[ptr++]; + let ForceY = tape[ptr++]; + let ForceZ = tape[ptr++]; + let MomentX = tape[ptr++]; + let MomentY = tape[ptr++]; + let MomentZ = tape[ptr++]; + let WarpingMoment = tape[ptr++]; + return new IfcStructuralLoadSingleForceWarping(expressID, type, Name, ForceX, ForceY, ForceZ, MomentX, MomentY, MomentZ, WarpingMoment); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.ForceX); + ; + args.push(this.ForceY); + ; + args.push(this.ForceZ); + ; + args.push(this.MomentX); + ; + args.push(this.MomentY); + ; + args.push(this.MomentZ); + ; + args.push(this.WarpingMoment); + ; + return args; + } +}; +var IfcStructuralLoadStatic = class { + constructor(expressID, type, Name) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + return new IfcStructuralLoadStatic(expressID, type, Name); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + return args; + } +}; +var IfcStructuralLoadTemperature = class { + constructor(expressID, type, Name, DeltaTConstant, DeltaTY, DeltaTZ) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.DeltaTConstant = DeltaTConstant; + this.DeltaTY = DeltaTY; + this.DeltaTZ = DeltaTZ; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let DeltaTConstant = tape[ptr++]; + let DeltaTY = tape[ptr++]; + let DeltaTZ = tape[ptr++]; + return new IfcStructuralLoadTemperature(expressID, type, Name, DeltaTConstant, DeltaTY, DeltaTZ); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.DeltaTConstant); + ; + args.push(this.DeltaTY); + ; + args.push(this.DeltaTZ); + ; + return args; + } +}; +var IfcStructuralMember = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + return new IfcStructuralMember(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + return args; + } +}; +var IfcStructuralPlanarAction = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal, DestabilizingLoad, ProjectedOrTrue, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.AppliedLoad = AppliedLoad; + this.GlobalOrLocal = GlobalOrLocal; + this.DestabilizingLoad = DestabilizingLoad; + this.ProjectedOrTrue = ProjectedOrTrue; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let AppliedLoad = tape[ptr++]; + let GlobalOrLocal = tape[ptr++]; + let DestabilizingLoad = tape[ptr++]; + let ProjectedOrTrue = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcStructuralPlanarAction(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal, DestabilizingLoad, ProjectedOrTrue, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.AppliedLoad); + ; + args.push(this.GlobalOrLocal); + ; + args.push(this.DestabilizingLoad); + ; + args.push(this.ProjectedOrTrue); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcStructuralPointAction = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal, DestabilizingLoad) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.AppliedLoad = AppliedLoad; + this.GlobalOrLocal = GlobalOrLocal; + this.DestabilizingLoad = DestabilizingLoad; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let AppliedLoad = tape[ptr++]; + let GlobalOrLocal = tape[ptr++]; + let DestabilizingLoad = tape[ptr++]; + return new IfcStructuralPointAction(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal, DestabilizingLoad); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.AppliedLoad); + ; + args.push(this.GlobalOrLocal); + ; + args.push(this.DestabilizingLoad); + ; + return args; + } +}; +var IfcStructuralPointConnection = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedCondition, ConditionCoordinateSystem) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.AppliedCondition = AppliedCondition; + this.ConditionCoordinateSystem = ConditionCoordinateSystem; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let AppliedCondition = tape[ptr++]; + let ConditionCoordinateSystem = tape[ptr++]; + return new IfcStructuralPointConnection(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedCondition, ConditionCoordinateSystem); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.AppliedCondition); + ; + args.push(this.ConditionCoordinateSystem); + ; + return args; + } +}; +var IfcStructuralPointReaction = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.AppliedLoad = AppliedLoad; + this.GlobalOrLocal = GlobalOrLocal; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let AppliedLoad = tape[ptr++]; + let GlobalOrLocal = tape[ptr++]; + return new IfcStructuralPointReaction(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.AppliedLoad); + ; + args.push(this.GlobalOrLocal); + ; + return args; + } +}; +var IfcStructuralReaction = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.AppliedLoad = AppliedLoad; + this.GlobalOrLocal = GlobalOrLocal; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let AppliedLoad = tape[ptr++]; + let GlobalOrLocal = tape[ptr++]; + return new IfcStructuralReaction(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.AppliedLoad); + ; + args.push(this.GlobalOrLocal); + ; + return args; + } +}; +var IfcStructuralResultGroup = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, TheoryType, ResultForLoadGroup, IsLinear) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.TheoryType = TheoryType; + this.ResultForLoadGroup = ResultForLoadGroup; + this.IsLinear = IsLinear; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let TheoryType = tape[ptr++]; + let ResultForLoadGroup = tape[ptr++]; + let IsLinear = tape[ptr++]; + return new IfcStructuralResultGroup(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, TheoryType, ResultForLoadGroup, IsLinear); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.TheoryType); + ; + args.push(this.ResultForLoadGroup); + ; + args.push(this.IsLinear); + ; + return args; + } +}; +var IfcStructuralSurfaceAction = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal, DestabilizingLoad, ProjectedOrTrue, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.AppliedLoad = AppliedLoad; + this.GlobalOrLocal = GlobalOrLocal; + this.DestabilizingLoad = DestabilizingLoad; + this.ProjectedOrTrue = ProjectedOrTrue; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let AppliedLoad = tape[ptr++]; + let GlobalOrLocal = tape[ptr++]; + let DestabilizingLoad = tape[ptr++]; + let ProjectedOrTrue = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcStructuralSurfaceAction(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal, DestabilizingLoad, ProjectedOrTrue, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.AppliedLoad); + ; + args.push(this.GlobalOrLocal); + ; + args.push(this.DestabilizingLoad); + ; + args.push(this.ProjectedOrTrue); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcStructuralSurfaceConnection = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedCondition) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.AppliedCondition = AppliedCondition; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let AppliedCondition = tape[ptr++]; + return new IfcStructuralSurfaceConnection(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedCondition); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.AppliedCondition); + ; + return args; + } +}; +var IfcStructuralSurfaceMember = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, PredefinedType, Thickness) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.PredefinedType = PredefinedType; + this.Thickness = Thickness; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let Thickness = tape[ptr++]; + return new IfcStructuralSurfaceMember(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, PredefinedType, Thickness); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.PredefinedType); + ; + args.push(this.Thickness); + ; + return args; + } +}; +var IfcStructuralSurfaceMemberVarying = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, PredefinedType, Thickness) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.PredefinedType = PredefinedType; + this.Thickness = Thickness; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let Thickness = tape[ptr++]; + return new IfcStructuralSurfaceMemberVarying(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, PredefinedType, Thickness); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.PredefinedType); + ; + args.push(this.Thickness); + ; + return args; + } +}; +var IfcStructuralSurfaceReaction = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.AppliedLoad = AppliedLoad; + this.GlobalOrLocal = GlobalOrLocal; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let AppliedLoad = tape[ptr++]; + let GlobalOrLocal = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcStructuralSurfaceReaction(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, AppliedLoad, GlobalOrLocal, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.AppliedLoad); + ; + args.push(this.GlobalOrLocal); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcStyleModel = class { + constructor(expressID, type, ContextOfItems, RepresentationIdentifier, RepresentationType, Items) { + this.expressID = expressID; + this.type = type; + this.ContextOfItems = ContextOfItems; + this.RepresentationIdentifier = RepresentationIdentifier; + this.RepresentationType = RepresentationType; + this.Items = Items; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ContextOfItems = tape[ptr++]; + let RepresentationIdentifier = tape[ptr++]; + let RepresentationType = tape[ptr++]; + let Items = tape[ptr++]; + return new IfcStyleModel(expressID, type, ContextOfItems, RepresentationIdentifier, RepresentationType, Items); + } + ToTape() { + let args = []; + args.push(this.ContextOfItems); + ; + args.push(this.RepresentationIdentifier); + ; + args.push(this.RepresentationType); + ; + args.push(this.Items); + ; + return args; + } +}; +var IfcStyledItem = class { + constructor(expressID, type, Item, Styles, Name) { + this.expressID = expressID; + this.type = type; + this.Item = Item; + this.Styles = Styles; + this.Name = Name; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Item = tape[ptr++]; + let Styles = tape[ptr++]; + let Name = tape[ptr++]; + return new IfcStyledItem(expressID, type, Item, Styles, Name); + } + ToTape() { + let args = []; + args.push(this.Item); + ; + args.push(this.Styles); + ; + args.push(this.Name); + ; + return args; + } +}; +var IfcStyledRepresentation = class { + constructor(expressID, type, ContextOfItems, RepresentationIdentifier, RepresentationType, Items) { + this.expressID = expressID; + this.type = type; + this.ContextOfItems = ContextOfItems; + this.RepresentationIdentifier = RepresentationIdentifier; + this.RepresentationType = RepresentationType; + this.Items = Items; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ContextOfItems = tape[ptr++]; + let RepresentationIdentifier = tape[ptr++]; + let RepresentationType = tape[ptr++]; + let Items = tape[ptr++]; + return new IfcStyledRepresentation(expressID, type, ContextOfItems, RepresentationIdentifier, RepresentationType, Items); + } + ToTape() { + let args = []; + args.push(this.ContextOfItems); + ; + args.push(this.RepresentationIdentifier); + ; + args.push(this.RepresentationType); + ; + args.push(this.Items); + ; + return args; + } +}; +var IfcSubContractResource = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, Usage, BaseCosts, BaseQuantity, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.Usage = Usage; + this.BaseCosts = BaseCosts; + this.BaseQuantity = BaseQuantity; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let Usage = tape[ptr++]; + let BaseCosts = tape[ptr++]; + let BaseQuantity = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSubContractResource(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, Usage, BaseCosts, BaseQuantity, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.Usage); + ; + args.push(this.BaseCosts); + ; + args.push(this.BaseQuantity); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcSubContractResourceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ResourceType, BaseCosts, BaseQuantity, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.ResourceType = ResourceType; + this.BaseCosts = BaseCosts; + this.BaseQuantity = BaseQuantity; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let ResourceType = tape[ptr++]; + let BaseCosts = tape[ptr++]; + let BaseQuantity = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSubContractResourceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ResourceType, BaseCosts, BaseQuantity, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.ResourceType); + ; + args.push(this.BaseCosts); + ; + args.push(this.BaseQuantity); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcSubedge = class { + constructor(expressID, type, EdgeStart, EdgeEnd, ParentEdge) { + this.expressID = expressID; + this.type = type; + this.EdgeStart = EdgeStart; + this.EdgeEnd = EdgeEnd; + this.ParentEdge = ParentEdge; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let EdgeStart = tape[ptr++]; + let EdgeEnd = tape[ptr++]; + let ParentEdge = tape[ptr++]; + return new IfcSubedge(expressID, type, EdgeStart, EdgeEnd, ParentEdge); + } + ToTape() { + let args = []; + args.push(this.EdgeStart); + ; + args.push(this.EdgeEnd); + ; + args.push(this.ParentEdge); + ; + return args; + } +}; +var IfcSurface = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcSurface(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcSurfaceCurve = class { + constructor(expressID, type, Curve3D, AssociatedGeometry, MasterRepresentation) { + this.expressID = expressID; + this.type = type; + this.Curve3D = Curve3D; + this.AssociatedGeometry = AssociatedGeometry; + this.MasterRepresentation = MasterRepresentation; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Curve3D = tape[ptr++]; + let AssociatedGeometry = tape[ptr++]; + let MasterRepresentation = tape[ptr++]; + return new IfcSurfaceCurve(expressID, type, Curve3D, AssociatedGeometry, MasterRepresentation); + } + ToTape() { + let args = []; + args.push(this.Curve3D); + ; + args.push(this.AssociatedGeometry); + ; + args.push(this.MasterRepresentation); + ; + return args; + } +}; +var IfcSurfaceCurveSweptAreaSolid = class { + constructor(expressID, type, SweptArea, Position, Directrix, StartParam, EndParam, ReferenceSurface) { + this.expressID = expressID; + this.type = type; + this.SweptArea = SweptArea; + this.Position = Position; + this.Directrix = Directrix; + this.StartParam = StartParam; + this.EndParam = EndParam; + this.ReferenceSurface = ReferenceSurface; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SweptArea = tape[ptr++]; + let Position = tape[ptr++]; + let Directrix = tape[ptr++]; + let StartParam = tape[ptr++]; + let EndParam = tape[ptr++]; + let ReferenceSurface = tape[ptr++]; + return new IfcSurfaceCurveSweptAreaSolid(expressID, type, SweptArea, Position, Directrix, StartParam, EndParam, ReferenceSurface); + } + ToTape() { + let args = []; + args.push(this.SweptArea); + ; + args.push(this.Position); + ; + args.push(this.Directrix); + ; + args.push(this.StartParam); + ; + args.push(this.EndParam); + ; + args.push(this.ReferenceSurface); + ; + return args; + } +}; +var IfcSurfaceFeature = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSurfaceFeature(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcSurfaceOfLinearExtrusion = class { + constructor(expressID, type, SweptCurve, Position, ExtrudedDirection, Depth) { + this.expressID = expressID; + this.type = type; + this.SweptCurve = SweptCurve; + this.Position = Position; + this.ExtrudedDirection = ExtrudedDirection; + this.Depth = Depth; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SweptCurve = tape[ptr++]; + let Position = tape[ptr++]; + let ExtrudedDirection = tape[ptr++]; + let Depth = tape[ptr++]; + return new IfcSurfaceOfLinearExtrusion(expressID, type, SweptCurve, Position, ExtrudedDirection, Depth); + } + ToTape() { + let args = []; + args.push(this.SweptCurve); + ; + args.push(this.Position); + ; + args.push(this.ExtrudedDirection); + ; + args.push(this.Depth); + ; + return args; + } +}; +var IfcSurfaceOfRevolution = class { + constructor(expressID, type, SweptCurve, Position, AxisPosition) { + this.expressID = expressID; + this.type = type; + this.SweptCurve = SweptCurve; + this.Position = Position; + this.AxisPosition = AxisPosition; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SweptCurve = tape[ptr++]; + let Position = tape[ptr++]; + let AxisPosition = tape[ptr++]; + return new IfcSurfaceOfRevolution(expressID, type, SweptCurve, Position, AxisPosition); + } + ToTape() { + let args = []; + args.push(this.SweptCurve); + ; + args.push(this.Position); + ; + args.push(this.AxisPosition); + ; + return args; + } +}; +var IfcSurfaceReinforcementArea = class { + constructor(expressID, type, Name, SurfaceReinforcement1, SurfaceReinforcement2, ShearReinforcement) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.SurfaceReinforcement1 = SurfaceReinforcement1; + this.SurfaceReinforcement2 = SurfaceReinforcement2; + this.ShearReinforcement = ShearReinforcement; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let SurfaceReinforcement1 = tape[ptr++]; + let SurfaceReinforcement2 = tape[ptr++]; + let ShearReinforcement = tape[ptr++]; + return new IfcSurfaceReinforcementArea(expressID, type, Name, SurfaceReinforcement1, SurfaceReinforcement2, ShearReinforcement); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.SurfaceReinforcement1); + ; + args.push(this.SurfaceReinforcement2); + ; + args.push(this.ShearReinforcement); + ; + return args; + } +}; +var IfcSurfaceStyle = class { + constructor(expressID, type, Name, Side, Styles) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Side = Side; + this.Styles = Styles; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Side = tape[ptr++]; + let Styles = tape[ptr++]; + return new IfcSurfaceStyle(expressID, type, Name, Side, Styles); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Side); + ; + args.push(this.Styles); + ; + return args; + } +}; +var IfcSurfaceStyleLighting = class { + constructor(expressID, type, DiffuseTransmissionColour, DiffuseReflectionColour, TransmissionColour, ReflectanceColour) { + this.expressID = expressID; + this.type = type; + this.DiffuseTransmissionColour = DiffuseTransmissionColour; + this.DiffuseReflectionColour = DiffuseReflectionColour; + this.TransmissionColour = TransmissionColour; + this.ReflectanceColour = ReflectanceColour; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let DiffuseTransmissionColour = tape[ptr++]; + let DiffuseReflectionColour = tape[ptr++]; + let TransmissionColour = tape[ptr++]; + let ReflectanceColour = tape[ptr++]; + return new IfcSurfaceStyleLighting(expressID, type, DiffuseTransmissionColour, DiffuseReflectionColour, TransmissionColour, ReflectanceColour); + } + ToTape() { + let args = []; + args.push(this.DiffuseTransmissionColour); + ; + args.push(this.DiffuseReflectionColour); + ; + args.push(this.TransmissionColour); + ; + args.push(this.ReflectanceColour); + ; + return args; + } +}; +var IfcSurfaceStyleRefraction = class { + constructor(expressID, type, RefractionIndex, DispersionFactor) { + this.expressID = expressID; + this.type = type; + this.RefractionIndex = RefractionIndex; + this.DispersionFactor = DispersionFactor; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let RefractionIndex = tape[ptr++]; + let DispersionFactor = tape[ptr++]; + return new IfcSurfaceStyleRefraction(expressID, type, RefractionIndex, DispersionFactor); + } + ToTape() { + let args = []; + args.push(this.RefractionIndex); + ; + args.push(this.DispersionFactor); + ; + return args; + } +}; +var IfcSurfaceStyleRendering = class { + constructor(expressID, type, SurfaceColour, Transparency, DiffuseColour, TransmissionColour, DiffuseTransmissionColour, ReflectionColour, SpecularColour, SpecularHighlight, ReflectanceMethod) { + this.expressID = expressID; + this.type = type; + this.SurfaceColour = SurfaceColour; + this.Transparency = Transparency; + this.DiffuseColour = DiffuseColour; + this.TransmissionColour = TransmissionColour; + this.DiffuseTransmissionColour = DiffuseTransmissionColour; + this.ReflectionColour = ReflectionColour; + this.SpecularColour = SpecularColour; + this.SpecularHighlight = SpecularHighlight; + this.ReflectanceMethod = ReflectanceMethod; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SurfaceColour = tape[ptr++]; + let Transparency = tape[ptr++]; + let DiffuseColour = tape[ptr++]; + let TransmissionColour = tape[ptr++]; + let DiffuseTransmissionColour = tape[ptr++]; + let ReflectionColour = tape[ptr++]; + let SpecularColour = tape[ptr++]; + let SpecularHighlight = tape[ptr++]; + let ReflectanceMethod = tape[ptr++]; + return new IfcSurfaceStyleRendering(expressID, type, SurfaceColour, Transparency, DiffuseColour, TransmissionColour, DiffuseTransmissionColour, ReflectionColour, SpecularColour, SpecularHighlight, ReflectanceMethod); + } + ToTape() { + let args = []; + args.push(this.SurfaceColour); + ; + args.push(this.Transparency); + ; + args.push(this.DiffuseColour); + ; + args.push(this.TransmissionColour); + ; + args.push(this.DiffuseTransmissionColour); + ; + args.push(this.ReflectionColour); + ; + args.push(this.SpecularColour); + ; + args.push(this.SpecularHighlight); + ; + args.push(this.ReflectanceMethod); + ; + return args; + } +}; +var IfcSurfaceStyleShading = class { + constructor(expressID, type, SurfaceColour, Transparency) { + this.expressID = expressID; + this.type = type; + this.SurfaceColour = SurfaceColour; + this.Transparency = Transparency; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SurfaceColour = tape[ptr++]; + let Transparency = tape[ptr++]; + return new IfcSurfaceStyleShading(expressID, type, SurfaceColour, Transparency); + } + ToTape() { + let args = []; + args.push(this.SurfaceColour); + ; + args.push(this.Transparency); + ; + return args; + } +}; +var IfcSurfaceStyleWithTextures = class { + constructor(expressID, type, Textures) { + this.expressID = expressID; + this.type = type; + this.Textures = Textures; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Textures = tape[ptr++]; + return new IfcSurfaceStyleWithTextures(expressID, type, Textures); + } + ToTape() { + let args = []; + args.push(this.Textures); + ; + return args; + } +}; +var IfcSurfaceTexture = class { + constructor(expressID, type, RepeatS, RepeatT, Mode, TextureTransform, Parameter) { + this.expressID = expressID; + this.type = type; + this.RepeatS = RepeatS; + this.RepeatT = RepeatT; + this.Mode = Mode; + this.TextureTransform = TextureTransform; + this.Parameter = Parameter; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let RepeatS = tape[ptr++]; + let RepeatT = tape[ptr++]; + let Mode = tape[ptr++]; + let TextureTransform = tape[ptr++]; + let Parameter = tape[ptr++]; + return new IfcSurfaceTexture(expressID, type, RepeatS, RepeatT, Mode, TextureTransform, Parameter); + } + ToTape() { + let args = []; + args.push(this.RepeatS); + ; + args.push(this.RepeatT); + ; + args.push(this.Mode); + ; + args.push(this.TextureTransform); + ; + args.push(this.Parameter); + ; + return args; + } +}; +var IfcSweptAreaSolid = class { + constructor(expressID, type, SweptArea, Position) { + this.expressID = expressID; + this.type = type; + this.SweptArea = SweptArea; + this.Position = Position; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SweptArea = tape[ptr++]; + let Position = tape[ptr++]; + return new IfcSweptAreaSolid(expressID, type, SweptArea, Position); + } + ToTape() { + let args = []; + args.push(this.SweptArea); + ; + args.push(this.Position); + ; + return args; + } +}; +var IfcSweptDiskSolid = class { + constructor(expressID, type, Directrix, Radius, InnerRadius, StartParam, EndParam) { + this.expressID = expressID; + this.type = type; + this.Directrix = Directrix; + this.Radius = Radius; + this.InnerRadius = InnerRadius; + this.StartParam = StartParam; + this.EndParam = EndParam; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Directrix = tape[ptr++]; + let Radius = tape[ptr++]; + let InnerRadius = tape[ptr++]; + let StartParam = tape[ptr++]; + let EndParam = tape[ptr++]; + return new IfcSweptDiskSolid(expressID, type, Directrix, Radius, InnerRadius, StartParam, EndParam); + } + ToTape() { + let args = []; + args.push(this.Directrix); + ; + args.push(this.Radius); + ; + args.push(this.InnerRadius); + ; + args.push(this.StartParam); + ; + args.push(this.EndParam); + ; + return args; + } +}; +var IfcSweptDiskSolidPolygonal = class { + constructor(expressID, type, Directrix, Radius, InnerRadius, StartParam, EndParam, FilletRadius) { + this.expressID = expressID; + this.type = type; + this.Directrix = Directrix; + this.Radius = Radius; + this.InnerRadius = InnerRadius; + this.StartParam = StartParam; + this.EndParam = EndParam; + this.FilletRadius = FilletRadius; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Directrix = tape[ptr++]; + let Radius = tape[ptr++]; + let InnerRadius = tape[ptr++]; + let StartParam = tape[ptr++]; + let EndParam = tape[ptr++]; + let FilletRadius = tape[ptr++]; + return new IfcSweptDiskSolidPolygonal(expressID, type, Directrix, Radius, InnerRadius, StartParam, EndParam, FilletRadius); + } + ToTape() { + let args = []; + args.push(this.Directrix); + ; + args.push(this.Radius); + ; + args.push(this.InnerRadius); + ; + args.push(this.StartParam); + ; + args.push(this.EndParam); + ; + args.push(this.FilletRadius); + ; + return args; + } +}; +var IfcSweptSurface = class { + constructor(expressID, type, SweptCurve, Position) { + this.expressID = expressID; + this.type = type; + this.SweptCurve = SweptCurve; + this.Position = Position; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let SweptCurve = tape[ptr++]; + let Position = tape[ptr++]; + return new IfcSweptSurface(expressID, type, SweptCurve, Position); + } + ToTape() { + let args = []; + args.push(this.SweptCurve); + ; + args.push(this.Position); + ; + return args; + } +}; +var IfcSwitchingDevice = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSwitchingDevice(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcSwitchingDeviceType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSwitchingDeviceType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcSystem = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + return new IfcSystem(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + return args; + } +}; +var IfcSystemFurnitureElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSystemFurnitureElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcSystemFurnitureElementType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcSystemFurnitureElementType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcTShapeProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, Position, Depth, FlangeWidth, WebThickness, FlangeThickness, FilletRadius, FlangeEdgeRadius, WebEdgeRadius, WebSlope, FlangeSlope) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.Position = Position; + this.Depth = Depth; + this.FlangeWidth = FlangeWidth; + this.WebThickness = WebThickness; + this.FlangeThickness = FlangeThickness; + this.FilletRadius = FilletRadius; + this.FlangeEdgeRadius = FlangeEdgeRadius; + this.WebEdgeRadius = WebEdgeRadius; + this.WebSlope = WebSlope; + this.FlangeSlope = FlangeSlope; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let Position = tape[ptr++]; + let Depth = tape[ptr++]; + let FlangeWidth = tape[ptr++]; + let WebThickness = tape[ptr++]; + let FlangeThickness = tape[ptr++]; + let FilletRadius = tape[ptr++]; + let FlangeEdgeRadius = tape[ptr++]; + let WebEdgeRadius = tape[ptr++]; + let WebSlope = tape[ptr++]; + let FlangeSlope = tape[ptr++]; + return new IfcTShapeProfileDef(expressID, type, ProfileType, ProfileName, Position, Depth, FlangeWidth, WebThickness, FlangeThickness, FilletRadius, FlangeEdgeRadius, WebEdgeRadius, WebSlope, FlangeSlope); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.Position); + ; + args.push(this.Depth); + ; + args.push(this.FlangeWidth); + ; + args.push(this.WebThickness); + ; + args.push(this.FlangeThickness); + ; + args.push(this.FilletRadius); + ; + args.push(this.FlangeEdgeRadius); + ; + args.push(this.WebEdgeRadius); + ; + args.push(this.WebSlope); + ; + args.push(this.FlangeSlope); + ; + return args; + } +}; +var IfcTable = class { + constructor(expressID, type, Name, Rows, Columns) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Rows = Rows; + this.Columns = Columns; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Rows = tape[ptr++]; + let Columns = tape[ptr++]; + return new IfcTable(expressID, type, Name, Rows, Columns); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Rows); + ; + args.push(this.Columns); + ; + return args; + } +}; +var IfcTableColumn = class { + constructor(expressID, type, Identifier, Name, Description, Unit, ReferencePath) { + this.expressID = expressID; + this.type = type; + this.Identifier = Identifier; + this.Name = Name; + this.Description = Description; + this.Unit = Unit; + this.ReferencePath = ReferencePath; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Identifier = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let Unit = tape[ptr++]; + let ReferencePath = tape[ptr++]; + return new IfcTableColumn(expressID, type, Identifier, Name, Description, Unit, ReferencePath); + } + ToTape() { + let args = []; + args.push(this.Identifier); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.Unit); + ; + args.push(this.ReferencePath); + ; + return args; + } +}; +var IfcTableRow = class { + constructor(expressID, type, RowCells, IsHeading) { + this.expressID = expressID; + this.type = type; + this.RowCells = RowCells; + this.IsHeading = IsHeading; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let RowCells = tape[ptr++]; + let IsHeading = tape[ptr++]; + return new IfcTableRow(expressID, type, RowCells, IsHeading); + } + ToTape() { + let args = []; + args.push(this.RowCells); + ; + args.push(this.IsHeading); + ; + return args; + } +}; +var IfcTank = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcTank(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcTankType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcTankType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcTask = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, Status, WorkMethod, IsMilestone, Priority, TaskTime, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.Status = Status; + this.WorkMethod = WorkMethod; + this.IsMilestone = IsMilestone; + this.Priority = Priority; + this.TaskTime = TaskTime; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let Status = tape[ptr++]; + let WorkMethod = tape[ptr++]; + let IsMilestone = tape[ptr++]; + let Priority = tape[ptr++]; + let TaskTime = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcTask(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, LongDescription, Status, WorkMethod, IsMilestone, Priority, TaskTime, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.Status); + ; + args.push(this.WorkMethod); + ; + args.push(this.IsMilestone); + ; + args.push(this.Priority); + ; + args.push(this.TaskTime); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcTaskTime = class { + constructor(expressID, type, Name, DataOrigin, UserDefinedDataOrigin, DurationType, ScheduleDuration, ScheduleStart, ScheduleFinish, EarlyStart, EarlyFinish, LateStart, LateFinish, FreeFloat, TotalFloat, IsCritical, StatusTime, ActualDuration, ActualStart, ActualFinish, RemainingTime, Completion) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.DataOrigin = DataOrigin; + this.UserDefinedDataOrigin = UserDefinedDataOrigin; + this.DurationType = DurationType; + this.ScheduleDuration = ScheduleDuration; + this.ScheduleStart = ScheduleStart; + this.ScheduleFinish = ScheduleFinish; + this.EarlyStart = EarlyStart; + this.EarlyFinish = EarlyFinish; + this.LateStart = LateStart; + this.LateFinish = LateFinish; + this.FreeFloat = FreeFloat; + this.TotalFloat = TotalFloat; + this.IsCritical = IsCritical; + this.StatusTime = StatusTime; + this.ActualDuration = ActualDuration; + this.ActualStart = ActualStart; + this.ActualFinish = ActualFinish; + this.RemainingTime = RemainingTime; + this.Completion = Completion; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let DataOrigin = tape[ptr++]; + let UserDefinedDataOrigin = tape[ptr++]; + let DurationType = tape[ptr++]; + let ScheduleDuration = tape[ptr++]; + let ScheduleStart = tape[ptr++]; + let ScheduleFinish = tape[ptr++]; + let EarlyStart = tape[ptr++]; + let EarlyFinish = tape[ptr++]; + let LateStart = tape[ptr++]; + let LateFinish = tape[ptr++]; + let FreeFloat = tape[ptr++]; + let TotalFloat = tape[ptr++]; + let IsCritical = tape[ptr++]; + let StatusTime = tape[ptr++]; + let ActualDuration = tape[ptr++]; + let ActualStart = tape[ptr++]; + let ActualFinish = tape[ptr++]; + let RemainingTime = tape[ptr++]; + let Completion = tape[ptr++]; + return new IfcTaskTime(expressID, type, Name, DataOrigin, UserDefinedDataOrigin, DurationType, ScheduleDuration, ScheduleStart, ScheduleFinish, EarlyStart, EarlyFinish, LateStart, LateFinish, FreeFloat, TotalFloat, IsCritical, StatusTime, ActualDuration, ActualStart, ActualFinish, RemainingTime, Completion); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.DataOrigin); + ; + args.push(this.UserDefinedDataOrigin); + ; + args.push(this.DurationType); + ; + args.push(this.ScheduleDuration); + ; + args.push(this.ScheduleStart); + ; + args.push(this.ScheduleFinish); + ; + args.push(this.EarlyStart); + ; + args.push(this.EarlyFinish); + ; + args.push(this.LateStart); + ; + args.push(this.LateFinish); + ; + args.push(this.FreeFloat); + ; + args.push(this.TotalFloat); + ; + args.push(this.IsCritical); + ; + args.push(this.StatusTime); + ; + args.push(this.ActualDuration); + ; + args.push(this.ActualStart); + ; + args.push(this.ActualFinish); + ; + args.push(this.RemainingTime); + ; + args.push(this.Completion); + ; + return args; + } +}; +var IfcTaskTimeRecurring = class { + constructor(expressID, type, Name, DataOrigin, UserDefinedDataOrigin, DurationType, ScheduleDuration, ScheduleStart, ScheduleFinish, EarlyStart, EarlyFinish, LateStart, LateFinish, FreeFloat, TotalFloat, IsCritical, StatusTime, ActualDuration, ActualStart, ActualFinish, RemainingTime, Completion, Recurrence) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.DataOrigin = DataOrigin; + this.UserDefinedDataOrigin = UserDefinedDataOrigin; + this.DurationType = DurationType; + this.ScheduleDuration = ScheduleDuration; + this.ScheduleStart = ScheduleStart; + this.ScheduleFinish = ScheduleFinish; + this.EarlyStart = EarlyStart; + this.EarlyFinish = EarlyFinish; + this.LateStart = LateStart; + this.LateFinish = LateFinish; + this.FreeFloat = FreeFloat; + this.TotalFloat = TotalFloat; + this.IsCritical = IsCritical; + this.StatusTime = StatusTime; + this.ActualDuration = ActualDuration; + this.ActualStart = ActualStart; + this.ActualFinish = ActualFinish; + this.RemainingTime = RemainingTime; + this.Completion = Completion; + this.Recurrence = Recurrence; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let DataOrigin = tape[ptr++]; + let UserDefinedDataOrigin = tape[ptr++]; + let DurationType = tape[ptr++]; + let ScheduleDuration = tape[ptr++]; + let ScheduleStart = tape[ptr++]; + let ScheduleFinish = tape[ptr++]; + let EarlyStart = tape[ptr++]; + let EarlyFinish = tape[ptr++]; + let LateStart = tape[ptr++]; + let LateFinish = tape[ptr++]; + let FreeFloat = tape[ptr++]; + let TotalFloat = tape[ptr++]; + let IsCritical = tape[ptr++]; + let StatusTime = tape[ptr++]; + let ActualDuration = tape[ptr++]; + let ActualStart = tape[ptr++]; + let ActualFinish = tape[ptr++]; + let RemainingTime = tape[ptr++]; + let Completion = tape[ptr++]; + let Recurrence = tape[ptr++]; + return new IfcTaskTimeRecurring(expressID, type, Name, DataOrigin, UserDefinedDataOrigin, DurationType, ScheduleDuration, ScheduleStart, ScheduleFinish, EarlyStart, EarlyFinish, LateStart, LateFinish, FreeFloat, TotalFloat, IsCritical, StatusTime, ActualDuration, ActualStart, ActualFinish, RemainingTime, Completion, Recurrence); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.DataOrigin); + ; + args.push(this.UserDefinedDataOrigin); + ; + args.push(this.DurationType); + ; + args.push(this.ScheduleDuration); + ; + args.push(this.ScheduleStart); + ; + args.push(this.ScheduleFinish); + ; + args.push(this.EarlyStart); + ; + args.push(this.EarlyFinish); + ; + args.push(this.LateStart); + ; + args.push(this.LateFinish); + ; + args.push(this.FreeFloat); + ; + args.push(this.TotalFloat); + ; + args.push(this.IsCritical); + ; + args.push(this.StatusTime); + ; + args.push(this.ActualDuration); + ; + args.push(this.ActualStart); + ; + args.push(this.ActualFinish); + ; + args.push(this.RemainingTime); + ; + args.push(this.Completion); + ; + args.push(this.Recurrence); + ; + return args; + } +}; +var IfcTaskType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ProcessType, PredefinedType, WorkMethod) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.ProcessType = ProcessType; + this.PredefinedType = PredefinedType; + this.WorkMethod = WorkMethod; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let ProcessType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let WorkMethod = tape[ptr++]; + return new IfcTaskType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ProcessType, PredefinedType, WorkMethod); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.ProcessType); + ; + args.push(this.PredefinedType); + ; + args.push(this.WorkMethod); + ; + return args; + } +}; +var IfcTelecomAddress = class { + constructor(expressID, type, Purpose, Description, UserDefinedPurpose, TelephoneNumbers, FacsimileNumbers, PagerNumber, ElectronicMailAddresses, WWWHomePageURL, MessagingIDs) { + this.expressID = expressID; + this.type = type; + this.Purpose = Purpose; + this.Description = Description; + this.UserDefinedPurpose = UserDefinedPurpose; + this.TelephoneNumbers = TelephoneNumbers; + this.FacsimileNumbers = FacsimileNumbers; + this.PagerNumber = PagerNumber; + this.ElectronicMailAddresses = ElectronicMailAddresses; + this.WWWHomePageURL = WWWHomePageURL; + this.MessagingIDs = MessagingIDs; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Purpose = tape[ptr++]; + let Description = tape[ptr++]; + let UserDefinedPurpose = tape[ptr++]; + let TelephoneNumbers = tape[ptr++]; + let FacsimileNumbers = tape[ptr++]; + let PagerNumber = tape[ptr++]; + let ElectronicMailAddresses = tape[ptr++]; + let WWWHomePageURL = tape[ptr++]; + let MessagingIDs = tape[ptr++]; + return new IfcTelecomAddress(expressID, type, Purpose, Description, UserDefinedPurpose, TelephoneNumbers, FacsimileNumbers, PagerNumber, ElectronicMailAddresses, WWWHomePageURL, MessagingIDs); + } + ToTape() { + let args = []; + args.push(this.Purpose); + ; + args.push(this.Description); + ; + args.push(this.UserDefinedPurpose); + ; + args.push(this.TelephoneNumbers); + ; + args.push(this.FacsimileNumbers); + ; + args.push(this.PagerNumber); + ; + args.push(this.ElectronicMailAddresses); + ; + args.push(this.WWWHomePageURL); + ; + args.push(this.MessagingIDs); + ; + return args; + } +}; +var IfcTendon = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, SteelGrade, PredefinedType, NominalDiameter, CrossSectionArea, TensionForce, PreStress, FrictionCoefficient, AnchorageSlip, MinCurvatureRadius) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.SteelGrade = SteelGrade; + this.PredefinedType = PredefinedType; + this.NominalDiameter = NominalDiameter; + this.CrossSectionArea = CrossSectionArea; + this.TensionForce = TensionForce; + this.PreStress = PreStress; + this.FrictionCoefficient = FrictionCoefficient; + this.AnchorageSlip = AnchorageSlip; + this.MinCurvatureRadius = MinCurvatureRadius; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let SteelGrade = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let NominalDiameter = tape[ptr++]; + let CrossSectionArea = tape[ptr++]; + let TensionForce = tape[ptr++]; + let PreStress = tape[ptr++]; + let FrictionCoefficient = tape[ptr++]; + let AnchorageSlip = tape[ptr++]; + let MinCurvatureRadius = tape[ptr++]; + return new IfcTendon(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, SteelGrade, PredefinedType, NominalDiameter, CrossSectionArea, TensionForce, PreStress, FrictionCoefficient, AnchorageSlip, MinCurvatureRadius); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.SteelGrade); + ; + args.push(this.PredefinedType); + ; + args.push(this.NominalDiameter); + ; + args.push(this.CrossSectionArea); + ; + args.push(this.TensionForce); + ; + args.push(this.PreStress); + ; + args.push(this.FrictionCoefficient); + ; + args.push(this.AnchorageSlip); + ; + args.push(this.MinCurvatureRadius); + ; + return args; + } +}; +var IfcTendonAnchor = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, SteelGrade, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.SteelGrade = SteelGrade; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let SteelGrade = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcTendonAnchor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, SteelGrade, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.SteelGrade); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcTendonAnchorType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcTendonAnchorType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcTendonConduit = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, SteelGrade, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.SteelGrade = SteelGrade; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let SteelGrade = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcTendonConduit(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, SteelGrade, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.SteelGrade); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcTendonConduitType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcTendonConduitType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcTendonType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType, NominalDiameter, CrossSectionArea, SheathDiameter) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + this.NominalDiameter = NominalDiameter; + this.CrossSectionArea = CrossSectionArea; + this.SheathDiameter = SheathDiameter; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let NominalDiameter = tape[ptr++]; + let CrossSectionArea = tape[ptr++]; + let SheathDiameter = tape[ptr++]; + return new IfcTendonType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType, NominalDiameter, CrossSectionArea, SheathDiameter); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + args.push(this.NominalDiameter); + ; + args.push(this.CrossSectionArea); + ; + args.push(this.SheathDiameter); + ; + return args; + } +}; +var IfcTessellatedFaceSet = class { + constructor(expressID, type, Coordinates) { + this.expressID = expressID; + this.type = type; + this.Coordinates = Coordinates; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Coordinates = tape[ptr++]; + return new IfcTessellatedFaceSet(expressID, type, Coordinates); + } + ToTape() { + let args = []; + args.push(this.Coordinates); + ; + return args; + } +}; +var IfcTessellatedItem = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcTessellatedItem(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcTextLiteral = class { + constructor(expressID, type, Literal, Placement, Path) { + this.expressID = expressID; + this.type = type; + this.Literal = Literal; + this.Placement = Placement; + this.Path = Path; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Literal = tape[ptr++]; + let Placement = tape[ptr++]; + let Path = tape[ptr++]; + return new IfcTextLiteral(expressID, type, Literal, Placement, Path); + } + ToTape() { + let args = []; + args.push(this.Literal); + ; + args.push(this.Placement); + ; + args.push(this.Path); + ; + return args; + } +}; +var IfcTextLiteralWithExtent = class { + constructor(expressID, type, Literal, Placement, Path, Extent, BoxAlignment) { + this.expressID = expressID; + this.type = type; + this.Literal = Literal; + this.Placement = Placement; + this.Path = Path; + this.Extent = Extent; + this.BoxAlignment = BoxAlignment; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Literal = tape[ptr++]; + let Placement = tape[ptr++]; + let Path = tape[ptr++]; + let Extent = tape[ptr++]; + let BoxAlignment = tape[ptr++]; + return new IfcTextLiteralWithExtent(expressID, type, Literal, Placement, Path, Extent, BoxAlignment); + } + ToTape() { + let args = []; + args.push(this.Literal); + ; + args.push(this.Placement); + ; + args.push(this.Path); + ; + args.push(this.Extent); + ; + args.push(this.BoxAlignment); + ; + return args; + } +}; +var IfcTextStyle = class { + constructor(expressID, type, Name, TextCharacterAppearance, TextStyle, TextFontStyle, ModelOrDraughting) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.TextCharacterAppearance = TextCharacterAppearance; + this.TextStyle = TextStyle; + this.TextFontStyle = TextFontStyle; + this.ModelOrDraughting = ModelOrDraughting; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let TextCharacterAppearance = tape[ptr++]; + let TextStyle = tape[ptr++]; + let TextFontStyle = tape[ptr++]; + let ModelOrDraughting = tape[ptr++]; + return new IfcTextStyle(expressID, type, Name, TextCharacterAppearance, TextStyle, TextFontStyle, ModelOrDraughting); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.TextCharacterAppearance); + ; + args.push(this.TextStyle); + ; + args.push(this.TextFontStyle); + ; + args.push(this.ModelOrDraughting); + ; + return args; + } +}; +var IfcTextStyleFontModel = class { + constructor(expressID, type, Name, FontFamily, FontStyle, FontVariant, FontWeight, FontSize) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.FontFamily = FontFamily; + this.FontStyle = FontStyle; + this.FontVariant = FontVariant; + this.FontWeight = FontWeight; + this.FontSize = FontSize; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let FontFamily = tape[ptr++]; + let FontStyle = tape[ptr++]; + let FontVariant = tape[ptr++]; + let FontWeight = tape[ptr++]; + let FontSize = tape[ptr++]; + return new IfcTextStyleFontModel(expressID, type, Name, FontFamily, FontStyle, FontVariant, FontWeight, FontSize); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.FontFamily); + ; + args.push(this.FontStyle); + ; + args.push(this.FontVariant); + ; + args.push(this.FontWeight); + ; + args.push(this.FontSize); + ; + return args; + } +}; +var IfcTextStyleForDefinedFont = class { + constructor(expressID, type, Colour, BackgroundColour) { + this.expressID = expressID; + this.type = type; + this.Colour = Colour; + this.BackgroundColour = BackgroundColour; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Colour = tape[ptr++]; + let BackgroundColour = tape[ptr++]; + return new IfcTextStyleForDefinedFont(expressID, type, Colour, BackgroundColour); + } + ToTape() { + let args = []; + args.push(this.Colour); + ; + args.push(this.BackgroundColour); + ; + return args; + } +}; +var IfcTextStyleTextModel = class { + constructor(expressID, type, TextIndent, TextAlign, TextDecoration, LetterSpacing, WordSpacing, TextTransform, LineHeight) { + this.expressID = expressID; + this.type = type; + this.TextIndent = TextIndent; + this.TextAlign = TextAlign; + this.TextDecoration = TextDecoration; + this.LetterSpacing = LetterSpacing; + this.WordSpacing = WordSpacing; + this.TextTransform = TextTransform; + this.LineHeight = LineHeight; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let TextIndent = tape[ptr++]; + let TextAlign = tape[ptr++]; + let TextDecoration = tape[ptr++]; + let LetterSpacing = tape[ptr++]; + let WordSpacing = tape[ptr++]; + let TextTransform = tape[ptr++]; + let LineHeight = tape[ptr++]; + return new IfcTextStyleTextModel(expressID, type, TextIndent, TextAlign, TextDecoration, LetterSpacing, WordSpacing, TextTransform, LineHeight); + } + ToTape() { + let args = []; + args.push(this.TextIndent); + ; + args.push(this.TextAlign); + ; + args.push(this.TextDecoration); + ; + args.push(this.LetterSpacing); + ; + args.push(this.WordSpacing); + ; + args.push(this.TextTransform); + ; + args.push(this.LineHeight); + ; + return args; + } +}; +var IfcTextureCoordinate = class { + constructor(expressID, type, Maps) { + this.expressID = expressID; + this.type = type; + this.Maps = Maps; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Maps = tape[ptr++]; + return new IfcTextureCoordinate(expressID, type, Maps); + } + ToTape() { + let args = []; + args.push(this.Maps); + ; + return args; + } +}; +var IfcTextureCoordinateGenerator = class { + constructor(expressID, type, Maps, Mode, Parameter) { + this.expressID = expressID; + this.type = type; + this.Maps = Maps; + this.Mode = Mode; + this.Parameter = Parameter; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Maps = tape[ptr++]; + let Mode = tape[ptr++]; + let Parameter = tape[ptr++]; + return new IfcTextureCoordinateGenerator(expressID, type, Maps, Mode, Parameter); + } + ToTape() { + let args = []; + args.push(this.Maps); + ; + args.push(this.Mode); + ; + args.push(this.Parameter); + ; + return args; + } +}; +var IfcTextureMap = class { + constructor(expressID, type, Maps, Vertices, MappedTo) { + this.expressID = expressID; + this.type = type; + this.Maps = Maps; + this.Vertices = Vertices; + this.MappedTo = MappedTo; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Maps = tape[ptr++]; + let Vertices = tape[ptr++]; + let MappedTo = tape[ptr++]; + return new IfcTextureMap(expressID, type, Maps, Vertices, MappedTo); + } + ToTape() { + let args = []; + args.push(this.Maps); + ; + args.push(this.Vertices); + ; + args.push(this.MappedTo); + ; + return args; + } +}; +var IfcTextureVertex = class { + constructor(expressID, type, Coordinates) { + this.expressID = expressID; + this.type = type; + this.Coordinates = Coordinates; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Coordinates = tape[ptr++]; + return new IfcTextureVertex(expressID, type, Coordinates); + } + ToTape() { + let args = []; + args.push(this.Coordinates); + ; + return args; + } +}; +var IfcTextureVertexList = class { + constructor(expressID, type, TexCoordsList) { + this.expressID = expressID; + this.type = type; + this.TexCoordsList = TexCoordsList; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let TexCoordsList = tape[ptr++]; + return new IfcTextureVertexList(expressID, type, TexCoordsList); + } + ToTape() { + let args = []; + args.push(this.TexCoordsList); + ; + return args; + } +}; +var IfcTimePeriod = class { + constructor(expressID, type, StartTime, EndTime) { + this.expressID = expressID; + this.type = type; + this.StartTime = StartTime; + this.EndTime = EndTime; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let StartTime = tape[ptr++]; + let EndTime = tape[ptr++]; + return new IfcTimePeriod(expressID, type, StartTime, EndTime); + } + ToTape() { + let args = []; + args.push(this.StartTime); + ; + args.push(this.EndTime); + ; + return args; + } +}; +var IfcTimeSeries = class { + constructor(expressID, type, Name, Description, StartTime, EndTime, TimeSeriesDataType, DataOrigin, UserDefinedDataOrigin, Unit) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.Description = Description; + this.StartTime = StartTime; + this.EndTime = EndTime; + this.TimeSeriesDataType = TimeSeriesDataType; + this.DataOrigin = DataOrigin; + this.UserDefinedDataOrigin = UserDefinedDataOrigin; + this.Unit = Unit; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let StartTime = tape[ptr++]; + let EndTime = tape[ptr++]; + let TimeSeriesDataType = tape[ptr++]; + let DataOrigin = tape[ptr++]; + let UserDefinedDataOrigin = tape[ptr++]; + let Unit = tape[ptr++]; + return new IfcTimeSeries(expressID, type, Name, Description, StartTime, EndTime, TimeSeriesDataType, DataOrigin, UserDefinedDataOrigin, Unit); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.StartTime); + ; + args.push(this.EndTime); + ; + args.push(this.TimeSeriesDataType); + ; + args.push(this.DataOrigin); + ; + args.push(this.UserDefinedDataOrigin); + ; + args.push(this.Unit); + ; + return args; + } +}; +var IfcTimeSeriesValue = class { + constructor(expressID, type, ListValues) { + this.expressID = expressID; + this.type = type; + this.ListValues = ListValues; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ListValues = tape[ptr++]; + return new IfcTimeSeriesValue(expressID, type, ListValues); + } + ToTape() { + let args = []; + args.push(this.ListValues); + ; + return args; + } +}; +var IfcTopologicalRepresentationItem = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcTopologicalRepresentationItem(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcTopologyRepresentation = class { + constructor(expressID, type, ContextOfItems, RepresentationIdentifier, RepresentationType, Items) { + this.expressID = expressID; + this.type = type; + this.ContextOfItems = ContextOfItems; + this.RepresentationIdentifier = RepresentationIdentifier; + this.RepresentationType = RepresentationType; + this.Items = Items; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ContextOfItems = tape[ptr++]; + let RepresentationIdentifier = tape[ptr++]; + let RepresentationType = tape[ptr++]; + let Items = tape[ptr++]; + return new IfcTopologyRepresentation(expressID, type, ContextOfItems, RepresentationIdentifier, RepresentationType, Items); + } + ToTape() { + let args = []; + args.push(this.ContextOfItems); + ; + args.push(this.RepresentationIdentifier); + ; + args.push(this.RepresentationType); + ; + args.push(this.Items); + ; + return args; + } +}; +var IfcToroidalSurface = class { + constructor(expressID, type, Position, MajorRadius, MinorRadius) { + this.expressID = expressID; + this.type = type; + this.Position = Position; + this.MajorRadius = MajorRadius; + this.MinorRadius = MinorRadius; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Position = tape[ptr++]; + let MajorRadius = tape[ptr++]; + let MinorRadius = tape[ptr++]; + return new IfcToroidalSurface(expressID, type, Position, MajorRadius, MinorRadius); + } + ToTape() { + let args = []; + args.push(this.Position); + ; + args.push(this.MajorRadius); + ; + args.push(this.MinorRadius); + ; + return args; + } +}; +var IfcTransformer = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcTransformer(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcTransformerType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcTransformerType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcTransitionCurveSegment2D = class { + constructor(expressID, type, StartPoint, StartDirection, SegmentLength, StartRadius, EndRadius, IsStartRadiusCCW, IsEndRadiusCCW, TransitionCurveType) { + this.expressID = expressID; + this.type = type; + this.StartPoint = StartPoint; + this.StartDirection = StartDirection; + this.SegmentLength = SegmentLength; + this.StartRadius = StartRadius; + this.EndRadius = EndRadius; + this.IsStartRadiusCCW = IsStartRadiusCCW; + this.IsEndRadiusCCW = IsEndRadiusCCW; + this.TransitionCurveType = TransitionCurveType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let StartPoint = tape[ptr++]; + let StartDirection = tape[ptr++]; + let SegmentLength = tape[ptr++]; + let StartRadius = tape[ptr++]; + let EndRadius = tape[ptr++]; + let IsStartRadiusCCW = tape[ptr++]; + let IsEndRadiusCCW = tape[ptr++]; + let TransitionCurveType = tape[ptr++]; + return new IfcTransitionCurveSegment2D(expressID, type, StartPoint, StartDirection, SegmentLength, StartRadius, EndRadius, IsStartRadiusCCW, IsEndRadiusCCW, TransitionCurveType); + } + ToTape() { + let args = []; + args.push(this.StartPoint); + ; + args.push(this.StartDirection); + ; + args.push(this.SegmentLength); + ; + args.push(this.StartRadius); + ; + args.push(this.EndRadius); + ; + args.push(this.IsStartRadiusCCW); + ; + args.push(this.IsEndRadiusCCW); + ; + args.push(this.TransitionCurveType); + ; + return args; + } +}; +var IfcTransportElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcTransportElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcTransportElementType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcTransportElementType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcTrapeziumProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, Position, BottomXDim, TopXDim, YDim, TopXOffset) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.Position = Position; + this.BottomXDim = BottomXDim; + this.TopXDim = TopXDim; + this.YDim = YDim; + this.TopXOffset = TopXOffset; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let Position = tape[ptr++]; + let BottomXDim = tape[ptr++]; + let TopXDim = tape[ptr++]; + let YDim = tape[ptr++]; + let TopXOffset = tape[ptr++]; + return new IfcTrapeziumProfileDef(expressID, type, ProfileType, ProfileName, Position, BottomXDim, TopXDim, YDim, TopXOffset); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.Position); + ; + args.push(this.BottomXDim); + ; + args.push(this.TopXDim); + ; + args.push(this.YDim); + ; + args.push(this.TopXOffset); + ; + return args; + } +}; +var IfcTriangulatedFaceSet = class { + constructor(expressID, type, Coordinates, Normals, Closed, CoordIndex, PnIndex) { + this.expressID = expressID; + this.type = type; + this.Coordinates = Coordinates; + this.Normals = Normals; + this.Closed = Closed; + this.CoordIndex = CoordIndex; + this.PnIndex = PnIndex; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Coordinates = tape[ptr++]; + let Normals = tape[ptr++]; + let Closed = tape[ptr++]; + let CoordIndex = tape[ptr++]; + let PnIndex = tape[ptr++]; + return new IfcTriangulatedFaceSet(expressID, type, Coordinates, Normals, Closed, CoordIndex, PnIndex); + } + ToTape() { + let args = []; + args.push(this.Coordinates); + ; + args.push(this.Normals); + ; + args.push(this.Closed); + ; + args.push(this.CoordIndex); + ; + args.push(this.PnIndex); + ; + return args; + } +}; +var IfcTriangulatedIrregularNetwork = class { + constructor(expressID, type, Coordinates, Normals, Closed, CoordIndex, PnIndex, Flags) { + this.expressID = expressID; + this.type = type; + this.Coordinates = Coordinates; + this.Normals = Normals; + this.Closed = Closed; + this.CoordIndex = CoordIndex; + this.PnIndex = PnIndex; + this.Flags = Flags; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Coordinates = tape[ptr++]; + let Normals = tape[ptr++]; + let Closed = tape[ptr++]; + let CoordIndex = tape[ptr++]; + let PnIndex = tape[ptr++]; + let Flags = tape[ptr++]; + return new IfcTriangulatedIrregularNetwork(expressID, type, Coordinates, Normals, Closed, CoordIndex, PnIndex, Flags); + } + ToTape() { + let args = []; + args.push(this.Coordinates); + ; + args.push(this.Normals); + ; + args.push(this.Closed); + ; + args.push(this.CoordIndex); + ; + args.push(this.PnIndex); + ; + args.push(this.Flags); + ; + return args; + } +}; +var IfcTrimmedCurve = class { + constructor(expressID, type, BasisCurve, Trim1, Trim2, SenseAgreement, MasterRepresentation) { + this.expressID = expressID; + this.type = type; + this.BasisCurve = BasisCurve; + this.Trim1 = Trim1; + this.Trim2 = Trim2; + this.SenseAgreement = SenseAgreement; + this.MasterRepresentation = MasterRepresentation; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let BasisCurve = tape[ptr++]; + let Trim1 = tape[ptr++]; + let Trim2 = tape[ptr++]; + let SenseAgreement = tape[ptr++]; + let MasterRepresentation = tape[ptr++]; + return new IfcTrimmedCurve(expressID, type, BasisCurve, Trim1, Trim2, SenseAgreement, MasterRepresentation); + } + ToTape() { + let args = []; + args.push(this.BasisCurve); + ; + args.push(this.Trim1); + ; + args.push(this.Trim2); + ; + args.push(this.SenseAgreement); + ; + args.push(this.MasterRepresentation); + ; + return args; + } +}; +var IfcTubeBundle = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcTubeBundle(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcTubeBundleType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcTubeBundleType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcTypeObject = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + return new IfcTypeObject(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + return args; + } +}; +var IfcTypeProcess = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ProcessType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.ProcessType = ProcessType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let ProcessType = tape[ptr++]; + return new IfcTypeProcess(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ProcessType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.ProcessType); + ; + return args; + } +}; +var IfcTypeProduct = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcTypeProduct(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcTypeResource = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ResourceType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.Identification = Identification; + this.LongDescription = LongDescription; + this.ResourceType = ResourceType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let Identification = tape[ptr++]; + let LongDescription = tape[ptr++]; + let ResourceType = tape[ptr++]; + return new IfcTypeResource(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, Identification, LongDescription, ResourceType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.Identification); + ; + args.push(this.LongDescription); + ; + args.push(this.ResourceType); + ; + return args; + } +}; +var IfcUShapeProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, Position, Depth, FlangeWidth, WebThickness, FlangeThickness, FilletRadius, EdgeRadius, FlangeSlope) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.Position = Position; + this.Depth = Depth; + this.FlangeWidth = FlangeWidth; + this.WebThickness = WebThickness; + this.FlangeThickness = FlangeThickness; + this.FilletRadius = FilletRadius; + this.EdgeRadius = EdgeRadius; + this.FlangeSlope = FlangeSlope; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let Position = tape[ptr++]; + let Depth = tape[ptr++]; + let FlangeWidth = tape[ptr++]; + let WebThickness = tape[ptr++]; + let FlangeThickness = tape[ptr++]; + let FilletRadius = tape[ptr++]; + let EdgeRadius = tape[ptr++]; + let FlangeSlope = tape[ptr++]; + return new IfcUShapeProfileDef(expressID, type, ProfileType, ProfileName, Position, Depth, FlangeWidth, WebThickness, FlangeThickness, FilletRadius, EdgeRadius, FlangeSlope); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.Position); + ; + args.push(this.Depth); + ; + args.push(this.FlangeWidth); + ; + args.push(this.WebThickness); + ; + args.push(this.FlangeThickness); + ; + args.push(this.FilletRadius); + ; + args.push(this.EdgeRadius); + ; + args.push(this.FlangeSlope); + ; + return args; + } +}; +var IfcUnitAssignment = class { + constructor(expressID, type, Units) { + this.expressID = expressID; + this.type = type; + this.Units = Units; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Units = tape[ptr++]; + return new IfcUnitAssignment(expressID, type, Units); + } + ToTape() { + let args = []; + args.push(this.Units); + ; + return args; + } +}; +var IfcUnitaryControlElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcUnitaryControlElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcUnitaryControlElementType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcUnitaryControlElementType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcUnitaryEquipment = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcUnitaryEquipment(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcUnitaryEquipmentType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcUnitaryEquipmentType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcValve = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcValve(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcValveType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcValveType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcVector = class { + constructor(expressID, type, Orientation, Magnitude) { + this.expressID = expressID; + this.type = type; + this.Orientation = Orientation; + this.Magnitude = Magnitude; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Orientation = tape[ptr++]; + let Magnitude = tape[ptr++]; + return new IfcVector(expressID, type, Orientation, Magnitude); + } + ToTape() { + let args = []; + args.push(this.Orientation); + ; + args.push(this.Magnitude); + ; + return args; + } +}; +var IfcVertex = class { + constructor(expressID, type) { + this.expressID = expressID; + this.type = type; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + return new IfcVertex(expressID, type); + } + ToTape() { + let args = []; + return args; + } +}; +var IfcVertexLoop = class { + constructor(expressID, type, LoopVertex) { + this.expressID = expressID; + this.type = type; + this.LoopVertex = LoopVertex; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let LoopVertex = tape[ptr++]; + return new IfcVertexLoop(expressID, type, LoopVertex); + } + ToTape() { + let args = []; + args.push(this.LoopVertex); + ; + return args; + } +}; +var IfcVertexPoint = class { + constructor(expressID, type, VertexGeometry) { + this.expressID = expressID; + this.type = type; + this.VertexGeometry = VertexGeometry; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let VertexGeometry = tape[ptr++]; + return new IfcVertexPoint(expressID, type, VertexGeometry); + } + ToTape() { + let args = []; + args.push(this.VertexGeometry); + ; + return args; + } +}; +var IfcVibrationDamper = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcVibrationDamper(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcVibrationDamperType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcVibrationDamperType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcVibrationIsolator = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcVibrationIsolator(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcVibrationIsolatorType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcVibrationIsolatorType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcVirtualElement = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + return new IfcVirtualElement(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + return args; + } +}; +var IfcVirtualGridIntersection = class { + constructor(expressID, type, IntersectingAxes, OffsetDistances) { + this.expressID = expressID; + this.type = type; + this.IntersectingAxes = IntersectingAxes; + this.OffsetDistances = OffsetDistances; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let IntersectingAxes = tape[ptr++]; + let OffsetDistances = tape[ptr++]; + return new IfcVirtualGridIntersection(expressID, type, IntersectingAxes, OffsetDistances); + } + ToTape() { + let args = []; + args.push(this.IntersectingAxes); + ; + args.push(this.OffsetDistances); + ; + return args; + } +}; +var IfcVoidingFeature = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcVoidingFeature(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcWall = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcWall(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcWallElementedCase = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcWallElementedCase(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcWallStandardCase = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcWallStandardCase(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcWallType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcWallType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcWasteTerminal = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcWasteTerminal(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcWasteTerminalType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcWasteTerminalType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcWindow = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, OverallHeight, OverallWidth, PredefinedType, PartitioningType, UserDefinedPartitioningType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.OverallHeight = OverallHeight; + this.OverallWidth = OverallWidth; + this.PredefinedType = PredefinedType; + this.PartitioningType = PartitioningType; + this.UserDefinedPartitioningType = UserDefinedPartitioningType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let OverallHeight = tape[ptr++]; + let OverallWidth = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let PartitioningType = tape[ptr++]; + let UserDefinedPartitioningType = tape[ptr++]; + return new IfcWindow(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, OverallHeight, OverallWidth, PredefinedType, PartitioningType, UserDefinedPartitioningType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.OverallHeight); + ; + args.push(this.OverallWidth); + ; + args.push(this.PredefinedType); + ; + args.push(this.PartitioningType); + ; + args.push(this.UserDefinedPartitioningType); + ; + return args; + } +}; +var IfcWindowLiningProperties = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, LiningDepth, LiningThickness, TransomThickness, MullionThickness, FirstTransomOffset, SecondTransomOffset, FirstMullionOffset, SecondMullionOffset, ShapeAspectStyle, LiningOffset, LiningToPanelOffsetX, LiningToPanelOffsetY) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.LiningDepth = LiningDepth; + this.LiningThickness = LiningThickness; + this.TransomThickness = TransomThickness; + this.MullionThickness = MullionThickness; + this.FirstTransomOffset = FirstTransomOffset; + this.SecondTransomOffset = SecondTransomOffset; + this.FirstMullionOffset = FirstMullionOffset; + this.SecondMullionOffset = SecondMullionOffset; + this.ShapeAspectStyle = ShapeAspectStyle; + this.LiningOffset = LiningOffset; + this.LiningToPanelOffsetX = LiningToPanelOffsetX; + this.LiningToPanelOffsetY = LiningToPanelOffsetY; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let LiningDepth = tape[ptr++]; + let LiningThickness = tape[ptr++]; + let TransomThickness = tape[ptr++]; + let MullionThickness = tape[ptr++]; + let FirstTransomOffset = tape[ptr++]; + let SecondTransomOffset = tape[ptr++]; + let FirstMullionOffset = tape[ptr++]; + let SecondMullionOffset = tape[ptr++]; + let ShapeAspectStyle = tape[ptr++]; + let LiningOffset = tape[ptr++]; + let LiningToPanelOffsetX = tape[ptr++]; + let LiningToPanelOffsetY = tape[ptr++]; + return new IfcWindowLiningProperties(expressID, type, GlobalId, OwnerHistory, Name, Description, LiningDepth, LiningThickness, TransomThickness, MullionThickness, FirstTransomOffset, SecondTransomOffset, FirstMullionOffset, SecondMullionOffset, ShapeAspectStyle, LiningOffset, LiningToPanelOffsetX, LiningToPanelOffsetY); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.LiningDepth); + ; + args.push(this.LiningThickness); + ; + args.push(this.TransomThickness); + ; + args.push(this.MullionThickness); + ; + args.push(this.FirstTransomOffset); + ; + args.push(this.SecondTransomOffset); + ; + args.push(this.FirstMullionOffset); + ; + args.push(this.SecondMullionOffset); + ; + args.push(this.ShapeAspectStyle); + ; + args.push(this.LiningOffset); + ; + args.push(this.LiningToPanelOffsetX); + ; + args.push(this.LiningToPanelOffsetY); + ; + return args; + } +}; +var IfcWindowPanelProperties = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, OperationType, PanelPosition, FrameDepth, FrameThickness, ShapeAspectStyle) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.OperationType = OperationType; + this.PanelPosition = PanelPosition; + this.FrameDepth = FrameDepth; + this.FrameThickness = FrameThickness; + this.ShapeAspectStyle = ShapeAspectStyle; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let OperationType = tape[ptr++]; + let PanelPosition = tape[ptr++]; + let FrameDepth = tape[ptr++]; + let FrameThickness = tape[ptr++]; + let ShapeAspectStyle = tape[ptr++]; + return new IfcWindowPanelProperties(expressID, type, GlobalId, OwnerHistory, Name, Description, OperationType, PanelPosition, FrameDepth, FrameThickness, ShapeAspectStyle); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.OperationType); + ; + args.push(this.PanelPosition); + ; + args.push(this.FrameDepth); + ; + args.push(this.FrameThickness); + ; + args.push(this.ShapeAspectStyle); + ; + return args; + } +}; +var IfcWindowStandardCase = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, OverallHeight, OverallWidth, PredefinedType, PartitioningType, UserDefinedPartitioningType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.ObjectPlacement = ObjectPlacement; + this.Representation = Representation; + this.Tag = Tag; + this.OverallHeight = OverallHeight; + this.OverallWidth = OverallWidth; + this.PredefinedType = PredefinedType; + this.PartitioningType = PartitioningType; + this.UserDefinedPartitioningType = UserDefinedPartitioningType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let ObjectPlacement = tape[ptr++]; + let Representation = tape[ptr++]; + let Tag = tape[ptr++]; + let OverallHeight = tape[ptr++]; + let OverallWidth = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let PartitioningType = tape[ptr++]; + let UserDefinedPartitioningType = tape[ptr++]; + return new IfcWindowStandardCase(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, ObjectPlacement, Representation, Tag, OverallHeight, OverallWidth, PredefinedType, PartitioningType, UserDefinedPartitioningType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.ObjectPlacement); + ; + args.push(this.Representation); + ; + args.push(this.Tag); + ; + args.push(this.OverallHeight); + ; + args.push(this.OverallWidth); + ; + args.push(this.PredefinedType); + ; + args.push(this.PartitioningType); + ; + args.push(this.UserDefinedPartitioningType); + ; + return args; + } +}; +var IfcWindowStyle = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ConstructionType, OperationType, ParameterTakesPrecedence, Sizeable) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ConstructionType = ConstructionType; + this.OperationType = OperationType; + this.ParameterTakesPrecedence = ParameterTakesPrecedence; + this.Sizeable = Sizeable; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ConstructionType = tape[ptr++]; + let OperationType = tape[ptr++]; + let ParameterTakesPrecedence = tape[ptr++]; + let Sizeable = tape[ptr++]; + return new IfcWindowStyle(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ConstructionType, OperationType, ParameterTakesPrecedence, Sizeable); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ConstructionType); + ; + args.push(this.OperationType); + ; + args.push(this.ParameterTakesPrecedence); + ; + args.push(this.Sizeable); + ; + return args; + } +}; +var IfcWindowType = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType, PartitioningType, ParameterTakesPrecedence, UserDefinedPartitioningType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ApplicableOccurrence = ApplicableOccurrence; + this.HasPropertySets = HasPropertySets; + this.RepresentationMaps = RepresentationMaps; + this.Tag = Tag; + this.ElementType = ElementType; + this.PredefinedType = PredefinedType; + this.PartitioningType = PartitioningType; + this.ParameterTakesPrecedence = ParameterTakesPrecedence; + this.UserDefinedPartitioningType = UserDefinedPartitioningType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ApplicableOccurrence = tape[ptr++]; + let HasPropertySets = tape[ptr++]; + let RepresentationMaps = tape[ptr++]; + let Tag = tape[ptr++]; + let ElementType = tape[ptr++]; + let PredefinedType = tape[ptr++]; + let PartitioningType = tape[ptr++]; + let ParameterTakesPrecedence = tape[ptr++]; + let UserDefinedPartitioningType = tape[ptr++]; + return new IfcWindowType(expressID, type, GlobalId, OwnerHistory, Name, Description, ApplicableOccurrence, HasPropertySets, RepresentationMaps, Tag, ElementType, PredefinedType, PartitioningType, ParameterTakesPrecedence, UserDefinedPartitioningType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ApplicableOccurrence); + ; + args.push(this.HasPropertySets); + ; + args.push(this.RepresentationMaps); + ; + args.push(this.Tag); + ; + args.push(this.ElementType); + ; + args.push(this.PredefinedType); + ; + args.push(this.PartitioningType); + ; + args.push(this.ParameterTakesPrecedence); + ; + args.push(this.UserDefinedPartitioningType); + ; + return args; + } +}; +var IfcWorkCalendar = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, WorkingTimes, ExceptionTimes, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.WorkingTimes = WorkingTimes; + this.ExceptionTimes = ExceptionTimes; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let WorkingTimes = tape[ptr++]; + let ExceptionTimes = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcWorkCalendar(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, WorkingTimes, ExceptionTimes, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.WorkingTimes); + ; + args.push(this.ExceptionTimes); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcWorkControl = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, CreationDate, Creators, Purpose, Duration, TotalFloat, StartTime, FinishTime) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.CreationDate = CreationDate; + this.Creators = Creators; + this.Purpose = Purpose; + this.Duration = Duration; + this.TotalFloat = TotalFloat; + this.StartTime = StartTime; + this.FinishTime = FinishTime; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let CreationDate = tape[ptr++]; + let Creators = tape[ptr++]; + let Purpose = tape[ptr++]; + let Duration = tape[ptr++]; + let TotalFloat = tape[ptr++]; + let StartTime = tape[ptr++]; + let FinishTime = tape[ptr++]; + return new IfcWorkControl(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, CreationDate, Creators, Purpose, Duration, TotalFloat, StartTime, FinishTime); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.CreationDate); + ; + args.push(this.Creators); + ; + args.push(this.Purpose); + ; + args.push(this.Duration); + ; + args.push(this.TotalFloat); + ; + args.push(this.StartTime); + ; + args.push(this.FinishTime); + ; + return args; + } +}; +var IfcWorkPlan = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, CreationDate, Creators, Purpose, Duration, TotalFloat, StartTime, FinishTime, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.CreationDate = CreationDate; + this.Creators = Creators; + this.Purpose = Purpose; + this.Duration = Duration; + this.TotalFloat = TotalFloat; + this.StartTime = StartTime; + this.FinishTime = FinishTime; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let CreationDate = tape[ptr++]; + let Creators = tape[ptr++]; + let Purpose = tape[ptr++]; + let Duration = tape[ptr++]; + let TotalFloat = tape[ptr++]; + let StartTime = tape[ptr++]; + let FinishTime = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcWorkPlan(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, CreationDate, Creators, Purpose, Duration, TotalFloat, StartTime, FinishTime, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.CreationDate); + ; + args.push(this.Creators); + ; + args.push(this.Purpose); + ; + args.push(this.Duration); + ; + args.push(this.TotalFloat); + ; + args.push(this.StartTime); + ; + args.push(this.FinishTime); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcWorkSchedule = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, CreationDate, Creators, Purpose, Duration, TotalFloat, StartTime, FinishTime, PredefinedType) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.Identification = Identification; + this.CreationDate = CreationDate; + this.Creators = Creators; + this.Purpose = Purpose; + this.Duration = Duration; + this.TotalFloat = TotalFloat; + this.StartTime = StartTime; + this.FinishTime = FinishTime; + this.PredefinedType = PredefinedType; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let Identification = tape[ptr++]; + let CreationDate = tape[ptr++]; + let Creators = tape[ptr++]; + let Purpose = tape[ptr++]; + let Duration = tape[ptr++]; + let TotalFloat = tape[ptr++]; + let StartTime = tape[ptr++]; + let FinishTime = tape[ptr++]; + let PredefinedType = tape[ptr++]; + return new IfcWorkSchedule(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, Identification, CreationDate, Creators, Purpose, Duration, TotalFloat, StartTime, FinishTime, PredefinedType); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.Identification); + ; + args.push(this.CreationDate); + ; + args.push(this.Creators); + ; + args.push(this.Purpose); + ; + args.push(this.Duration); + ; + args.push(this.TotalFloat); + ; + args.push(this.StartTime); + ; + args.push(this.FinishTime); + ; + args.push(this.PredefinedType); + ; + return args; + } +}; +var IfcWorkTime = class { + constructor(expressID, type, Name, DataOrigin, UserDefinedDataOrigin, RecurrencePattern, Start, Finish) { + this.expressID = expressID; + this.type = type; + this.Name = Name; + this.DataOrigin = DataOrigin; + this.UserDefinedDataOrigin = UserDefinedDataOrigin; + this.RecurrencePattern = RecurrencePattern; + this.Start = Start; + this.Finish = Finish; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let Name = tape[ptr++]; + let DataOrigin = tape[ptr++]; + let UserDefinedDataOrigin = tape[ptr++]; + let RecurrencePattern = tape[ptr++]; + let Start = tape[ptr++]; + let Finish = tape[ptr++]; + return new IfcWorkTime(expressID, type, Name, DataOrigin, UserDefinedDataOrigin, RecurrencePattern, Start, Finish); + } + ToTape() { + let args = []; + args.push(this.Name); + ; + args.push(this.DataOrigin); + ; + args.push(this.UserDefinedDataOrigin); + ; + args.push(this.RecurrencePattern); + ; + args.push(this.Start); + ; + args.push(this.Finish); + ; + return args; + } +}; +var IfcZShapeProfileDef = class { + constructor(expressID, type, ProfileType, ProfileName, Position, Depth, FlangeWidth, WebThickness, FlangeThickness, FilletRadius, EdgeRadius) { + this.expressID = expressID; + this.type = type; + this.ProfileType = ProfileType; + this.ProfileName = ProfileName; + this.Position = Position; + this.Depth = Depth; + this.FlangeWidth = FlangeWidth; + this.WebThickness = WebThickness; + this.FlangeThickness = FlangeThickness; + this.FilletRadius = FilletRadius; + this.EdgeRadius = EdgeRadius; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let ProfileType = tape[ptr++]; + let ProfileName = tape[ptr++]; + let Position = tape[ptr++]; + let Depth = tape[ptr++]; + let FlangeWidth = tape[ptr++]; + let WebThickness = tape[ptr++]; + let FlangeThickness = tape[ptr++]; + let FilletRadius = tape[ptr++]; + let EdgeRadius = tape[ptr++]; + return new IfcZShapeProfileDef(expressID, type, ProfileType, ProfileName, Position, Depth, FlangeWidth, WebThickness, FlangeThickness, FilletRadius, EdgeRadius); + } + ToTape() { + let args = []; + args.push(this.ProfileType); + ; + args.push(this.ProfileName); + ; + args.push(this.Position); + ; + args.push(this.Depth); + ; + args.push(this.FlangeWidth); + ; + args.push(this.WebThickness); + ; + args.push(this.FlangeThickness); + ; + args.push(this.FilletRadius); + ; + args.push(this.EdgeRadius); + ; + return args; + } +}; +var IfcZone = class { + constructor(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, LongName) { + this.expressID = expressID; + this.type = type; + this.GlobalId = GlobalId; + this.OwnerHistory = OwnerHistory; + this.Name = Name; + this.Description = Description; + this.ObjectType = ObjectType; + this.LongName = LongName; + } + static FromTape(expressID, type, tape) { + let ptr = 0; + let GlobalId = tape[ptr++]; + let OwnerHistory = tape[ptr++]; + let Name = tape[ptr++]; + let Description = tape[ptr++]; + let ObjectType = tape[ptr++]; + let LongName = tape[ptr++]; + return new IfcZone(expressID, type, GlobalId, OwnerHistory, Name, Description, ObjectType, LongName); + } + ToTape() { + let args = []; + args.push(this.GlobalId); + ; + args.push(this.OwnerHistory); + ; + args.push(this.Name); + ; + args.push(this.Description); + ; + args.push(this.ObjectType); + ; + args.push(this.LongName); + ; + return args; + } +}; + +// dist/web-ifc-api.ts +var WebIFCWasm = require_web_ifc(); +var UNKNOWN = 0; +var STRING = 1; +var LABEL = 2; +var ENUM = 3; +var REAL = 4; +var REF = 5; +var EMPTY = 6; +var SET_BEGIN = 7; +var SET_END = 8; +var LINE_END = 9; +function ms() { + return new Date().getTime(); +} +var IfcAPI = class { + constructor() { + this.wasmModule = void 0; + this.fs = void 0; + } + async Init() { + if (WebIFCWasm) { + this.wasmModule = await WebIFCWasm({noInitialRun: true}); + this.fs = this.wasmModule.FS; + } else { + console.error(`Could not find wasm module at './web-ifc' from web-ifc-api.ts`); + } + } + OpenModel(data, settings) { + this.wasmModule["FS_createDataFile"]("/", "filename", data, true, true, true); + let s = settings ? settings : { + COORDINATE_TO_ORIGIN: false + }; + let result = this.wasmModule.OpenModel(s); + this.wasmModule["FS_unlink"]("/filename"); + return result; + } + ExportFileAsIFC(modelID) { + this.wasmModule.ExportFileAsIFC(modelID); + let result = this.fs.readFile("/export.ifc"); + this.wasmModule["FS_unlink"]("/export.ifc"); + return result; + } + GetGeometry(modelID, geometryExpressID) { + return this.wasmModule.GetGeometry(modelID, geometryExpressID); + } + GetLine(modelID, expressID, flatten = false) { + let rawLineData = this.GetRawLineData(modelID, expressID); + let lineData = FromRawLineData[rawLineData.type](rawLineData); + if (flatten) { + this.FlattenLine(modelID, lineData); + } + return lineData; + } + WriteLine(modelID, lineObject) { + Object.keys(lineObject).forEach((propertyName) => { + let property = lineObject[propertyName]; + if (property && property.expressID !== void 0) { + this.WriteLine(modelID, property); + lineObject[propertyName] = { + type: 5, + value: property.expressID + }; + } else if (Array.isArray(property) && property.length > 0) { + for (let i = 0; i < property.length; i++) { + if (property[i].expressID !== void 0) { + this.WriteLine(modelID, property[i]); + lineObject[propertyName][i] = { + type: 5, + value: property[i].expressID + }; + } + } + } + }); + let rawLineData = { + ID: lineObject.expressID, + type: lineObject.type, + arguments: lineObject.ToTape() + }; + this.WriteRawLineData(modelID, rawLineData); + } + FlattenLine(modelID, line) { + Object.keys(line).forEach((propertyName) => { + let property = line[propertyName]; + if (property && property.type === 5) { + line[propertyName] = this.GetLine(modelID, property.value, true); + } else if (Array.isArray(property) && property.length > 0 && property[0].type === 5) { + for (let i = 0; i < property.length; i++) { + line[propertyName][i] = this.GetLine(modelID, property[i].value, true); + } + } + }); + } + GetRawLineData(modelID, expressID) { + return this.wasmModule.GetLine(modelID, expressID); + } + WriteRawLineData(modelID, data) { + return this.wasmModule.WriteLine(modelID, data.ID, data.type, data.arguments); + } + GetLineIDsWithType(modelID, type) { + return this.wasmModule.GetLineIDsWithType(modelID, type); + } + GetAllLines(modelID) { + return this.wasmModule.GetAllLines(modelID); + } + SetGeometryTransformation(modelID, transformationMatrix) { + if (transformationMatrix.length != 16) { + console.log(`Bad transformation matrix size: ${transformationMatrix.length}`); + return; + } + this.wasmModule.SetGeometryTransformation(modelID, transformationMatrix); + } + GetVertexArray(ptr, size) { + return this.getSubArray(this.wasmModule.HEAPF32, ptr, size); + } + GetIndexArray(ptr, size) { + return this.getSubArray(this.wasmModule.HEAPU32, ptr, size); + } + getSubArray(heap, startPtr, sizeBytes) { + return heap.subarray(startPtr / 4, startPtr / 4 + sizeBytes).slice(0); + } + CloseModel(modelID) { + this.wasmModule.CloseModel(modelID); + } + IsModelOpen(modelID) { + return this.wasmModule.IsModelOpen(modelID); + } + LoadAllGeometry(modelID) { + return this.wasmModule.LoadAllGeometry(modelID); + } + SetWasmPath(path) { + WasmPath = path; + } +}; + + var WasmPath = ""; \ No newline at end of file diff --git a/libs/web-ifc.license.md b/libs/web-ifc.license.md new file mode 100644 index 0000000..6bd699b --- /dev/null +++ b/libs/web-ifc.license.md @@ -0,0 +1,375 @@ +Mozilla Public License Version 2.0 +================================== + +Copyright (c) 2020-2021 web-ifc contributors + +1. Definitions +-------------- + +1.1. "Contributor" + means each individual or legal entity that creates, contributes to + the creation of, or owns Covered Software. + +1.2. "Contributor Version" + means the combination of the Contributions of others (if any) used + by a Contributor and that particular Contributor's Contribution. + +1.3. "Contribution" + means Covered Software of a particular Contributor. + +1.4. "Covered Software" + means Source Code Form to which the initial Contributor has attached + the notice in Exhibit A, the Executable Form of such Source Code + Form, and Modifications of such Source Code Form, in each case + including portions thereof. + +1.5. "Incompatible With Secondary Licenses" + means + + (a) that the initial Contributor has attached the notice described + in Exhibit B to the Covered Software; or + + (b) that the Covered Software was made available under the terms of + version 1.1 or earlier of the License, but not also under the + terms of a Secondary License. + +1.6. "Executable Form" + means any form of the work other than Source Code Form. + +1.7. "Larger Work" + means a work that combines Covered Software with other material, in + a separate file or files, that is not Covered Software. + +1.8. "License" + means this document. + +1.9. "Licensable" + means having the right to grant, to the maximum extent possible, + whether at the time of the initial grant or subsequently, any and + all of the rights conveyed by this License. + +1.10. "Modifications" + means any of the following: + + (a) any file in Source Code Form that results from an addition to, + deletion from, or modification of the contents of Covered + Software; or + + (b) any new file in Source Code Form that contains any Covered + Software. + +1.11. "Patent Claims" of a Contributor + means any patent claim(s), including without limitation, method, + process, and apparatus claims, in any patent Licensable by such + Contributor that would be infringed, but for the grant of the + License, by the making, using, selling, offering for sale, having + made, import, or transfer of either its Contributions or its + Contributor Version. + +1.12. "Secondary License" + means either the GNU General Public License, Version 2.0, the GNU + Lesser General Public License, Version 2.1, the GNU Affero General + Public License, Version 3.0, or any later versions of those + licenses. + +1.13. "Source Code Form" + means the form of the work preferred for making modifications. + +1.14. "You" (or "Your") + means an individual or a legal entity exercising rights under this + License. For legal entities, "You" includes any entity that + controls, is controlled by, or is under common control with You. For + purposes of this definition, "control" means (a) the power, direct + or indirect, to cause the direction or management of such entity, + whether by contract or otherwise, or (b) ownership of more than + fifty percent (50%) of the outstanding shares or beneficial + ownership of such entity. + +2. License Grants and Conditions +-------------------------------- + +2.1. Grants + +Each Contributor hereby grants You a world-wide, royalty-free, +non-exclusive license: + +(a) under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or + as part of a Larger Work; and + +(b) under Patent Claims of such Contributor to make, use, sell, offer + for sale, have made, import, and otherwise transfer either its + Contributions or its Contributor Version. + +2.2. Effective Date + +The licenses granted in Section 2.1 with respect to any Contribution +become effective for each Contribution on the date the Contributor first +distributes such Contribution. + +2.3. Limitations on Grant Scope + +The licenses granted in this Section 2 are the only rights granted under +this License. No additional rights or licenses will be implied from the +distribution or licensing of Covered Software under this License. +Notwithstanding Section 2.1(b) above, no patent license is granted by a +Contributor: + +(a) for any code that a Contributor has removed from Covered Software; + or + +(b) for infringements caused by: (i) Your and any other third party's + modifications of Covered Software, or (ii) the combination of its + Contributions with other software (except as part of its Contributor + Version); or + +(c) under Patent Claims infringed by Covered Software in the absence of + its Contributions. + +This License does not grant any rights in the trademarks, service marks, +or logos of any Contributor (except as may be necessary to comply with +the notice requirements in Section 3.4). + +2.4. Subsequent Licenses + +No Contributor makes additional grants as a result of Your choice to +distribute the Covered Software under a subsequent version of this +License (see Section 10.2) or under the terms of a Secondary License (if +permitted under the terms of Section 3.3). + +2.5. Representation + +Each Contributor represents that the Contributor believes its +Contributions are its original creation(s) or it has sufficient rights +to grant the rights to its Contributions conveyed by this License. + +2.6. Fair Use + +This License is not intended to limit any rights You have under +applicable copyright doctrines of fair use, fair dealing, or other +equivalents. + +2.7. Conditions + +Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted +in Section 2.1. + +3. Responsibilities +------------------- + +3.1. Distribution of Source Form + +All distribution of Covered Software in Source Code Form, including any +Modifications that You create or to which You contribute, must be under +the terms of this License. You must inform recipients that the Source +Code Form of the Covered Software is governed by the terms of this +License, and how they can obtain a copy of this License. You may not +attempt to alter or restrict the recipients' rights in the Source Code +Form. + +3.2. Distribution of Executable Form + +If You distribute Covered Software in Executable Form then: + +(a) such Covered Software must also be made available in Source Code + Form, as described in Section 3.1, and You must inform recipients of + the Executable Form how they can obtain a copy of such Source Code + Form by reasonable means in a timely manner, at a charge no more + than the cost of distribution to the recipient; and + +(b) You may distribute such Executable Form under the terms of this + License, or sublicense it under different terms, provided that the + license for the Executable Form does not attempt to limit or alter + the recipients' rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + +You may create and distribute a Larger Work under terms of Your choice, +provided that You also comply with the requirements of this License for +the Covered Software. If the Larger Work is a combination of Covered +Software with a work governed by one or more Secondary Licenses, and the +Covered Software is not Incompatible With Secondary Licenses, this +License permits You to additionally distribute such Covered Software +under the terms of such Secondary License(s), so that the recipient of +the Larger Work may, at their option, further distribute the Covered +Software under the terms of either this License or such Secondary +License(s). + +3.4. Notices + +You may not remove or alter the substance of any license notices +(including copyright notices, patent notices, disclaimers of warranty, +or limitations of liability) contained within the Source Code Form of +the Covered Software, except that You may alter any license notices to +the extent required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + +You may choose to offer, and to charge a fee for, warranty, support, +indemnity or liability obligations to one or more recipients of Covered +Software. However, You may do so only on Your own behalf, and not on +behalf of any Contributor. You must make it absolutely clear that any +such warranty, support, indemnity, or liability obligation is offered by +You alone, and You hereby agree to indemnify every Contributor for any +liability incurred by such Contributor as a result of warranty, support, +indemnity or liability terms You offer. You may include additional +disclaimers of warranty and limitations of liability specific to any +jurisdiction. + +4. Inability to Comply Due to Statute or Regulation +--------------------------------------------------- + +If it is impossible for You to comply with any of the terms of this +License with respect to some or all of the Covered Software due to +statute, judicial order, or regulation then You must: (a) comply with +the terms of this License to the maximum extent possible; and (b) +describe the limitations and the code they affect. Such description must +be placed in a text file included with all distributions of the Covered +Software under this License. Except to the extent prohibited by statute +or regulation, such description must be sufficiently detailed for a +recipient of ordinary skill to be able to understand it. + +5. Termination +-------------- + +5.1. The rights granted under this License will terminate automatically +if You fail to comply with any of its terms. However, if You become +compliant, then the rights granted under this License from a particular +Contributor are reinstated (a) provisionally, unless and until such +Contributor explicitly and finally terminates Your grants, and (b) on an +ongoing basis, if such Contributor fails to notify You of the +non-compliance by some reasonable means prior to 60 days after You have +come back into compliance. Moreover, Your grants from a particular +Contributor are reinstated on an ongoing basis if such Contributor +notifies You of the non-compliance by some reasonable means, this is the +first time You have received notice of non-compliance with this License +from such Contributor, and You become compliant prior to 30 days after +Your receipt of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent +infringement claim (excluding declaratory judgment actions, +counter-claims, and cross-claims) alleging that a Contributor Version +directly or indirectly infringes any patent, then the rights granted to +You by any and all Contributors for the Covered Software under Section +2.1 of this License shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all +end user license agreements (excluding distributors and resellers) which +have been validly granted by You or Your distributors under this License +prior to termination shall survive termination. + +************************************************************************ +* * +* 6. Disclaimer of Warranty * +* ------------------------- * +* * +* Covered Software is provided under this License on an "as is" * +* basis, without warranty of any kind, either expressed, implied, or * +* statutory, including, without limitation, warranties that the * +* Covered Software is free of defects, merchantable, fit for a * +* particular purpose or non-infringing. The entire risk as to the * +* quality and performance of the Covered Software is with You. * +* Should any Covered Software prove defective in any respect, You * +* (not any Contributor) assume the cost of any necessary servicing, * +* repair, or correction. This disclaimer of warranty constitutes an * +* essential part of this License. No use of any Covered Software is * +* authorized under this License except under this disclaimer. * +* * +************************************************************************ + +************************************************************************ +* * +* 7. Limitation of Liability * +* -------------------------- * +* * +* Under no circumstances and under no legal theory, whether tort * +* (including negligence), contract, or otherwise, shall any * +* Contributor, or anyone who distributes Covered Software as * +* permitted above, be liable to You for any direct, indirect, * +* special, incidental, or consequential damages of any character * +* including, without limitation, damages for lost profits, loss of * +* goodwill, work stoppage, computer failure or malfunction, or any * +* and all other commercial damages or losses, even if such party * +* shall have been informed of the possibility of such damages. This * +* limitation of liability shall not apply to liability for death or * +* personal injury resulting from such party's negligence to the * +* extent applicable law prohibits such limitation. Some * +* jurisdictions do not allow the exclusion or limitation of * +* incidental or consequential damages, so this exclusion and * +* limitation may not apply to You. * +* * +************************************************************************ + +8. Litigation +------------- + +Any litigation relating to this License may be brought only in the +courts of a jurisdiction where the defendant maintains its principal +place of business and such litigation shall be governed by laws of that +jurisdiction, without reference to its conflict-of-law provisions. +Nothing in this Section shall prevent a party's ability to bring +cross-claims or counter-claims. + +9. Miscellaneous +---------------- + +This License represents the complete agreement concerning the subject +matter hereof. If any provision of this License is held to be +unenforceable, such provision shall be reformed only to the extent +necessary to make it enforceable. Any law or regulation which provides +that the language of a contract shall be construed against the drafter +shall not be used to construe this License against a Contributor. + +10. Versions of the License +--------------------------- + +10.1. New Versions + +Mozilla Foundation is the license steward. Except as provided in Section +10.3, no one other than the license steward has the right to modify or +publish new versions of this License. Each version will be given a +distinguishing version number. + +10.2. Effect of New Versions + +You may distribute the Covered Software under the terms of the version +of the License under which You originally received the Covered Software, +or under the terms of any subsequent version published by the license +steward. + +10.3. Modified Versions + +If you create software not governed by this License, and you want to +create a new license for such software, you may create and use a +modified version of this License if you rename the license and remove +any references to the name of the license steward (except to note that +such modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary +Licenses + +If You choose to distribute Source Code Form that is Incompatible With +Secondary Licenses under the terms of this version of the License, the +notice described in Exhibit B of this License must be attached. + +Exhibit A - Source Code Form License Notice +------------------------------------------- + + This Source Code Form is subject to the terms of the Mozilla Public + License, v. 2.0. If a copy of the MPL was not distributed with this + file, You can obtain one at http://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular +file, then You may include the notice in a location (such as a LICENSE +file in a relevant directory) where a recipient would be likely to look +for such a notice. + +You may add additional accurate notices of copyright ownership. + +Exhibit B - "Incompatible With Secondary Licenses" Notice +--------------------------------------------------------- + + This Source Code Form is "Incompatible With Secondary Licenses", as + defined by the Mozilla Public License, v. 2.0. \ No newline at end of file diff --git a/libs/web-ifc.wasm b/libs/web-ifc.wasm new file mode 100644 index 0000000000000000000000000000000000000000..176b4b0930513fb58728feb95bfc14f3ba751ace GIT binary patch literal 379639 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 literal 0 HcmV?d00001 diff --git a/sandbox/embed_selfhost_fullscreen.html b/sandbox/embed_selfhost_fullscreen.html index 9418ba4..eeef69e 100644 --- a/sandbox/embed_selfhost_fullscreen.html +++ b/sandbox/embed_selfhost_fullscreen.html @@ -56,6 +56,7 @@ + diff --git a/sandbox/embed_selfhost_multiple.html b/sandbox/embed_selfhost_multiple.html index f18425a..4f43e90 100644 --- a/sandbox/embed_selfhost_multiple.html +++ b/sandbox/embed_selfhost_multiple.html @@ -57,6 +57,7 @@ + diff --git a/sandbox/embed_selfhost_single.html b/sandbox/embed_selfhost_single.html index e4cbd66..99ef519 100644 --- a/sandbox/embed_selfhost_single.html +++ b/sandbox/embed_selfhost_single.html @@ -56,6 +56,7 @@ + diff --git a/sandbox/embed_selfhost_single_scroll.html b/sandbox/embed_selfhost_single_scroll.html index 0851ef8..25e28d9 100644 --- a/sandbox/embed_selfhost_single_scroll.html +++ b/sandbox/embed_selfhost_single_scroll.html @@ -56,6 +56,7 @@ + diff --git a/source/external/ifcimporter.js b/source/external/ifcimporter.js new file mode 100644 index 0000000..c1a06b4 --- /dev/null +++ b/source/external/ifcimporter.js @@ -0,0 +1,134 @@ +OV.ImporterIfc = class extends OV.ImporterBase +{ + constructor () + { + super (); + this.ifc = null; + } + + CanImportExtension (extension) + { + return extension === 'ifc'; + } + + GetKnownFileFormats () + { + return { + 'ifc' : OV.FileFormat.Binary + }; + } + + GetUpDirection () + { + return OV.Direction.Y; + } + + ClearContent () + { + this.materialNameToIndex = null; + } + + ResetContent () + { + this.materialNameToIndex = {}; + } + + ImportContent (fileContent, onFinish) + { + if (this.ifc === null) { + let obj = this; + OV.LoadExternalLibrary ('web-ifc-api.js', { + success : function () { + obj.ifc = new IfcAPI (); + obj.ifc.Init ().then (function () { + obj.ImportIfcContent (fileContent) + onFinish (); + }); + }, + error : function () { + onFinish (); + } + }); + } else { + // TODO: without another Init call it fails + // to load the same model multiple times + this.ImportIfcContent (fileContent); + onFinish (); + } + } + + ImportIfcContent (fileContent) + { + const fileBuffer = new Uint8Array (fileContent); + const modelID = this.ifc.OpenModel (fileBuffer, { + COORDINATE_TO_ORIGIN : true + }); + const ifcMeshes = this.ifc.LoadAllGeometry (modelID); + for (let meshIndex = 0; meshIndex < ifcMeshes.size (); meshIndex++) { + const ifcMesh = ifcMeshes.get (meshIndex); + this.ImportIfcMesh (modelID, ifcMesh); + } + } + + ImportIfcMesh (modelID, ifcMesh) + { + let mesh = new OV.Mesh (); + mesh.SetName ('Mesh ' + ifcMesh.expressID.toString ()); + + let vertexOffset = 0; + const ifcGeometries = ifcMesh.geometries; + for (let geometryIndex = 0; geometryIndex < ifcGeometries.size (); geometryIndex++) { + const ifcGeometry = ifcGeometries.get (geometryIndex); + const ifcGeometryData = this.ifc.GetGeometry (modelID, ifcGeometry.geometryExpressID); + const ifcVertices = this.ifc.GetVertexArray (ifcGeometryData.GetVertexData (), ifcGeometryData.GetVertexDataSize ()); + const ifcIndices = this.ifc.GetIndexArray (ifcGeometryData.GetIndexData (), ifcGeometryData.GetIndexDataSize ()); + const materialIndex = this.GetMaterialIndexByColor (ifcGeometry.color); + const matrix = new OV.Matrix (ifcGeometry.flatTransformation); + const transformation = new OV.Transformation (matrix); + + for (let i = 0; i < ifcVertices.length; i += 6) { + const x = ifcVertices[i]; + const y = ifcVertices[i + 1]; + const z = ifcVertices[i + 2]; + const coord = new OV.Coord3D (x, y, z) + const transformed = transformation.TransformCoord3D (coord); + mesh.AddVertex (transformed); + } + // TODO: normals + for (let i = 0; i < ifcIndices.length; i += 3) { + const v0 = ifcIndices[i]; + const v1 = ifcIndices[i + 1]; + const v2 = ifcIndices[i + 2]; + const triangle = new OV.Triangle ( + vertexOffset + v0, + vertexOffset + v1, + vertexOffset + v2 + ); + triangle.SetMaterial (materialIndex); + mesh.AddTriangle (triangle); + } + vertexOffset += ifcVertices.length / 6; + } + + this.model.AddMesh (mesh); + } + + GetMaterialIndexByColor (ifcColor) + { + const color = new OV.Color ( + parseInt (ifcColor.x * 255.0, 10), + parseInt (ifcColor.y * 255.0, 10), + parseInt (ifcColor.z * 255.0, 10) + ); + const materialName = 'Color ' + OV.ColorToHexString (color); + let materialIndex = this.materialNameToIndex[materialName]; + if (materialIndex === undefined) { + let material = new OV.Material (); + material.name = materialName; + material.diffuse = color; + materialIndex = this.model.AddMaterial (material); + this.materialNameToIndex[materialName] = materialIndex; + } + return materialIndex; + } +}; diff --git a/source/external/threemodelloader.js b/source/external/threemodelloader.js index 76653f2..6c3c748 100644 --- a/source/external/threemodelloader.js +++ b/source/external/threemodelloader.js @@ -4,6 +4,7 @@ OV.ThreeModelLoader = class { this.importer = new OV.Importer (); this.importer.AddImporter (new OV.Importer3dm ()); + this.importer.AddImporter (new OV.ImporterIfc ()); this.callbacks = null; this.inProgress = false; this.hasHighpDriverIssue = OV.HasHighpDriverIssue (); diff --git a/tools/config.json b/tools/config.json index cd38227..51bebd3 100644 --- a/tools/config.json +++ b/tools/config.json @@ -51,6 +51,7 @@ "source/external/externallibs.js", "source/external/rhinoimporter.js", "source/external/rhinoexporter.js", + "source/external/ifcimporter.js", "source/external/threeutils.js", "source/external/threeconverter.js", "source/external/threemodelloader.js", diff --git a/website/embed.html b/website/embed.html index 52d9b5b..8d08058 100644 --- a/website/embed.html +++ b/website/embed.html @@ -64,6 +64,7 @@ + diff --git a/website/index.html b/website/index.html index c1479cf..67e6034 100644 --- a/website/index.html +++ b/website/index.html @@ -64,6 +64,7 @@ +