From 475d8d889e9ee2907cd63e75e5ae75b2269f02d3 Mon Sep 17 00:00:00 2001 From: Adam Hathcock Date: Thu, 6 Jun 2024 09:03:39 +0100 Subject: [PATCH] Initial check in of used types --- .config/dotnet-tools.json | 12 + .csharpierrc.yaml | 7 + .editorconfig | 305 +++++ .gitattributes | 5 + .gitignore | 21 + Directory.Build.props | 17 + Directory.Packages.props | 7 + Speckle.Api.sln | 45 + Speckle.Revit.Api/DocumentExtensions.cs | 10 + Speckle.Revit.Api/IRevitDocumentProxy.cs | 53 + .../IRevitModelCurveArrArrayProxy.cs | 52 + .../IRevitModelCurveArrayProxy.cs | 52 + Speckle.Revit.Api/IRevitModelCurveProxy.cs | 33 + Speckle.Revit.Api/IRevitUnitsProxy.cs | 14 + Speckle.Revit.Api/RevitFilterFactory.cs | 70 + Speckle.Revit.Api/RevitUnitUtils.cs | 15 + Speckle.Revit.Api/Speckle.Revit.Api.projitems | 14 + Speckle.Revit.Api/Speckle.Revit.Api.shproj | 13 + Speckle.Revit.Interfaces/Extensions.cs | 35 + .../IRevitCategory.cs | 0 .../IRevitCurtainGrid.cs | 0 .../IRevitCurve.cs | 0 .../IRevitCurveElement.cs | 0 Speckle.Revit.Interfaces/IRevitDocument.cs | 12 + .../IRevitElement.cs | 0 .../IRevitElementFilter.cs | 0 .../IRevitElementId.cs | 0 .../IRevitElementIsElementTypeFilter.cs | 0 .../IRevitElementMulticategoryFilter.cs | 0 .../IRevitFilterFactory.cs | 16 + .../IRevitFilteredElementCollector.cs | 0 .../IRevitForgeTypeId.cs | 0 .../IRevitFormatOptions.cs | 0 .../IRevitHostObject.cs | 0 .../IRevitLocation.cs | 0 .../IRevitLocationCurve.cs | 0 .../IRevitLocationPoint.cs | 0 .../IRevitLogicalAndFilterFilter.cs | 0 Speckle.Revit.Interfaces/IRevitModelCurve.cs | 3 + .../IRevitModelCurveArrArray.cs | 0 .../IRevitModelCurveArray.cs | 6 + .../IRevitUnitUtils.cs | 0 Speckle.Revit.Interfaces/IRevitUnits.cs | 11 + .../IRevitWall.cs | 0 .../IRevitXYZ.cs | 0 .../RevitBuiltInCategory.cs | 1197 +++++++++++++++++ .../Speckle.Revit.Interfaces.projitems | 14 + .../Speckle.Revit.Interfaces.shproj | 13 + .../Speckle.Revit2023.Api.csproj | 17 + Speckle.Revit2023.Api/packages.lock.json | 48 + .../Speckle.Revit2023.Interfaces.csproj | 6 + .../packages.lock.json | 21 + global.json | 6 + 53 files changed, 2150 insertions(+) create mode 100644 .config/dotnet-tools.json create mode 100644 .csharpierrc.yaml create mode 100644 .editorconfig create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 Directory.Build.props create mode 100644 Directory.Packages.props create mode 100644 Speckle.Api.sln create mode 100644 Speckle.Revit.Api/DocumentExtensions.cs create mode 100644 Speckle.Revit.Api/IRevitDocumentProxy.cs create mode 100644 Speckle.Revit.Api/IRevitModelCurveArrArrayProxy.cs create mode 100644 Speckle.Revit.Api/IRevitModelCurveArrayProxy.cs create mode 100644 Speckle.Revit.Api/IRevitModelCurveProxy.cs create mode 100644 Speckle.Revit.Api/IRevitUnitsProxy.cs create mode 100644 Speckle.Revit.Api/RevitFilterFactory.cs create mode 100644 Speckle.Revit.Api/RevitUnitUtils.cs create mode 100644 Speckle.Revit.Api/Speckle.Revit.Api.projitems create mode 100644 Speckle.Revit.Api/Speckle.Revit.Api.shproj create mode 100644 Speckle.Revit.Interfaces/Extensions.cs rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitCategory.cs (100%) rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitCurtainGrid.cs (100%) rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitCurve.cs (100%) rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitCurveElement.cs (100%) create mode 100644 Speckle.Revit.Interfaces/IRevitDocument.cs rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitElement.cs (100%) rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitElementFilter.cs (100%) rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitElementId.cs (100%) rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitElementIsElementTypeFilter.cs (100%) rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitElementMulticategoryFilter.cs (100%) create mode 100644 Speckle.Revit.Interfaces/IRevitFilterFactory.cs rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitFilteredElementCollector.cs (100%) rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitForgeTypeId.cs (100%) rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitFormatOptions.cs (100%) rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitHostObject.cs (100%) rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitLocation.cs (100%) rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitLocationCurve.cs (100%) rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitLocationPoint.cs (100%) rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitLogicalAndFilterFilter.cs (100%) create mode 100644 Speckle.Revit.Interfaces/IRevitModelCurve.cs rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitModelCurveArrArray.cs (100%) create mode 100644 Speckle.Revit.Interfaces/IRevitModelCurveArray.cs rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitUnitUtils.cs (100%) create mode 100644 Speckle.Revit.Interfaces/IRevitUnits.cs rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitWall.cs (100%) rename {Speckle.Revit2023.Interfaces => Speckle.Revit.Interfaces}/IRevitXYZ.cs (100%) create mode 100644 Speckle.Revit.Interfaces/RevitBuiltInCategory.cs create mode 100644 Speckle.Revit.Interfaces/Speckle.Revit.Interfaces.projitems create mode 100644 Speckle.Revit.Interfaces/Speckle.Revit.Interfaces.shproj create mode 100644 Speckle.Revit2023.Api/Speckle.Revit2023.Api.csproj create mode 100644 Speckle.Revit2023.Api/packages.lock.json create mode 100644 Speckle.Revit2023.Interfaces/Speckle.Revit2023.Interfaces.csproj create mode 100644 Speckle.Revit2023.Interfaces/packages.lock.json create mode 100644 global.json diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json new file mode 100644 index 0000000..00b1a06 --- /dev/null +++ b/.config/dotnet-tools.json @@ -0,0 +1,12 @@ +{ + "version": 1, + "isRoot": true, + "tools": { + "csharpier": { + "version": "0.28.1", + "commands": [ + "dotnet-csharpier" + ] + } + } +} \ No newline at end of file diff --git a/.csharpierrc.yaml b/.csharpierrc.yaml new file mode 100644 index 0000000..152a715 --- /dev/null +++ b/.csharpierrc.yaml @@ -0,0 +1,7 @@ +printWidth: 120 +useTabs: false +tabWidth: 2 +preprocessorSymbolSets: + - "" + - "DEBUG" + - "DEBUG,CODE_STYLE" diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..aad43bc --- /dev/null +++ b/.editorconfig @@ -0,0 +1,305 @@ +root = true +# Don't use tabs for indentation. +[*] +indent_style = space + +# Microsoft .NET properties +csharp_using_directive_placement = outside_namespace:silent + +dotnet_style_parentheses_in_arithmetic_binary_operators = never_if_unnecessary:none +dotnet_style_parentheses_in_other_binary_operators = never_if_unnecessary:none +dotnet_style_parentheses_in_relational_binary_operators = never_if_unnecessary:none + + +# Standard properties +insert_final_newline = true + +# (Please don't specify an indent_size here; that has too many unintended consequences.) + +# Code files +[*.{cs,csx,vb,vbx}] +indent_size = 2 +charset = utf-8 + +# Xml project files +[*.{csproj,vbproj,vcxproj,vcxproj.filters,proj,projitems,shproj}] +indent_size = 2 +space_after_last_pi_attribute = false +# Xml config files +[*.{props,targets,ruleset,config,nuspec,resx,vsixmanifest,vsct}] +indent_size = 2 +space_after_last_pi_attribute = false + +# JSON files +[*.json] +indent_size = 2 + +# Dotnet code style settings: +[*.{cs,vb}] +# Sort using and Import directives with System.* appearing first +dotnet_sort_system_directives_first = true +dotnet_separate_import_directive_groups = false + +# Avoid "this." and "Me." if not necessary +dotnet_style_qualification_for_field = false:suggestion +dotnet_style_qualification_for_property = false:suggestion +dotnet_style_qualification_for_method = false:suggestion +dotnet_style_qualification_for_event = false:suggestion + +# Use language keywords instead of framework type names for type references +dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion +dotnet_style_predefined_type_for_member_access = true:suggestion +# Parentheses preferences +dotnet_style_parentheses_in_arithmetic_binary_operators = never_if_unnecessary:silent +dotnet_style_parentheses_in_relational_binary_operators = never_if_unnecessary:silent +dotnet_style_parentheses_in_other_binary_operators = never_if_unnecessary:silent +dotnet_style_parentheses_in_other_operators = never_if_unnecessary:silent + +# Modifier preferences +dotnet_style_require_accessibility_modifiers = for_non_interface_members:silent +dotnet_style_readonly_field = true:suggestion + +# Expression-level preferences +dotnet_style_object_initializer = true:suggestion +dotnet_style_collection_initializer = true:suggestion +dotnet_style_coalesce_expression = true:suggestion +dotnet_style_null_propagation = true:suggestion +dotnet_style_explicit_tuple_names = true:suggestion +dotnet_style_prefer_is_null_check_over_reference_equality_method = true:silent +dotnet_style_prefer_inferred_tuple_names = true:suggestion +dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion +dotnet_style_prefer_auto_properties = true:warning +dotnet_style_prefer_conditional_expression_over_assignment = true:silent +dotnet_style_prefer_conditional_expression_over_return = true:silent + + +# CSharp code style settings: +[*.cs] +# Prefer "var" everywhere +csharp_style_var_elsewhere = false:none +csharp_style_var_for_built_in_types = false:none +csharp_style_var_when_type_is_apparent = false:none + +# Prefer method-like constructs to have a block body +csharp_style_expression_bodied_methods = true:suggestion +csharp_style_expression_bodied_constructors = false:suggestion +csharp_style_expression_bodied_operators = true:suggestion + +# Prefer property-like constructs to have an expression-body +csharp_style_expression_bodied_properties = true:suggestion +csharp_style_expression_bodied_indexers = true:suggestion +csharp_style_expression_bodied_accessors = true:suggestion + +# Suggest more modern language features when available +csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion +csharp_style_pattern_matching_over_as_with_null_check = true:suggestion +csharp_style_inlined_variable_declaration = true:suggestion +csharp_style_throw_expression = true:suggestion +csharp_style_conditional_delegate_call = true:suggestion +csharp_style_namespace_declarations = file_scoped + +# Newline settings +csharp_new_line_before_open_brace = all +csharp_new_line_before_else = true +csharp_new_line_before_catch = true +csharp_new_line_before_finally = true +csharp_new_line_before_members_in_object_initializers = true +csharp_new_line_before_members_in_anonymous_types = true + +# Space preferences +csharp_space_after_cast = false +csharp_space_after_keywords_in_control_flow_statements = true +csharp_space_between_method_call_parameter_list_parentheses = false +csharp_space_between_method_declaration_parameter_list_parentheses = false +csharp_space_between_parentheses = false +csharp_space_before_colon_in_inheritance_clause = true +csharp_space_after_colon_in_inheritance_clause = true +csharp_space_around_binary_operators = before_and_after +csharp_space_between_method_declaration_empty_parameter_list_parentheses = false +csharp_space_between_method_call_name_and_opening_parenthesis = false +csharp_space_between_method_call_empty_parameter_list_parentheses = false + +# Wrapping preferences +csharp_preserve_single_line_statements = true +csharp_preserve_single_line_blocks = true + + + +# SYMBOL NAMING RULES +# Copied from https://github.com/dotnet/roslyn/blob/main/.editorconfig +# Adapted rules: +# - Constants are ALL_UPPER +# - Non-private fields are PascalCase + +# Non-private fields are PascalCase +dotnet_naming_rule.non_private_readonly_fields_should_be_pascal_case.severity = warning +dotnet_naming_rule.non_private_readonly_fields_should_be_pascal_case.symbols = non_private_readonly_fields +dotnet_naming_rule.non_private_readonly_fields_should_be_pascal_case.style = non_private_readonly_field_style + +dotnet_naming_symbols.non_private_readonly_fields.applicable_kinds = field +dotnet_naming_symbols.non_private_readonly_fields.applicable_accessibilities = public, protected, internal, protected_internal, private_protected + +dotnet_naming_style.non_private_readonly_field_style.capitalization = pascal_case + +# Constants are ALL_UPPER +dotnet_naming_rule.constants_should_be_all_upper.severity = warning +dotnet_naming_rule.constants_should_be_all_upper.symbols = constants +dotnet_naming_rule.constants_should_be_all_upper.style = constant_style + +dotnet_naming_symbols.constants.applicable_kinds = field, local +dotnet_naming_symbols.constants.required_modifiers = const + +dotnet_naming_style.constant_style.capitalization = all_upper + +# Private static fields are camelCase and start with s_ +dotnet_naming_rule.static_fields_should_be_camel_case.severity = warning +dotnet_naming_rule.static_fields_should_be_camel_case.symbols = static_fields +dotnet_naming_rule.static_fields_should_be_camel_case.style = static_field_style + +dotnet_naming_symbols.static_fields.applicable_accessibilities = private +dotnet_naming_symbols.static_fields.applicable_kinds = field +dotnet_naming_symbols.static_fields.required_modifiers = static + +dotnet_naming_style.static_field_style.capitalization = camel_case +dotnet_naming_style.static_field_style.required_prefix = s_ + + +# Instance fields are camelCase and start with _ +dotnet_naming_rule.instance_fields_should_be_camel_case.severity = warning +dotnet_naming_rule.instance_fields_should_be_camel_case.symbols = instance_fields +dotnet_naming_rule.instance_fields_should_be_camel_case.style = instance_field_style + +dotnet_naming_symbols.instance_fields.applicable_kinds = field + +dotnet_naming_style.instance_field_style.capitalization = camel_case +dotnet_naming_style.instance_field_style.required_prefix = _ + +# Locals and parameters are camelCase +dotnet_naming_rule.locals_should_be_camel_case.severity = warning +dotnet_naming_rule.locals_should_be_camel_case.symbols = locals_and_parameters +dotnet_naming_rule.locals_should_be_camel_case.style = camel_case_style + +dotnet_naming_symbols.locals_and_parameters.applicable_kinds = parameter, local + +dotnet_naming_style.camel_case_style.capitalization = camel_case + +# Local functions are PascalCase +dotnet_naming_rule.local_functions_should_be_pascal_case.severity = warning +dotnet_naming_rule.local_functions_should_be_pascal_case.symbols = local_functions +dotnet_naming_rule.local_functions_should_be_pascal_case.style = local_function_style + +dotnet_naming_symbols.local_functions.applicable_kinds = local_function + +dotnet_naming_style.local_function_style.capitalization = pascal_case + +# By default, name items with PascalCase +dotnet_naming_rule.members_should_be_pascal_case.severity = warning +dotnet_naming_rule.members_should_be_pascal_case.symbols = all_members +dotnet_naming_rule.members_should_be_pascal_case.style = pascal_case_style + +dotnet_naming_symbols.all_members.applicable_kinds = * + +dotnet_naming_style.pascal_case_style.capitalization = pascal_case + + +# Analyzer settings +dotnet_analyzer_diagnostic.category-Style.severity = warning # All rules will use this severity unless overriden +dotnet_diagnostic.ide0055.severity = none # Formatting rule: Incompatible with CSharpier +dotnet_diagnostic.ide0007.severity = none # Use var instead of explicit type: Preference +dotnet_diagnostic.ide0009.severity = none # Add this or Me qualification: Preference +dotnet_diagnostic.ide0200.severity = none # Remove unnecessary lambda expression: may be performance reasons not to +dotnet_diagnostic.ide0058.severity = none # Remove unnecessary expression value: Subjective +dotnet_diagnostic.ide0010.severity = none # Add missing cases to switch statement: Too verbose +dotnet_diagnostic.ide0200.severity = none # Remove unnecessary lambda expression: may be performance reasons not to +dotnet_diagnostic.ide0058.severity = none # Remove unnecessary expression value: Subjective +dotnet_diagnostic.ide0001.severity = suggestion # Name can be simplified: Non enforceable in build +dotnet_diagnostic.ide0046.severity = suggestion # Use conditional expression for return: Subjective +dotnet_diagnostic.ide0045.severity = suggestion # Use conditional expression for assignment: Subjective +dotnet_diagnostic.ide0078.severity = suggestion # Use pattern matching: Subjective +dotnet_diagnostic.ide0260.severity = suggestion # Use pattern matching: Subjective +dotnet_diagnostic.ide0022.severity = suggestion # Use expression body for method: Subjective +dotnet_diagnostic.ide0061.severity = suggestion # Use expression body for local functions: Subjective +dotnet_diagnostic.ide0063.severity = suggestion # Using directive can be simplified +dotnet_diagnostic.ide0066.severity = suggestion # Use switch expression: Subjective +dotnet_diagnostic.ide0029.severity = suggestion # Null check can be simplified: Subjective +dotnet_diagnostic.ide0030.severity = suggestion # Null check can be simplified: Subjective +dotnet_diagnostic.ide0270.severity = suggestion # Null check can be simplified: Subjective +dotnet_diagnostic.ide0042.severity = suggestion # Deconstruct variable declaration: Subjective +dotnet_diagnostic.ide0039.severity = suggestion # Use local function instead of lambda: Subjective +dotnet_diagnostic.ide0029.severity = suggestion # Null check can be simplified: Subjective +dotnet_diagnostic.ide0030.severity = suggestion # Null check can be simplified: Subjective +dotnet_diagnostic.ide0270.severity = suggestion # Null check can be simplified: Subjective +dotnet_diagnostic.ide0042.severity = suggestion # Deconstruct variable declaration: Subjective +dotnet_diagnostic.ide0028.severity = suggestion # Use collection initializers: Subjective +dotnet_diagnostic.ide0072.severity = suggestion # Populate switch statement: Subjective +dotnet_diagnostic.ide0074.severity = suggestion # Use compound assignment: Subjective + +# Maintainability rules +dotnet_diagnostic.ca1501.severity = warning # Avoid excessive inheritance +dotnet_diagnostic.ca1502.severity = warning # Avoid excessive complexity +dotnet_diagnostic.ca1505.severity = warning # Avoid unmaintainable code +dotnet_diagnostic.ca1506.severity = warning # Avoid excessive class coupling +dotnet_diagnostic.ca1507.severity = warning # Use nameof in place of string +dotnet_diagnostic.ca1508.severity = warning # Avoid dead conditional code +dotnet_diagnostic.ca1509.severity = warning # Invalid entry in code metrics configuration file +dotnet_diagnostic.ca1861.severity = none # Prefer 'static readonly' fields over constant array arguments if the called method is called repeatedly and is not mutating the passed array (https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1861) + + +# Performance rules +dotnet_diagnostic.ca1849.severity = suggestion # Call async methods when in an async method: May decrease performance +dotnet_diagnostic.ca1822.severity = suggestion # Mark member as static +dotnet_diagnostic.ca1859.severity = suggestion # Use concrete types when possible for improved performance + +# Design rule +dotnet_diagnostic.ca1002.severity = suggestion # Do not expose generic lists +dotnet_diagnostic.ca1051.severity = warning # Do not declare visible instance fields +dotnet_diagnostic.ca1056.severity = suggestion # URI properties should not be strings +dotnet_diagnostic.ca1062.severity = none # Public method must check all parameters for null + +# Naming +dotnet_diagnostic.ca1707.severity = none # Remove underscores in names + +# Usage +dotnet_diagnostic.ca2227.severity = suggestion # Collection props should be read-only + +dotnet_code_quality.ca1051.exclude_structs = true # CA1051 is excluded in structs +dotnet_code_quality.dispose_ownership_transfer_at_constructor = true # CA2000 has a lot of false positives without this +dotnet_code_quality.dispose_ownership_transfer_at_method_call = true # CA2000 has a lot of false positives without this +dotnet_code_quality.dispose_analysis_kind = NonExceptionPathsOnlyNotDisposed # CA2000 has a lot of false positives without this + +# NUnit +dotnet_diagnostic.NUnit2001.severity = warning # Consider using Assert.That(expr, Is.False) instead of Assert.False(expr) +dotnet_diagnostic.NUnit2002.severity = warning # Consider using Assert.That(expr, Is.False) instead of Assert.IsFalse(expr) +dotnet_diagnostic.NUnit2003.severity = warning # Consider using Assert.That(expr, Is.True) instead of Assert.IsTrue(expr) +dotnet_diagnostic.NUnit2004.severity = warning # Consider using Assert.That(expr, Is.True) instead of Assert.True(expr) +dotnet_diagnostic.NUnit2005.severity = warning # Consider using Assert.That(actual, Is.EqualTo(expected)) instead of Assert.AreEqual(expected, actual) +dotnet_diagnostic.NUnit2006.severity = warning # Consider using Assert.That(actual, Is.Not.EqualTo(expected)) instead of Assert.AreNotEqual(expected, actual) + +dotnet_diagnostic.NUnit2010.severity = warning # Use EqualConstraint for better assertion messages in case of failure +dotnet_diagnostic.NUnit2011.severity = warning # Use ContainsConstraint for better assertion messages in case of failure +dotnet_diagnostic.NUnit2011.severity = warning # Use StartsWithConstraint for better assertion messages in case of failure +dotnet_diagnostic.NUnit2011.severity = warning # Use EndsWithConstraint for better assertion messages in case of failure +dotnet_diagnostic.NUnit2014.severity = warning # Use SomeItemsConstraint for better assertion messages in case of failure + +dotnet_diagnostic.NUnit2015.severity = warning # Consider using Assert.That(actual, Is.SameAs(expected)) instead of Assert.AreSame(expected, actual) +dotnet_diagnostic.NUnit2016.severity = warning # Consider using Assert.That(expr, Is.Null) instead of Assert.Null(expr) +dotnet_diagnostic.NUnit2017.severity = warning # Consider using Assert.That(expr, Is.Null) instead of Assert.IsNull(expr) +dotnet_diagnostic.NUnit2018.severity = warning # Consider using Assert.That(expr, Is.Not.Null) instead of Assert.NotNull(expr) +dotnet_diagnostic.NUnit2028.severity = warning # Consider using Assert.That(actual, Is.GreaterThanOrEqualTo(expected)) instead of Assert.GreaterOrEqual(actual, expected) +dotnet_diagnostic.NUnit2027.severity = warning # Consider using Assert.That(actual, Is.GreaterThan(expected)) instead of Assert.Greater(actual, expected) +dotnet_diagnostic.NUnit2029.severity = warning # Consider using Assert.That(actual, Is.LessThan(expected)) instead of Assert.Less(actual, expected) +dotnet_diagnostic.NUnit2030.severity = warning # Consider using Assert.That(actual, Is.LessThanOrEqualTo(expected)) instead of Assert.LessOrEqual(actual, expected) +dotnet_diagnostic.NUnit2031.severity = warning # Consider using Assert.That(actual, Is.Not.SameAs(expected)) instead of Assert.AreNotSame(expected, actual) +dotnet_diagnostic.NUnit2032.severity = warning # Consider using Assert.That(expr, Is.Zero) instead of Assert.Zero(expr) +dotnet_diagnostic.NUnit2033.severity = warning # Consider using Assert.That(expr, Is.Not.Zero) instead of Assert.NotZero(expr) +dotnet_diagnostic.NUnit2034.severity = warning # Consider using Assert.That(expr, Is.NaN) instead of Assert.IsNaN(expr) +dotnet_diagnostic.NUnit2035.severity = warning # Consider using Assert.That(collection, Is.Empty) instead of Assert.IsEmpty(collection) +dotnet_diagnostic.NUnit2036.severity = warning # Consider using Assert.That(collection, Is.Not.Empty) instead of Assert.IsNotEmpty(collection) +dotnet_diagnostic.NUnit2037.severity = warning # Consider using Assert.That(collection, Does.Contain(instance)) instead of Assert.Contains(instance, collection) +dotnet_diagnostic.NUnit2038.severity = warning # Consider using Assert.That(actual, Is.InstanceOf(expected)) instead of Assert.IsInstanceOf(expected, actual) +dotnet_diagnostic.NUnit2039.severity = warning # Consider using Assert.That(actual, Is.Not.InstanceOf(expected)) instead of Assert.IsNotInstanceOf(expected, actual) + +[*.{appxmanifest,asax,ascx,aspx,axaml,build,c,c++,cc,cginc,compute,cp,cpp,cs,cshtml,cu,cuh,cxx,dtd,fs,fsi,fsscript,fsx,fx,fxh,h,hh,hlsl,hlsli,hlslinc,hpp,hxx,inc,inl,ino,ipp,ixx,master,ml,mli,mpp,mq4,mq5,mqh,nuspec,paml,razor,resw,resx,shader,skin,tpp,usf,ush,vb,xaml,xamlx,xoml,xsd}] +indent_style = space +indent_size = 2 +tab_width = 2 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..0a96b77 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,5 @@ +# Set the default behavior, in case people don't have core.autocrlf set. +* text=auto + +# need original files to be windows +*.txt text eol=crlf \ No newline at end of file diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d6a5a1d --- /dev/null +++ b/.gitignore @@ -0,0 +1,21 @@ +**/bin/* +**/obj/* +_ReSharper.SharpCompress/ +bin/ +*.suo +*.user +TestArchives/Scratch/ +TestArchives/Scratch2/ +TestResults/ +*.nupkg +packages/*/ +project.lock.json +tests/TestArchives/Scratch +.vs +tools +.vscode +.idea/ + +.DS_Store +*.snupkg +/tests/TestArchives/6d23a38c-f064-4ef1-ad89-b942396f53b9/Scratch diff --git a/Directory.Build.props b/Directory.Build.props new file mode 100644 index 0000000..bf47a79 --- /dev/null +++ b/Directory.Build.props @@ -0,0 +1,17 @@ + + + latest + enable + enable + Recommended + true + true + true + true + true + False + False + true + true + + diff --git a/Directory.Packages.props b/Directory.Packages.props new file mode 100644 index 0000000..25fa482 --- /dev/null +++ b/Directory.Packages.props @@ -0,0 +1,7 @@ + + + + + + + diff --git a/Speckle.Api.sln b/Speckle.Api.sln new file mode 100644 index 0000000..a28be14 --- /dev/null +++ b/Speckle.Api.sln @@ -0,0 +1,45 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Speckle.Revit2023.Api", "Speckle.Revit2023.Api\Speckle.Revit2023.Api.csproj", "{199733E0-5C61-4C9C-A115-0CADD5058F20}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Revit", "Revit", "{8F540B7F-7548-46E9-BDEC-4DAB99367908}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Speckle.Revit2023.Interfaces", "Speckle.Revit2023.Interfaces\Speckle.Revit2023.Interfaces.csproj", "{86D5D9A2-7885-4871-AD5B-081B62E87908}" +EndProject +Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "Speckle.Revit.Interfaces", "Speckle.Revit.Interfaces\Speckle.Revit.Interfaces.shproj", "{E1C43415-3200-45F4-8BF9-A4DD7D7F2ED6}" +EndProject +Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "Speckle.Revit.Api", "Speckle.Revit.Api\Speckle.Revit.Api.shproj", "{E1C43415-3200-45F4-8BF9-A4DD7D7F2ED7}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Config", "Config", "{7A91F6BF-EA8A-428E-BB97-B6C448C247EF}" + ProjectSection(SolutionItems) = preProject + .editorconfig = .editorconfig + Directory.Build.props = Directory.Build.props + Directory.Packages.props = Directory.Packages.props + global.json = global.json + EndProjectSection +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Versions", "Versions", "{80F2939A-20C8-4128-82EA-F14274D9E57D}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {199733E0-5C61-4C9C-A115-0CADD5058F20}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {199733E0-5C61-4C9C-A115-0CADD5058F20}.Debug|Any CPU.Build.0 = Debug|Any CPU + {199733E0-5C61-4C9C-A115-0CADD5058F20}.Release|Any CPU.ActiveCfg = Release|Any CPU + {199733E0-5C61-4C9C-A115-0CADD5058F20}.Release|Any CPU.Build.0 = Release|Any CPU + {86D5D9A2-7885-4871-AD5B-081B62E87908}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {86D5D9A2-7885-4871-AD5B-081B62E87908}.Debug|Any CPU.Build.0 = Debug|Any CPU + {86D5D9A2-7885-4871-AD5B-081B62E87908}.Release|Any CPU.ActiveCfg = Release|Any CPU + {86D5D9A2-7885-4871-AD5B-081B62E87908}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(NestedProjects) = preSolution + {E1C43415-3200-45F4-8BF9-A4DD7D7F2ED6} = {8F540B7F-7548-46E9-BDEC-4DAB99367908} + {E1C43415-3200-45F4-8BF9-A4DD7D7F2ED7} = {8F540B7F-7548-46E9-BDEC-4DAB99367908} + {80F2939A-20C8-4128-82EA-F14274D9E57D} = {8F540B7F-7548-46E9-BDEC-4DAB99367908} + {199733E0-5C61-4C9C-A115-0CADD5058F20} = {80F2939A-20C8-4128-82EA-F14274D9E57D} + {86D5D9A2-7885-4871-AD5B-081B62E87908} = {80F2939A-20C8-4128-82EA-F14274D9E57D} + EndGlobalSection +EndGlobal diff --git a/Speckle.Revit.Api/DocumentExtensions.cs b/Speckle.Revit.Api/DocumentExtensions.cs new file mode 100644 index 0000000..77bc984 --- /dev/null +++ b/Speckle.Revit.Api/DocumentExtensions.cs @@ -0,0 +1,10 @@ +using Speckle.Revit2023.Interfaces; +using DB = Autodesk.Revit.DB; + +namespace Speckle.Revit2023.Api; + +public static class DocumentExtensions +{ + public static DB.Element GetElement(this IRevitDocument document, DB.ElementId id) => + ((IRevitDocumentProxy)document)._Instance.GetElement(id); +} diff --git a/Speckle.Revit.Api/IRevitDocumentProxy.cs b/Speckle.Revit.Api/IRevitDocumentProxy.cs new file mode 100644 index 0000000..8918c41 --- /dev/null +++ b/Speckle.Revit.Api/IRevitDocumentProxy.cs @@ -0,0 +1,53 @@ +using System.Diagnostics.CodeAnalysis; +using Autodesk.Revit.DB; +using Speckle.ProxyGenerator; +using Speckle.Revit2023.Interfaces; +#pragma warning disable CA1010 +#pragma warning disable CA1710 + +namespace Speckle.Revit2023.Api; + +[Proxy( + typeof(Document), + ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface, + new[] { "PlanTopology", "PlanTopologies", "TypeOfStorage", "Equals" } +)] +[SuppressMessage("Maintainability", "CA1506:Avoid excessive class coupling")] +public partial interface IRevitDocumentProxy : IRevitDocument { } + +[Proxy( + typeof(ForgeTypeId), + ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface, + new[] { "Equals" } +)] +public partial interface IRevitForgeTypeIdProxy : IRevitForgeTypeId { } + +[Proxy( + typeof(Element), + ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface, + new[] { "Parameter", "BoundingBox", "Geometry" } +)] +public partial interface IRevitElementProxy : IRevitElement { } + +[Proxy( + typeof(Category), + ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface, + new[] { "AllowsVisibilityControl", "Visible" } +)] +public partial interface IRevitCategoryProxy : IRevitCategory { } + +[Proxy( + typeof(ElementId), + ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface, + new[] { "Equals" } +)] +public partial interface IRevitElementIdProxy : IRevitElementId { } + +[Proxy(typeof(CurtainGrid), ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface)] +public partial interface IRevitCurtainGridProxy : IRevitCurtainGrid { } + +[Proxy(typeof(Wall), ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface)] +public partial interface IRevitWallProxy : IRevitWall { } + +[Proxy(typeof(HostObject), ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface)] +public partial interface IRevitHostObjectProxy : IRevitHostObject { } diff --git a/Speckle.Revit.Api/IRevitModelCurveArrArrayProxy.cs b/Speckle.Revit.Api/IRevitModelCurveArrArrayProxy.cs new file mode 100644 index 0000000..319f1fe --- /dev/null +++ b/Speckle.Revit.Api/IRevitModelCurveArrArrayProxy.cs @@ -0,0 +1,52 @@ +using System.Collections; +using Autodesk.Revit.DB; +using Speckle.ProxyGenerator; +using Speckle.Revit2023.Interfaces; + +namespace Speckle.Revit2023.Api; + +[Proxy( + typeof(ModelCurveArrArray), + ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface, + new[] { "GetEnumerator", "Item", "get_Item", "set_Item" } +)] +public partial interface IRevitModelCurveArrArrayProxy : IRevitModelCurveArrArray { } + +public partial class ModelCurveArrArrayProxy +{ + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + + public int Count => Size; + + public IEnumerator GetEnumerator() => + new RevitModelCurveArrayIterator(_Instance.ForwardIterator()); + + private readonly struct RevitModelCurveArrayIterator : IEnumerator + { + private readonly ModelCurveArrArrayIterator _curveArrayIterator; + + public RevitModelCurveArrayIterator(ModelCurveArrArrayIterator curveArrayIterator) + { + _curveArrayIterator = curveArrayIterator; + } + + public void Dispose() => _curveArrayIterator.Dispose(); + + public bool MoveNext() => _curveArrayIterator.MoveNext(); + + public void Reset() => _curveArrayIterator.Reset(); + + object IEnumerator.Current => Current; + + public IRevitModelCurveArray Current => new ModelCurveArrayProxy((ModelCurveArray)_curveArrayIterator.Current); + } + + public IRevitModelCurveArray this[int index] + { + get + { + var obj = _Instance.get_Item(index); + return Mapster.TypeAdapter.Adapt(obj); + } + } +} diff --git a/Speckle.Revit.Api/IRevitModelCurveArrayProxy.cs b/Speckle.Revit.Api/IRevitModelCurveArrayProxy.cs new file mode 100644 index 0000000..019ae22 --- /dev/null +++ b/Speckle.Revit.Api/IRevitModelCurveArrayProxy.cs @@ -0,0 +1,52 @@ +using System.Collections; +using Autodesk.Revit.DB; +using Speckle.ProxyGenerator; +using Speckle.Revit2023.Interfaces; + +namespace Speckle.Revit2023.Api; + +[Proxy( + typeof(ModelCurveArray), + ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface, + new[] { "GetEnumerator", "Item", "get_Item", "set_Item" } +)] +public partial interface IRevitModelCurveArrayProxy : IRevitModelCurveArray { } + +public partial class ModelCurveArrayProxy +{ + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + + public int Count => Size; + + public IEnumerator GetEnumerator() => + new RevitModelCurveCollectionIterator(_Instance.ForwardIterator()); + + private readonly struct RevitModelCurveCollectionIterator : IEnumerator + { + private readonly ModelCurveArrayIterator _curveArrayIterator; + + public RevitModelCurveCollectionIterator(ModelCurveArrayIterator curveArrayIterator) + { + _curveArrayIterator = curveArrayIterator; + } + + public void Dispose() => _curveArrayIterator.Dispose(); + + public bool MoveNext() => _curveArrayIterator.MoveNext(); + + public void Reset() => _curveArrayIterator.Reset(); + + object IEnumerator.Current => Current; + + public IRevitModelCurve Current => new ModelCurveProxy((ModelCurve)_curveArrayIterator.Current); + } + + public IRevitModelCurve this[int index] + { + get + { + var obj = _Instance.get_Item(index); + return Mapster.TypeAdapter.Adapt(obj); + } + } +} diff --git a/Speckle.Revit.Api/IRevitModelCurveProxy.cs b/Speckle.Revit.Api/IRevitModelCurveProxy.cs new file mode 100644 index 0000000..7ce6884 --- /dev/null +++ b/Speckle.Revit.Api/IRevitModelCurveProxy.cs @@ -0,0 +1,33 @@ +using Autodesk.Revit.DB; +using Speckle.ProxyGenerator; +using Speckle.Revit2023.Interfaces; + +namespace Speckle.Revit2023.Api; + +[Proxy(typeof(ModelCurve), ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface)] +public partial interface IRevitModelCurveProxy : IRevitModelCurve { } + +[Proxy(typeof(CurveElement), ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface)] +public partial interface IRevitCurveElementProxy : IRevitCurveElement { } + +[Proxy(typeof(Curve), ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface)] +public partial interface IRevitCurveProxy : IRevitCurve { } + +[Proxy(typeof(XYZ), ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface)] +public partial interface IRevitXYZProxy : IRevitXYZ { } + +[Proxy( + typeof(LocationCurve), + ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface, + new[] { "JoinType", "ElementsAtJoin" } +)] +public partial interface IRevitLocationCurveProxy : IRevitLocationCurve { } + +[Proxy(typeof(Location), ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface)] +public partial interface IRevitLocationProxy : IRevitLocation { } + +[Proxy( + typeof(LocationPoint), + ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface +)] +public partial interface IRevitLocationPointProxy : IRevitLocationPoint { } diff --git a/Speckle.Revit.Api/IRevitUnitsProxy.cs b/Speckle.Revit.Api/IRevitUnitsProxy.cs new file mode 100644 index 0000000..4b66c5f --- /dev/null +++ b/Speckle.Revit.Api/IRevitUnitsProxy.cs @@ -0,0 +1,14 @@ +using Autodesk.Revit.DB; +using Speckle.ProxyGenerator; +using Speckle.Revit2023.Interfaces; + +namespace Speckle.Revit2023.Api; + +[Proxy(typeof(Units), ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface)] +public partial interface IRevitUnitsProxy : IRevitUnits { } + +[Proxy( + typeof(FormatOptions), + ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface +)] +public partial interface IRevitFormatOptionsProxy : IRevitFormatOptions { } diff --git a/Speckle.Revit.Api/RevitFilterFactory.cs b/Speckle.Revit.Api/RevitFilterFactory.cs new file mode 100644 index 0000000..fc6ce9d --- /dev/null +++ b/Speckle.Revit.Api/RevitFilterFactory.cs @@ -0,0 +1,70 @@ +using Autodesk.Revit.DB; +using Speckle.ProxyGenerator; +using Speckle.Revit2023.Interfaces; + +namespace Speckle.Revit2023.Api; + +public class RevitFilterFactory : IRevitFilterFactory +{ + public IRevitElementIsElementTypeFilter CreateElementIsElementTypeFilter(bool inverted) => + new ElementIsElementTypeFilterProxy(new ElementIsElementTypeFilter()); + + public IRevitLogicalAndFilterFilter CreateLogicalAndFilter(params IRevitElementFilter[] filters) => + new LogicalAndFilterProxy( + new LogicalAndFilter(filters.Cast().Select(x => x._Instance).ToList()) + ); + + public IRevitElementMulticategoryFilter CreateElementMulticategoryFilter( + ICollection categories, + bool inverted + ) => + new ElementMulticategoryFilterProxy( + new ElementMulticategoryFilter(categories.Select(x => (BuiltInCategory)x).ToArray(), inverted) + ); + + public IRevitFilteredElementCollector CreateFilteredElementCollector( + IRevitDocument document, + params IRevitElementId[] elementIds + ) => + new FilteredElementCollectorProxy( + new FilteredElementCollector( + ((IRevitDocumentProxy)document)._Instance, + elementIds.Cast().Select(x => x._Instance).ToList() + ) + ); +} + +[Proxy( + typeof(ElementFilter), + ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface +)] +public partial interface IRevitElementFilterProxy : IRevitElementFilter { } + +[Proxy( + typeof(ElementIsElementTypeFilter), + ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface +)] +public partial interface IRevitElementIsElementTypeFilterProxy : IRevitElementIsElementTypeFilter { } + +[Proxy( + typeof(ElementMulticategoryFilter), + ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface +)] +public partial interface IRevitElementMulticategoryFilterProxy : IRevitElementMulticategoryFilter { } + +[Proxy( + typeof(LogicalAndFilter), + ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface +)] +public partial interface IRevitLogicalAndFilterProxy : IRevitLogicalAndFilterFilter { } + +[Proxy( + typeof(FilteredElementCollector), + ImplementationOptions.UseExtendedInterfaces | ImplementationOptions.ProxyForBaseInterface +)] +public partial interface IRevitFilteredElementCollectorProxy : IRevitFilteredElementCollector { } + +public partial class FilteredElementCollectorProxy +{ + public IEnumerable OfClass() => _Instance.OfClass(typeof(T)).Cast(); +} diff --git a/Speckle.Revit.Api/RevitUnitUtils.cs b/Speckle.Revit.Api/RevitUnitUtils.cs new file mode 100644 index 0000000..dd0bc44 --- /dev/null +++ b/Speckle.Revit.Api/RevitUnitUtils.cs @@ -0,0 +1,15 @@ +using Autodesk.Revit.DB; +using Speckle.Revit2023.Interfaces; + +namespace Speckle.Revit2023.Api; + +public class RevitUnitUtils : IRevitUnitUtils +{ + public double ConvertFromInternalUnits(double value, IRevitForgeTypeId forgeTypeId) => + UnitUtils.ConvertFromInternalUnits(value, ((IRevitForgeTypeIdProxy)forgeTypeId)._Instance); +} + +public static class RevitSpecTypeId +{ + public static IRevitForgeTypeId Length => new ForgeTypeIdProxy(SpecTypeId.Length); +} diff --git a/Speckle.Revit.Api/Speckle.Revit.Api.projitems b/Speckle.Revit.Api/Speckle.Revit.Api.projitems new file mode 100644 index 0000000..28989c0 --- /dev/null +++ b/Speckle.Revit.Api/Speckle.Revit.Api.projitems @@ -0,0 +1,14 @@ + + + + $(MSBuildAllProjects);$(MSBuildThisFileFullPath) + true + 9655be78-8070-4b9f-b0dc-68bb6150b52d + + + Speckle.Revit.Api + + + + + \ No newline at end of file diff --git a/Speckle.Revit.Api/Speckle.Revit.Api.shproj b/Speckle.Revit.Api/Speckle.Revit.Api.shproj new file mode 100644 index 0000000..a2268e0 --- /dev/null +++ b/Speckle.Revit.Api/Speckle.Revit.Api.shproj @@ -0,0 +1,13 @@ + + + + {E1C43415-3200-45F4-8BF9-A4DD7D7F2ED7} + 14.0 + + + + + + + + \ No newline at end of file diff --git a/Speckle.Revit.Interfaces/Extensions.cs b/Speckle.Revit.Interfaces/Extensions.cs new file mode 100644 index 0000000..4ff60b4 --- /dev/null +++ b/Speckle.Revit.Interfaces/Extensions.cs @@ -0,0 +1,35 @@ +namespace Speckle.Revit2023.Interfaces; + +public static class Extensions +{ + public static IList GetHostedElementIds( + this IRevitElement host, + IRevitFilterFactory revitFilterFactory + ) + { + IList ids; + if (host is IRevitHostObject hostObject) + { + ids = hostObject.FindInserts(true, false, false, false); + } + else + { + var typeFilter = revitFilterFactory.CreateElementIsElementTypeFilter(true); + var categoryFilter = revitFilterFactory.CreateElementMulticategoryFilter( + new List() + { + RevitBuiltInCategory.OST_CLines, + RevitBuiltInCategory.OST_SketchLines, + RevitBuiltInCategory.OST_WeakDims + }, + true + ); + ids = host.GetDependentElements(revitFilterFactory.CreateLogicalAndFilter(typeFilter, categoryFilter)); + } + + // dont include host elementId + ids.Remove(host.Id); + + return ids; + } +} diff --git a/Speckle.Revit2023.Interfaces/IRevitCategory.cs b/Speckle.Revit.Interfaces/IRevitCategory.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitCategory.cs rename to Speckle.Revit.Interfaces/IRevitCategory.cs diff --git a/Speckle.Revit2023.Interfaces/IRevitCurtainGrid.cs b/Speckle.Revit.Interfaces/IRevitCurtainGrid.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitCurtainGrid.cs rename to Speckle.Revit.Interfaces/IRevitCurtainGrid.cs diff --git a/Speckle.Revit2023.Interfaces/IRevitCurve.cs b/Speckle.Revit.Interfaces/IRevitCurve.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitCurve.cs rename to Speckle.Revit.Interfaces/IRevitCurve.cs diff --git a/Speckle.Revit2023.Interfaces/IRevitCurveElement.cs b/Speckle.Revit.Interfaces/IRevitCurveElement.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitCurveElement.cs rename to Speckle.Revit.Interfaces/IRevitCurveElement.cs diff --git a/Speckle.Revit.Interfaces/IRevitDocument.cs b/Speckle.Revit.Interfaces/IRevitDocument.cs new file mode 100644 index 0000000..c7d6d39 --- /dev/null +++ b/Speckle.Revit.Interfaces/IRevitDocument.cs @@ -0,0 +1,12 @@ +#pragma warning disable CA1040 + +namespace Speckle.Revit2023.Interfaces; + +public interface IRevitDocument +{ + string PathName { get; } + bool IsFamilyDocument { get; } + IRevitUnits GetUnits(); + + IRevitElement GetElement(IRevitElementId elementId); +} diff --git a/Speckle.Revit2023.Interfaces/IRevitElement.cs b/Speckle.Revit.Interfaces/IRevitElement.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitElement.cs rename to Speckle.Revit.Interfaces/IRevitElement.cs diff --git a/Speckle.Revit2023.Interfaces/IRevitElementFilter.cs b/Speckle.Revit.Interfaces/IRevitElementFilter.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitElementFilter.cs rename to Speckle.Revit.Interfaces/IRevitElementFilter.cs diff --git a/Speckle.Revit2023.Interfaces/IRevitElementId.cs b/Speckle.Revit.Interfaces/IRevitElementId.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitElementId.cs rename to Speckle.Revit.Interfaces/IRevitElementId.cs diff --git a/Speckle.Revit2023.Interfaces/IRevitElementIsElementTypeFilter.cs b/Speckle.Revit.Interfaces/IRevitElementIsElementTypeFilter.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitElementIsElementTypeFilter.cs rename to Speckle.Revit.Interfaces/IRevitElementIsElementTypeFilter.cs diff --git a/Speckle.Revit2023.Interfaces/IRevitElementMulticategoryFilter.cs b/Speckle.Revit.Interfaces/IRevitElementMulticategoryFilter.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitElementMulticategoryFilter.cs rename to Speckle.Revit.Interfaces/IRevitElementMulticategoryFilter.cs diff --git a/Speckle.Revit.Interfaces/IRevitFilterFactory.cs b/Speckle.Revit.Interfaces/IRevitFilterFactory.cs new file mode 100644 index 0000000..50dba01 --- /dev/null +++ b/Speckle.Revit.Interfaces/IRevitFilterFactory.cs @@ -0,0 +1,16 @@ +namespace Speckle.Revit2023.Interfaces; + +#pragma warning disable CA1040 +public interface IRevitFilterFactory +{ + IRevitElementIsElementTypeFilter CreateElementIsElementTypeFilter(bool inverted); + IRevitElementMulticategoryFilter CreateElementMulticategoryFilter( + ICollection categories, + bool inverted + ); + IRevitLogicalAndFilterFilter CreateLogicalAndFilter(params IRevitElementFilter[] filters); + IRevitFilteredElementCollector CreateFilteredElementCollector( + IRevitDocument document, + params IRevitElementId[] elementIds + ); +} diff --git a/Speckle.Revit2023.Interfaces/IRevitFilteredElementCollector.cs b/Speckle.Revit.Interfaces/IRevitFilteredElementCollector.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitFilteredElementCollector.cs rename to Speckle.Revit.Interfaces/IRevitFilteredElementCollector.cs diff --git a/Speckle.Revit2023.Interfaces/IRevitForgeTypeId.cs b/Speckle.Revit.Interfaces/IRevitForgeTypeId.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitForgeTypeId.cs rename to Speckle.Revit.Interfaces/IRevitForgeTypeId.cs diff --git a/Speckle.Revit2023.Interfaces/IRevitFormatOptions.cs b/Speckle.Revit.Interfaces/IRevitFormatOptions.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitFormatOptions.cs rename to Speckle.Revit.Interfaces/IRevitFormatOptions.cs diff --git a/Speckle.Revit2023.Interfaces/IRevitHostObject.cs b/Speckle.Revit.Interfaces/IRevitHostObject.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitHostObject.cs rename to Speckle.Revit.Interfaces/IRevitHostObject.cs diff --git a/Speckle.Revit2023.Interfaces/IRevitLocation.cs b/Speckle.Revit.Interfaces/IRevitLocation.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitLocation.cs rename to Speckle.Revit.Interfaces/IRevitLocation.cs diff --git a/Speckle.Revit2023.Interfaces/IRevitLocationCurve.cs b/Speckle.Revit.Interfaces/IRevitLocationCurve.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitLocationCurve.cs rename to Speckle.Revit.Interfaces/IRevitLocationCurve.cs diff --git a/Speckle.Revit2023.Interfaces/IRevitLocationPoint.cs b/Speckle.Revit.Interfaces/IRevitLocationPoint.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitLocationPoint.cs rename to Speckle.Revit.Interfaces/IRevitLocationPoint.cs diff --git a/Speckle.Revit2023.Interfaces/IRevitLogicalAndFilterFilter.cs b/Speckle.Revit.Interfaces/IRevitLogicalAndFilterFilter.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitLogicalAndFilterFilter.cs rename to Speckle.Revit.Interfaces/IRevitLogicalAndFilterFilter.cs diff --git a/Speckle.Revit.Interfaces/IRevitModelCurve.cs b/Speckle.Revit.Interfaces/IRevitModelCurve.cs new file mode 100644 index 0000000..b945ae5 --- /dev/null +++ b/Speckle.Revit.Interfaces/IRevitModelCurve.cs @@ -0,0 +1,3 @@ +namespace Speckle.Revit2023.Interfaces; + +public interface IRevitModelCurve : IRevitCurveElement { } \ No newline at end of file diff --git a/Speckle.Revit2023.Interfaces/IRevitModelCurveArrArray.cs b/Speckle.Revit.Interfaces/IRevitModelCurveArrArray.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitModelCurveArrArray.cs rename to Speckle.Revit.Interfaces/IRevitModelCurveArrArray.cs diff --git a/Speckle.Revit.Interfaces/IRevitModelCurveArray.cs b/Speckle.Revit.Interfaces/IRevitModelCurveArray.cs new file mode 100644 index 0000000..1c8797a --- /dev/null +++ b/Speckle.Revit.Interfaces/IRevitModelCurveArray.cs @@ -0,0 +1,6 @@ +using System.Diagnostics.CodeAnalysis; + +namespace Speckle.Revit2023.Interfaces; + +[SuppressMessage("Naming", "CA1711:Identifiers should not have incorrect suffix")] +public interface IRevitModelCurveArray : IReadOnlyList { } \ No newline at end of file diff --git a/Speckle.Revit2023.Interfaces/IRevitUnitUtils.cs b/Speckle.Revit.Interfaces/IRevitUnitUtils.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitUnitUtils.cs rename to Speckle.Revit.Interfaces/IRevitUnitUtils.cs diff --git a/Speckle.Revit.Interfaces/IRevitUnits.cs b/Speckle.Revit.Interfaces/IRevitUnits.cs new file mode 100644 index 0000000..e3d90b6 --- /dev/null +++ b/Speckle.Revit.Interfaces/IRevitUnits.cs @@ -0,0 +1,11 @@ +#pragma warning disable CA1040 + +namespace Speckle.Revit2023.Interfaces; + +public interface IRevitUnits +{ + IRevitFormatOptions GetFormatOptions(IRevitForgeTypeId length); +} + + +#pragma warning restore CA1040 diff --git a/Speckle.Revit2023.Interfaces/IRevitWall.cs b/Speckle.Revit.Interfaces/IRevitWall.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitWall.cs rename to Speckle.Revit.Interfaces/IRevitWall.cs diff --git a/Speckle.Revit2023.Interfaces/IRevitXYZ.cs b/Speckle.Revit.Interfaces/IRevitXYZ.cs similarity index 100% rename from Speckle.Revit2023.Interfaces/IRevitXYZ.cs rename to Speckle.Revit.Interfaces/IRevitXYZ.cs diff --git a/Speckle.Revit.Interfaces/RevitBuiltInCategory.cs b/Speckle.Revit.Interfaces/RevitBuiltInCategory.cs new file mode 100644 index 0000000..013541a --- /dev/null +++ b/Speckle.Revit.Interfaces/RevitBuiltInCategory.cs @@ -0,0 +1,1197 @@ +using System.Diagnostics.CodeAnalysis; + +namespace Speckle.Revit2023.Interfaces; + +[SuppressMessage("Design", "CA1008:Enums should have zero value")] +public enum RevitBuiltInCategory +{ + OST_StackedWalls_Obsolete_IdInWrongRange = -20034100, // 0xFECE4DCC + OST_MassTags_Obsolete_IdInWrongRange = -20034005, // 0xFECE4E2B + OST_MassSurface_Obsolete_IdInWrongRange = -20034004, // 0xFECE4E2C + OST_MassFloor_Obsolete_IdInWrongRange = -20034003, // 0xFECE4E2D + OST_Mass_Obsolete_IdInWrongRange = -20034000, // 0xFECE4E30 + OST_WallRefPlanes_Obsolete_IdInWrongRange = -20000896, // 0xFECECF80 + OST_StickSymbols_Obsolete_IdInWrongRange = -20000828, // 0xFECECFC4 + OST_RemovedGridSeg_Obsolete_IdInWrongRange = -20000827, // 0xFECECFC5 + OST_PointClouds = -2010001, // 0xFFE1546F + OST_AnalyticalPanelLocalCoordSys = -2009667, // 0xFFE155BD + OST_AnalyticalMemberLocalCoordSys = -2009666, // 0xFFE155BE + OST_AnalyticalOpening = -2009665, // 0xFFE155BF + OST_AnalyticalPanel = -2009664, // 0xFFE155C0 + OST_AnalyticalMemberTags = -2009663, // 0xFFE155C1 + OST_AnalyticalMember = -2009662, // 0xFFE155C2 + OST_AssemblyOrigin_Lines = -2009661, // 0xFFE155C3 + OST_AssemblyOrigin_Planes = -2009660, // 0xFFE155C4 + OST_AssemblyOrigin_Points = -2009659, // 0xFFE155C5 + OST_AssemblyOrigin = -2009658, // 0xFFE155C6 + OST_LinksAnalytical = -2009657, // 0xFFE155C7 + OST_FoundationSlabAnalyticalTags = -2009656, // 0xFFE155C8 + OST_WallFoundationAnalyticalTags = -2009655, // 0xFFE155C9 + OST_IsolatedFoundationAnalyticalTags = -2009654, // 0xFFE155CA + OST_WallAnalyticalTags = -2009653, // 0xFFE155CB + OST_FloorAnalyticalTags = -2009652, // 0xFFE155CC + OST_ColumnAnalyticalTags = -2009651, // 0xFFE155CD + OST_BraceAnalyticalTags = -2009650, // 0xFFE155CE + OST_BeamAnalyticalTags = -2009649, // 0xFFE155CF + OST_AnalyticalNodes_Lines = -2009648, // 0xFFE155D0 + OST_AnalyticalNodes_Planes = -2009647, // 0xFFE155D1 + OST_AnalyticalNodes_Points = -2009646, // 0xFFE155D2 + OST_AnalyticalNodes = -2009645, // 0xFFE155D3 + OST_RigidLinksAnalytical = -2009644, // 0xFFE155D4 + OST_FoundationSlabAnalytical = -2009643, // 0xFFE155D5 + OST_WallFoundationAnalytical = -2009642, // 0xFFE155D6 + OST_IsolatedFoundationAnalytical = -2009641, // 0xFFE155D7 + OST_WallAnalytical = -2009640, // 0xFFE155D8 + OST_FloorAnalytical = -2009639, // 0xFFE155D9 + OST_ColumnEndSegment = -2009638, // 0xFFE155DA + OST_ColumnStartSegment = -2009637, // 0xFFE155DB + OST_ColumnAnalytical = -2009636, // 0xFFE155DC + OST_BraceEndSegment = -2009635, // 0xFFE155DD + OST_BraceStartSegment = -2009634, // 0xFFE155DE + OST_BraceAnalytical = -2009633, // 0xFFE155DF + OST_BeamEndSegment = -2009632, // 0xFFE155E0 + OST_BeamStartSegment = -2009631, // 0xFFE155E1 + OST_BeamAnalytical = -2009630, // 0xFFE155E2 + OST_CompassSecondaryMonth = -2009624, // 0xFFE155E8 + OST_CompassPrimaryMonth = -2009623, // 0xFFE155E9 + OST_CompassSectionFilled = -2009622, // 0xFFE155EA + OST_LightLine = -2009621, // 0xFFE155EB + OST_MultiSurface = -2009620, // 0xFFE155EC + OST_SunSurface = -2009619, // 0xFFE155ED + OST_Analemma = -2009618, // 0xFFE155EE + OST_SunsetText = -2009617, // 0xFFE155EF + OST_CompassSection = -2009616, // 0xFFE155F0 + OST_CompassOuter = -2009615, // 0xFFE155F1 + OST_SunriseText = -2009614, // 0xFFE155F2 + OST_CompassInner = -2009613, // 0xFFE155F3 + OST_SunPath2 = -2009612, // 0xFFE155F4 + OST_SunPath1 = -2009611, // 0xFFE155F5 + OST_Sun = -2009610, // 0xFFE155F6 + OST_SunStudy = -2009609, // 0xFFE155F7 + OST_StructuralTrussStickSymbols = -2009608, // 0xFFE155F8 + OST_StructuralTrussHiddenLines = -2009607, // 0xFFE155F9 + OST_TrussChord = -2009606, // 0xFFE155FA + OST_TrussWeb = -2009605, // 0xFFE155FB + OST_TrussBottomChordCurve = -2009604, // 0xFFE155FC + OST_TrussTopChordCurve = -2009603, // 0xFFE155FD + OST_TrussVertWebCurve = -2009602, // 0xFFE155FE + OST_TrussDiagWebCurve = -2009601, // 0xFFE155FF + OST_Truss = -2009600, // 0xFFE15600 + OST_PlumbingEquipmentHiddenLines = -2009551, // 0xFFE15631 + OST_MechanicalControlDevicesHiddenLines = -2009550, // 0xFFE15632 + OST_RailingSystemTransitionHiddenLines_Deprecated = -2009549, // 0xFFE15633 + OST_RailingSystemTerminationHiddenLines_Deprecated = -2009548, // 0xFFE15634 + OST_RailingSystemRailHiddenLines_Deprecated = -2009547, // 0xFFE15635 + OST_RailingSystemTopRailHiddenLines_Deprecated = -2009546, // 0xFFE15636 + OST_RailingSystemHandRailBracketHiddenLines_Deprecated = -2009545, // 0xFFE15637 + OST_RailingSystemHandRailHiddenLines_Deprecated = -2009544, // 0xFFE15638 + OST_RailingSystemPanelBracketHiddenLines_Deprecated = -2009543, // 0xFFE15639 + OST_RailingSystemPanelHiddenLines_Deprecated = -2009542, // 0xFFE1563A + OST_RailingSystemBalusterHiddenLines_Deprecated = -2009541, // 0xFFE1563B + OST_RailingSystemPostHiddenLines_Deprecated = -2009540, // 0xFFE1563C + OST_RailingSystemSegmentHiddenLines_Deprecated = -2009539, // 0xFFE1563D + OST_RailingSystemHiddenLines_Deprecated = -2009538, // 0xFFE1563E + OST_StairStringer2012HiddenLines_Deprecated = -2009537, // 0xFFE1563F + OST_StairTread2012HiddenLines_Deprecated = -2009536, // 0xFFE15640 + OST_StairLanding2012HiddenLines_Deprecated = -2009535, // 0xFFE15641 + OST_StairRun2012HiddenLines_Deprecated = -2009534, // 0xFFE15642 + OST_Stairs2012HiddenLines_Deprecated = -2009533, // 0xFFE15643 + OST_MassHiddenLines = -2009532, // 0xFFE15644 + OST_CurtaSystemHiddenLines = -2009531, // 0xFFE15645 + OST_OBSOLETE_ElemArrayHiddenLines = -2009530, // 0xFFE15646 + OST_EntourageHiddenLines = -2009529, // 0xFFE15647 + OST_PlantingHiddenLines = -2009528, // 0xFFE15648 + OST_SpecialityEquipmentHiddenLines = -2009527, // 0xFFE15649 + OST_TopographyHiddenLines = -2009526, // 0xFFE1564A + OST_StructuralFramingSystemHiddenLines_Obsolete = -2009525, // 0xFFE1564B + OST_SiteHiddenLines = -2009524, // 0xFFE1564C + OST_RoadsHiddenLines = -2009523, // 0xFFE1564D + OST_ParkingHiddenLines = -2009522, // 0xFFE1564E + OST_PlumbingFixturesHiddenLines = -2009521, // 0xFFE1564F + OST_MechanicalEquipmentHiddenLines = -2009520, // 0xFFE15650 + OST_LightingFixturesHiddenLines = -2009519, // 0xFFE15651 + OST_FurnitureSystemsHiddenLines = -2009518, // 0xFFE15652 + OST_ElectricalFixturesHiddenLines = -2009517, // 0xFFE15653 + OST_ElectricalEquipmentHiddenLines = -2009516, // 0xFFE15654 + OST_CaseworkHiddenLines = -2009515, // 0xFFE15655 + OST_DetailComponentsHiddenLines = -2009514, // 0xFFE15656 + OST_ShaftOpeningHiddenLines = -2009513, // 0xFFE15657 + OST_GenericModelHiddenLines = -2009512, // 0xFFE15658 + OST_CurtainWallMullionsHiddenLines = -2009511, // 0xFFE15659 + OST_CurtainWallPanelsHiddenLines = -2009510, // 0xFFE1565A + OST_RampsHiddenLines = -2009509, // 0xFFE1565B + OST_StairsRailingHiddenLines = -2009508, // 0xFFE1565C + OST_StairsHiddenLines = -2009507, // 0xFFE1565D + OST_ColumnsHiddenLines = -2009506, // 0xFFE1565E + OST_FurnitureHiddenLines = -2009505, // 0xFFE1565F + OST_LinesHiddenLines = -2009504, // 0xFFE15660 + OST_CeilingsHiddenLines = -2009503, // 0xFFE15661 + OST_RoofsHiddenLines = -2009502, // 0xFFE15662 + OST_DoorsHiddenLines = -2009501, // 0xFFE15663 + OST_WindowsHiddenLines = -2009500, // 0xFFE15664 + OST_StructConnectionProfilesTags = -2009064, // 0xFFE15818 + OST_StructConnectionHoleTags = -2009063, // 0xFFE15819 + OST_CouplerHiddenLines = -2009062, // 0xFFE1581A + OST_CouplerTags = -2009061, // 0xFFE1581B + OST_Coupler = -2009060, // 0xFFE1581C + OST_StructConnectionWeldTags = -2009059, // 0xFFE1581D + OST_StructConnectionShearStudTags = -2009058, // 0xFFE1581E + OST_StructConnectionAnchorTags = -2009057, // 0xFFE1581F + OST_StructConnectionBoltTags = -2009056, // 0xFFE15820 + OST_StructConnectionPlateTags = -2009055, // 0xFFE15821 + OST_RebarHiddenLines = -2009050, // 0xFFE15826 + OST_StructSubConnections = -2009049, // 0xFFE15827 + OST_SteelElementStale = -2009048, // 0xFFE15828 + OST_StructConnectionModifiers = -2009047, // 0xFFE15829 + OST_StructConnectionWelds = -2009046, // 0xFFE1582A + OST_StructConnectionHoles = -2009045, // 0xFFE1582B + OST_StructConnectionShearStuds = -2009044, // 0xFFE1582C + OST_StructConnectionNobleWarning = -2009043, // 0xFFE1582D + OST_StructConnectionOthers = -2009042, // 0xFFE1582E + OST_StructConnectionBolts = -2009041, // 0xFFE1582F + OST_StructConnectionTags = -2009040, // 0xFFE15830 + OST_StructConnectionAnchors = -2009039, // 0xFFE15831 + OST_StructConnectionPlates = -2009038, // 0xFFE15832 + OST_StructConnectionProfiles = -2009037, // 0xFFE15833 + OST_StructConnectionReference = -2009036, // 0xFFE15834 + OST_StructConnectionFailed = -2009035, // 0xFFE15835 + OST_StructConnectionStale = -2009034, // 0xFFE15836 + OST_StructConnectionSymbol = -2009033, // 0xFFE15837 + OST_StructConnectionHiddenLines = -2009032, // 0xFFE15838 + OST_StructWeldLines = -2009031, // 0xFFE15839 + OST_StructConnections = -2009030, // 0xFFE1583A + OST_FabricAreaBoundary = -2009029, // 0xFFE1583B + OST_FabricReinSpanSymbol = -2009028, // 0xFFE1583C + OST_FabricReinforcementWire = -2009027, // 0xFFE1583D + OST_FabricReinforcementBoundary = -2009026, // 0xFFE1583E + OST_RebarSetToggle = -2009025, // 0xFFE1583F + OST_FabricAreaTags = -2009023, // 0xFFE15841 + OST_FabricReinforcementTags = -2009022, // 0xFFE15842 + OST_AreaReinTags = -2009021, // 0xFFE15843 + OST_RebarTags = -2009020, // 0xFFE15844 + OST_FabricAreaSketchSheetsLines = -2009019, // 0xFFE15845 + OST_FabricAreaSketchEnvelopeLines = -2009018, // 0xFFE15846 + OST_FabricAreas = -2009017, // 0xFFE15847 + OST_FabricReinforcement = -2009016, // 0xFFE15848 + OST_RebarCover = -2009015, // 0xFFE15849 + OST_CoverType = -2009014, // 0xFFE1584A + OST_RebarShape = -2009013, // 0xFFE1584B + OST_PathReinBoundary = -2009012, // 0xFFE1584C + OST_PathReinTags = -2009011, // 0xFFE1584D + OST_PathReinSpanSymbol = -2009010, // 0xFFE1584E + OST_PathRein = -2009009, // 0xFFE1584F + OST_Cage = -2009008, // 0xFFE15850 + OST_AreaReinXVisibility = -2009007, // 0xFFE15851 + OST_AreaReinBoundary = -2009006, // 0xFFE15852 + OST_AreaReinSpanSymbol = -2009005, // 0xFFE15853 + OST_AreaReinSketchOverride = -2009004, // 0xFFE15854 + OST_AreaRein = -2009003, // 0xFFE15855 + OST_RebarLines = -2009002, // 0xFFE15856 + OST_RebarSketchLines = -2009001, // 0xFFE15857 + OST_Rebar = -2009000, // 0xFFE15858 + OST_MEPAncillaryFramingTags = -2008236, // 0xFFE15B54 + OST_PlumbingEquipmentTags = -2008235, // 0xFFE15B55 + OST_PlumbingEquipment = -2008234, // 0xFFE15B56 + OST_MechanicalControlDeviceTags = -2008233, // 0xFFE15B57 + OST_MechanicalControlDevices = -2008232, // 0xFFE15B58 + OST_MEPAncillaryFraming = -2008231, // 0xFFE15B59 + OST_MEPAncillaries_Obsolete = -2008230, // 0xFFE15B5A + OST_FabricationDuctworkStiffenerTags = -2008229, // 0xFFE15B5B + OST_FabricationDuctworkStiffeners = -2008228, // 0xFFE15B5C + OST_ELECTRICAL_AreaBasedLoads_Reference_Visibility = -2008227, // 0xFFE15B5D + OST_ELECTRICAL_AreaBasedLoads_InteriorFill_Visibility = -2008226, // 0xFFE15B5E + OST_ELECTRICAL_AreaBasedLoads_ColorFill_Obsolete = -2008225, // 0xFFE15B5F + OST_ELECTRICAL_AreaBasedLoads_Reference = -2008224, // 0xFFE15B60 + OST_ELECTRICAL_AreaBasedLoads_InteriorFill = -2008223, // 0xFFE15B61 + OST_ELECTRICAL_AreaBasedLoads_Boundary = -2008222, // 0xFFE15B62 + OST_FabricationPipeworkInsulation = -2008221, // 0xFFE15B63 + OST_FabricationDuctworkLining = -2008220, // 0xFFE15B64 + OST_FabricationContainmentDrop = -2008219, // 0xFFE15B65 + OST_FabricationContainmentRise = -2008218, // 0xFFE15B66 + OST_FabricationPipeworkDrop = -2008217, // 0xFFE15B67 + OST_FabricationPipeworkRise = -2008216, // 0xFFE15B68 + OST_FabricationContainmentSymbology = -2008215, // 0xFFE15B69 + OST_FabricationContainmentCenterLine = -2008214, // 0xFFE15B6A + OST_FabricationContainmentTags = -2008213, // 0xFFE15B6B + OST_FabricationContainment = -2008212, // 0xFFE15B6C + OST_FabricationPipeworkSymbology = -2008211, // 0xFFE15B6D + OST_FabricationPipeworkCenterLine = -2008210, // 0xFFE15B6E + OST_FabricationPipeworkTags = -2008209, // 0xFFE15B6F + OST_FabricationPipework = -2008208, // 0xFFE15B70 + OST_FabricationDuctworkSymbology = -2008207, // 0xFFE15B71 + OST_FabricationDuctworkDrop = -2008206, // 0xFFE15B72 + OST_FabricationDuctworkRise = -2008205, // 0xFFE15B73 + OST_FabricationHangerTags = -2008204, // 0xFFE15B74 + OST_FabricationHangers = -2008203, // 0xFFE15B75 + OST_OBSOLETE_FabricationPartsTmpGraphicDropDrag = -2008202, // 0xFFE15B76 + OST_FabricationPartsTmpGraphicDrag = -2008201, // 0xFFE15B77 + OST_OBSOLETE_FabricationPartsTmpGraphicDrop = -2008200, // 0xFFE15B78 + OST_FabricationPartsTmpGraphicEnd = -2008199, // 0xFFE15B79 + OST_FabricationDuctworkInsulation = -2008198, // 0xFFE15B7A + OST_LayoutNodes = -2008197, // 0xFFE15B7B + OST_FabricationDuctworkCenterLine = -2008196, // 0xFFE15B7C + OST_FabricationServiceElements = -2008195, // 0xFFE15B7D + OST_FabricationDuctworkTags = -2008194, // 0xFFE15B7E + OST_FabricationDuctwork = -2008193, // 0xFFE15B7F + OST_LayoutPathBase_Pipings = -2008192, // 0xFFE15B80 + OST_NumberingSchemas = -2008191, // 0xFFE15B81 + OST_DivisionRules = -2008190, // 0xFFE15B82 + OST_gbXML_Shade = -2008187, // 0xFFE15B85 + OST_AnalyticSurfaces = -2008186, // 0xFFE15B86 + OST_AnalyticSpaces = -2008185, // 0xFFE15B87 + OST_gbXML_OpeningAir = -2008184, // 0xFFE15B88 + OST_gbXML_NonSlidingDoor = -2008183, // 0xFFE15B89 + OST_gbXML_SlidingDoor = -2008182, // 0xFFE15B8A + OST_gbXML_OperableSkylight = -2008181, // 0xFFE15B8B + OST_gbXML_FixedSkylight = -2008180, // 0xFFE15B8C + OST_gbXML_OperableWindow = -2008179, // 0xFFE15B8D + OST_gbXML_FixedWindow = -2008178, // 0xFFE15B8E + OST_gbXML_UndergroundCeiling = -2008177, // 0xFFE15B8F + OST_gbXML_UndergroundSlab = -2008176, // 0xFFE15B90 + OST_gbXML_UndergroundWall = -2008175, // 0xFFE15B91 + OST_gbXML_SurfaceAir = -2008174, // 0xFFE15B92 + OST_gbXML_Ceiling = -2008173, // 0xFFE15B93 + OST_gbXML_InteriorFloor = -2008172, // 0xFFE15B94 + OST_gbXML_InteriorWall = -2008171, // 0xFFE15B95 + OST_gbXML_SlabOnGrade = -2008170, // 0xFFE15B96 + OST_gbXML_RaisedFloor = -2008169, // 0xFFE15B97 + OST_gbXML_Roof = -2008168, // 0xFFE15B98 + OST_gbXML_ExteriorWall = -2008167, // 0xFFE15B99 + OST_DivisionProfile = -2008165, // 0xFFE15B9B + OST_SplitterProfile = -2008164, // 0xFFE15B9C + OST_PipeSegments = -2008163, // 0xFFE15B9D + OST_GraphicalWarning_OpenConnector = -2008162, // 0xFFE15B9E + OST_PlaceHolderPipes = -2008161, // 0xFFE15B9F + OST_PlaceHolderDucts = -2008160, // 0xFFE15BA0 + OST_PipingSystem_Reference_Visibility = -2008159, // 0xFFE15BA1 + OST_PipingSystem_Reference = -2008158, // 0xFFE15BA2 + OST_DuctSystem_Reference_Visibility = -2008157, // 0xFFE15BA3 + OST_DuctSystem_Reference = -2008156, // 0xFFE15BA4 + OST_PipeInsulationsTags = -2008155, // 0xFFE15BA5 + OST_DuctLiningsTags = -2008154, // 0xFFE15BA6 + OST_DuctInsulationsTags = -2008153, // 0xFFE15BA7 + OST_ElectricalInternalCircuits = -2008152, // 0xFFE15BA8 + OST_PanelScheduleGraphics = -2008151, // 0xFFE15BA9 + OST_CableTrayRun = -2008150, // 0xFFE15BAA + OST_ConduitRun = -2008149, // 0xFFE15BAB + OST_ParamElemElectricalLoadClassification = -2008148, // 0xFFE15BAC + OST_DataPanelScheduleTemplates = -2008147, // 0xFFE15BAD + OST_SwitchboardScheduleTemplates = -2008146, // 0xFFE15BAE + OST_BranchPanelScheduleTemplates = -2008145, // 0xFFE15BAF + OST_ConduitStandards = -2008144, // 0xFFE15BB0 + OST_ElectricalLoadClassifications = -2008143, // 0xFFE15BB1 + OST_ElectricalDemandFactorDefinitions = -2008142, // 0xFFE15BB2 + OST_ConduitFittingCenterLine = -2008141, // 0xFFE15BB3 + OST_CableTrayFittingCenterLine = -2008140, // 0xFFE15BB4 + OST_ConduitCenterLine = -2008139, // 0xFFE15BB5 + OST_ConduitDrop = -2008138, // 0xFFE15BB6 + OST_ConduitRiseDrop = -2008137, // 0xFFE15BB7 + OST_CableTrayCenterLine = -2008136, // 0xFFE15BB8 + OST_CableTrayDrop = -2008135, // 0xFFE15BB9 + OST_CableTrayRiseDrop = -2008134, // 0xFFE15BBA + OST_ConduitTags = -2008133, // 0xFFE15BBB + OST_Conduit = -2008132, // 0xFFE15BBC + OST_CableTrayTags = -2008131, // 0xFFE15BBD + OST_CableTray = -2008130, // 0xFFE15BBE + OST_ConduitFittingTags = -2008129, // 0xFFE15BBF + OST_ConduitFitting = -2008128, // 0xFFE15BC0 + OST_CableTrayFittingTags = -2008127, // 0xFFE15BC1 + OST_CableTrayFitting = -2008126, // 0xFFE15BC2 + OST_RoutingPreferences = -2008125, // 0xFFE15BC3 + OST_DuctLinings = -2008124, // 0xFFE15BC4 + OST_DuctInsulations = -2008123, // 0xFFE15BC5 + OST_PipeInsulations = -2008122, // 0xFFE15BC6 + OST_HVAC_Load_Schedules = -2008121, // 0xFFE15BC7 + OST_HVAC_Load_Building_Types = -2008120, // 0xFFE15BC8 + OST_HVAC_Load_Space_Types = -2008119, // 0xFFE15BC9 + OST_HVAC_Zones_Reference_Visibility = -2008118, // 0xFFE15BCA + OST_HVAC_Zones_InteriorFill_Visibility = -2008117, // 0xFFE15BCB + OST_HVAC_Zones_ColorFill = -2008116, // 0xFFE15BCC + OST_ZoneTags = -2008115, // 0xFFE15BCD + OST_LayoutPath_Bases = -2008114, // 0xFFE15BCE + OST_WireTemperatureRatings = -2008113, // 0xFFE15BCF + OST_WireInsulations = -2008112, // 0xFFE15BD0 + OST_WireMaterials = -2008111, // 0xFFE15BD1 + OST_HVAC_Zones_Reference = -2008110, // 0xFFE15BD2 + OST_HVAC_Zones_InteriorFill = -2008109, // 0xFFE15BD3 + OST_HVAC_Zones_Boundary = -2008108, // 0xFFE15BD4 + OST_HVAC_Zones = -2008107, // 0xFFE15BD5 + OST_Fluids = -2008106, // 0xFFE15BD6 + OST_PipeSchedules = -2008105, // 0xFFE15BD7 + OST_PipeMaterials = -2008104, // 0xFFE15BD8 + OST_PipeConnections = -2008103, // 0xFFE15BD9 + OST_EAConstructions = -2008102, // 0xFFE15BDA + OST_SwitchSystem = -2008101, // 0xFFE15BDB + OST_SprinklerTags = -2008100, // 0xFFE15BDC + OST_Sprinklers = -2008099, // 0xFFE15BDD + OST_RouteCurveBranch = -2008098, // 0xFFE15BDE + OST_RouteCurveMain = -2008097, // 0xFFE15BDF + OST_RouteCurve = -2008096, // 0xFFE15BE0 + OST_GbXML_Opening = -2008095, // 0xFFE15BE1 + OST_GbXML_SType_Underground = -2008094, // 0xFFE15BE2 + OST_GbXML_SType_Shade = -2008093, // 0xFFE15BE3 + OST_GbXML_SType_Exterior = -2008092, // 0xFFE15BE4 + OST_GbXML_SType_Interior = -2008091, // 0xFFE15BE5 + OST_GbXMLFaces = -2008090, // 0xFFE15BE6 + OST_WireHomeRunArrows = -2008089, // 0xFFE15BE7 + OST_LightingDeviceTags = -2008088, // 0xFFE15BE8 + OST_LightingDevices = -2008087, // 0xFFE15BE9 + OST_FireAlarmDeviceTags = -2008086, // 0xFFE15BEA + OST_FireAlarmDevices = -2008085, // 0xFFE15BEB + OST_DataDeviceTags = -2008084, // 0xFFE15BEC + OST_DataDevices = -2008083, // 0xFFE15BED + OST_CommunicationDeviceTags = -2008082, // 0xFFE15BEE + OST_CommunicationDevices = -2008081, // 0xFFE15BEF + OST_SecurityDeviceTags = -2008080, // 0xFFE15BF0 + OST_SecurityDevices = -2008079, // 0xFFE15BF1 + OST_NurseCallDeviceTags = -2008078, // 0xFFE15BF2 + OST_NurseCallDevices = -2008077, // 0xFFE15BF3 + OST_TelephoneDeviceTags = -2008076, // 0xFFE15BF4 + OST_TelephoneDevices = -2008075, // 0xFFE15BF5 + OST_WireTickMarks = -2008074, // 0xFFE15BF6 + OST_PipeFittingInsulation = -2008073, // 0xFFE15BF7 + OST_PipeFittingCenterLine = -2008072, // 0xFFE15BF8 + OST_FlexPipeCurvesInsulation = -2008071, // 0xFFE15BF9 + OST_PipeCurvesInsulation = -2008070, // 0xFFE15BFA + OST_PipeCurvesDrop = -2008069, // 0xFFE15BFB + OST_DuctFittingLining = -2008068, // 0xFFE15BFC + OST_DuctFittingInsulation = -2008067, // 0xFFE15BFD + OST_DuctFittingCenterLine = -2008066, // 0xFFE15BFE + OST_FlexDuctCurvesInsulation = -2008065, // 0xFFE15BFF + OST_DuctCurvesLining = -2008064, // 0xFFE15C00 + OST_DuctCurvesInsulation = -2008063, // 0xFFE15C01 + OST_DuctCurvesDrop = -2008062, // 0xFFE15C02 + OST_DuctFittingTags = -2008061, // 0xFFE15C03 + OST_PipeFittingTags = -2008060, // 0xFFE15C04 + OST_PipeColorFills = -2008059, // 0xFFE15C05 + OST_PipeColorFillLegends = -2008058, // 0xFFE15C06 + OST_WireTags = -2008057, // 0xFFE15C07 + OST_PipeAccessoryTags = -2008056, // 0xFFE15C08 + OST_PipeAccessory = -2008055, // 0xFFE15C09 + OST_PipeCurvesRiseDrop = -2008054, // 0xFFE15C0A + OST_FlexPipeCurvesPattern = -2008053, // 0xFFE15C0B + OST_FlexPipeCurvesContour = -2008052, // 0xFFE15C0C + OST_FlexPipeCurvesCenterLine = -2008051, // 0xFFE15C0D + OST_FlexPipeCurves = -2008050, // 0xFFE15C0E + OST_PipeFitting = -2008049, // 0xFFE15C0F + OST_FlexPipeTags = -2008048, // 0xFFE15C10 + OST_PipeTags = -2008047, // 0xFFE15C11 + OST_PipeCurvesContour = -2008046, // 0xFFE15C12 + OST_PipeCurvesCenterLine = -2008045, // 0xFFE15C13 + OST_PipeCurves = -2008044, // 0xFFE15C14 + OST_PipingSystem = -2008043, // 0xFFE15C15 + OST_ElectricalDemandFactor = -2008042, // 0xFFE15C16 + OST_ElecDistributionSys = -2008041, // 0xFFE15C17 + OST_ElectricalVoltage = -2008040, // 0xFFE15C18 + OST_Wire = -2008039, // 0xFFE15C19 + OST_ElectricalCircuitTags = -2008038, // 0xFFE15C1A + OST_ElectricalCircuit = -2008037, // 0xFFE15C1B + OST_DuctCurvesRiseDrop = -2008036, // 0xFFE15C1C + OST_FlexDuctCurvesPattern = -2008023, // 0xFFE15C29 + OST_FlexDuctCurvesContour = -2008022, // 0xFFE15C2A + OST_FlexDuctCurvesCenterLine = -2008021, // 0xFFE15C2B + OST_FlexDuctCurves = -2008020, // 0xFFE15C2C + OST_DuctAccessoryTags = -2008017, // 0xFFE15C2F + OST_DuctAccessory = -2008016, // 0xFFE15C30 + OST_DuctSystem = -2008015, // 0xFFE15C31 + OST_DuctTerminalTags = -2008014, // 0xFFE15C32 + OST_DuctTerminal = -2008013, // 0xFFE15C33 + OST_DuctFitting = -2008010, // 0xFFE15C36 + OST_DuctColorFills = -2008005, // 0xFFE15C3B + OST_FlexDuctTags = -2008004, // 0xFFE15C3C + OST_DuctTags = -2008003, // 0xFFE15C3D + OST_DuctCurvesContour = -2008002, // 0xFFE15C3E + OST_DuctCurvesCenterLine = -2008001, // 0xFFE15C3F + OST_DuctCurves = -2008000, // 0xFFE15C40 + OST_DuctColorFillLegends = -2007004, // 0xFFE16024 + OST_ConnectorElemZAxis = -2007003, // 0xFFE16025 + OST_ConnectorElemYAxis = -2007002, // 0xFFE16026 + OST_ConnectorElemXAxis = -2007001, // 0xFFE16027 + OST_ConnectorElem = -2007000, // 0xFFE16028 + OST_VibrationManagementTags = -2006282, // 0xFFE162F6 + OST_BridgeFramingTrussTags = -2006281, // 0xFFE162F7 + OST_BridgeFramingDiaphragmTags = -2006279, // 0xFFE162F9 + OST_BridgeFramingCrossBracingTags = -2006278, // 0xFFE162FA + OST_StructuralTendonTags = -2006276, // 0xFFE162FC + OST_StructuralTendonHiddenLines = -2006275, // 0xFFE162FD + OST_StructuralTendons = -2006274, // 0xFFE162FE + OST_ExpansionJointTags = -2006273, // 0xFFE162FF + OST_ExpansionJointHiddenLines = -2006272, // 0xFFE16300 + OST_ExpansionJoints = -2006271, // 0xFFE16301 + OST_VibrationIsolatorTags = -2006266, // 0xFFE16306 + OST_VibrationIsolators = -2006265, // 0xFFE16307 + OST_VibrationDamperTags = -2006264, // 0xFFE16308 + OST_VibrationDampers = -2006263, // 0xFFE16309 + OST_VibrationManagementHiddenLines = -2006262, // 0xFFE1630A + OST_VibrationManagement = -2006261, // 0xFFE1630B + OST_BridgeFramingTrusses = -2006248, // 0xFFE16318 + OST_BridgeFramingDiaphragms = -2006246, // 0xFFE1631A + OST_BridgeFramingCrossBracing = -2006245, // 0xFFE1631B + OST_BridgeFramingTags = -2006243, // 0xFFE1631D + OST_BridgeFramingHiddenLines = -2006242, // 0xFFE1631E + OST_BridgeFraming = -2006241, // 0xFFE1631F + OST_PierWallTags = -2006230, // 0xFFE1632A + OST_PierWalls = -2006229, // 0xFFE1632B + OST_PierPileTags = -2006226, // 0xFFE1632E + OST_PierPiles = -2006225, // 0xFFE1632F + OST_PierColumnTags = -2006222, // 0xFFE16332 + OST_PierColumns = -2006221, // 0xFFE16333 + OST_PierCapTags = -2006220, // 0xFFE16334 + OST_PierCaps = -2006219, // 0xFFE16335 + OST_ApproachSlabTags = -2006211, // 0xFFE1633D + OST_AbutmentWallTags = -2006210, // 0xFFE1633E + OST_AbutmentPileTags = -2006209, // 0xFFE1633F + OST_AbutmentFoundationTags = -2006208, // 0xFFE16340 + OST_ApproachSlabs = -2006205, // 0xFFE16343 + OST_AbutmentWalls = -2006204, // 0xFFE16344 + OST_AbutmentPiles = -2006203, // 0xFFE16345 + OST_AbutmentFoundations = -2006202, // 0xFFE16346 + OST_BridgeBearingTags = -2006178, // 0xFFE1635E + OST_BridgeGirderTags = -2006177, // 0xFFE1635F + OST_BridgeFoundationTags = -2006176, // 0xFFE16360 + OST_BridgeDeckTags = -2006175, // 0xFFE16361 + OST_BridgeArchTags = -2006174, // 0xFFE16362 + OST_BridgeCableTags = -2006173, // 0xFFE16363 + OST_BridgeTowerTags = -2006172, // 0xFFE16364 + OST_BridgePierTags = -2006171, // 0xFFE16365 + OST_BridgeAbutmentTags = -2006170, // 0xFFE16366 + OST_BridgeBearingHiddenLines = -2006158, // 0xFFE16372 + OST_BridgeGirderHiddenLines2021_Deprecated = -2006157, // 0xFFE16373 + OST_BridgeFoundationHiddenLines2021_Deprecated = -2006156, // 0xFFE16374 + OST_BridgeDeckHiddenLines = -2006155, // 0xFFE16375 + OST_BridgeArchHiddenLines2021_Deprecated = -2006154, // 0xFFE16376 + OST_BridgeCableHiddenLines2021_Deprecated = -2006153, // 0xFFE16377 + OST_BridgeTowerHiddenLines2021_Deprecated = -2006152, // 0xFFE16378 + OST_BridgePierHiddenLines = -2006151, // 0xFFE16379 + OST_BridgeAbutmentHiddenLines = -2006150, // 0xFFE1637A + OST_BridgeBearings = -2006138, // 0xFFE16386 + OST_BridgeGirders = -2006137, // 0xFFE16387 + OST_BridgeFoundations = -2006136, // 0xFFE16388 + OST_BridgeDecks = -2006135, // 0xFFE16389 + OST_BridgeArches = -2006134, // 0xFFE1638A + OST_BridgeCables = -2006133, // 0xFFE1638B + OST_BridgeTowers = -2006132, // 0xFFE1638C + OST_BridgePiers = -2006131, // 0xFFE1638D + OST_BridgeAbutments = -2006130, // 0xFFE1638E + OST_DesignOptions = -2006114, // 0xFFE1639E + OST_DesignOptionSets = -2006112, // 0xFFE163A0 + OST_StructuralBracePlanReps = -2006110, // 0xFFE163A2 + OST_StructConnectionSymbols = -2006100, // 0xFFE163AC + OST_StructuralAnnotations = -2006090, // 0xFFE163B6 + OST_RevisionCloudTags = -2006080, // 0xFFE163C0 + OST_RevisionNumberingSequences = -2006071, // 0xFFE163C9 + OST_Revisions = -2006070, // 0xFFE163CA + OST_RevisionClouds = -2006060, // 0xFFE163D4 + OST_EditCutProfile = -2006050, // 0xFFE163DE + OST_ElevationMarks = -2006045, // 0xFFE163E3 + OST_GridHeads = -2006040, // 0xFFE163E8 + OST_LevelHeads = -2006020, // 0xFFE163FC + OST_DecalType = -2006002, // 0xFFE1640E + OST_DecalElement = -2006001, // 0xFFE1640F + OST_VolumeOfInterest = -2006000, // 0xFFE16410 + OST_BoundaryConditions = -2005301, // 0xFFE166CB + OST_InternalAreaLoadTags = -2005255, // 0xFFE166F9 + OST_InternalLineLoadTags = -2005254, // 0xFFE166FA + OST_InternalPointLoadTags = -2005253, // 0xFFE166FB + OST_AreaLoadTags = -2005252, // 0xFFE166FC + OST_LineLoadTags = -2005251, // 0xFFE166FD + OST_PointLoadTags = -2005250, // 0xFFE166FE + OST_LoadCasesSeismic = -2005218, // 0xFFE1671E + OST_LoadCasesTemperature = -2005217, // 0xFFE1671F + OST_LoadCasesAccidental = -2005216, // 0xFFE16720 + OST_LoadCasesRoofLive = -2005215, // 0xFFE16721 + OST_LoadCasesSnow = -2005214, // 0xFFE16722 + OST_LoadCasesWind = -2005213, // 0xFFE16723 + OST_LoadCasesLive = -2005212, // 0xFFE16724 + OST_LoadCasesDead = -2005211, // 0xFFE16725 + OST_LoadCases = -2005210, // 0xFFE16726 + OST_InternalAreaLoads = -2005207, // 0xFFE16729 + OST_InternalLineLoads = -2005206, // 0xFFE1672A + OST_InternalPointLoads = -2005205, // 0xFFE1672B + OST_InternalLoads = -2005204, // 0xFFE1672C + OST_AreaLoads = -2005203, // 0xFFE1672D + OST_LineLoads = -2005202, // 0xFFE1672E + OST_PointLoads = -2005201, // 0xFFE1672F + OST_Loads = -2005200, // 0xFFE16730 + OST_BeamSystemTags = -2005130, // 0xFFE16776 + OST_FootingSpanDirectionSymbol = -2005111, // 0xFFE16789 + OST_SpanDirectionSymbol = -2005110, // 0xFFE1678A + OST_SpotSlopesSymbols = -2005102, // 0xFFE16792 + OST_SpotCoordinateSymbols = -2005101, // 0xFFE16793 + OST_SpotElevSymbols = -2005100, // 0xFFE16794 + OST_MultiLeaderTag = -2005033, // 0xFFE167D7 + OST_CurtainWallMullionTags = -2005032, // 0xFFE167D8 + OST_StructuralConnectionHandlerTags_Deprecated = -2005031, // 0xFFE167D9 + OST_TrussTags = -2005030, // 0xFFE167DA + OST_KeynoteTags = -2005029, // 0xFFE167DB + OST_DetailComponentTags = -2005028, // 0xFFE167DC + OST_MaterialTags = -2005027, // 0xFFE167DD + OST_FloorTags = -2005026, // 0xFFE167DE + OST_CurtaSystemTags = -2005025, // 0xFFE167DF + OST_HostFinTags = -2005024, // 0xFFE167E0 + OST_StairsTags = -2005023, // 0xFFE167E1 + OST_MultiCategoryTags = -2005022, // 0xFFE167E2 + OST_PlantingTags = -2005021, // 0xFFE167E3 + OST_AreaTags = -2005020, // 0xFFE167E4 + OST_StructuralFoundationTags = -2005019, // 0xFFE167E5 + OST_StructuralColumnTags = -2005018, // 0xFFE167E6 + OST_ParkingTags = -2005017, // 0xFFE167E7 + OST_SiteTags = -2005016, // 0xFFE167E8 + OST_StructuralFramingTags = -2005015, // 0xFFE167E9 + OST_SpecialityEquipmentTags = -2005014, // 0xFFE167EA + OST_GenericModelTags = -2005013, // 0xFFE167EB + OST_CurtainWallPanelTags = -2005012, // 0xFFE167EC + OST_WallTags = -2005011, // 0xFFE167ED + OST_PlumbingFixtureTags = -2005010, // 0xFFE167EE + OST_MechanicalEquipmentTags = -2005009, // 0xFFE167EF + OST_LightingFixtureTags = -2005008, // 0xFFE167F0 + OST_FurnitureSystemTags = -2005007, // 0xFFE167F1 + OST_FurnitureTags = -2005006, // 0xFFE167F2 + OST_ElectricalFixtureTags = -2005004, // 0xFFE167F4 + OST_ElectricalEquipmentTags = -2005003, // 0xFFE167F5 + OST_CeilingTags = -2005002, // 0xFFE167F6 + OST_CaseworkTags = -2005001, // 0xFFE167F7 + OST_Tags = -2005000, // 0xFFE167F8 + OST_MEPSpaceColorFill = -2003605, // 0xFFE16D6B + OST_MEPSpaceReference = -2003604, // 0xFFE16D6C + OST_MEPSpaceInteriorFill = -2003603, // 0xFFE16D6D + OST_MEPSpaceReferenceVisibility = -2003602, // 0xFFE16D6E + OST_MEPSpaceInteriorFillVisibility = -2003601, // 0xFFE16D6F + OST_MEPSpaces = -2003600, // 0xFFE16D70 + OST_StackedWalls = -2003500, // 0xFFE16DD4 + OST_MassGlazingAll = -2003423, // 0xFFE16E21 + OST_MassFloorsAll = -2003422, // 0xFFE16E22 + OST_MassWallsAll = -2003421, // 0xFFE16E23 + OST_MassExteriorWallUnderground = -2003420, // 0xFFE16E24 + OST_MassSlab = -2003419, // 0xFFE16E25 + OST_MassShade = -2003418, // 0xFFE16E26 + OST_MassOpening = -2003417, // 0xFFE16E27 + OST_MassSkylights = -2003416, // 0xFFE16E28 + OST_MassGlazing = -2003415, // 0xFFE16E29 + OST_MassRoof = -2003414, // 0xFFE16E2A + OST_MassExteriorWall = -2003413, // 0xFFE16E2B + OST_MassInteriorWall = -2003412, // 0xFFE16E2C + OST_MassZone = -2003411, // 0xFFE16E2D + OST_MassAreaFaceTags = -2003410, // 0xFFE16E2E + OST_HostTemplate = -2003409, // 0xFFE16E2F + OST_MassFaceSplitter = -2003408, // 0xFFE16E30 + OST_MassCutter = -2003407, // 0xFFE16E31 + OST_ZoningEnvelope = -2003406, // 0xFFE16E32 + OST_MassTags = -2003405, // 0xFFE16E33 + OST_MassForm = -2003404, // 0xFFE16E34 + OST_MassFloor = -2003403, // 0xFFE16E35 + OST_Mass = -2003400, // 0xFFE16E38 + OST_DividedSurface_DiscardedDivisionLines = -2003333, // 0xFFE16E7B + OST_DividedSurfaceBelt = -2003332, // 0xFFE16E7C + OST_TilePatterns = -2003331, // 0xFFE16E7D + OST_AlwaysExcludedInAllViews = -2003330, // 0xFFE16E7E + OST_DividedSurface_TransparentFace = -2003329, // 0xFFE16E7F + OST_DividedSurface_PreDividedSurface = -2003328, // 0xFFE16E80 + OST_DividedSurface_PatternFill = -2003327, // 0xFFE16E81 + OST_DividedSurface_PatternLines = -2003326, // 0xFFE16E82 + OST_DividedSurface_Gridlines = -2003325, // 0xFFE16E83 + OST_DividedSurface_Nodes = -2003324, // 0xFFE16E84 + OST_DividedSurface = -2003323, // 0xFFE16E85 + OST_RepeatingDetailLines = -2003321, // 0xFFE16E87 + OST_RampsDownArrow = -2003308, // 0xFFE16E94 + OST_RampsUpArrow = -2003307, // 0xFFE16E95 + OST_RampsDownText = -2003306, // 0xFFE16E96 + OST_RampsUpText = -2003305, // 0xFFE16E97 + OST_RampsStringerAboveCut = -2003304, // 0xFFE16E98 + OST_RampsStringer = -2003303, // 0xFFE16E99 + OST_RampsAboveCut = -2003302, // 0xFFE16E9A + OST_RampsIncomplete = -2003301, // 0xFFE16E9B + OST_TrussDummy = -2003300, // 0xFFE16E9C + OST_ZoneSchemes = -2003225, // 0xFFE16EE7 + OST_AreaSchemes = -2003201, // 0xFFE16EFF + OST_Areas = -2003200, // 0xFFE16F00 + OST_ProjectInformation = -2003101, // 0xFFE16F63 + OST_Sheets = -2003100, // 0xFFE16F64 + OST_ProfileFamilies = -2003000, // 0xFFE16FC8 + OST_DetailComponents = -2002000, // 0xFFE173B0 + OST_RoofSoffit = -2001393, // 0xFFE1760F + OST_EdgeSlab = -2001392, // 0xFFE17610 + OST_Gutter = -2001391, // 0xFFE17611 + OST_Fascia = -2001390, // 0xFFE17612 + OST_Entourage = -2001370, // 0xFFE17626 + OST_Planting = -2001360, // 0xFFE17630 + OST_Blocks = -2001359, // 0xFFE17631 + OST_StructuralStiffenerHiddenLines = -2001358, // 0xFFE17632 + OST_StructuralColumnLocationLine = -2001357, // 0xFFE17633 + OST_StructuralFramingLocationLine = -2001356, // 0xFFE17634 + OST_StructuralStiffenerTags = -2001355, // 0xFFE17635 + OST_StructuralStiffener = -2001354, // 0xFFE17636 + OST_FootingAnalyticalGeometry = -2001353, // 0xFFE17637 + OST_RvtLinks = -2001352, // 0xFFE17638 + OST_Automatic = -2001351, // 0xFFE17639 + OST_SpecialityEquipment = -2001350, // 0xFFE1763A + OST_ColumnAnalyticalRigidLinks = -2001344, // 0xFFE17640 + OST_SecondaryTopographyContours = -2001343, // 0xFFE17641 + OST_TopographyContours = -2001342, // 0xFFE17642 + OST_TopographySurface = -2001341, // 0xFFE17643 + OST_Topography = -2001340, // 0xFFE17644 + OST_TopographyLink = -2001339, // 0xFFE17645 + OST_StructuralTruss = -2001336, // 0xFFE17648 + OST_StructuralColumnStickSymbols = -2001335, // 0xFFE17649 + OST_HiddenStructuralColumnLines = -2001334, // 0xFFE1764A + OST_AnalyticalRigidLinks = -2001333, // 0xFFE1764B + OST_ColumnAnalyticalGeometry = -2001332, // 0xFFE1764C + OST_FramingAnalyticalGeometry = -2001331, // 0xFFE1764D + OST_StructuralColumns = -2001330, // 0xFFE1764E + OST_HiddenStructuralFramingLines = -2001329, // 0xFFE1764F + OST_KickerBracing = -2001328, // 0xFFE17650 + OST_StructuralFramingSystem = -2001327, // 0xFFE17651 + OST_VerticalBracing = -2001326, // 0xFFE17652 + OST_HorizontalBracing = -2001325, // 0xFFE17653 + OST_Purlin = -2001324, // 0xFFE17654 + OST_Joist = -2001323, // 0xFFE17655 + OST_Girder = -2001322, // 0xFFE17656 + OST_StructuralFramingOther = -2001321, // 0xFFE17657 + OST_StructuralFraming = -2001320, // 0xFFE17658 + OST_HiddenStructuralFoundationLines = -2001302, // 0xFFE1766A + OST_StructuralFoundation = -2001300, // 0xFFE1766C + OST_LinkBasePoint = -2001276, // 0xFFE17684 + OST_BasePointAxisZ = -2001275, // 0xFFE17685 + OST_BasePointAxisY = -2001274, // 0xFFE17686 + OST_BasePointAxisX = -2001273, // 0xFFE17687 + OST_SharedBasePoint = -2001272, // 0xFFE17688 + OST_ProjectBasePoint = -2001271, // 0xFFE17689 + OST_SiteRegion = -2001270, // 0xFFE1768A + OST_SitePropertyLineSegmentTags = -2001269, // 0xFFE1768B + OST_SitePropertyLineSegment = -2001268, // 0xFFE1768C + OST_SitePropertyTags = -2001267, // 0xFFE1768D + OST_SitePointBoundary = -2001266, // 0xFFE1768E + OST_SiteProperty = -2001265, // 0xFFE1768F + OST_BuildingPad = -2001263, // 0xFFE17691 + OST_SitePoint = -2001262, // 0xFFE17692 + OST_SiteSurface = -2001261, // 0xFFE17693 + OST_Site = -2001260, // 0xFFE17694 + OST_Sewer = -2001240, // 0xFFE176A8 + OST_RoadTags = -2001221, // 0xFFE176BB + OST_Roads = -2001220, // 0xFFE176BC + OST_Property = -2001200, // 0xFFE176D0 + OST_Parking = -2001180, // 0xFFE176E4 + OST_PlumbingFixtures = -2001160, // 0xFFE176F8 + OST_MechanicalEquipment = -2001140, // 0xFFE1770C + OST_LightingFixtureSource = -2001121, // 0xFFE1771F + OST_LightingFixtures = -2001120, // 0xFFE17720 + OST_FurnitureSystems = -2001100, // 0xFFE17734 + OST_ElectricalLoadSet = -2001098, // 0xFFE17736 + OST_ToposolidLink = -2001097, // 0xFFE17737 + OST_ElectricalAnalyticalFeeder = -2001096, // 0xFFE17738 + OST_ToposolidOpening = -2001095, // 0xFFE17739 + OST_ToposolidTags = -2001094, // 0xFFE1773A + OST_ToposolidInsulation = -2001093, // 0xFFE1773B + OST_ToposolidSurfacePattern = -2001092, // 0xFFE1773C + OST_ToposolidFinish2 = -2001091, // 0xFFE1773D + OST_ToposolidFinish1 = -2001090, // 0xFFE1773E + OST_ToposolidSubstrate = -2001089, // 0xFFE1773F + OST_ToposolidStructure = -2001088, // 0xFFE17740 + OST_ToposolidMembrane = -2001087, // 0xFFE17741 + OST_ToposolidCutPattern = -2001086, // 0xFFE17742 + OST_ToposolidDefault = -2001085, // 0xFFE17743 + OST_ToposolidSplitLines = -2001084, // 0xFFE17744 + OST_ToposolidFoldingLines = -2001083, // 0xFFE17745 + OST_ToposolidSecondaryContours = -2001082, // 0xFFE17746 + OST_ToposolidContours = -2001081, // 0xFFE17747 + OST_ToposolidHiddenLines = -2001080, // 0xFFE17748 + OST_Toposolid = -2001079, // 0xFFE17749 + OST_ELECTRICAL_AreaBasedLoads_Tags = -2001078, // 0xFFE1774A + OST_ElectricalAnalyticalTransformer = -2001077, // 0xFFE1774B + OST_FloorsSplitLines = -2001076, // 0xFFE1774C + OST_AnalyticalMemberCrossSection = -2001075, // 0xFFE1774D + OST_RvtLinksTags = -2001074, // 0xFFE1774E + OST_ModelGroupTags = -2001073, // 0xFFE1774F + OST_WallSweepTags = -2001072, // 0xFFE17750 + OST_TopRailTags = -2001071, // 0xFFE17751 + OST_SlabEdgeTags = -2001070, // 0xFFE17752 + OST_RoofSoffitTags = -2001069, // 0xFFE17753 + OST_RampTags = -2001068, // 0xFFE17754 + OST_PadTags = -2001067, // 0xFFE17755 + OST_HandrailTags = -2001066, // 0xFFE17756 + OST_GutterTags = -2001065, // 0xFFE17757 + OST_EntourageTags = -2001064, // 0xFFE17758 + OST_ColumnTags = -2001063, // 0xFFE17759 + OST_FasciaTags = -2001062, // 0xFFE1775A + OST_SignageTags = -2001061, // 0xFFE1775B + OST_ElectricalFixtures = -2001060, // 0xFFE1775C + OST_SignageHiddenLines = -2001059, // 0xFFE1775D + OST_Signage = -2001058, // 0xFFE1775E + OST_AudioVisualDeviceTags = -2001057, // 0xFFE1775F + OST_AudioVisualDevicesHiddenLines = -2001056, // 0xFFE17760 + OST_AudioVisualDevices = -2001055, // 0xFFE17761 + OST_VerticalCirculationTags = -2001054, // 0xFFE17762 + OST_VerticalCirculationHiddenLines = -2001053, // 0xFFE17763 + OST_VerticalCirculation = -2001052, // 0xFFE17764 + OST_FireProtectionTags = -2001051, // 0xFFE17765 + OST_FireProtectionHiddenLines = -2001050, // 0xFFE17766 + OST_FireProtection = -2001049, // 0xFFE17767 + OST_MedicalEquipmentTags = -2001048, // 0xFFE17768 + OST_MedicalEquipmentHiddenLines = -2001047, // 0xFFE17769 + OST_MedicalEquipment = -2001046, // 0xFFE1776A + OST_FoodServiceEquipmentTags = -2001045, // 0xFFE1776B + OST_FoodServiceEquipmentHiddenLines = -2001044, // 0xFFE1776C + OST_FoodServiceEquipment = -2001043, // 0xFFE1776D + OST_TemporaryStructureTags = -2001042, // 0xFFE1776E + OST_TemporaryStructureHiddenLines = -2001041, // 0xFFE1776F + OST_ElectricalEquipment = -2001040, // 0xFFE17770 + OST_TemporaryStructure = -2001039, // 0xFFE17771 + OST_HardscapeTags = -2001038, // 0xFFE17772 + OST_HardscapeHiddenLines = -2001037, // 0xFFE17773 + OST_Hardscape = -2001036, // 0xFFE17774 + OST_WallCoreLayer = -2001035, // 0xFFE17775 + OST_WallNonCoreLayer = -2001034, // 0xFFE17776 + OST_MEPLoadAreaSeparationLines = -2001033, // 0xFFE17777 + OST_MEPLoadAreaReferenceVisibility = -2001031, // 0xFFE17779 + OST_MEPLoadAreaInteriorFillVisibility = -2001030, // 0xFFE1777A + OST_MEPLoadAreaReference = -2001029, // 0xFFE1777B + OST_MEPLoadAreaInteriorFill = -2001028, // 0xFFE1777C + OST_MEPLoadAreaColorFill = -2001027, // 0xFFE1777D + OST_ElectricalPowerSource = -2001026, // 0xFFE1777E + OST_MEPLoadAreaTags_OBSOLETE = -2001025, // 0xFFE1777F + OST_MEPLoadAreas = -2001024, // 0xFFE17780 + OST_MEPAnalyticalTransferSwitch = -2001023, // 0xFFE17781 + OST_OBSOLETE_MEPAnalyticalElectricalBranch = -2001022, // 0xFFE17782 + OST_MEPAnalyticalBus = -2001021, // 0xFFE17783 + OST_ElectricalLoadZoneInstance = -2001020, // 0xFFE17784 + OST_ElectricalLoadZoneType = -2001019, // 0xFFE17785 + OST_ElectricalZoneEquipment_Obsolete = -2001018, // 0xFFE17786 + OST_AlignmentStationLabels = -2001017, // 0xFFE17787 + OST_AlignmentStationLabelSets = -2001016, // 0xFFE17788 + OST_AlignmentsTags = -2001015, // 0xFFE17789 + OST_MinorStations_Deprecated = -2001014, // 0xFFE1778A + OST_MajorStations_Deprecated = -2001013, // 0xFFE1778B + OST_Alignments = -2001012, // 0xFFE1778C + OST_ElectricalCircuitNaming = -2001011, // 0xFFE1778D + OST_ZoneEquipment = -2001010, // 0xFFE1778E + OST_MEPAnalyticalWaterLoop = -2001009, // 0xFFE1778F + OST_MEPAnalyticalAirLoop = -2001008, // 0xFFE17790 + OST_MEPSystemZoneTags = -2001007, // 0xFFE17791 + OST_MEPSystemZoneReferenceLinesVisibility = -2001006, // 0xFFE17792 + OST_MEPSystemZoneInteriorFillVisibility = -2001005, // 0xFFE17793 + OST_MEPSystemZoneReferenceLines = -2001004, // 0xFFE17794 + OST_MEPSystemZoneInteriorFill = -2001003, // 0xFFE17795 + OST_MEPSystemZoneBoundary = -2001002, // 0xFFE17796 + OST_MEPSystemZone = -2001001, // 0xFFE17797 + OST_Casework = -2001000, // 0xFFE17798 + OST_ArcWallRectOpening = -2000999, // 0xFFE17799 + OST_DormerOpeningIncomplete = -2000998, // 0xFFE1779A + OST_SWallRectOpening = -2000997, // 0xFFE1779B + OST_ShaftOpening = -2000996, // 0xFFE1779C + OST_StructuralFramingOpening = -2000995, // 0xFFE1779D + OST_ColumnOpening = -2000994, // 0xFFE1779E + OST_RiseDropSymbols = -2000989, // 0xFFE177A3 + OST_PipeHydronicSeparationSymbols = -2000988, // 0xFFE177A4 + OST_MechanicalEquipmentSetBoundaryLines = -2000987, // 0xFFE177A5 + OST_MechanicalEquipmentSetTags = -2000986, // 0xFFE177A6 + OST_MechanicalEquipmentSet = -2000985, // 0xFFE177A7 + OST_AnalyticalPipeConnectionLineSymbol = -2000984, // 0xFFE177A8 + OST_AnalyticalPipeConnections = -2000983, // 0xFFE177A9 + OST_Coordination_Model = -2000982, // 0xFFE177AA + OST_MultistoryStairs = -2000980, // 0xFFE177AC + OST_HiddenStructuralConnectionLines_Deprecated = -2000979, // 0xFFE177AD + OST_StructuralConnectionHandler_Deprecated = -2000978, // 0xFFE177AE + OST_CoordinateSystem = -2000977, // 0xFFE177AF + OST_FndSlabLocalCoordSys = -2000976, // 0xFFE177B0 + OST_FloorLocalCoordSys = -2000975, // 0xFFE177B1 + OST_WallLocalCoordSys = -2000974, // 0xFFE177B2 + OST_BraceLocalCoordSys = -2000973, // 0xFFE177B3 + OST_ColumnLocalCoordSys = -2000972, // 0xFFE177B4 + OST_BeamLocalCoordSys = -2000971, // 0xFFE177B5 + OST_MultiReferenceAnnotations = -2000970, // 0xFFE177B6 + OST_DSR_LeaderTickMarkStyleId = -2000969, // 0xFFE177B7 + OST_DSR_InteriorTickMarkStyleId = -2000968, // 0xFFE177B8 + OST_DSR_ArrowHeadStyleId = -2000967, // 0xFFE177B9 + OST_DSR_CenterlineTickMarkStyleId = -2000966, // 0xFFE177BA + OST_DSR_CenterlinePatternCatId = -2000965, // 0xFFE177BB + OST_DSR_DimStyleHeavyEndCategoryId = -2000964, // 0xFFE177BC + OST_DSR_DimStyleHeavyEndCatId = -2000963, // 0xFFE177BD + OST_DSR_DimStyleTickCategoryId = -2000962, // 0xFFE177BE + OST_DSR_LineAndTextAttrFontId = -2000961, // 0xFFE177BF + OST_DSR_LineAndTextAttrCategoryId = -2000960, // 0xFFE177C0 + OST_AnalyticalOpeningTags = -2000958, // 0xFFE177C2 + OST_AnalyticalPanelTags = -2000957, // 0xFFE177C3 + OST_NodeAnalyticalTags = -2000956, // 0xFFE177C4 + OST_LinkAnalyticalTags = -2000955, // 0xFFE177C5 + OST_RailingRailPathExtensionLines = -2000954, // 0xFFE177C6 + OST_RailingRailPathLines = -2000953, // 0xFFE177C7 + OST_StairsSupports = -2000952, // 0xFFE177C8 + OST_RailingHandRailAboveCut = -2000951, // 0xFFE177C9 + OST_RailingTopRailAboveCut = -2000950, // 0xFFE177CA + OST_RailingTermination = -2000949, // 0xFFE177CB + OST_RailingSupport = -2000948, // 0xFFE177CC + OST_RailingHandRail = -2000947, // 0xFFE177CD + OST_RailingTopRail = -2000946, // 0xFFE177CE + OST_StairsSketchPathLines = -2000945, // 0xFFE177CF + OST_StairsTriserNumbers = -2000944, // 0xFFE177D0 + OST_StairsTriserTags = -2000943, // 0xFFE177D1 + OST_StairsSupportTags = -2000942, // 0xFFE177D2 + OST_StairsLandingTags = -2000941, // 0xFFE177D3 + OST_StairsRunTags = -2000940, // 0xFFE177D4 + OST_StairsPathsAboveCut = -2000939, // 0xFFE177D5 + OST_StairsPaths = -2000938, // 0xFFE177D6 + OST_StairsRiserLinesAboveCut = -2000937, // 0xFFE177D7 + OST_StairsRiserLines = -2000936, // 0xFFE177D8 + OST_StairsOutlinesAboveCut = -2000935, // 0xFFE177D9 + OST_StairsOutlines = -2000934, // 0xFFE177DA + OST_StairsNosingLinesAboveCut = -2000933, // 0xFFE177DB + OST_StairsNosingLines = -2000932, // 0xFFE177DC + OST_StairsCutMarksAboveCut = -2000931, // 0xFFE177DD + OST_StairsCutMarks = -2000930, // 0xFFE177DE + OST_ComponentRepeaterSlot = -2000928, // 0xFFE177E0 + OST_ComponentRepeater = -2000927, // 0xFFE177E1 + OST_DividedPath = -2000926, // 0xFFE177E2 + OST_IOSRoomCalculationPoint = -2000925, // 0xFFE177E3 + OST_PropertySet = -2000924, // 0xFFE177E4 + OST_AppearanceAsset = -2000923, // 0xFFE177E5 + OST_StairStringer2012_Deprecated = -2000922, // 0xFFE177E6 + OST_StairsTrisers = -2000921, // 0xFFE177E7 + OST_StairsLandings = -2000920, // 0xFFE177E8 + OST_StairsRuns = -2000919, // 0xFFE177E9 + OST_Stair2012_Deprecated = -2000918, // 0xFFE177EA + OST_RailingSystemTags = -2000917, // 0xFFE177EB + OST_RailingSystemTransition = -2000916, // 0xFFE177EC + OST_RailingSystemTermination = -2000915, // 0xFFE177ED + OST_RailingSystemRail = -2000914, // 0xFFE177EE + OST_RailingSystemTopRail = -2000913, // 0xFFE177EF + OST_RailingSystemHandRailBracket = -2000912, // 0xFFE177F0 + OST_RailingSystemHandRail = -2000911, // 0xFFE177F1 + OST_RailingSystemHardware = -2000910, // 0xFFE177F2 + OST_RailingSystemPanel = -2000909, // 0xFFE177F3 + OST_RailingSystemBaluster = -2000908, // 0xFFE177F4 + OST_RailingSystemPost = -2000907, // 0xFFE177F5 + OST_RailingSystemSegment = -2000906, // 0xFFE177F6 + OST_RailingSystem = -2000905, // 0xFFE177F7 + OST_AdaptivePoints_HiddenLines = -2000904, // 0xFFE177F8 + OST_AdaptivePoints_Lines = -2000903, // 0xFFE177F9 + OST_AdaptivePoints_Planes = -2000902, // 0xFFE177FA + OST_AdaptivePoints_Points = -2000901, // 0xFFE177FB + OST_AdaptivePoints = -2000900, // 0xFFE177FC + OST_CeilingOpening = -2000899, // 0xFFE177FD + OST_FloorOpening = -2000898, // 0xFFE177FE + OST_RoofOpening = -2000897, // 0xFFE177FF + OST_WallRefPlanes = -2000896, // 0xFFE17800 + OST_StructLocationLineControl = -2000880, // 0xFFE17810 + OST_PathOfTravelTags = -2000834, // 0xFFE1783E + OST_PathOfTravelLines = -2000833, // 0xFFE1783F + OST_DimLockControlLeader = -2000832, // 0xFFE17840 + OST_MEPSpaceSeparationLines = -2000831, // 0xFFE17841 + OST_AreaPolylines = -2000830, // 0xFFE17842 + OST_RoomPolylines = -2000829, // 0xFFE17843 + OST_InstanceDrivenLineStyle = -2000828, // 0xFFE17844 + OST_RemovedGridSeg = -2000827, // 0xFFE17845 + OST_IOSOpening = -2000810, // 0xFFE17856 + OST_IOSTilePatternGrid = -2000800, // 0xFFE17860 + OST_ControlLocal = -2000774, // 0xFFE1787A + OST_ControlAxisZ = -2000773, // 0xFFE1787B + OST_ControlAxisY = -2000772, // 0xFFE1787C + OST_ControlAxisX = -2000721, // 0xFFE178AF + OST_XRayConstrainedProfileEdge = -2000720, // 0xFFE178B0 + OST_XRayImplicitPathCurve = -2000719, // 0xFFE178B1 + OST_XRayPathPoint = -2000718, // 0xFFE178B2 + OST_XRayPathCurve = -2000717, // 0xFFE178B3 + OST_XRaySideEdge = -2000716, // 0xFFE178B4 + OST_XRayProfileEdge = -2000715, // 0xFFE178B5 + OST_ReferencePoints_HiddenLines = -2000714, // 0xFFE178B6 + OST_ReferencePoints_Lines = -2000713, // 0xFFE178B7 + OST_ReferencePoints_Planes = -2000712, // 0xFFE178B8 + OST_ReferencePoints_Points = -2000711, // 0xFFE178B9 + OST_ReferencePoints = -2000710, // 0xFFE178BA + OST_Materials = -2000700, // 0xFFE178C4 + OST_CeilingsCutPattern = -2000617, // 0xFFE17917 + OST_CeilingsDefault = -2000616, // 0xFFE17918 + OST_CeilingsFinish2 = -2000615, // 0xFFE17919 + OST_CeilingsFinish1 = -2000614, // 0xFFE1791A + OST_CeilingsSubstrate = -2000613, // 0xFFE1791B + OST_CeilingsInsulation = -2000612, // 0xFFE1791C + OST_CeilingsStructure = -2000611, // 0xFFE1791D + OST_CeilingsMembrane = -2000610, // 0xFFE1791E + OST_FloorsInteriorEdges = -2000609, // 0xFFE1791F + OST_FloorsCutPattern = -2000608, // 0xFFE17920 + OST_HiddenFloorLines = -2000607, // 0xFFE17921 + OST_FloorsDefault = -2000606, // 0xFFE17922 + OST_FloorsFinish2 = -2000605, // 0xFFE17923 + OST_FloorsFinish1 = -2000604, // 0xFFE17924 + OST_FloorsSubstrate = -2000603, // 0xFFE17925 + OST_FloorsInsulation = -2000602, // 0xFFE17926 + OST_FloorsStructure = -2000601, // 0xFFE17927 + OST_FloorsMembrane = -2000600, // 0xFFE17928 + OST_RoofsInteriorEdges = -2000598, // 0xFFE1792A + OST_RoofsCutPattern = -2000597, // 0xFFE1792B + OST_RoofsDefault = -2000596, // 0xFFE1792C + OST_RoofsFinish2 = -2000595, // 0xFFE1792D + OST_RoofsFinish1 = -2000594, // 0xFFE1792E + OST_RoofsSubstrate = -2000593, // 0xFFE1792F + OST_RoofsInsulation = -2000592, // 0xFFE17930 + OST_RoofsStructure = -2000591, // 0xFFE17931 + OST_RoofsMembrane = -2000590, // 0xFFE17932 + OST_WallsCutPattern = -2000588, // 0xFFE17934 + OST_HiddenWallLines = -2000587, // 0xFFE17935 + OST_WallsDefault = -2000586, // 0xFFE17936 + OST_WallsFinish2 = -2000585, // 0xFFE17937 + OST_WallsFinish1 = -2000584, // 0xFFE17938 + OST_WallsSubstrate = -2000583, // 0xFFE17939 + OST_WallsInsulation = -2000582, // 0xFFE1793A + OST_WallsStructure = -2000581, // 0xFFE1793B + OST_WallsMembrane = -2000580, // 0xFFE1793C + OST_PreviewLegendComponents = -2000576, // 0xFFE17940 + OST_LegendComponents = -2000575, // 0xFFE17941 + OST_Schedules = -2000573, // 0xFFE17943 + OST_ScheduleGraphics = -2000570, // 0xFFE17946 + OST_RasterImages = -2000560, // 0xFFE17950 + OST_ColorFillSchema = -2000552, // 0xFFE17958 + OST_RoomColorFill = -2000551, // 0xFFE17959 + OST_ColorFillLegends = -2000550, // 0xFFE1795A + OST_AnnotationCropSpecial = -2000549, // 0xFFE1795B + OST_CropBoundarySpecial = -2000548, // 0xFFE1795C + OST_AnnotationCrop = -2000547, // 0xFFE1795D + OST_FloorsAnalyticalGeometry = -2000546, // 0xFFE1795E + OST_WallsAnalyticalGeometry = -2000545, // 0xFFE1795F + OST_CalloutLeaderLine = -2000544, // 0xFFE17960 + OST_CeilingsSurfacePattern = -2000543, // 0xFFE17961 + OST_RoofsSurfacePattern = -2000542, // 0xFFE17962 + OST_FloorsSurfacePattern = -2000541, // 0xFFE17963 + OST_WallsSurfacePattern = -2000540, // 0xFFE17964 + OST_CalloutBoundary = -2000539, // 0xFFE17965 + OST_CalloutHeads = -2000538, // 0xFFE17966 + OST_Callouts = -2000537, // 0xFFE17967 + OST_CropBoundary = -2000536, // 0xFFE17968 + OST_Elev = -2000535, // 0xFFE17969 + OST_AxisZ = -2000533, // 0xFFE1796B + OST_AxisY = -2000532, // 0xFFE1796C + OST_AxisX = -2000531, // 0xFFE1796D + OST_CLines = -2000530, // 0xFFE1796E + OST_Lights = -2000520, // 0xFFE17978 + OST_ViewportLabel = -2000515, // 0xFFE1797D + OST_Viewports = -2000510, // 0xFFE17982 + OST_Camera_Lines = -2000501, // 0xFFE1798B + OST_Cameras = -2000500, // 0xFFE1798C + OST_MEPSpaceTags = -2000485, // 0xFFE1799B + OST_RoomTags = -2000480, // 0xFFE179A0 + OST_DoorTags = -2000460, // 0xFFE179B4 + OST_WindowTags = -2000450, // 0xFFE179BE + OST_SectionHeadWideLines = -2000404, // 0xFFE179EC + OST_SectionHeadMediumLines = -2000403, // 0xFFE179ED + OST_SectionHeadThinLines = -2000401, // 0xFFE179EF + OST_SectionHeads = -2000400, // 0xFFE179F0 + OST_ContourLabels = -2000350, // 0xFFE17A22 + OST_CurtaSystemFaceManager = -2000341, // 0xFFE17A2B + OST_CurtaSystem = -2000340, // 0xFFE17A2C + OST_AreaReport_Arc_Minus = -2000328, // 0xFFE17A38 + OST_AreaReport_Arc_Plus = -2000327, // 0xFFE17A39 + OST_AreaReport_Boundary = -2000326, // 0xFFE17A3A + OST_AreaReport_Triangle = -2000325, // 0xFFE17A3B + OST_CurtainGridsCurtaSystem = -2000323, // 0xFFE17A3D + OST_CurtainGridsSystem = -2000322, // 0xFFE17A3E + OST_CurtainGridsWall = -2000321, // 0xFFE17A3F + OST_CurtainGridsRoof = -2000320, // 0xFFE17A40 + OST_HostFinHF = -2000315, // 0xFFE17A45 + OST_HostFinWall = -2000314, // 0xFFE17A46 + OST_HostFinCeiling = -2000313, // 0xFFE17A47 + OST_HostFinRoof = -2000312, // 0xFFE17A48 + OST_HostFinFloor = -2000311, // 0xFFE17A49 + OST_HostFin = -2000310, // 0xFFE17A4A + OST_AnalysisDisplayStyle = -2000304, // 0xFFE17A50 + OST_AnalysisResults = -2000303, // 0xFFE17A51 + OST_RenderRegions = -2000302, // 0xFFE17A52 + OST_SectionBox = -2000301, // 0xFFE17A53 + OST_TextNotes = -2000300, // 0xFFE17A54 + OST_Divisions = -2000291, // 0xFFE17A5D + OST_Catalogs = -2000290, // 0xFFE17A5E + OST_DirectionEdgeLines = -2000289, // 0xFFE17A5F + OST_CenterLines = -2000288, // 0xFFE17A60 + OST_LinesBeyond = -2000287, // 0xFFE17A61 + OST_HiddenLines = -2000286, // 0xFFE17A62 + OST_DemolishedLines = -2000285, // 0xFFE17A63 + OST_OverheadLines = -2000284, // 0xFFE17A64 + OST_TitleBlockWideLines = -2000283, // 0xFFE17A65 + OST_TitleBlockMediumLines = -2000282, // 0xFFE17A66 + OST_TitleBlockThinLines = -2000281, // 0xFFE17A67 + OST_TitleBlocks = -2000280, // 0xFFE17A68 + OST_Views = -2000279, // 0xFFE17A69 + OST_Viewers = -2000278, // 0xFFE17A6A + OST_PartHiddenLines = -2000271, // 0xFFE17A71 + OST_PartTags = -2000270, // 0xFFE17A72 + OST_Parts = -2000269, // 0xFFE17A73 + OST_AssemblyTags = -2000268, // 0xFFE17A74 + OST_Assemblies = -2000267, // 0xFFE17A75 + OST_RoofTags = -2000266, // 0xFFE17A76 + OST_SpotSlopes = -2000265, // 0xFFE17A77 + OST_SpotCoordinates = -2000264, // 0xFFE17A78 + OST_SpotElevations = -2000263, // 0xFFE17A79 + OST_Constraints = -2000262, // 0xFFE17A7A + OST_WeakDims = -2000261, // 0xFFE17A7B + OST_Dimensions = -2000260, // 0xFFE17A7C + OST_Levels = -2000240, // 0xFFE17A90 + OST_DisplacementPath = -2000223, // 0xFFE17AA1 + OST_DisplacementElements = -2000222, // 0xFFE17AA2 + OST_GridChains = -2000221, // 0xFFE17AA3 + OST_Grids = -2000220, // 0xFFE17AA4 + OST_BrokenSectionLine = -2000202, // 0xFFE17AB6 + OST_SectionLine = -2000201, // 0xFFE17AB7 + OST_Sections = -2000200, // 0xFFE17AB8 + OST_ReferenceViewer = -2000198, // 0xFFE17ABA + OST_ReferenceViewerSymbol = -2000197, // 0xFFE17ABB + OST_ImportObjectStyles = -2000196, // 0xFFE17ABC + OST_ModelText = -2000195, // 0xFFE17ABD + OST_MaskingRegion = -2000194, // 0xFFE17ABE + OST_Matchline = -2000193, // 0xFFE17ABF + OST_FaceSplitter = -2000192, // 0xFFE17AC0 + OST_PlanRegion = -2000191, // 0xFFE17AC1 + OST_FilledRegion = -2000190, // 0xFFE17AC2 + OST_MassingProjectionOutlines = -2000187, // 0xFFE17AC5 + OST_MassingCutOutlines = -2000186, // 0xFFE17AC6 + OST_Massing = -2000185, // 0xFFE17AC7 + OST_Reveals = -2000182, // 0xFFE17ACA + OST_Cornices = -2000181, // 0xFFE17ACB + OST_Ramps = -2000180, // 0xFFE17ACC + OST_RailingBalusterRailCut = -2000177, // 0xFFE17ACF + OST_RailingBalusterRail = -2000176, // 0xFFE17AD0 + OST_Railings = -2000175, // 0xFFE17AD1 + OST_CurtainGrids = -2000173, // 0xFFE17AD3 + OST_CurtainWallMullionsCut = -2000172, // 0xFFE17AD4 + OST_CurtainWallMullions = -2000171, // 0xFFE17AD5 + OST_CurtainWallPanels = -2000170, // 0xFFE17AD6 + OST_AreaReference = -2000169, // 0xFFE17AD7 + OST_AreaInteriorFill = -2000168, // 0xFFE17AD8 + OST_RoomReference = -2000167, // 0xFFE17AD9 + OST_RoomInteriorFill = -2000166, // 0xFFE17ADA + OST_AreaColorFill = -2000165, // 0xFFE17ADB + OST_AreaReferenceVisibility = -2000164, // 0xFFE17ADC + OST_AreaInteriorFillVisibility = -2000163, // 0xFFE17ADD + OST_RoomReferenceVisibility = -2000162, // 0xFFE17ADE + OST_RoomInteriorFillVisibility = -2000161, // 0xFFE17ADF + OST_Rooms = -2000160, // 0xFFE17AE0 + OST_GenericModel = -2000151, // 0xFFE17AE9 + OST_GenericAnnotation = -2000150, // 0xFFE17AEA + OST_Fixtures = -2000140, // 0xFFE17AF4 + OST_StairsRailingTags = -2000133, // 0xFFE17AFB + OST_StairsRailingAboveCut = -2000132, // 0xFFE17AFC + OST_StairsDownArrows = -2000131, // 0xFFE17AFD + OST_StairsUpArrows = -2000130, // 0xFFE17AFE + OST_StairsDownText = -2000129, // 0xFFE17AFF + OST_StairsRailingRail = -2000128, // 0xFFE17B00 + OST_StairsRailingBaluster = -2000127, // 0xFFE17B01 + OST_StairsRailing = -2000126, // 0xFFE17B02 + OST_StairsUpText = -2000125, // 0xFFE17B03 + OST_StairsSupportsAboveCut = -2000124, // 0xFFE17B04 + OST_StairsStringerCarriage = -2000123, // 0xFFE17B05 + OST_StairsAboveCut_ToBeDeprecated = -2000122, // 0xFFE17B06 + OST_StairsIncomplete_Deprecated = -2000121, // 0xFFE17B07 + OST_Stairs = -2000120, // 0xFFE17B08 + OST_IOSNavWheelPivotBall = -2000117, // 0xFFE17B0B + OST_IOSRoomComputationHeight = -2000116, // 0xFFE17B0C + OST_IOSRoomUpperLowerLines = -2000115, // 0xFFE17B0D + OST_IOSDragBoxInverted = -2000114, // 0xFFE17B0E + OST_IOSDragBox = -2000113, // 0xFFE17B0F + OST_Phases = -2000112, // 0xFFE17B10 + OST_IOS_GeoSite = -2000111, // 0xFFE17B11 + OST_IOS_GeoLocations = -2000110, // 0xFFE17B12 + OST_IOSFabricReinSpanSymbolCtrl = -2000109, // 0xFFE17B13 + OST_GuideGrid = -2000107, // 0xFFE17B15 + OST_EPS_Future = -2000106, // 0xFFE17B16 + OST_EPS_Temporary = -2000105, // 0xFFE17B17 + OST_EPS_New = -2000104, // 0xFFE17B18 + OST_EPS_Demolished = -2000103, // 0xFFE17B19 + OST_EPS_Existing = -2000102, // 0xFFE17B1A + OST_IOSMeasureLineScreenSize = -2000101, // 0xFFE17B1B + OST_Columns = -2000100, // 0xFFE17B1C + OST_IOSRebarSystemSpanSymbolCtrl = -2000099, // 0xFFE17B1D + OST_IOSRoomTagToRoomLines = -2000098, // 0xFFE17B1E + OST_IOSAttachedDetailGroups = -2000097, // 0xFFE17B1F + OST_IOSDetailGroups = -2000096, // 0xFFE17B20 + OST_IOSModelGroups = -2000095, // 0xFFE17B21 + OST_IOSSuspendedSketch = -2000094, // 0xFFE17B22 + OST_IOSWallCoreBoundary = -2000093, // 0xFFE17B23 + OST_IOSMeasureLine = -2000092, // 0xFFE17B24 + OST_IOSArrays = -2000091, // 0xFFE17B25 + OST_Curtain_Systems = -2000090, // 0xFFE17B26 + OST_IOSBBoxScreenSize = -2000089, // 0xFFE17B27 + OST_IOSSlabShapeEditorPointInterior = -2000088, // 0xFFE17B28 + OST_IOSSlabShapeEditorPointBoundary = -2000087, // 0xFFE17B29 + OST_IOSSlabShapeEditorBoundary = -2000086, // 0xFFE17B2A + OST_IOSSlabShapeEditorAutoCrease = -2000085, // 0xFFE17B2B + OST_IOSSlabShapeEditorExplitCrease = -2000084, // 0xFFE17B2C + OST_ReferenceLines = -2000083, // 0xFFE17B2D + OST_IOSNotSilhouette = -2000082, // 0xFFE17B2E + OST_FillPatterns = -2000081, // 0xFFE17B2F + OST_Furniture = -2000080, // 0xFFE17B30 + OST_AreaSchemeLines = -2000079, // 0xFFE17B31 + OST_GenericLines = -2000078, // 0xFFE17B32 + OST_InsulationLines = -2000077, // 0xFFE17B33 + OST_CloudLines = -2000076, // 0xFFE17B34 + OST_IOSRoomPerimeterLines = -2000075, // 0xFFE17B35 + OST_IOSCuttingGeometry = -2000074, // 0xFFE17B36 + OST_IOSCrashGraphics = -2000073, // 0xFFE17B37 + OST_IOSGroups = -2000072, // 0xFFE17B38 + OST_IOSGhost = -2000071, // 0xFFE17B39 + OST_StairsSketchLandingCenterLines = -2000070, // 0xFFE17B3A + OST_StairsSketchRunLines = -2000069, // 0xFFE17B3B + OST_StairsSketchRiserLines = -2000068, // 0xFFE17B3C + OST_StairsSketchBoundaryLines = -2000067, // 0xFFE17B3D + OST_RoomSeparationLines = -2000066, // 0xFFE17B3E + OST_AxisOfRotation = -2000065, // 0xFFE17B3F + OST_InvisibleLines = -2000064, // 0xFFE17B40 + OST_IOSThinPixel_DashDot = -2000063, // 0xFFE17B41 + OST_IOSThinPixel_Dash = -2000062, // 0xFFE17B42 + OST_IOSThinPixel_Dot = -2000061, // 0xFFE17B43 + OST_Extrusions = -2000060, // 0xFFE17B44 + OST_IOS = -2000059, // 0xFFE17B45 + OST_CutOutlines = -2000058, // 0xFFE17B46 + OST_IOSThinPixel = -2000057, // 0xFFE17B47 + OST_IOSFlipControl = -2000056, // 0xFFE17B48 + OST_IOSSketchGrid = -2000055, // 0xFFE17B49 + OST_IOSSuspendedSketch_obsolete = -2000054, // 0xFFE17B4A + OST_IOSFreeSnapLine = -2000053, // 0xFFE17B4B + OST_IOSDatumPlane = -2000052, // 0xFFE17B4C + OST_Lines = -2000051, // 0xFFE17B4D + OST_IOSConstructionLine = -2000050, // 0xFFE17B4E + OST_IOSAlignmentGraphics = -2000049, // 0xFFE17B4F + OST_IOSAligningLine = -2000048, // 0xFFE17B50 + OST_IOSBackedUpElements = -2000047, // 0xFFE17B51 + OST_IOSRegeneratedElements = -2000046, // 0xFFE17B52 + OST_SketchLines = -2000045, // 0xFFE17B53 + OST_CurvesWideLines = -2000044, // 0xFFE17B54 + OST_CurvesMediumLines = -2000043, // 0xFFE17B55 + OST_CurvesThinLines = -2000042, // 0xFFE17B56 + OST_Curves = -2000041, // 0xFFE17B57 + OST_CeilingsProjection = -2000040, // 0xFFE17B58 + OST_CeilingsCut = -2000039, // 0xFFE17B59 + OST_Ceilings = -2000038, // 0xFFE17B5A + OST_RoofsProjection = -2000037, // 0xFFE17B5B + OST_RoofsCut = -2000036, // 0xFFE17B5C + OST_Roofs = -2000035, // 0xFFE17B5D + OST_FloorsProjection = -2000034, // 0xFFE17B5E + OST_FloorsCut = -2000033, // 0xFFE17B5F + OST_Floors = -2000032, // 0xFFE17B60 + OST_DoorsGlassProjection = -2000031, // 0xFFE17B61 + OST_DoorsGlassCut = -2000030, // 0xFFE17B62 + OST_DoorsFrameMullionProjection = -2000029, // 0xFFE17B63 + OST_DoorsFrameMullionCut = -2000028, // 0xFFE17B64 + OST_DoorsOpeningProjection = -2000027, // 0xFFE17B65 + OST_DoorsOpeningCut = -2000026, // 0xFFE17B66 + OST_DoorsPanelProjection = -2000025, // 0xFFE17B67 + OST_DoorsPanelCut = -2000024, // 0xFFE17B68 + OST_Doors = -2000023, // 0xFFE17B69 + OST_WindowsOpeningProjection = -2000022, // 0xFFE17B6A + OST_WindowsOpeningCut = -2000021, // 0xFFE17B6B + OST_WindowsSillHeadProjection = -2000020, // 0xFFE17B6C + OST_WindowsSillHeadCut = -2000019, // 0xFFE17B6D + OST_WindowsFrameMullionProjection = -2000018, // 0xFFE17B6E + OST_WindowsFrameMullionCut = -2000017, // 0xFFE17B6F + OST_WindowsGlassProjection = -2000016, // 0xFFE17B70 + OST_WindowsGlassCut = -2000015, // 0xFFE17B71 + OST_Windows = -2000014, // 0xFFE17B72 + OST_WallsProjectionOutlines = -2000013, // 0xFFE17B73 + OST_WallsCutOutlines = -2000012, // 0xFFE17B74 + OST_Walls = -2000011, // 0xFFE17B75 + OST_IOSRegenerationFailure = -2000010, // 0xFFE17B76 + OST_ScheduleViewParamGroup = -2000008, // 0xFFE17B78 + OST_MatchSiteComponent = -2000007, // 0xFFE17B79 + OST_MatchProfile = -2000006, // 0xFFE17B7A + OST_MatchDetail = -2000005, // 0xFFE17B7B + OST_MatchAnnotation = -2000004, // 0xFFE17B7C + OST_MatchModel = -2000003, // 0xFFE17B7D + OST_MatchAll = -2000002, // 0xFFE17B7E + INVALID = -1, // 0xFFFFFFFF +} diff --git a/Speckle.Revit.Interfaces/Speckle.Revit.Interfaces.projitems b/Speckle.Revit.Interfaces/Speckle.Revit.Interfaces.projitems new file mode 100644 index 0000000..aedfe67 --- /dev/null +++ b/Speckle.Revit.Interfaces/Speckle.Revit.Interfaces.projitems @@ -0,0 +1,14 @@ + + + + $(MSBuildAllProjects);$(MSBuildThisFileFullPath) + true + 9655be78-8070-4b9f-b0dc-68bb6150b52e + + + Speckle.Revit.Interfaces + + + + + \ No newline at end of file diff --git a/Speckle.Revit.Interfaces/Speckle.Revit.Interfaces.shproj b/Speckle.Revit.Interfaces/Speckle.Revit.Interfaces.shproj new file mode 100644 index 0000000..c5f0083 --- /dev/null +++ b/Speckle.Revit.Interfaces/Speckle.Revit.Interfaces.shproj @@ -0,0 +1,13 @@ + + + + {E1C43415-3200-45F4-8BF9-A4DD7D7F2ED6} + 14.0 + + + + + + + + \ No newline at end of file diff --git a/Speckle.Revit2023.Api/Speckle.Revit2023.Api.csproj b/Speckle.Revit2023.Api/Speckle.Revit2023.Api.csproj new file mode 100644 index 0000000..63e75b0 --- /dev/null +++ b/Speckle.Revit2023.Api/Speckle.Revit2023.Api.csproj @@ -0,0 +1,17 @@ + + + + net48 + x64 + + + + + + + + + + + + diff --git a/Speckle.Revit2023.Api/packages.lock.json b/Speckle.Revit2023.Api/packages.lock.json new file mode 100644 index 0000000..8e3c8b2 --- /dev/null +++ b/Speckle.Revit2023.Api/packages.lock.json @@ -0,0 +1,48 @@ +{ + "version": 2, + "dependencies": { + ".NETFramework,Version=v4.8": { + "Mapster": { + "type": "Direct", + "requested": "[7.3.0, )", + "resolved": "7.3.0", + "contentHash": "NrCUX/rJa5PTyo6iW4AL5dZLU9PDNlYnrJOVjgdpo5OQM9EtWH2CMHnC5sSuJWC0d0b0SnmeRrIviEem6WxtuQ==", + "dependencies": { + "Mapster.Core": "1.2.0", + "Microsoft.CSharp": "4.3.0", + "System.Reflection.Emit": "4.3.0" + } + }, + "Speckle.ProxyGenerator": { + "type": "Direct", + "requested": "[0.1.6, )", + "resolved": "0.1.6", + "contentHash": "SO9Udllol9Krpq+UFBr54Es79kmiIQmtSRXKFcvplnisdwmjo5CBlucuuvgZYmQUSvF/9KC4BcuVllZRTCBDHQ==" + }, + "Speckle.Revit.API": { + "type": "Direct", + "requested": "[2023.0.0, )", + "resolved": "2023.0.0", + "contentHash": "tq40eD7psgTbV+epNouYyqfo6+hEi7FmXZqcxEOsAV7zfYyWhL6Rt3vmojkWGNuerGbH6oRI6KIIxrnlCNb8Hw==" + }, + "Mapster.Core": { + "type": "Transitive", + "resolved": "1.2.0", + "contentHash": "TNdqZk2zAuBYfJF88D/3clQTOyOdqr1crU81yZQtlGa+e7FYWhJdK/buBWT+TpM3qQko9UzmzfOT4iq3JCs/ZA==" + }, + "Microsoft.CSharp": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "P+MBhIM0YX+JqROuf7i306ZLJEjQYA9uUyRDE+OqwUI5sh41e2ZbPQV3LfAPh+29cmceE1pUffXsGfR4eMY3KA==" + }, + "System.Reflection.Emit": { + "type": "Transitive", + "resolved": "4.3.0", + "contentHash": "228FG0jLcIwTVJyz8CLFKueVqQK36ANazUManGaJHkO0icjiIypKW7YLWLIWahyIkdh5M7mV2dJepllLyA1SKg==" + }, + "speckle.revit2023.interfaces": { + "type": "Project" + } + } + } +} \ No newline at end of file diff --git a/Speckle.Revit2023.Interfaces/Speckle.Revit2023.Interfaces.csproj b/Speckle.Revit2023.Interfaces/Speckle.Revit2023.Interfaces.csproj new file mode 100644 index 0000000..64dbb45 --- /dev/null +++ b/Speckle.Revit2023.Interfaces/Speckle.Revit2023.Interfaces.csproj @@ -0,0 +1,6 @@ + + + netstandard2.0 + + + diff --git a/Speckle.Revit2023.Interfaces/packages.lock.json b/Speckle.Revit2023.Interfaces/packages.lock.json new file mode 100644 index 0000000..5224309 --- /dev/null +++ b/Speckle.Revit2023.Interfaces/packages.lock.json @@ -0,0 +1,21 @@ +{ + "version": 2, + "dependencies": { + ".NETStandard,Version=v2.0": { + "NETStandard.Library": { + "type": "Direct", + "requested": "[2.0.3, )", + "resolved": "2.0.3", + "contentHash": "st47PosZSHrjECdjeIzZQbzivYBJFv6P2nv4cj2ypdI204DO+vZ7l5raGMiX4eXMJ53RfOIg+/s4DHVZ54Nu2A==", + "dependencies": { + "Microsoft.NETCore.Platforms": "1.1.0" + } + }, + "Microsoft.NETCore.Platforms": { + "type": "Transitive", + "resolved": "1.1.0", + "contentHash": "kz0PEW2lhqygehI/d6XsPCQzD7ff7gUJaVGPVETX611eadGsA3A877GdSlU0LRVMCTH/+P3o2iDTak+S08V2+A==" + } + } + } +} \ No newline at end of file diff --git a/global.json b/global.json new file mode 100644 index 0000000..c19a2e0 --- /dev/null +++ b/global.json @@ -0,0 +1,6 @@ +{ + "sdk": { + "version": "8.0.100", + "rollForward": "latestMinor" + } +}