jonathan
/
Portfolio
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Dies ist das Repository meines kleinen Portfolios. Im Hintergrund läuft eine Planetensimulation, geschrieben in JavaScript und Three.js. Die zu sehenden Texturen stammen von: https://www.solarsystemscope.com/textures/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10 Commits
1 Branch
0 Tags
29 MiB
 
 
 
Tag: Branch: Tree: 886769c880
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '886769c880'
${ noResults }
Portfolio/node_modules/three/examples/jsm/loaders/ifc/web-ifc-api.js

47503 lines
1.4 MiB
Raw Blame History

var __defProp = Object.defineProperty;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __require = (x) => {
if (typeof require !== "undefined")
return require(x);
throw new Error('Dynamic require of "' + x + '" is not supported');
};
var __commonJS = (cb, mod) => function __require2() {
return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __async = (__this, __arguments, generator) => {
return new Promise((resolve, reject) => {
var fulfilled = (value) => {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
};
var rejected = (value) => {
try {
step(generator.throw(value));
} catch (e) {
reject(e);
}
};
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
step((generator = generator.apply(__this, __arguments)).next());
});
};
// (disabled):crypto
var require_crypto = __commonJS({
"(disabled):crypto"() {
}
});
// dist/web-ifc.js
var require_web_ifc = __commonJS({
"dist/web-ifc.js"(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) {
idx >>>= 0;
var endIdx = idx + maxBytesToRead;
var endPtr = idx;
while (heap[endPtr >>> 0] && !(endPtr >= endIdx))
++endPtr;
if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {
return UTF8Decoder.decode(heap.subarray(idx >>> 0, endPtr >>> 0));
} else {
var str = "";
while (idx < endPtr) {
var u0 = heap[idx++ >>> 0];
if (!(u0 & 128)) {
str += String.fromCharCode(u0);
continue;
}
var u1 = heap[idx++ >>> 0] & 63;
if ((u0 & 224) == 192) {
str += String.fromCharCode((u0 & 31) << 6 | u1);
continue;
}
var u2 = heap[idx++ >>> 0] & 63;
if ((u0 & 240) == 224) {
u0 = (u0 & 15) << 12 | u1 << 6 | u2;
} else {
u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heap[idx++ >>> 0] & 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) {
ptr >>>= 0;
return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
}
function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
outIdx >>>= 0;
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++ >>> 0] = u;
} else if (u <= 2047) {
if (outIdx + 1 >= endIdx)
break;
heap[outIdx++ >>> 0] = 192 | u >> 6;
heap[outIdx++ >>> 0] = 128 | u & 63;
} else if (u <= 65535) {
if (outIdx + 2 >= endIdx)
break;
heap[outIdx++ >>> 0] = 224 | u >> 12;
heap[outIdx++ >>> 0] = 128 | u >> 6 & 63;
heap[outIdx++ >>> 0] = 128 | u & 63;
} else {
if (outIdx + 3 >= endIdx)
break;
heap[outIdx++ >>> 0] = 240 | u >> 18;
heap[outIdx++ >>> 0] = 128 | u >> 12 & 63;
heap[outIdx++ >>> 0] = 128 | u >> 6 & 63;
heap[outIdx++ >>> 0] = 128 | u & 63;
}
}
heap[outIdx >>> 0] = 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 >>> 0])
++idx;
endPtr = idx << 1;
if (endPtr - ptr > 32 && UTF16Decoder) {
return UTF16Decoder.decode(HEAPU8.subarray(ptr >>> 0, endPtr >>> 0));
} 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) {
outPtr >>>= 0;
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 >>> 0);
}
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": 4294967296 / 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"]["X"];
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] = 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) {
newCapacity >>>= 0;
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) {
newSize >>>= 0;
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);
}
ptr >>>= 0;
HEAP8.set(contents, ptr >>> 0);
}
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) {
offset >>>= 0;
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) {
offset >>>= 0;
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) {
address >>>= 0;
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) {
offset >>>= 0;
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 = "<generic error, no stack>";
});
}, staticInit: function() {
FS.ensureErrnoError();
FS.nameTable = new Array(4096);
FS.mount(MEMFS, {}, "/");
FS.createDefaultDirectories();
FS.createDefaultDevices();
FS.createSpecialDirectories();
FS.filesystems = { "MEMFS": 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 >>> 0];
stringToUTF8(ret, buf, bufsize + 1);
HEAP8[buf + len >>> 0] = 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 >>> 0]) {
ret += embind_charCodes[HEAPU8[c++ >>> 0]];
}
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 >>> 0]);
}
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 >>> 0];
} : function readU8FromPointer(pointer) {
return HEAPU8[pointer >>> 0];
};
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": 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 >>> 0];
var data = heap[handle + 1 >>> 0];
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] == 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 >>> 0]);
}
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);
ptr >>>= 0;
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 >>> 0] = charCode;
}
} else {
for (var i = 0; i < length; ++i) {
HEAPU8[ptr + 4 + i >>> 0] = 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);
ptr >>>= 0;
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);
}
function __emval_lookupTypes(argCount, argTypes) {
var a = new Array(argCount);
for (var i = 0; i < argCount; ++i) {
a[i] = requireRegisteredType(HEAP32[(argTypes >> 2) + i >>> 0], "parameter " + i);
}
return a;
}
function __emval_call(handle, argCount, argTypes, argv) {
handle = requireHandle(handle);
var types = __emval_lookupTypes(argCount, argTypes);
var args = new Array(argCount);
for (var i = 0; i < argCount; ++i) {
var type = types[i];
args[i] = type["readValueFromPointer"](argv);
argv += type["argPackAdvance"];
}
var rv = handle.apply(void 0, args);
return __emval_register(rv);
}
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 >>> 0, src >>> 0, src + num >>> 0);
}
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 = 4294967296;
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, "P": ___sys_ioctl, "Q": ___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, "h": __embind_register_function, "m": __embind_register_integer, "k": __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, "j": __embind_register_value_object_field, "T": __embind_register_void, "q": __emval_as, "W": __emval_call, "b": __emval_decref, "F": __emval_get_global, "n": __emval_get_property, "l": __emval_incref, "N": __emval_instanceof, "E": __emval_is_number, "y": __emval_new_array, "f": __emval_new_cstring, "r": __emval_new_object, "p": __emval_run_destructors, "i": __emval_set_property, "e": __emval_take_value, "c": _abort, "M": _clock_gettime, "I": _emscripten_memcpy_big, "o": _emscripten_resize_heap, "K": _environ_get, "L": _environ_sizes_get, "B": _fd_close, "O": _fd_read, "G": _fd_seek, "z": _fd_write, "a": wasmMemory, "H": _setTempRet0, "J": _strftime_l };
var asm = createWasm();
var ___wasm_call_ctors = Module["___wasm_call_ctors"] = function() {
return (___wasm_call_ctors = Module["___wasm_call_ctors"] = Module["asm"]["Y"]).apply(null, arguments);
};
var _main = Module["_main"] = function() {
return (_main = Module["_main"] = Module["asm"]["Z"]).apply(null, arguments);
};
var _malloc = Module["_malloc"] = function() {
return (_malloc = Module["_malloc"] = Module["asm"]["_"]).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"]["aa"]).apply(null, arguments);
};
var ___errno_location = Module["___errno_location"] = function() {
return (___errno_location = Module["___errno_location"] = Module["asm"]["ba"]).apply(null, arguments);
};
var _free = Module["_free"] = function() {
return (_free = Module["_free"] = Module["asm"]["ca"]).apply(null, arguments);
};
var dynCall_jiji = Module["dynCall_jiji"] = function() {
return (dynCall_jiji = Module["dynCall_jiji"] = Module["asm"]["da"]).apply(null, arguments);
};
var dynCall_viijii = Module["dynCall_viijii"] = function() {
return (dynCall_viijii = Module["dynCall_viijii"] = Module["asm"]["ea"]).apply(null, arguments);
};
var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = function() {
return (dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = Module["asm"]["fa"]).apply(null, arguments);
};
var dynCall_iiiiij = Module["dynCall_iiiiij"] = function() {
return (dynCall_iiiiij = Module["dynCall_iiiiij"] = Module["asm"]["ga"]).apply(null, arguments);
};
var dynCall_iiiiijj = Module["dynCall_iiiiijj"] = function() {
return (dynCall_iiiiijj = Module["dynCall_iiiiijj"] = Module["asm"]["ha"]).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;
}
Init() {
return __async(this, null, function* () {
if (WebIFCWasm) {
this.wasmModule = yield 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 = __spreadValues({
COORDINATE_TO_ORIGIN: false,
USE_FAST_BOOLS: false,
CIRCLE_SEGMENTS_LOW: 5,
CIRCLE_SEGMENTS_MEDIUM: 8,
CIRCLE_SEGMENTS_HIGH: 12
}, settings);
let result = this.wasmModule.OpenModel(s);
this.wasmModule["FS_unlink"]("/filename");
return result;
}
CreateModel(settings) {
let s = __spreadValues({
COORDINATE_TO_ORIGIN: false,
USE_FAST_BOOLS: false,
CIRCLE_SEGMENTS_LOW: 5,
CIRCLE_SEGMENTS_MEDIUM: 8,
CIRCLE_SEGMENTS_HIGH: 12
}, settings);
let result = this.wasmModule.CreateModel(s);
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);
}
StreamAllMeshes(modelID, meshCallback) {
this.wasmModule.StreamAllMeshes(modelID, meshCallback);
}
IsModelOpen(modelID) {
return this.wasmModule.IsModelOpen(modelID);
}
LoadAllGeometry(modelID) {
return this.wasmModule.LoadAllGeometry(modelID);
}
GetFlatMesh(modelID, expressID) {
return this.wasmModule.GetFlatMesh(modelID, expressID);
}
SetWasmPath(path) {
WasmPath = path;
}
};
export {
EMPTY,
ENUM,
FromRawLineData,
Handle,
IFCACTIONREQUEST,
IFCACTOR,
IFCACTORROLE,
IFCACTUATOR,
IFCACTUATORTYPE,
IFCADDRESS,
IFCADVANCEDBREP,
IFCADVANCEDBREPWITHVOIDS,
IFCADVANCEDFACE,
IFCAIRTERMINAL,
IFCAIRTERMINALBOX,
IFCAIRTERMINALBOXTYPE,
IFCAIRTERMINALTYPE,
IFCAIRTOAIRHEATRECOVERY,
IFCAIRTOAIRHEATRECOVERYTYPE,
IFCALARM,
IFCALARMTYPE,
IFCALIGNMENT,
IFCALIGNMENT2DHORIZONTAL,
IFCALIGNMENT2DHORIZONTALSEGMENT,
IFCALIGNMENT2DSEGMENT,
IFCALIGNMENT2DVERSEGCIRCULARARC,
IFCALIGNMENT2DVERSEGLINE,
IFCALIGNMENT2DVERSEGPARABOLICARC,
IFCALIGNMENT2DVERTICAL,
IFCALIGNMENT2DVERTICALSEGMENT,
IFCALIGNMENTCURVE,
IFCANNOTATION,
IFCANNOTATIONFILLAREA,
IFCAPPLICATION,
IFCAPPLIEDVALUE,
IFCAPPROVAL,
IFCAPPROVALRELATIONSHIP,
IFCARBITRARYCLOSEDPROFILEDEF,
IFCARBITRARYOPENPROFILEDEF,
IFCARBITRARYPROFILEDEFWITHVOIDS,
IFCASSET,
IFCASYMMETRICISHAPEPROFILEDEF,
IFCAUDIOVISUALAPPLIANCE,
IFCAUDIOVISUALAPPLIANCETYPE,
IFCAXIS1PLACEMENT,
IFCAXIS2PLACEMENT2D,
IFCAXIS2PLACEMENT3D,
IFCBEAM,
IFCBEAMSTANDARDCASE,
IFCBEAMTYPE,
IFCBEARING,
IFCBEARINGTYPE,
IFCBLOBTEXTURE,
IFCBLOCK,
IFCBOILER,
IFCBOILERTYPE,
IFCBOOLEANCLIPPINGRESULT,
IFCBOOLEANRESULT,
IFCBOUNDARYCONDITION,
IFCBOUNDARYCURVE,
IFCBOUNDARYEDGECONDITION,
IFCBOUNDARYFACECONDITION,
IFCBOUNDARYNODECONDITION,
IFCBOUNDARYNODECONDITIONWARPING,
IFCBOUNDEDCURVE,
IFCBOUNDEDSURFACE,
IFCBOUNDINGBOX,
IFCBOXEDHALFSPACE,
IFCBRIDGE,
IFCBRIDGEPART,
IFCBSPLINECURVE,
IFCBSPLINECURVEWITHKNOTS,
IFCBSPLINESURFACE,
IFCBSPLINESURFACEWITHKNOTS,
IFCBUILDING,
IFCBUILDINGELEMENT,
IFCBUILDINGELEMENTPART,
IFCBUILDINGELEMENTPARTTYPE,
IFCBUILDINGELEMENTPROXY,
IFCBUILDINGELEMENTPROXYTYPE,
IFCBUILDINGELEMENTTYPE,
IFCBUILDINGSTOREY,
IFCBUILDINGSYSTEM,
IFCBURNER,
IFCBURNERTYPE,
IFCCABLECARRIERFITTING,
IFCCABLECARRIERFITTINGTYPE,
IFCCABLECARRIERSEGMENT,
IFCCABLECARRIERSEGMENTTYPE,
IFCCABLEFITTING,
IFCCABLEFITTINGTYPE,
IFCCABLESEGMENT,
IFCCABLESEGMENTTYPE,
IFCCAISSONFOUNDATION,
IFCCAISSONFOUNDATIONTYPE,
IFCCARTESIANPOINT,
IFCCARTESIANPOINTLIST,
IFCCARTESIANPOINTLIST2D,
IFCCARTESIANPOINTLIST3D,
IFCCARTESIANTRANSFORMATIONOPERATOR,
IFCCARTESIANTRANSFORMATIONOPERATOR2D,
IFCCARTESIANTRANSFORMATIONOPERATOR2DNONUNIFORM,
IFCCARTESIANTRANSFORMATIONOPERATOR3D,
IFCCARTESIANTRANSFORMATIONOPERATOR3DNONUNIFORM,
IFCCENTERLINEPROFILEDEF,
IFCCHILLER,
IFCCHILLERTYPE,
IFCCHIMNEY,
IFCCHIMNEYTYPE,
IFCCIRCLE,
IFCCIRCLEHOLLOWPROFILEDEF,
IFCCIRCLEPROFILEDEF,
IFCCIRCULARARCSEGMENT2D,
IFCCIVILELEMENT,
IFCCIVILELEMENTTYPE,
IFCCLASSIFICATION,
IFCCLASSIFICATIONREFERENCE,
IFCCLOSEDSHELL,
IFCCOIL,
IFCCOILTYPE,
IFCCOLOURRGB,
IFCCOLOURRGBLIST,
IFCCOLOURSPECIFICATION,
IFCCOLUMN,
IFCCOLUMNSTANDARDCASE,
IFCCOLUMNTYPE,
IFCCOMMUNICATIONSAPPLIANCE,
IFCCOMMUNICATIONSAPPLIANCETYPE,
IFCCOMPLEXPROPERTY,
IFCCOMPLEXPROPERTYTEMPLATE,
IFCCOMPOSITECURVE,
IFCCOMPOSITECURVEONSURFACE,
IFCCOMPOSITECURVESEGMENT,
IFCCOMPOSITEPROFILEDEF,
IFCCOMPRESSOR,
IFCCOMPRESSORTYPE,
IFCCONDENSER,
IFCCONDENSERTYPE,
IFCCONIC,
IFCCONNECTEDFACESET,
IFCCONNECTIONCURVEGEOMETRY,
IFCCONNECTIONGEOMETRY,
IFCCONNECTIONPOINTECCENTRICITY,
IFCCONNECTIONPOINTGEOMETRY,
IFCCONNECTIONSURFACEGEOMETRY,
IFCCONNECTIONVOLUMEGEOMETRY,
IFCCONSTRAINT,
IFCCONSTRUCTIONEQUIPMENTRESOURCE,
IFCCONSTRUCTIONEQUIPMENTRESOURCETYPE,
IFCCONSTRUCTIONMATERIALRESOURCE,
IFCCONSTRUCTIONMATERIALRESOURCETYPE,
IFCCONSTRUCTIONPRODUCTRESOURCE,
IFCCONSTRUCTIONPRODUCTRESOURCETYPE,
IFCCONSTRUCTIONRESOURCE,
IFCCONSTRUCTIONRESOURCETYPE,
IFCCONTEXT,
IFCCONTEXTDEPENDENTUNIT,
IFCCONTROL,
IFCCONTROLLER,
IFCCONTROLLERTYPE,
IFCCONVERSIONBASEDUNIT,
IFCCONVERSIONBASEDUNITWITHOFFSET,
IFCCOOLEDBEAM,
IFCCOOLEDBEAMTYPE,
IFCCOOLINGTOWER,
IFCCOOLINGTOWERTYPE,
IFCCOORDINATEOPERATION,
IFCCOORDINATEREFERENCESYSTEM,
IFCCOSTITEM,
IFCCOSTSCHEDULE,
IFCCOSTVALUE,
IFCCOVERING,
IFCCOVERINGTYPE,
IFCCREWRESOURCE,
IFCCREWRESOURCETYPE,
IFCCSGPRIMITIVE3D,
IFCCSGSOLID,
IFCCSHAPEPROFILEDEF,
IFCCURRENCYRELATIONSHIP,
IFCCURTAINWALL,
IFCCURTAINWALLTYPE,
IFCCURVE,
IFCCURVEBOUNDEDPLANE,
IFCCURVEBOUNDEDSURFACE,
IFCCURVESEGMENT2D,
IFCCURVESTYLE,
IFCCURVESTYLEFONT,
IFCCURVESTYLEFONTANDSCALING,
IFCCURVESTYLEFONTPATTERN,
IFCCYLINDRICALSURFACE,
IFCDAMPER,
IFCDAMPERTYPE,
IFCDEEPFOUNDATION,
IFCDEEPFOUNDATIONTYPE,
IFCDERIVEDPROFILEDEF,
IFCDERIVEDUNIT,
IFCDERIVEDUNITELEMENT,
IFCDIMENSIONALEXPONENTS,
IFCDIRECTION,
IFCDISCRETEACCESSORY,
IFCDISCRETEACCESSORYTYPE,
IFCDISTANCEEXPRESSION,
IFCDISTRIBUTIONCHAMBERELEMENT,
IFCDISTRIBUTIONCHAMBERELEMENTTYPE,
IFCDISTRIBUTIONCIRCUIT,
IFCDISTRIBUTIONCONTROLELEMENT,
IFCDISTRIBUTIONCONTROLELEMENTTYPE,
IFCDISTRIBUTIONELEMENT,
IFCDISTRIBUTIONELEMENTTYPE,
IFCDISTRIBUTIONFLOWELEMENT,
IFCDISTRIBUTIONFLOWELEMENTTYPE,
IFCDISTRIBUTIONPORT,
IFCDISTRIBUTIONSYSTEM,
IFCDOCUMENTINFORMATION,
IFCDOCUMENTINFORMATIONRELATIONSHIP,
IFCDOCUMENTREFERENCE,
IFCDOOR,
IFCDOORLININGPROPERTIES,
IFCDOORPANELPROPERTIES,
IFCDOORSTANDARDCASE,
IFCDOORSTYLE,
IFCDOORTYPE,
IFCDRAUGHTINGPREDEFINEDCOLOUR,
IFCDRAUGHTINGPREDEFINEDCURVEFONT,
IFCDUCTFITTING,
IFCDUCTFITTINGTYPE,
IFCDUCTSEGMENT,
IFCDUCTSEGMENTTYPE,
IFCDUCTSILENCER,
IFCDUCTSILENCERTYPE,
IFCEDGE,
IFCEDGECURVE,
IFCEDGELOOP,
IFCELECTRICAPPLIANCE,
IFCELECTRICAPPLIANCETYPE,
IFCELECTRICDISTRIBUTIONBOARD,
IFCELECTRICDISTRIBUTIONBOARDTYPE,
IFCELECTRICFLOWSTORAGEDEVICE,
IFCELECTRICFLOWSTORAGEDEVICETYPE,
IFCELECTRICGENERATOR,
IFCELECTRICGENERATORTYPE,
IFCELECTRICMOTOR,
IFCELECTRICMOTORTYPE,
IFCELECTRICTIMECONTROL,
IFCELECTRICTIMECONTROLTYPE,
IFCELEMENT,
IFCELEMENTARYSURFACE,
IFCELEMENTASSEMBLY,
IFCELEMENTASSEMBLYTYPE,
IFCELEMENTCOMPONENT,
IFCELEMENTCOMPONENTTYPE,
IFCELEMENTQUANTITY,
IFCELEMENTTYPE,
IFCELLIPSE,
IFCELLIPSEPROFILEDEF,
IFCENERGYCONVERSIONDEVICE,
IFCENERGYCONVERSIONDEVICETYPE,
IFCENGINE,
IFCENGINETYPE,
IFCEVAPORATIVECOOLER,
IFCEVAPORATIVECOOLERTYPE,
IFCEVAPORATOR,
IFCEVAPORATORTYPE,
IFCEVENT,
IFCEVENTTIME,
IFCEVENTTYPE,
IFCEXTENDEDPROPERTIES,
IFCEXTERNALINFORMATION,
IFCEXTERNALLYDEFINEDHATCHSTYLE,
IFCEXTERNALLYDEFINEDSURFACESTYLE,
IFCEXTERNALLYDEFINEDTEXTFONT,
IFCEXTERNALREFERENCE,
IFCEXTERNALREFERENCERELATIONSHIP,
IFCEXTERNALSPATIALELEMENT,
IFCEXTERNALSPATIALSTRUCTUREELEMENT,
IFCEXTRUDEDAREASOLID,
IFCEXTRUDEDAREASOLIDTAPERED,
IFCFACE,
IFCFACEBASEDSURFACEMODEL,
IFCFACEBOUND,
IFCFACEOUTERBOUND,
IFCFACESURFACE,
IFCFACETEDBREP,
IFCFACETEDBREPWITHVOIDS,
IFCFACILITY,
IFCFACILITYPART,
IFCFAILURECONNECTIONCONDITION,
IFCFAN,
IFCFANTYPE,
IFCFASTENER,
IFCFASTENERTYPE,
IFCFEATUREELEMENT,
IFCFEATUREELEMENTADDITION,
IFCFEATUREELEMENTSUBTRACTION,
IFCFILLAREASTYLE,
IFCFILLAREASTYLEHATCHING,
IFCFILLAREASTYLETILES,
IFCFILTER,
IFCFILTERTYPE,
IFCFIRESUPPRESSIONTERMINAL,
IFCFIRESUPPRESSIONTERMINALTYPE,
IFCFIXEDREFERENCESWEPTAREASOLID,
IFCFLOWCONTROLLER,
IFCFLOWCONTROLLERTYPE,
IFCFLOWFITTING,
IFCFLOWFITTINGTYPE,
IFCFLOWINSTRUMENT,
IFCFLOWINSTRUMENTTYPE,
IFCFLOWMETER,
IFCFLOWMETERTYPE,
IFCFLOWMOVINGDEVICE,
IFCFLOWMOVINGDEVICETYPE,
IFCFLOWSEGMENT,
IFCFLOWSEGMENTTYPE,
IFCFLOWSTORAGEDEVICE,
IFCFLOWSTORAGEDEVICETYPE,
IFCFLOWTERMINAL,
IFCFLOWTERMINALTYPE,
IFCFLOWTREATMENTDEVICE,
IFCFLOWTREATMENTDEVICETYPE,
IFCFOOTING,
IFCFOOTINGTYPE,
IFCFURNISHINGELEMENT,
IFCFURNISHINGELEMENTTYPE,
IFCFURNITURE,
IFCFURNITURETYPE,
IFCGEOGRAPHICELEMENT,
IFCGEOGRAPHICELEMENTTYPE,
IFCGEOMETRICCURVESET,
IFCGEOMETRICREPRESENTATIONCONTEXT,
IFCGEOMETRICREPRESENTATIONITEM,
IFCGEOMETRICREPRESENTATIONSUBCONTEXT,
IFCGEOMETRICSET,
IFCGRID,
IFCGRIDAXIS,
IFCGRIDPLACEMENT,
IFCGROUP,
IFCHALFSPACESOLID,
IFCHEATEXCHANGER,
IFCHEATEXCHANGERTYPE,
IFCHUMIDIFIER,
IFCHUMIDIFIERTYPE,
IFCIMAGETEXTURE,
IFCINDEXEDCOLOURMAP,
IFCINDEXEDPOLYCURVE,
IFCINDEXEDPOLYGONALFACE,
IFCINDEXEDPOLYGONALFACEWITHVOIDS,
IFCINDEXEDTEXTUREMAP,
IFCINDEXEDTRIANGLETEXTUREMAP,
IFCINTERCEPTOR,
IFCINTERCEPTORTYPE,
IFCINTERSECTIONCURVE,
IFCINVENTORY,
IFCIRREGULARTIMESERIES,
IFCIRREGULARTIMESERIESVALUE,
IFCISHAPEPROFILEDEF,
IFCJUNCTIONBOX,
IFCJUNCTIONBOXTYPE,
IFCLABORRESOURCE,
IFCLABORRESOURCETYPE,
IFCLAGTIME,
IFCLAMP,
IFCLAMPTYPE,
IFCLIBRARYINFORMATION,
IFCLIBRARYREFERENCE,
IFCLIGHTDISTRIBUTIONDATA,
IFCLIGHTFIXTURE,
IFCLIGHTFIXTURETYPE,
IFCLIGHTINTENSITYDISTRIBUTION,
IFCLIGHTSOURCE,
IFCLIGHTSOURCEAMBIENT,
IFCLIGHTSOURCEDIRECTIONAL,
IFCLIGHTSOURCEGONIOMETRIC,
IFCLIGHTSOURCEPOSITIONAL,
IFCLIGHTSOURCESPOT,
IFCLINE,
IFCLINEARPLACEMENT,
IFCLINEARPOSITIONINGELEMENT,
IFCLINESEGMENT2D,
IFCLOCALPLACEMENT,
IFCLOOP,
IFCLSHAPEPROFILEDEF,
IFCMANIFOLDSOLIDBREP,
IFCMAPCONVERSION,
IFCMAPPEDITEM,
IFCMATERIAL,
IFCMATERIALCLASSIFICATIONRELATIONSHIP,
IFCMATERIALCONSTITUENT,
IFCMATERIALCONSTITUENTSET,
IFCMATERIALDEFINITION,
IFCMATERIALDEFINITIONREPRESENTATION,
IFCMATERIALLAYER,
IFCMATERIALLAYERSET,
IFCMATERIALLAYERSETUSAGE,
IFCMATERIALLAYERWITHOFFSETS,
IFCMATERIALLIST,
IFCMATERIALPROFILE,
IFCMATERIALPROFILESET,
IFCMATERIALPROFILESETUSAGE,
IFCMATERIALPROFILESETUSAGETAPERING,
IFCMATERIALPROFILEWITHOFFSETS,
IFCMATERIALPROPERTIES,
IFCMATERIALRELATIONSHIP,
IFCMATERIALUSAGEDEFINITION,
IFCMEASUREWITHUNIT,
IFCMECHANICALFASTENER,
IFCMECHANICALFASTENERTYPE,
IFCMEDICALDEVICE,
IFCMEDICALDEVICETYPE,
IFCMEMBER,
IFCMEMBERSTANDARDCASE,
IFCMEMBERTYPE,
IFCMETRIC,
IFCMIRROREDPROFILEDEF,
IFCMONETARYUNIT,
IFCMOTORCONNECTION,
IFCMOTORCONNECTIONTYPE,
IFCNAMEDUNIT,
IFCOBJECT,
IFCOBJECTDEFINITION,
IFCOBJECTIVE,
IFCOBJECTPLACEMENT,
IFCOCCUPANT,
IFCOFFSETCURVE,
IFCOFFSETCURVE2D,
IFCOFFSETCURVE3D,
IFCOFFSETCURVEBYDISTANCES,
IFCOPENINGELEMENT,
IFCOPENINGSTANDARDCASE,
IFCOPENSHELL,
IFCORGANIZATION,
IFCORGANIZATIONRELATIONSHIP,
IFCORIENTATIONEXPRESSION,
IFCORIENTEDEDGE,
IFCOUTERBOUNDARYCURVE,
IFCOUTLET,
IFCOUTLETTYPE,
IFCOWNERHISTORY,
IFCPARAMETERIZEDPROFILEDEF,
IFCPATH,
IFCPCURVE,
IFCPERFORMANCEHISTORY,
IFCPERMEABLECOVERINGPROPERTIES,
IFCPERMIT,
IFCPERSON,
IFCPERSONANDORGANIZATION,
IFCPHYSICALCOMPLEXQUANTITY,
IFCPHYSICALQUANTITY,
IFCPHYSICALSIMPLEQUANTITY,
IFCPILE,
IFCPILETYPE,
IFCPIPEFITTING,
IFCPIPEFITTINGTYPE,
IFCPIPESEGMENT,
IFCPIPESEGMENTTYPE,
IFCPIXELTEXTURE,
IFCPLACEMENT,
IFCPLANARBOX,
IFCPLANAREXTENT,
IFCPLANE,
IFCPLATE,
IFCPLATESTANDARDCASE,
IFCPLATETYPE,
IFCPOINT,
IFCPOINTONCURVE,
IFCPOINTONSURFACE,
IFCPOLYGONALBOUNDEDHALFSPACE,
IFCPOLYGONALFACESET,
IFCPOLYLINE,
IFCPOLYLOOP,
IFCPORT,
IFCPOSITIONINGELEMENT,
IFCPOSTALADDRESS,
IFCPREDEFINEDCOLOUR,
IFCPREDEFINEDCURVEFONT,
IFCPREDEFINEDITEM,
IFCPREDEFINEDPROPERTIES,
IFCPREDEFINEDPROPERTYSET,
IFCPREDEFINEDTEXTFONT,
IFCPRESENTATIONITEM,
IFCPRESENTATIONLAYERASSIGNMENT,
IFCPRESENTATIONLAYERWITHSTYLE,
IFCPRESENTATIONSTYLE,
IFCPRESENTATIONSTYLEASSIGNMENT,
IFCPROCEDURE,
IFCPROCEDURETYPE,
IFCPROCESS,
IFCPRODUCT,
IFCPRODUCTDEFINITIONSHAPE,
IFCPRODUCTREPRESENTATION,
IFCPROFILEDEF,
IFCPROFILEPROPERTIES,
IFCPROJECT,
IFCPROJECTEDCRS,
IFCPROJECTIONELEMENT,
IFCPROJECTLIBRARY,
IFCPROJECTORDER,
IFCPROPERTY,
IFCPROPERTYABSTRACTION,
IFCPROPERTYBOUNDEDVALUE,
IFCPROPERTYDEFINITION,
IFCPROPERTYDEPENDENCYRELATIONSHIP,
IFCPROPERTYENUMERATEDVALUE,
IFCPROPERTYENUMERATION,
IFCPROPERTYLISTVALUE,
IFCPROPERTYREFERENCEVALUE,
IFCPROPERTYSET,
IFCPROPERTYSETDEFINITION,
IFCPROPERTYSETTEMPLATE,
IFCPROPERTYSINGLEVALUE,
IFCPROPERTYTABLEVALUE,
IFCPROPERTYTEMPLATE,
IFCPROPERTYTEMPLATEDEFINITION,
IFCPROTECTIVEDEVICE,
IFCPROTECTIVEDEVICETRIPPINGUNIT,
IFCPROTECTIVEDEVICETRIPPINGUNITTYPE,
IFCPROTECTIVEDEVICETYPE,
IFCPROXY,
IFCPUMP,
IFCPUMPTYPE,
IFCQUANTITYAREA,
IFCQUANTITYCOUNT,
IFCQUANTITYLENGTH,
IFCQUANTITYSET,
IFCQUANTITYTIME,
IFCQUANTITYVOLUME,
IFCQUANTITYWEIGHT,
IFCRAILING,
IFCRAILINGTYPE,
IFCRAMP,
IFCRAMPFLIGHT,
IFCRAMPFLIGHTTYPE,
IFCRAMPTYPE,
IFCRATIONALBSPLINECURVEWITHKNOTS,
IFCRATIONALBSPLINESURFACEWITHKNOTS,
IFCRECTANGLEHOLLOWPROFILEDEF,
IFCRECTANGLEPROFILEDEF,
IFCRECTANGULARPYRAMID,
IFCRECTANGULARTRIMMEDSURFACE,
IFCRECURRENCEPATTERN,
IFCREFERENCE,
IFCREFERENT,
IFCREGULARTIMESERIES,
IFCREINFORCEMENTBARPROPERTIES,
IFCREINFORCEMENTDEFINITIONPROPERTIES,
IFCREINFORCINGBAR,
IFCREINFORCINGBARTYPE,
IFCREINFORCINGELEMENT,
IFCREINFORCINGELEMENTTYPE,
IFCREINFORCINGMESH,
IFCREINFORCINGMESHTYPE,
IFCRELAGGREGATES,
IFCRELASSIGNS,
IFCRELASSIGNSTOACTOR,
IFCRELASSIGNSTOCONTROL,
IFCRELASSIGNSTOGROUP,
IFCRELASSIGNSTOGROUPBYFACTOR,
IFCRELASSIGNSTOPROCESS,
IFCRELASSIGNSTOPRODUCT,
IFCRELASSIGNSTORESOURCE,
IFCRELASSOCIATES,
IFCRELASSOCIATESAPPROVAL,
IFCRELASSOCIATESCLASSIFICATION,
IFCRELASSOCIATESCONSTRAINT,
IFCRELASSOCIATESDOCUMENT,
IFCRELASSOCIATESLIBRARY,
IFCRELASSOCIATESMATERIAL,
IFCRELATIONSHIP,
IFCRELCONNECTS,
IFCRELCONNECTSELEMENTS,
IFCRELCONNECTSPATHELEMENTS,
IFCRELCONNECTSPORTS,
IFCRELCONNECTSPORTTOELEMENT,
IFCRELCONNECTSSTRUCTURALACTIVITY,
IFCRELCONNECTSSTRUCTURALMEMBER,
IFCRELCONNECTSWITHECCENTRICITY,
IFCRELCONNECTSWITHREALIZINGELEMENTS,
IFCRELCONTAINEDINSPATIALSTRUCTURE,
IFCRELCOVERSBLDGELEMENTS,
IFCRELCOVERSSPACES,
IFCRELDECLARES,
IFCRELDECOMPOSES,
IFCRELDEFINES,
IFCRELDEFINESBYOBJECT,
IFCRELDEFINESBYPROPERTIES,
IFCRELDEFINESBYTEMPLATE,
IFCRELDEFINESBYTYPE,
IFCRELFILLSELEMENT,
IFCRELFLOWCONTROLELEMENTS,
IFCRELINTERFERESELEMENTS,
IFCRELNESTS,
IFCRELPOSITIONS,
IFCRELPROJECTSELEMENT,
IFCRELREFERENCEDINSPATIALSTRUCTURE,
IFCRELSEQUENCE,
IFCRELSERVICESBUILDINGS,
IFCRELSPACEBOUNDARY,
IFCRELSPACEBOUNDARY1STLEVEL,
IFCRELSPACEBOUNDARY2NDLEVEL,
IFCRELVOIDSELEMENT,
IFCREPARAMETRISEDCOMPOSITECURVESEGMENT,
IFCREPRESENTATION,
IFCREPRESENTATIONCONTEXT,
IFCREPRESENTATIONITEM,
IFCREPRESENTATIONMAP,
IFCRESOURCE,
IFCRESOURCEAPPROVALRELATIONSHIP,
IFCRESOURCECONSTRAINTRELATIONSHIP,
IFCRESOURCELEVELRELATIONSHIP,
IFCRESOURCETIME,
IFCREVOLVEDAREASOLID,
IFCREVOLVEDAREASOLIDTAPERED,
IFCRIGHTCIRCULARCONE,
IFCRIGHTCIRCULARCYLINDER,
IFCROOF,
IFCROOFTYPE,
IFCROOT,
IFCROUNDEDRECTANGLEPROFILEDEF,
IFCSANITARYTERMINAL,
IFCSANITARYTERMINALTYPE,
IFCSCHEDULINGTIME,
IFCSEAMCURVE,
IFCSECTIONEDSOLID,
IFCSECTIONEDSOLIDHORIZONTAL,
IFCSECTIONEDSPINE,
IFCSECTIONPROPERTIES,
IFCSECTIONREINFORCEMENTPROPERTIES,
IFCSENSOR,
IFCSENSORTYPE,
IFCSHADINGDEVICE,
IFCSHADINGDEVICETYPE,
IFCSHAPEASPECT,
IFCSHAPEMODEL,
IFCSHAPEREPRESENTATION,
IFCSHELLBASEDSURFACEMODEL,
IFCSIMPLEPROPERTY,
IFCSIMPLEPROPERTYTEMPLATE,
IFCSITE,
IFCSIUNIT,
IFCSLAB,
IFCSLABELEMENTEDCASE,
IFCSLABSTANDARDCASE,
IFCSLABTYPE,
IFCSLIPPAGECONNECTIONCONDITION,
IFCSOLARDEVICE,
IFCSOLARDEVICETYPE,
IFCSOLIDMODEL,
IFCSPACE,
IFCSPACEHEATER,
IFCSPACEHEATERTYPE,
IFCSPACETYPE,
IFCSPATIALELEMENT,
IFCSPATIALELEMENTTYPE,
IFCSPATIALSTRUCTUREELEMENT,
IFCSPATIALSTRUCTUREELEMENTTYPE,
IFCSPATIALZONE,
IFCSPATIALZONETYPE,
IFCSPHERE,
IFCSPHERICALSURFACE,
IFCSTACKTERMINAL,
IFCSTACKTERMINALTYPE,
IFCSTAIR,
IFCSTAIRFLIGHT,
IFCSTAIRFLIGHTTYPE,
IFCSTAIRTYPE,
IFCSTRUCTURALACTION,
IFCSTRUCTURALACTIVITY,
IFCSTRUCTURALANALYSISMODEL,
IFCSTRUCTURALCONNECTION,
IFCSTRUCTURALCONNECTIONCONDITION,
IFCSTRUCTURALCURVEACTION,
IFCSTRUCTURALCURVECONNECTION,
IFCSTRUCTURALCURVEMEMBER,
IFCSTRUCTURALCURVEMEMBERVARYING,
IFCSTRUCTURALCURVEREACTION,
IFCSTRUCTURALITEM,
IFCSTRUCTURALLINEARACTION,
IFCSTRUCTURALLOAD,
IFCSTRUCTURALLOADCASE,
IFCSTRUCTURALLOADCONFIGURATION,
IFCSTRUCTURALLOADGROUP,
IFCSTRUCTURALLOADLINEARFORCE,
IFCSTRUCTURALLOADORRESULT,
IFCSTRUCTURALLOADPLANARFORCE,
IFCSTRUCTURALLOADSINGLEDISPLACEMENT,
IFCSTRUCTURALLOADSINGLEDISPLACEMENTDISTORTION,
IFCSTRUCTURALLOADSINGLEFORCE,
IFCSTRUCTURALLOADSINGLEFORCEWARPING,
IFCSTRUCTURALLOADSTATIC,
IFCSTRUCTURALLOADTEMPERATURE,
IFCSTRUCTURALMEMBER,
IFCSTRUCTURALPLANARACTION,
IFCSTRUCTURALPOINTACTION,
IFCSTRUCTURALPOINTCONNECTION,
IFCSTRUCTURALPOINTREACTION,
IFCSTRUCTURALREACTION,
IFCSTRUCTURALRESULTGROUP,
IFCSTRUCTURALSURFACEACTION,
IFCSTRUCTURALSURFACECONNECTION,
IFCSTRUCTURALSURFACEMEMBER,
IFCSTRUCTURALSURFACEMEMBERVARYING,
IFCSTRUCTURALSURFACEREACTION,
IFCSTYLEDITEM,
IFCSTYLEDREPRESENTATION,
IFCSTYLEMODEL,
IFCSUBCONTRACTRESOURCE,
IFCSUBCONTRACTRESOURCETYPE,
IFCSUBEDGE,
IFCSURFACE,
IFCSURFACECURVE,
IFCSURFACECURVESWEPTAREASOLID,
IFCSURFACEFEATURE,
IFCSURFACEOFLINEAREXTRUSION,
IFCSURFACEOFREVOLUTION,
IFCSURFACEREINFORCEMENTAREA,
IFCSURFACESTYLE,
IFCSURFACESTYLELIGHTING,
IFCSURFACESTYLEREFRACTION,
IFCSURFACESTYLERENDERING,
IFCSURFACESTYLESHADING,
IFCSURFACESTYLEWITHTEXTURES,
IFCSURFACETEXTURE,
IFCSWEPTAREASOLID,
IFCSWEPTDISKSOLID,
IFCSWEPTDISKSOLIDPOLYGONAL,
IFCSWEPTSURFACE,
IFCSWITCHINGDEVICE,
IFCSWITCHINGDEVICETYPE,
IFCSYSTEM,
IFCSYSTEMFURNITUREELEMENT,
IFCSYSTEMFURNITUREELEMENTTYPE,
IFCTABLE,
IFCTABLECOLUMN,
IFCTABLEROW,
IFCTANK,
IFCTANKTYPE,
IFCTASK,
IFCTASKTIME,
IFCTASKTIMERECURRING,
IFCTASKTYPE,
IFCTELECOMADDRESS,
IFCTENDON,
IFCTENDONANCHOR,
IFCTENDONANCHORTYPE,
IFCTENDONCONDUIT,
IFCTENDONCONDUITTYPE,
IFCTENDONTYPE,
IFCTESSELLATEDFACESET,
IFCTESSELLATEDITEM,
IFCTEXTLITERAL,
IFCTEXTLITERALWITHEXTENT,
IFCTEXTSTYLE,
IFCTEXTSTYLEFONTMODEL,
IFCTEXTSTYLEFORDEFINEDFONT,
IFCTEXTSTYLETEXTMODEL,
IFCTEXTURECOORDINATE,
IFCTEXTURECOORDINATEGENERATOR,
IFCTEXTUREMAP,
IFCTEXTUREVERTEX,
IFCTEXTUREVERTEXLIST,
IFCTIMEPERIOD,
IFCTIMESERIES,
IFCTIMESERIESVALUE,
IFCTOPOLOGICALREPRESENTATIONITEM,
IFCTOPOLOGYREPRESENTATION,
IFCTOROIDALSURFACE,
IFCTRANSFORMER,
IFCTRANSFORMERTYPE,
IFCTRANSITIONCURVESEGMENT2D,
IFCTRANSPORTELEMENT,
IFCTRANSPORTELEMENTTYPE,
IFCTRAPEZIUMPROFILEDEF,
IFCTRIANGULATEDFACESET,
IFCTRIANGULATEDIRREGULARNETWORK,
IFCTRIMMEDCURVE,
IFCTSHAPEPROFILEDEF,
IFCTUBEBUNDLE,
IFCTUBEBUNDLETYPE,
IFCTYPEOBJECT,
IFCTYPEPROCESS,
IFCTYPEPRODUCT,
IFCTYPERESOURCE,
IFCUNITARYCONTROLELEMENT,
IFCUNITARYCONTROLELEMENTTYPE,
IFCUNITARYEQUIPMENT,
IFCUNITARYEQUIPMENTTYPE,
IFCUNITASSIGNMENT,
IFCUSHAPEPROFILEDEF,
IFCVALVE,
IFCVALVETYPE,
IFCVECTOR,
IFCVERTEX,
IFCVERTEXLOOP,
IFCVERTEXPOINT,
IFCVIBRATIONDAMPER,
IFCVIBRATIONDAMPERTYPE,
IFCVIBRATIONISOLATOR,
IFCVIBRATIONISOLATORTYPE,
IFCVIRTUALELEMENT,
IFCVIRTUALGRIDINTERSECTION,
IFCVOIDINGFEATURE,
IFCWALL,
IFCWALLELEMENTEDCASE,
IFCWALLSTANDARDCASE,
IFCWALLTYPE,
IFCWASTETERMINAL,
IFCWASTETERMINALTYPE,
IFCWINDOW,
IFCWINDOWLININGPROPERTIES,
IFCWINDOWPANELPROPERTIES,
IFCWINDOWSTANDARDCASE,
IFCWINDOWSTYLE,
IFCWINDOWTYPE,
IFCWORKCALENDAR,
IFCWORKCONTROL,
IFCWORKPLAN,
IFCWORKSCHEDULE,
IFCWORKTIME,
IFCZONE,
IFCZSHAPEPROFILEDEF,
IfcAPI,
IfcAbsorbedDoseMeasure,
IfcAccelerationMeasure,
IfcActionRequest,
IfcActionRequestTypeEnum,
IfcActionSourceTypeEnum,
IfcActionTypeEnum,
IfcActor,
IfcActorRole,
IfcActuator,
IfcActuatorType,
IfcActuatorTypeEnum,
IfcAddress,
IfcAddressTypeEnum,
IfcAdvancedBrep,
IfcAdvancedBrepWithVoids,
IfcAdvancedFace,
IfcAirTerminal,
IfcAirTerminalBox,
IfcAirTerminalBoxType,
IfcAirTerminalBoxTypeEnum,
IfcAirTerminalType,
IfcAirTerminalTypeEnum,
IfcAirToAirHeatRecovery,
IfcAirToAirHeatRecoveryType,
IfcAirToAirHeatRecoveryTypeEnum,
IfcAlarm,
IfcAlarmType,
IfcAlarmTypeEnum,
IfcAlignment,
IfcAlignment2DHorizontal,
IfcAlignment2DHorizontalSegment,
IfcAlignment2DSegment,
IfcAlignment2DVerSegCircularArc,
IfcAlignment2DVerSegLine,
IfcAlignment2DVerSegParabolicArc,
IfcAlignment2DVertical,
IfcAlignment2DVerticalSegment,
IfcAlignmentCurve,
IfcAlignmentTypeEnum,
IfcAmountOfSubstanceMeasure,
IfcAnalysisModelTypeEnum,
IfcAnalysisTheoryTypeEnum,
IfcAngularVelocityMeasure,
IfcAnnotation,
IfcAnnotationFillArea,
IfcApplication,
IfcAppliedValue,
IfcApproval,
IfcApprovalRelationship,
IfcArbitraryClosedProfileDef,
IfcArbitraryOpenProfileDef,
IfcArbitraryProfileDefWithVoids,
IfcAreaDensityMeasure,
IfcAreaMeasure,
IfcArithmeticOperatorEnum,
IfcAssemblyPlaceEnum,
IfcAsset,
IfcAsymmetricIShapeProfileDef,
IfcAudioVisualAppliance,
IfcAudioVisualApplianceType,
IfcAudioVisualApplianceTypeEnum,
IfcAxis1Placement,
IfcAxis2Placement2D,
IfcAxis2Placement3D,
IfcBSplineCurve,
IfcBSplineCurveForm,
IfcBSplineCurveWithKnots,
IfcBSplineSurface,
IfcBSplineSurfaceForm,
IfcBSplineSurfaceWithKnots,
IfcBeam,
IfcBeamStandardCase,
IfcBeamType,
IfcBeamTypeEnum,
IfcBearing,
IfcBearingType,
IfcBearingTypeDisplacementEnum,
IfcBearingTypeEnum,
IfcBenchmarkEnum,
IfcBinary,
IfcBlobTexture,
IfcBlock,
IfcBoiler,
IfcBoilerType,
IfcBoilerTypeEnum,
IfcBoolean,
IfcBooleanClippingResult,
IfcBooleanOperator,
IfcBooleanResult,
IfcBoundaryCondition,
IfcBoundaryCurve,
IfcBoundaryEdgeCondition,
IfcBoundaryFaceCondition,
IfcBoundaryNodeCondition,
IfcBoundaryNodeConditionWarping,
IfcBoundedCurve,
IfcBoundedSurface,
IfcBoundingBox,
IfcBoxAlignment,
IfcBoxedHalfSpace,
IfcBridge,
IfcBridgePart,
IfcBridgePartTypeEnum,
IfcBridgeTypeEnum,
IfcBuilding,
IfcBuildingElement,
IfcBuildingElementPart,
IfcBuildingElementPartType,
IfcBuildingElementPartTypeEnum,
IfcBuildingElementProxy,
IfcBuildingElementProxyType,
IfcBuildingElementProxyTypeEnum,
IfcBuildingElementType,
IfcBuildingStorey,
IfcBuildingSystem,
IfcBuildingSystemTypeEnum,
IfcBurner,
IfcBurnerType,
IfcBurnerTypeEnum,
IfcCShapeProfileDef,
IfcCableCarrierFitting,
IfcCableCarrierFittingType,
IfcCableCarrierFittingTypeEnum,
IfcCableCarrierSegment,
IfcCableCarrierSegmentType,
IfcCableCarrierSegmentTypeEnum,
IfcCableFitting,
IfcCableFittingType,
IfcCableFittingTypeEnum,
IfcCableSegment,
IfcCableSegmentType,
IfcCableSegmentTypeEnum,
IfcCaissonFoundation,
IfcCaissonFoundationType,
IfcCaissonFoundationTypeEnum,
IfcCardinalPointReference,
IfcCartesianPoint,
IfcCartesianPointList,
IfcCartesianPointList2D,
IfcCartesianPointList3D,
IfcCartesianTransformationOperator,
IfcCartesianTransformationOperator2D,
IfcCartesianTransformationOperator2DnonUniform,
IfcCartesianTransformationOperator3D,
IfcCartesianTransformationOperator3DnonUniform,
IfcCenterLineProfileDef,
IfcChangeActionEnum,
IfcChiller,
IfcChillerType,
IfcChillerTypeEnum,
IfcChimney,
IfcChimneyType,
IfcChimneyTypeEnum,
IfcCircle,
IfcCircleHollowProfileDef,
IfcCircleProfileDef,
IfcCircularArcSegment2D,
IfcCivilElement,
IfcCivilElementType,
IfcClassification,
IfcClassificationReference,
IfcClosedShell,
IfcCoil,
IfcCoilType,
IfcCoilTypeEnum,
IfcColourRgb,
IfcColourRgbList,
IfcColourSpecification,
IfcColumn,
IfcColumnStandardCase,
IfcColumnType,
IfcColumnTypeEnum,
IfcCommunicationsAppliance,
IfcCommunicationsApplianceType,
IfcCommunicationsApplianceTypeEnum,
IfcComplexProperty,
IfcComplexPropertyTemplate,
IfcComplexPropertyTemplateTypeEnum,
IfcCompositeCurve,
IfcCompositeCurveOnSurface,
IfcCompositeCurveSegment,
IfcCompositeProfileDef,
IfcCompressor,
IfcCompressorType,
IfcCompressorTypeEnum,
IfcCondenser,
IfcCondenserType,
IfcCondenserTypeEnum,
IfcConic,
IfcConnectedFaceSet,
IfcConnectionCurveGeometry,
IfcConnectionGeometry,
IfcConnectionPointEccentricity,
IfcConnectionPointGeometry,
IfcConnectionSurfaceGeometry,
IfcConnectionTypeEnum,
IfcConnectionVolumeGeometry,
IfcConstraint,
IfcConstraintEnum,
IfcConstructionEquipmentResource,
IfcConstructionEquipmentResourceType,
IfcConstructionEquipmentResourceTypeEnum,
IfcConstructionMaterialResource,
IfcConstructionMaterialResourceType,
IfcConstructionMaterialResourceTypeEnum,
IfcConstructionProductResource,
IfcConstructionProductResourceType,
IfcConstructionProductResourceTypeEnum,
IfcConstructionResource,
IfcConstructionResourceType,
IfcContext,
IfcContextDependentMeasure,
IfcContextDependentUnit,
IfcControl,
IfcController,
IfcControllerType,
IfcControllerTypeEnum,
IfcConversionBasedUnit,
IfcConversionBasedUnitWithOffset,
IfcCooledBeam,
IfcCooledBeamType,
IfcCooledBeamTypeEnum,
IfcCoolingTower,
IfcCoolingTowerType,
IfcCoolingTowerTypeEnum,
IfcCoordinateOperation,
IfcCoordinateReferenceSystem,
IfcCostItem,
IfcCostItemTypeEnum,
IfcCostSchedule,
IfcCostScheduleTypeEnum,
IfcCostValue,
IfcCountMeasure,
IfcCovering,
IfcCoveringType,
IfcCoveringTypeEnum,
IfcCrewResource,
IfcCrewResourceType,
IfcCrewResourceTypeEnum,
IfcCsgPrimitive3D,
IfcCsgSolid,
IfcCurrencyRelationship,
IfcCurtainWall,
IfcCurtainWallType,
IfcCurtainWallTypeEnum,
IfcCurvatureMeasure,
IfcCurve,
IfcCurveBoundedPlane,
IfcCurveBoundedSurface,
IfcCurveInterpolationEnum,
IfcCurveSegment2D,
IfcCurveStyle,
IfcCurveStyleFont,
IfcCurveStyleFontAndScaling,
IfcCurveStyleFontPattern,
IfcCylindricalSurface,
IfcDamper,
IfcDamperType,
IfcDamperTypeEnum,
IfcDataOriginEnum,
IfcDate,
IfcDateTime,
IfcDayInMonthNumber,
IfcDayInWeekNumber,
IfcDeepFoundation,
IfcDeepFoundationType,
IfcDerivedProfileDef,
IfcDerivedUnit,
IfcDerivedUnitElement,
IfcDerivedUnitEnum,
IfcDescriptiveMeasure,
IfcDimensionCount,
IfcDimensionalExponents,
IfcDirection,
IfcDirectionSenseEnum,
IfcDiscreteAccessory,
IfcDiscreteAccessoryType,
IfcDiscreteAccessoryTypeEnum,
IfcDistanceExpression,
IfcDistributionChamberElement,
IfcDistributionChamberElementType,
IfcDistributionChamberElementTypeEnum,
IfcDistributionCircuit,
IfcDistributionControlElement,
IfcDistributionControlElementType,
IfcDistributionElement,
IfcDistributionElementType,
IfcDistributionFlowElement,
IfcDistributionFlowElementType,
IfcDistributionPort,
IfcDistributionPortTypeEnum,
IfcDistributionSystem,
IfcDistributionSystemEnum,
IfcDocumentConfidentialityEnum,
IfcDocumentInformation,
IfcDocumentInformationRelationship,
IfcDocumentReference,
IfcDocumentStatusEnum,
IfcDoor,
IfcDoorLiningProperties,
IfcDoorPanelOperationEnum,
IfcDoorPanelPositionEnum,
IfcDoorPanelProperties,
IfcDoorStandardCase,
IfcDoorStyle,
IfcDoorStyleConstructionEnum,
IfcDoorStyleOperationEnum,
IfcDoorType,
IfcDoorTypeEnum,
IfcDoorTypeOperationEnum,
IfcDoseEquivalentMeasure,
IfcDraughtingPreDefinedColour,
IfcDraughtingPreDefinedCurveFont,
IfcDuctFitting,
IfcDuctFittingType,
IfcDuctFittingTypeEnum,
IfcDuctSegment,
IfcDuctSegmentType,
IfcDuctSegmentTypeEnum,
IfcDuctSilencer,
IfcDuctSilencerType,
IfcDuctSilencerTypeEnum,
IfcDuration,
IfcDynamicViscosityMeasure,
IfcEdge,
IfcEdgeCurve,
IfcEdgeLoop,
IfcElectricAppliance,
IfcElectricApplianceType,
IfcElectricApplianceTypeEnum,
IfcElectricCapacitanceMeasure,
IfcElectricChargeMeasure,
IfcElectricConductanceMeasure,
IfcElectricCurrentMeasure,
IfcElectricDistributionBoard,
IfcElectricDistributionBoardType,
IfcElectricDistributionBoardTypeEnum,
IfcElectricFlowStorageDevice,
IfcElectricFlowStorageDeviceType,
IfcElectricFlowStorageDeviceTypeEnum,
IfcElectricGenerator,
IfcElectricGeneratorType,
IfcElectricGeneratorTypeEnum,
IfcElectricMotor,
IfcElectricMotorType,
IfcElectricMotorTypeEnum,
IfcElectricResistanceMeasure,
IfcElectricTimeControl,
IfcElectricTimeControlType,
IfcElectricTimeControlTypeEnum,
IfcElectricVoltageMeasure,
IfcElement,
IfcElementAssembly,
IfcElementAssemblyType,
IfcElementAssemblyTypeEnum,
IfcElementComponent,
IfcElementComponentType,
IfcElementCompositionEnum,
IfcElementQuantity,
IfcElementType,
IfcElementarySurface,
IfcElements,
IfcEllipse,
IfcEllipseProfileDef,
IfcEnergyConversionDevice,
IfcEnergyConversionDeviceType,
IfcEnergyMeasure,
IfcEngine,
IfcEngineType,
IfcEngineTypeEnum,
IfcEvaporativeCooler,
IfcEvaporativeCoolerType,
IfcEvaporativeCoolerTypeEnum,
IfcEvaporator,
IfcEvaporatorType,
IfcEvaporatorTypeEnum,
IfcEvent,
IfcEventTime,
IfcEventTriggerTypeEnum,
IfcEventType,
IfcEventTypeEnum,
IfcExtendedProperties,
IfcExternalInformation,
IfcExternalReference,
IfcExternalReferenceRelationship,
IfcExternalSpatialElement,
IfcExternalSpatialElementTypeEnum,
IfcExternalSpatialStructureElement,
IfcExternallyDefinedHatchStyle,
IfcExternallyDefinedSurfaceStyle,
IfcExternallyDefinedTextFont,
IfcExtrudedAreaSolid,
IfcExtrudedAreaSolidTapered,
IfcFace,
IfcFaceBasedSurfaceModel,
IfcFaceBound,
IfcFaceOuterBound,
IfcFaceSurface,
IfcFacetedBrep,
IfcFacetedBrepWithVoids,
IfcFacility,
IfcFacilityPart,
IfcFailureConnectionCondition,
IfcFan,
IfcFanType,
IfcFanTypeEnum,
IfcFastener,
IfcFastenerType,
IfcFastenerTypeEnum,
IfcFeatureElement,
IfcFeatureElementAddition,
IfcFeatureElementSubtraction,
IfcFillAreaStyle,
IfcFillAreaStyleHatching,
IfcFillAreaStyleTiles,
IfcFilter,
IfcFilterType,
IfcFilterTypeEnum,
IfcFireSuppressionTerminal,
IfcFireSuppressionTerminalType,
IfcFireSuppressionTerminalTypeEnum,
IfcFixedReferenceSweptAreaSolid,
IfcFlowController,
IfcFlowControllerType,
IfcFlowDirectionEnum,
IfcFlowFitting,
IfcFlowFittingType,
IfcFlowInstrument,
IfcFlowInstrumentType,
IfcFlowInstrumentTypeEnum,
IfcFlowMeter,
IfcFlowMeterType,
IfcFlowMeterTypeEnum,
IfcFlowMovingDevice,
IfcFlowMovingDeviceType,
IfcFlowSegment,
IfcFlowSegmentType,
IfcFlowStorageDevice,
IfcFlowStorageDeviceType,
IfcFlowTerminal,
IfcFlowTerminalType,
IfcFlowTreatmentDevice,
IfcFlowTreatmentDeviceType,
IfcFontStyle,
IfcFontVariant,
IfcFontWeight,
IfcFooting,
IfcFootingType,
IfcFootingTypeEnum,
IfcForceMeasure,
IfcFrequencyMeasure,
IfcFurnishingElement,
IfcFurnishingElementType,
IfcFurniture,
IfcFurnitureType,
IfcFurnitureTypeEnum,
IfcGeographicElement,
IfcGeographicElementType,
IfcGeographicElementTypeEnum,
IfcGeometricCurveSet,
IfcGeometricProjectionEnum,
IfcGeometricRepresentationContext,
IfcGeometricRepresentationItem,
IfcGeometricRepresentationSubContext,
IfcGeometricSet,
IfcGlobalOrLocalEnum,
IfcGloballyUniqueId,
IfcGrid,
IfcGridAxis,
IfcGridPlacement,
IfcGridTypeEnum,
IfcGroup,
IfcHalfSpaceSolid,
IfcHeatExchanger,
IfcHeatExchangerType,
IfcHeatExchangerTypeEnum,
IfcHeatFluxDensityMeasure,
IfcHeatingValueMeasure,
IfcHumidifier,
IfcHumidifierType,
IfcHumidifierTypeEnum,
IfcIShapeProfileDef,
IfcIdentifier,
IfcIlluminanceMeasure,
IfcImageTexture,
IfcIndexedColourMap,
IfcIndexedPolyCurve,
IfcIndexedPolygonalFace,
IfcIndexedPolygonalFaceWithVoids,
IfcIndexedTextureMap,
IfcIndexedTriangleTextureMap,
IfcInductanceMeasure,
IfcInteger,
IfcIntegerCountRateMeasure,
IfcInterceptor,
IfcInterceptorType,
IfcInterceptorTypeEnum,
IfcInternalOrExternalEnum,
IfcIntersectionCurve,
IfcInventory,
IfcInventoryTypeEnum,
IfcIonConcentrationMeasure,
IfcIrregularTimeSeries,
IfcIrregularTimeSeriesValue,
IfcIsothermalMoistureCapacityMeasure,
IfcJunctionBox,
IfcJunctionBoxType,
IfcJunctionBoxTypeEnum,
IfcKinematicViscosityMeasure,
IfcKnotType,
IfcLShapeProfileDef,
IfcLabel,
IfcLaborResource,
IfcLaborResourceType,
IfcLaborResourceTypeEnum,
IfcLagTime,
IfcLamp,
IfcLampType,
IfcLampTypeEnum,
IfcLanguageId,
IfcLayerSetDirectionEnum,
IfcLengthMeasure,
IfcLibraryInformation,
IfcLibraryReference,
IfcLightDistributionCurveEnum,
IfcLightDistributionData,
IfcLightEmissionSourceEnum,
IfcLightFixture,
IfcLightFixtureType,
IfcLightFixtureTypeEnum,
IfcLightIntensityDistribution,
IfcLightSource,
IfcLightSourceAmbient,
IfcLightSourceDirectional,
IfcLightSourceGoniometric,
IfcLightSourcePositional,
IfcLightSourceSpot,
IfcLine,
IfcLineSegment2D,
IfcLinearForceMeasure,
IfcLinearMomentMeasure,
IfcLinearPlacement,
IfcLinearPositioningElement,
IfcLinearStiffnessMeasure,
IfcLinearVelocityMeasure,
IfcLoadGroupTypeEnum,
IfcLocalPlacement,
IfcLogical,
IfcLogicalOperatorEnum,
IfcLoop,
IfcLuminousFluxMeasure,
IfcLuminousIntensityDistributionMeasure,
IfcLuminousIntensityMeasure,
IfcMagneticFluxDensityMeasure,
IfcMagneticFluxMeasure,
IfcManifoldSolidBrep,
IfcMapConversion,
IfcMappedItem,
IfcMassDensityMeasure,
IfcMassFlowRateMeasure,
IfcMassMeasure,
IfcMassPerLengthMeasure,
IfcMaterial,
IfcMaterialClassificationRelationship,
IfcMaterialConstituent,
IfcMaterialConstituentSet,
IfcMaterialDefinition,
IfcMaterialDefinitionRepresentation,
IfcMaterialLayer,
IfcMaterialLayerSet,
IfcMaterialLayerSetUsage,
IfcMaterialLayerWithOffsets,
IfcMaterialList,
IfcMaterialProfile,
IfcMaterialProfileSet,
IfcMaterialProfileSetUsage,
IfcMaterialProfileSetUsageTapering,
IfcMaterialProfileWithOffsets,
IfcMaterialProperties,
IfcMaterialRelationship,
IfcMaterialUsageDefinition,
IfcMeasureWithUnit,
IfcMechanicalFastener,
IfcMechanicalFastenerType,
IfcMechanicalFastenerTypeEnum,
IfcMedicalDevice,
IfcMedicalDeviceType,
IfcMedicalDeviceTypeEnum,
IfcMember,
IfcMemberStandardCase,
IfcMemberType,
IfcMemberTypeEnum,
IfcMetric,
IfcMirroredProfileDef,
IfcModulusOfElasticityMeasure,
IfcModulusOfLinearSubgradeReactionMeasure,
IfcModulusOfRotationalSubgradeReactionMeasure,
IfcModulusOfSubgradeReactionMeasure,
IfcMoistureDiffusivityMeasure,
IfcMolecularWeightMeasure,
IfcMomentOfInertiaMeasure,
IfcMonetaryMeasure,
IfcMonetaryUnit,
IfcMonthInYearNumber,
IfcMotorConnection,
IfcMotorConnectionType,
IfcMotorConnectionTypeEnum,
IfcNamedUnit,
IfcNonNegativeLengthMeasure,
IfcNormalisedRatioMeasure,
IfcNullStyle,
IfcNumericMeasure,
IfcObject,
IfcObjectDefinition,
IfcObjectPlacement,
IfcObjectTypeEnum,
IfcObjective,
IfcObjectiveEnum,
IfcOccupant,
IfcOccupantTypeEnum,
IfcOffsetCurve,
IfcOffsetCurve2D,
IfcOffsetCurve3D,
IfcOffsetCurveByDistances,
IfcOpenShell,
IfcOpeningElement,
IfcOpeningElementTypeEnum,
IfcOpeningStandardCase,
IfcOrganization,
IfcOrganizationRelationship,
IfcOrientationExpression,
IfcOrientedEdge,
IfcOuterBoundaryCurve,
IfcOutlet,
IfcOutletType,
IfcOutletTypeEnum,
IfcOwnerHistory,
IfcPHMeasure,
IfcParameterValue,
IfcParameterizedProfileDef,
IfcPath,
IfcPcurve,
IfcPerformanceHistory,
IfcPerformanceHistoryTypeEnum,
IfcPermeableCoveringOperationEnum,
IfcPermeableCoveringProperties,
IfcPermit,
IfcPermitTypeEnum,
IfcPerson,
IfcPersonAndOrganization,
IfcPhysicalComplexQuantity,
IfcPhysicalOrVirtualEnum,
IfcPhysicalQuantity,
IfcPhysicalSimpleQuantity,
IfcPile,
IfcPileConstructionEnum,
IfcPileType,
IfcPileTypeEnum,
IfcPipeFitting,
IfcPipeFittingType,
IfcPipeFittingTypeEnum,
IfcPipeSegment,
IfcPipeSegmentType,
IfcPipeSegmentTypeEnum,
IfcPixelTexture,
IfcPlacement,
IfcPlanarBox,
IfcPlanarExtent,
IfcPlanarForceMeasure,
IfcPlane,
IfcPlaneAngleMeasure,
IfcPlate,
IfcPlateStandardCase,
IfcPlateType,
IfcPlateTypeEnum,
IfcPoint,
IfcPointOnCurve,
IfcPointOnSurface,
IfcPolyLoop,
IfcPolygonalBoundedHalfSpace,
IfcPolygonalFaceSet,
IfcPolyline,
IfcPort,
IfcPositioningElement,
IfcPositiveInteger,
IfcPositiveLengthMeasure,
IfcPositivePlaneAngleMeasure,
IfcPositiveRatioMeasure,
IfcPostalAddress,
IfcPowerMeasure,
IfcPreDefinedColour,
IfcPreDefinedCurveFont,
IfcPreDefinedItem,
IfcPreDefinedProperties,
IfcPreDefinedPropertySet,
IfcPreDefinedTextFont,
IfcPreferredSurfaceCurveRepresentation,
IfcPresentableText,
IfcPresentationItem,
IfcPresentationLayerAssignment,
IfcPresentationLayerWithStyle,
IfcPresentationStyle,
IfcPresentationStyleAssignment,
IfcPressureMeasure,
IfcProcedure,
IfcProcedureType,
IfcProcedureTypeEnum,
IfcProcess,
IfcProduct,
IfcProductDefinitionShape,
IfcProductRepresentation,
IfcProfileDef,
IfcProfileProperties,
IfcProfileTypeEnum,
IfcProject,
IfcProjectLibrary,
IfcProjectOrder,
IfcProjectOrderTypeEnum,
IfcProjectedCRS,
IfcProjectedOrTrueLengthEnum,
IfcProjectionElement,
IfcProjectionElementTypeEnum,
IfcProperty,
IfcPropertyAbstraction,
IfcPropertyBoundedValue,
IfcPropertyDefinition,
IfcPropertyDependencyRelationship,
IfcPropertyEnumeratedValue,
IfcPropertyEnumeration,
IfcPropertyListValue,
IfcPropertyReferenceValue,
IfcPropertySet,
IfcPropertySetDefinition,
IfcPropertySetTemplate,
IfcPropertySetTemplateTypeEnum,
IfcPropertySingleValue,
IfcPropertyTableValue,
IfcPropertyTemplate,
IfcPropertyTemplateDefinition,
IfcProtectiveDevice,
IfcProtectiveDeviceTrippingUnit,
IfcProtectiveDeviceTrippingUnitType,
IfcProtectiveDeviceTrippingUnitTypeEnum,
IfcProtectiveDeviceType,
IfcProtectiveDeviceTypeEnum,
IfcProxy,
IfcPump,
IfcPumpType,
IfcPumpTypeEnum,
IfcQuantityArea,
IfcQuantityCount,
IfcQuantityLength,
IfcQuantitySet,
IfcQuantityTime,
IfcQuantityVolume,
IfcQuantityWeight,
IfcRadioActivityMeasure,
IfcRailing,
IfcRailingType,
IfcRailingTypeEnum,
IfcRamp,
IfcRampFlight,
IfcRampFlightType,
IfcRampFlightTypeEnum,
IfcRampType,
IfcRampTypeEnum,
IfcRatioMeasure,
IfcRationalBSplineCurveWithKnots,
IfcRationalBSplineSurfaceWithKnots,
IfcReal,
IfcRectangleHollowProfileDef,
IfcRectangleProfileDef,
IfcRectangularPyramid,
IfcRectangularTrimmedSurface,
IfcRecurrencePattern,
IfcRecurrenceTypeEnum,
IfcReference,
IfcReferent,
IfcReferentTypeEnum,
IfcReflectanceMethodEnum,
IfcRegularTimeSeries,
IfcReinforcementBarProperties,
IfcReinforcementDefinitionProperties,
IfcReinforcingBar,
IfcReinforcingBarRoleEnum,
IfcReinforcingBarSurfaceEnum,
IfcReinforcingBarType,
IfcReinforcingBarTypeEnum,
IfcReinforcingElement,
IfcReinforcingElementType,
IfcReinforcingMesh,
IfcReinforcingMeshType,
IfcReinforcingMeshTypeEnum,
IfcRelAggregates,
IfcRelAssigns,
IfcRelAssignsToActor,
IfcRelAssignsToControl,
IfcRelAssignsToGroup,
IfcRelAssignsToGroupByFactor,
IfcRelAssignsToProcess,
IfcRelAssignsToProduct,
IfcRelAssignsToResource,
IfcRelAssociates,
IfcRelAssociatesApproval,
IfcRelAssociatesClassification,
IfcRelAssociatesConstraint,
IfcRelAssociatesDocument,
IfcRelAssociatesLibrary,
IfcRelAssociatesMaterial,
IfcRelConnects,
IfcRelConnectsElements,
IfcRelConnectsPathElements,
IfcRelConnectsPortToElement,
IfcRelConnectsPorts,
IfcRelConnectsStructuralActivity,
IfcRelConnectsStructuralMember,
IfcRelConnectsWithEccentricity,
IfcRelConnectsWithRealizingElements,
IfcRelContainedInSpatialStructure,
IfcRelCoversBldgElements,
IfcRelCoversSpaces,
IfcRelDeclares,
IfcRelDecomposes,
IfcRelDefines,
IfcRelDefinesByObject,
IfcRelDefinesByProperties,
IfcRelDefinesByTemplate,
IfcRelDefinesByType,
IfcRelFillsElement,
IfcRelFlowControlElements,
IfcRelInterferesElements,
IfcRelNests,
IfcRelPositions,
IfcRelProjectsElement,
IfcRelReferencedInSpatialStructure,
IfcRelSequence,
IfcRelServicesBuildings,
IfcRelSpaceBoundary,
IfcRelSpaceBoundary1stLevel,
IfcRelSpaceBoundary2ndLevel,
IfcRelVoidsElement,
IfcRelationship,
IfcReparametrisedCompositeCurveSegment,
IfcRepresentation,
IfcRepresentationContext,
IfcRepresentationItem,
IfcRepresentationMap,
IfcResource,
IfcResourceApprovalRelationship,
IfcResourceConstraintRelationship,
IfcResourceLevelRelationship,
IfcResourceTime,
IfcRevolvedAreaSolid,
IfcRevolvedAreaSolidTapered,
IfcRightCircularCone,
IfcRightCircularCylinder,
IfcRoleEnum,
IfcRoof,
IfcRoofType,
IfcRoofTypeEnum,
IfcRoot,
IfcRotationalFrequencyMeasure,
IfcRotationalMassMeasure,
IfcRotationalStiffnessMeasure,
IfcRoundedRectangleProfileDef,
IfcSIPrefix,
IfcSIUnit,
IfcSIUnitName,
IfcSanitaryTerminal,
IfcSanitaryTerminalType,
IfcSanitaryTerminalTypeEnum,
IfcSchedulingTime,
IfcSeamCurve,
IfcSectionModulusMeasure,
IfcSectionProperties,
IfcSectionReinforcementProperties,
IfcSectionTypeEnum,
IfcSectionalAreaIntegralMeasure,
IfcSectionedSolid,
IfcSectionedSolidHorizontal,
IfcSectionedSpine,
IfcSensor,
IfcSensorType,
IfcSensorTypeEnum,
IfcSequenceEnum,
IfcShadingDevice,
IfcShadingDeviceType,
IfcShadingDeviceTypeEnum,
IfcShapeAspect,
IfcShapeModel,
IfcShapeRepresentation,
IfcShearModulusMeasure,
IfcShellBasedSurfaceModel,
IfcSimpleProperty,
IfcSimplePropertyTemplate,
IfcSimplePropertyTemplateTypeEnum,
IfcSite,
IfcSlab,
IfcSlabElementedCase,
IfcSlabStandardCase,
IfcSlabType,
IfcSlabTypeEnum,
IfcSlippageConnectionCondition,
IfcSolarDevice,
IfcSolarDeviceType,
IfcSolarDeviceTypeEnum,
IfcSolidAngleMeasure,
IfcSolidModel,
IfcSoundPowerLevelMeasure,
IfcSoundPowerMeasure,
IfcSoundPressureLevelMeasure,
IfcSoundPressureMeasure,
IfcSpace,
IfcSpaceHeater,
IfcSpaceHeaterType,
IfcSpaceHeaterTypeEnum,
IfcSpaceType,
IfcSpaceTypeEnum,
IfcSpatialElement,
IfcSpatialElementType,
IfcSpatialStructureElement,
IfcSpatialStructureElementType,
IfcSpatialZone,
IfcSpatialZoneType,
IfcSpatialZoneTypeEnum,
IfcSpecificHeatCapacityMeasure,
IfcSpecularExponent,
IfcSpecularRoughness,
IfcSphere,
IfcSphericalSurface,
IfcStackTerminal,
IfcStackTerminalType,
IfcStackTerminalTypeEnum,
IfcStair,
IfcStairFlight,
IfcStairFlightType,
IfcStairFlightTypeEnum,
IfcStairType,
IfcStairTypeEnum,
IfcStateEnum,
IfcStructuralAction,
IfcStructuralActivity,
IfcStructuralAnalysisModel,
IfcStructuralConnection,
IfcStructuralConnectionCondition,
IfcStructuralCurveAction,
IfcStructuralCurveActivityTypeEnum,
IfcStructuralCurveConnection,
IfcStructuralCurveMember,
IfcStructuralCurveMemberTypeEnum,
IfcStructuralCurveMemberVarying,
IfcStructuralCurveReaction,
IfcStructuralItem,
IfcStructuralLinearAction,
IfcStructuralLoad,
IfcStructuralLoadCase,
IfcStructuralLoadConfiguration,
IfcStructuralLoadGroup,
IfcStructuralLoadLinearForce,
IfcStructuralLoadOrResult,
IfcStructuralLoadPlanarForce,
IfcStructuralLoadSingleDisplacement,
IfcStructuralLoadSingleDisplacementDistortion,
IfcStructuralLoadSingleForce,
IfcStructuralLoadSingleForceWarping,
IfcStructuralLoadStatic,
IfcStructuralLoadTemperature,
IfcStructuralMember,
IfcStructuralPlanarAction,
IfcStructuralPointAction,
IfcStructuralPointConnection,
IfcStructuralPointReaction,
IfcStructuralReaction,
IfcStructuralResultGroup,
IfcStructuralSurfaceAction,
IfcStructuralSurfaceActivityTypeEnum,
IfcStructuralSurfaceConnection,
IfcStructuralSurfaceMember,
IfcStructuralSurfaceMemberTypeEnum,
IfcStructuralSurfaceMemberVarying,
IfcStructuralSurfaceReaction,
IfcStyleModel,
IfcStyledItem,
IfcStyledRepresentation,
IfcSubContractResource,
IfcSubContractResourceType,
IfcSubContractResourceTypeEnum,
IfcSubedge,
IfcSurface,
IfcSurfaceCurve,
IfcSurfaceCurveSweptAreaSolid,
IfcSurfaceFeature,
IfcSurfaceFeatureTypeEnum,
IfcSurfaceOfLinearExtrusion,
IfcSurfaceOfRevolution,
IfcSurfaceReinforcementArea,
IfcSurfaceSide,
IfcSurfaceStyle,
IfcSurfaceStyleLighting,
IfcSurfaceStyleRefraction,
IfcSurfaceStyleRendering,
IfcSurfaceStyleShading,
IfcSurfaceStyleWithTextures,
IfcSurfaceTexture,
IfcSweptAreaSolid,
IfcSweptDiskSolid,
IfcSweptDiskSolidPolygonal,
IfcSweptSurface,
IfcSwitchingDevice,
IfcSwitchingDeviceType,
IfcSwitchingDeviceTypeEnum,
IfcSystem,
IfcSystemFurnitureElement,
IfcSystemFurnitureElementType,
IfcSystemFurnitureElementTypeEnum,
IfcTShapeProfileDef,
IfcTable,
IfcTableColumn,
IfcTableRow,
IfcTank,
IfcTankType,
IfcTankTypeEnum,
IfcTask,
IfcTaskDurationEnum,
IfcTaskTime,
IfcTaskTimeRecurring,
IfcTaskType,
IfcTaskTypeEnum,
IfcTelecomAddress,
IfcTemperatureGradientMeasure,
IfcTemperatureRateOfChangeMeasure,
IfcTendon,
IfcTendonAnchor,
IfcTendonAnchorType,
IfcTendonAnchorTypeEnum,
IfcTendonConduit,
IfcTendonConduitType,
IfcTendonConduitTypeEnum,
IfcTendonType,
IfcTendonTypeEnum,
IfcTessellatedFaceSet,
IfcTessellatedItem,
IfcText,
IfcTextAlignment,
IfcTextDecoration,
IfcTextFontName,
IfcTextLiteral,
IfcTextLiteralWithExtent,
IfcTextPath,
IfcTextStyle,
IfcTextStyleFontModel,
IfcTextStyleForDefinedFont,
IfcTextStyleTextModel,
IfcTextTransformation,
IfcTextureCoordinate,
IfcTextureCoordinateGenerator,
IfcTextureMap,
IfcTextureVertex,
IfcTextureVertexList,
IfcThermalAdmittanceMeasure,
IfcThermalConductivityMeasure,
IfcThermalExpansionCoefficientMeasure,
IfcThermalResistanceMeasure,
IfcThermalTransmittanceMeasure,
IfcThermodynamicTemperatureMeasure,
IfcTime,
IfcTimeMeasure,
IfcTimePeriod,
IfcTimeSeries,
IfcTimeSeriesDataTypeEnum,
IfcTimeSeriesValue,
IfcTimeStamp,
IfcTopologicalRepresentationItem,
IfcTopologyRepresentation,
IfcToroidalSurface,
IfcTorqueMeasure,
IfcTransformer,
IfcTransformerType,
IfcTransformerTypeEnum,
IfcTransitionCode,
IfcTransitionCurveSegment2D,
IfcTransitionCurveType,
IfcTransportElement,
IfcTransportElementType,
IfcTransportElementTypeEnum,
IfcTrapeziumProfileDef,
IfcTriangulatedFaceSet,
IfcTriangulatedIrregularNetwork,
IfcTrimmedCurve,
IfcTrimmingPreference,
IfcTubeBundle,
IfcTubeBundleType,
IfcTubeBundleTypeEnum,
IfcTypeObject,
IfcTypeProcess,
IfcTypeProduct,
IfcTypeResource,
IfcURIReference,
IfcUShapeProfileDef,
IfcUnitAssignment,
IfcUnitEnum,
IfcUnitaryControlElement,
IfcUnitaryControlElementType,
IfcUnitaryControlElementTypeEnum,
IfcUnitaryEquipment,
IfcUnitaryEquipmentType,
IfcUnitaryEquipmentTypeEnum,
IfcValve,
IfcValveType,
IfcValveTypeEnum,
IfcVaporPermeabilityMeasure,
IfcVector,
IfcVertex,
IfcVertexLoop,
IfcVertexPoint,
IfcVibrationDamper,
IfcVibrationDamperType,
IfcVibrationDamperTypeEnum,
IfcVibrationIsolator,
IfcVibrationIsolatorType,
IfcVibrationIsolatorTypeEnum,
IfcVirtualElement,
IfcVirtualGridIntersection,
IfcVoidingFeature,
IfcVoidingFeatureTypeEnum,
IfcVolumeMeasure,
IfcVolumetricFlowRateMeasure,
IfcWall,
IfcWallElementedCase,
IfcWallStandardCase,
IfcWallType,
IfcWallTypeEnum,
IfcWarpingConstantMeasure,
IfcWarpingMomentMeasure,
IfcWasteTerminal,
IfcWasteTerminalType,
IfcWasteTerminalTypeEnum,
IfcWindow,
IfcWindowLiningProperties,
IfcWindowPanelOperationEnum,
IfcWindowPanelPositionEnum,
IfcWindowPanelProperties,
IfcWindowStandardCase,
IfcWindowStyle,
IfcWindowStyleConstructionEnum,
IfcWindowStyleOperationEnum,
IfcWindowType,
IfcWindowTypeEnum,
IfcWindowTypePartitioningEnum,
IfcWorkCalendar,
IfcWorkCalendarTypeEnum,
IfcWorkControl,
IfcWorkPlan,
IfcWorkPlanTypeEnum,
IfcWorkSchedule,
IfcWorkScheduleTypeEnum,
IfcWorkTime,
IfcZShapeProfileDef,
IfcZone,
LABEL,
LINE_END,
REAL,
REF,
SET_BEGIN,
SET_END,
STRING,
UNKNOWN,
Value,
ms
};
var WasmPath = "";