wangzijun
/
3D-Demo
1
0
Fork 0
Code Issues Pull Requests Projects 1 Releases Wiki Activity
3D-Demo/jsm/loaders/ifc/web-ifc-api.js

47505 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.slice(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.slice(-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.slice(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.slice(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).slice(1);
to = PATH_FS.resolve(to).slice(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.slice(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 = "";
Reference in New Issue View Git Blame Copy Permalink