package SystemRequirements {
  private import ScalarValues::*;
  private import Requirements::*;
  public import ModelingMetadata::*;
  public import RequirementDerivation::*;

  metadata def <trace> Trace { :>> annotatedElement : SysML::Dependency; }
  part def Developer;
  part def SystemOperator;
  part def User;
  part def Administrator;
  part def Customer;
  part def SystemAdmin;

  requirement def MutableBSONInterface {
    subject;
    doc /* The C++ client driver shall provide a mutable BSON abstraction interface for document manipulation */
    attribute id : String = "REQ-001";
    attribute interface_available : Boolean;
    attribute abstraction_level : String;
    stakeholder developer : Developer;
    require constraint InterfaceProvision { interface_available == true and abstraction_level == "mutable" }
    }

  requirement def MutableBSONImplementation {
    subject;
    doc /* The C++ client driver shall implement mutable BSON functionality for runtime document operations */
    attribute id : String = "REQ-002";
    attribute runtime_operations_supported : Boolean;
    attribute functionality_implemented : Boolean;
    stakeholder developer : Developer;
    require constraint FunctionalityImplementation { functionality_implemented == true and runtime_operations_supported == true }
    }

  requirement def DocumentationStandardsUpdate {
    subject;
    doc /* The documentation system shall update all outdated C++ driver documentation pages to current standards */
    attribute id : String = "REQ-003";
    attribute pages_updated : Boolean;
    attribute standards_compliance : Boolean;
    stakeholder developer : Developer;
    require constraint StandardsCompliance { pages_updated == true implies standards_compliance == true }
    }

  requirement def DocumentationMigration {
    subject;
    doc /* The documentation system shall migrate C++ driver documentation to appropriate repository locations */
    attribute id : String = "REQ-004";
    attribute migration_completed : Boolean;
    attribute target_locations_identified : Boolean;
    stakeholder developer : Developer;
    require constraint MigrationCompletion { target_locations_identified == true implies migration_completed == true }
    }

  requirement def DocumentationWikiMigration {
    subject;
    doc /* The documentation system shall migrate C++ driver documentation to the repository wiki */
    attribute id : String = "REQ-004.1";
    attribute wiki_migration_completed : Boolean;
    stakeholder developer : Developer;
    require constraint WikiMigrationCompletion { wiki_migration_completed == true }
    }

  requirement def DocumentationReadmeMigration {
    subject;
    doc /* The documentation system shall migrate C++ driver documentation to branch READMEs */
    attribute id : String = "REQ-004.2";
    attribute readme_migration_completed : Boolean;
    stakeholder developer : Developer;
    require constraint ReadmeMigrationCompletion { readme_migration_completed == true }
    }

  requirement def BoostMutexUsage {
    subject;
    doc /* The C++ client driver shall use boost::mutex instead of custom mutex wrapper classes */
    attribute id : String = "REQ-005";
    attribute boost_mutex_used : Boolean;
    attribute custom_wrappers_removed : Boolean;
    stakeholder developer : Developer;
    require constraint MutexStandardization { boost_mutex_used == true and custom_wrappers_removed == true }
    }

  requirement def ListenFilesRemoval {
    subject;
    doc /* The C++ client driver shall remove listen.h and listen.cpp files from the codebase */
    attribute id : String = "REQ-006";
    attribute listen_files_removed : Boolean;
    stakeholder developer : Developer;
    require constraint ListenFilesRemoval { listen_files_removed == true }
    }

  requirement def ShardingDirectoryRemoval {
    subject;
    doc /* The C++ client driver shall remove all files in the src/mongo/s/ directory */
    attribute id : String = "REQ-007";
    attribute sharding_directory_removed : Boolean;
    stakeholder developer : Developer;
    require constraint ShardingDirectoryRemoval { sharding_directory_removed == true }
    }

  requirement def CollectionSizeManagement {
    subject;
    doc /* The insert_demo application shall implement collection size management to prevent unbounded growth */
    attribute id : String = "REQ-008";
    attribute size_management_implemented : Boolean;
    attribute unbounded_growth_prevented : Boolean;
    stakeholder developer : Developer;
    require constraint SizeManagementPrevention { size_management_implemented == true implies unbounded_growth_prevented == true }
    }

  requirement def WindowsDLLVersions {
    subject;
    doc /* The Windows build system shall produce two DLL versions with different names for debug and release runtimes */
    attribute id : String = "REQ-009";
    attribute debug_dll_produced : Boolean;
    attribute release_dll_produced : Boolean;
    attribute different_names_used : Boolean;
    stakeholder developer : Developer;
    require constraint DualDLLProduction { debug_dll_produced == true and release_dll_produced == true and different_names_used == true }
    }

  requirement def WindowsDebugDLL {
    subject;
    doc /* The Windows build system shall produce a DLL version with a specific name for debug runtime */
    attribute id : String = "REQ-009.1";
    attribute debug_dll_name_specific : Boolean;
    stakeholder developer : Developer;
    require constraint DebugDLLNaming { debug_dll_name_specific == true }
    }

  requirement def WindowsReleaseDLL {
    subject;
    doc /* The Windows build system shall produce a DLL version with a specific name for release runtime */
    attribute id : String = "REQ-009.2";
    attribute release_dll_name_specific : Boolean;
    stakeholder developer : Developer;
    require constraint ReleaseDLLNaming { release_dll_name_specific == true }
    }

  requirement def DLLNameDifferentiation {
    subject;
    doc /* The debug and release DLL versions shall have different names */
    attribute id : String = "REQ-009.3";
    attribute dll_names_different : Boolean;
    stakeholder developer : Developer;
    require constraint DLLNameDifferentiation { dll_names_different == true }
    }

  requirement def DynamicBoostOption {
    subject;
    doc /* The build system shall provide a --dynamic-boost option to select between dynamic and static boost linking */
    attribute id : String = "REQ-010";
    attribute dynamic_boost_option_available : Boolean;
    attribute linking_selection_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint BoostLinkingOption { dynamic_boost_option_available == true implies linking_selection_enabled == true }
    }

  requirement def WinSockInitialization {
    subject;
    doc /* The C++ client driver shall initialize WinSock using the mongo initializer system instead of global objects */
    attribute id : String = "REQ-011";
    attribute winsock_mongo_initializer_used : Boolean;
    attribute global_objects_removed : Boolean;
    stakeholder developer : Developer;
    require constraint WinSockInitializerUsage { winsock_mongo_initializer_used == true and global_objects_removed == true }
    }

  requirement def WindowsCallingConvention {
    subject;
    doc /* The SConstruct build system shall provide an option to specify the default Windows calling convention */
    attribute id : String = "REQ-012";
    attribute calling_convention_option_available : Boolean;
    attribute default_convention_configurable : Boolean;
    stakeholder developer : Developer;
    require constraint CallingConventionOption { calling_convention_option_available == true implies default_convention_configurable == true }
    }

  requirement def ProgrammaticVersionInfo {
    subject;
    doc /* The C++ driver headers shall provide version information that can be determined programmatically */
    attribute id : String = "REQ-013";
    attribute version_info_programmatic : Boolean;
    attribute headers_provide_version : Boolean;
    stakeholder developer : Developer;
    require constraint ProgrammaticVersionAccess { headers_provide_version == true implies version_info_programmatic == true }
    }

  requirement def PreprocessorVersionMacros {
    subject;
    doc /* The C++ driver shall define preprocessor macros for version identification */
    attribute id : String = "REQ-014";
    attribute version_macros_defined : Boolean;
    attribute preprocessor_identification_available : Boolean;
    stakeholder developer : Developer;
    require constraint VersionMacroDefinition { version_macros_defined == true implies preprocessor_identification_available == true }
    }

  requirement def PrecompiledHeaderRemoval {
    subject;
    doc /* The C++ client driver shall remove precompiled header support and the pch.h file */
    attribute id : String = "REQ-015";
    attribute precompiled_header_removed : Boolean;
    attribute pch_file_removed : Boolean;
    stakeholder developer : Developer;
    require constraint PrecompiledHeaderElimination { precompiled_header_removed == true and pch_file_removed == true }
    }

  requirement def WindowsRuntimeFlag {
    subject;
    doc /* The Windows build system shall default to using the /MD runtime flag for C++ client driver builds */
    attribute id : String = "REQ-016";
    attribute md_runtime_flag_default : Boolean;
    attribute windows_build_configured : Boolean;
    stakeholder developer : Developer;
    require constraint RuntimeFlagDefault { windows_build_configured == true implies md_runtime_flag_default == true }
    }

  requirement def VersionFilesRework {
    subject;
    doc /* The C++ client driver shall rework version.h and buildinfo.cpp files to provide client-relevant information */
    attribute id : String = "REQ-017";
    attribute version_files_reworked : Boolean;
    attribute client_relevant_info_provided : Boolean;
    stakeholder developer : Developer;
    require constraint FilesReworkedForClient { version_files_reworked == true implies client_relevant_info_provided == true }
    }

  requirement def VersionHeaderRework {
    subject;
    doc /* The C++ client driver shall rework version.h file to provide client-relevant information */
    attribute id : String = "REQ-017.1";
    attribute version_header_reworked : Boolean;
    attribute client_info_request_received : Boolean;
    stakeholder developer : Developer;
    require constraint HeaderReworkTriggered { client_info_request_received == true implies version_header_reworked == true }
    }

  requirement def BuildInfoRework {
    subject;
    doc /* The C++ client driver shall rework buildinfo.cpp file to provide client-relevant information */
    attribute id : String = "REQ-017.2";
    attribute buildinfo_file_reworked : Boolean;
    attribute client_info_request_received : Boolean;
    stakeholder developer : Developer;
    require constraint BuildInfoReworkTriggered { client_info_request_received == true implies buildinfo_file_reworked == true }
    }

  requirement def SignalHandlingRemoval {
    subject;
    doc /* The C++ client library shall remove signal handling functionality from the codebase */
    attribute id : String = "REQ-018";
    attribute signal_handling_removed : Boolean;
    attribute cleanup_task_initiated : Boolean;
    stakeholder developer : Developer;
    require constraint SignalHandlingCleanup { cleanup_task_initiated == true implies signal_handling_removed == true }
    }

  requirement def ExitCallsRemoval {
    subject;
    doc /* The C++ client library shall remove _exit calls from the codebase */
    attribute id : String = "REQ-019";
    attribute exit_calls_removed : Boolean;
    attribute cleanup_task_initiated : Boolean;
    stakeholder developer : Developer;
    require constraint ExitCallsCleanup { cleanup_task_initiated == true implies exit_calls_removed == true }
    }

  requirement def DebuggerSupportRemoval {
    subject;
    doc /* The C++ client library shall remove debugger support functionality from the codebase */
    attribute id : String = "REQ-020";
    attribute debugger_support_removed : Boolean;
    attribute cleanup_task_initiated : Boolean;
    stakeholder developer : Developer;
    require constraint DebuggerSupportCleanup { cleanup_task_initiated == true implies debugger_support_removed == true }
    }

  requirement def BSONBuilderBaseRemoval {
    subject;
    doc /* The C++ client driver shall remove the unused BSONBuilderBase base class */
    attribute id : String = "REQ-021";
    attribute bson_builder_base_removed : Boolean;
    attribute cleanup_task_initiated : Boolean;
    stakeholder developer : Developer;
    require constraint BSONBuilderBaseCleanup { cleanup_task_initiated == true implies bson_builder_base_removed == true }
    }

  requirement def NamespaceDeclarationRestriction {
    subject;
    doc /* The client-facing headers shall not use 'using namespace std' declarations in header scope */
    attribute id : String = "REQ-022";
    attribute namespace_declarations_restricted : Boolean;
    attribute header_scope_clean : Boolean;
    stakeholder developer : Developer;
    require constraint NamespaceRestrictionEnforced { namespace_declarations_restricted == true implies header_scope_clean == true }
    }

  requirement def ConfigHeaderGeneration {
    subject;
    doc /* The C++ client driver shall generate a config.h header that captures preprocessor define values */
    attribute id : String = "REQ-023";
    attribute config_header_generated : Boolean;
    attribute preprocessor_values_captured : Boolean;
    stakeholder developer : Developer;
    require constraint ConfigHeaderCapture { config_header_generated == true implies preprocessor_values_captured == true }
    }

  requirement def ConfigHeaderInclusion {
    subject;
    doc /* The config.h header shall be included by mongoclient headers to ensure consistent preprocessor definitions */
    attribute id : String = "REQ-024";
    attribute config_header_included : Boolean;
    attribute consistent_definitions_ensured : Boolean;
    stakeholder developer : Developer;
    require constraint ConfigHeaderConsistency { config_header_included == true implies consistent_definitions_ensured == true }
    }

  requirement def BSONHeaderReachability {
    subject;
    doc /* The driver installation shall include only headers that are reachable through bson.h */
    attribute id : String = "REQ-036";
    attribute headers_reachable_only : Boolean;
    attribute entry_header : String = "bson.h";
    attribute installation_compliant : Boolean;
    stakeholder developer : Developer;
    require constraint HeaderReachabilityCompliance { headers_reachable_only == true implies installation_compliant == true }
    }

  requirement def DBClientHeaderReachability {
    subject;
    doc /* The driver installation shall include only headers that are reachable through dbclient.h */
    attribute id : String = "REQ-037";
    attribute headers_reachable_only : Boolean;
    attribute entry_header : String = "dbclient.h";
    attribute installation_compliant : Boolean;
    stakeholder developer : Developer;
    require constraint DBClientHeaderCompliance { headers_reachable_only == true implies installation_compliant == true }
    }

  requirement def ClientInitializationPortOption {
    subject;
    doc /* The C++ driver shall provide a client initialization options structure containing default MongoDB port */
    attribute id : String = "REQ-064";
    attribute default_mongodb_port : Integer = 27017;
    attribute options_structure_available : Boolean;
    attribute port_configurable : Boolean;
    stakeholder developer : Developer;
    require constraint PortOptionsAvailable { options_structure_available == true and port_configurable == true }
    }

  requirement def ClientInitializationSSLOptions {
    subject;
    doc /* The C++ driver shall provide a client initialization options structure containing SSL configuration options */
    attribute id : String = "REQ-065";
    attribute ssl_options_available : Boolean;
    attribute ssl_configurable : Boolean;
    attribute options_structure_complete : Boolean;
    stakeholder developer : Developer;
    require constraint SSLOptionsComplete { ssl_options_available == true and ssl_configurable == true and options_structure_complete == true }
    }

  requirement def WindowsAutolibSupport {
    subject;
    doc /* The C++ driver shall support autolib linking on Windows */
    attribute id : String = "REQ-054";
    attribute autolib_enabled : Boolean;
    attribute windows_platform : Boolean;
    attribute linking_automatic : Boolean;
    stakeholder developer : Developer;
    require constraint WindowsAutolibEnabled { windows_platform == true implies autolib_enabled == true and linking_automatic == true }
    }

  requirement def ODRViolationPrevention {
    subject;
    doc /* The driver shall prevent ODR violations by ensuring AtomicWord and AtomicIntrinsics implementation choices are fixed at build time */
    attribute id : String = "REQ-068";
    attribute atomic_word_implementation_fixed : Boolean;
    attribute atomic_intrinsics_implementation_fixed : Boolean;
    attribute odr_violations_prevented : Boolean;
    stakeholder developer : Developer;
    require constraint ODRViolationPrevention { atomic_word_implementation_fixed == true and atomic_intrinsics_implementation_fixed == true implies odr_violations_prevented == true }
    }

  requirement def FromJsonArraySupport {
    subject;
    doc /* The mongo::fromjson function shall accept JSON strings with outermost arrays */
    attribute id : String = "REQ-079";
    attribute accepts_array_input : Boolean;
    attribute json_input_type : String;
    stakeholder developer : Developer;
    require constraint ArrayInputAcceptance { json_input_type == "array" implies accepts_array_input == true }
    }

  requirement def BSONArrayJsonOutput {
    subject;
    doc /* The BSONArray class shall implement a jsonString() method that outputs arrays using square bracket notation */
    attribute id : String = "REQ-081";
    attribute has_json_string_method : Boolean;
    attribute uses_square_brackets : Boolean;
    attribute output_format : String = "square_bracket_notation";
    stakeholder developer : Developer;
    require constraint JsonStringSquareBrackets { has_json_string_method == true implies uses_square_brackets == true }
    }

  requirement def FromJsonTypeParameter {
    subject;
    doc /* The mongo::fromjson function shall provide an optional boolean parameter to specify whether the input is an array or object */
    attribute id : String = "REQ-080";
    attribute has_type_parameter : Boolean;
    attribute parameter_is_optional : Boolean;
    attribute parameter_type : String = "boolean";
    stakeholder developer : Developer;
    require constraint TypeParameterAvailability { parameter_is_optional == true and parameter_type == "boolean" implies has_type_parameter == true }
    }

  requirement def BSONArrayBuilderAppendRegex {
    subject;
    doc /* The BSONArrayBuilder class shall provide an appendRegex method to support regex elements in BSON arrays */
    attribute id : String = "REQ-100";
    attribute appendRegex_method_available : Boolean;
    attribute regex_elements_supported : Boolean;
    attribute bson_array_compatibility : Boolean;
    stakeholder developer : Developer;
    require constraint AppendRegexMethodProvision { appendRegex_method_available == true and regex_elements_supported == true }
    require constraint BSONArrayCompatibility { appendRegex_method_available == true implies bson_array_compatibility == true }
    }

  requirement def ServerVersionPopulationTiming {
    subject;
    doc /* The MongoDB C++ driver shall populate server version specific values upon the first database request rather than during connection */
    attribute id : String = "REQ-098";
    attribute server_version_populated : Boolean;
    attribute connection_phase_complete : Boolean;
    attribute first_request_initiated : Boolean;
    attribute version_values_available : Boolean;
    stakeholder developer : Developer;
    require constraint DeferredVersionPopulation { connection_phase_complete == true and server_version_populated == false implies first_request_initiated == false }
    require constraint VersionAvailabilityTiming { first_request_initiated == true implies version_values_available == true }
    }

  requirement def BSONArrayBuilderMethods {
    subject;
    doc /* The BSONArrayBuilder class shall provide missing appendX methods that are available in BSONObjBuilder */
    attribute id : String = "REQ-099";
    attribute appendX_methods_available : Boolean;
    attribute bsonObjBuilder_methods_count : Integer;
    attribute bsonArrayBuilder_methods_count : Integer;
    attribute method_parity_achieved : Boolean;
    stakeholder developer : Developer;
    require constraint MethodAvailability { appendX_methods_available == true implies method_parity_achieved == true }
    require constraint MethodCountParity { bsonArrayBuilder_methods_count >= bsonObjBuilder_methods_count implies method_parity_achieved == true }
    }

  requirement def DeferredIsMasterCalls {
    subject;
    doc /* The MongoDB C++ driver shall defer isMaster calls until the first database operation request instead of executing during connection establishment */
    attribute id : String = "REQ-097";
    attribute isMaster_deferred : Boolean;
    attribute connection_established : Boolean;
    attribute first_operation_requested : Boolean;
    attribute isMaster_executed : Boolean;
    stakeholder developer : Developer;
    require constraint IsMasterDeferral { connection_established == true and isMaster_executed == false implies isMaster_deferred == true }
    require constraint IsMasterExecutionTiming { first_operation_requested == true implies isMaster_executed == true }
    }

  requirement def AppendRegexParameterConsistency {
    subject;
    doc /* The BSONArrayBuilder appendRegex method shall accept regex pattern and flags parameters consistent with BSONObjBuilder appendRegex implementation */
    attribute id : String = "REQ-101";
    attribute regex_pattern_parameter : Boolean;
    attribute flags_parameter : Boolean;
    attribute parameter_consistency_maintained : Boolean;
    attribute bsonObjBuilder_compatibility : Boolean;
    stakeholder developer : Developer;
    require constraint ParameterSupport { regex_pattern_parameter == true and flags_parameter == true }
    require constraint ConsistencyMaintenance { parameter_consistency_maintained == true implies bsonObjBuilder_compatibility == true }
    }

  requirement def BSONStrictAliasingCompliance {
    subject;
    doc /* The BSON library headers shall compile without strict aliasing warnings */
    attribute id : String = "REQ-131";
    attribute compilation_warnings_count : Integer = 0;
    attribute strict_aliasing_compliant : Boolean;
    stakeholder developer : Developer;
    require constraint NoStrictAliasingWarnings { strict_aliasing_compliant == true implies compilation_warnings_count == 0 }
    }

  requirement def BSONMemcpyUsage {
    subject;
    doc /* The BSON headers shall use memcpy calls instead of unaligned memory access casts */
    attribute id : String = "REQ-130";
    attribute memory_access_method : String = "memcpy";
    attribute avoids_unaligned_casts : Boolean;
    attribute uses_memcpy_calls : Boolean;
    stakeholder developer : Developer;
    require constraint MemoryAccessMethod { memory_access_method == "memcpy" implies uses_memcpy_calls == true and avoids_unaligned_casts == true }
    }

  requirement def StaticDestructorSafety {
    subject;
    doc /* The driver shall support safe execution of static object destructors during process termination */
    attribute id : String = "REQ-127";
    attribute static_destructors_safe : Boolean;
    attribute process_termination_handled : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint SafeDestructorExecution { static_destructors_safe == true and process_termination_handled == true }
    }

  requirement def ClientShutdownThreadManagement {
    subject;
    doc /* The mongo::client::shutdown() function shall stop all threads created by initialize() when called */
    attribute id : String = "REQ-111";
    attribute function_name : String = "mongo::client::shutdown";
    attribute stops_all_threads : Boolean;
    attribute threads_created_by_initialize : Boolean;
    stakeholder developer : Developer;
    require constraint ShutdownStopsThreads { threads_created_by_initialize == true implies stops_all_threads == true }
    }

  requirement def BSONIntegerEndianConversion {
    subject;
    doc /* The BSON library shall apply endian conversions for integer encoding on big-endian systems */
    attribute id : String = "REQ-128";
    attribute data_type : String = "integer";
    attribute system_type : String = "big-endian";
    attribute endian_conversion_applied : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint IntegerEndianConversion { data_type == "integer" and system_type == "big-endian" implies endian_conversion_applied == true }
    }

  requirement def ClientInitLoggingOptions {
    subject;
    doc /* The mongo::client::init function shall accept Options argument for logging configuration */
    attribute id : String = "REQ-118";
    attribute function_name : String = "mongo::client::init";
    attribute parameter_name : String = "Options";
    attribute logging_configuration_supported : Boolean;
    attribute options_argument_accepted : Boolean;
    stakeholder developer : Developer;
    require constraint InitLoggingOptions { function_name == "mongo::client::init" and parameter_name == "Options" implies options_argument_accepted == true and logging_configuration_supported == true }
    }

  requirement def BSONDoubleEndianConversion {
    subject;
    doc /* The BSON library shall apply endian conversions for double encoding on big-endian systems */
    attribute id : String = "REQ-129";
    attribute data_type : String = "double";
    attribute system_type : String = "big-endian";
    attribute endian_conversion_applied : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint DoubleEndianConversion { data_type == "double" and system_type == "big-endian" implies endian_conversion_applied == true }
    }

  requirement def DeprecatedConnectionStringParsing {
    subject;
    doc /* The driver shall provide a separate parsing function to handle deprecated internal connection string format */
    attribute id : String = "REQ-109";
    attribute parsing_function_provided : Boolean;
    attribute handles_deprecated_format : Boolean;
    attribute separate_function_exists : Boolean;
    stakeholder developer : Developer;
    require constraint SeparateParsingFunction { parsing_function_provided == true and separate_function_exists == true and handles_deprecated_format == true }
    }

  requirement def ConnectionStringValidation {
    subject;
    doc /* The ConnectionString::parse function shall accept only valid MongoDB connection strings starting with mongodb:// */
    attribute id : String = "REQ-108";
    attribute function_name : String = "ConnectionString::parse";
    attribute required_prefix : String = "mongodb://";
    attribute validates_format : Boolean;
    attribute accepts_valid_strings : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint MongoDBConnectionStringValidation { required_prefix == "mongodb://" implies validates_format == true and accepts_valid_strings == true }
    }

  requirement def ClusterTestingSupport {
    subject;
    doc /* The driver shall support cluster testing via Mongo Orchestration */
    attribute id : String = "REQ-114";
    attribute testing_framework : String = "Mongo Orchestration";
    attribute cluster_testing_supported : Boolean;
    stakeholder developer : Developer;
    require constraint TestingFrameworkSupport { testing_framework == "Mongo Orchestration" implies cluster_testing_supported == true }
    }

  requirement def BigEndianArchitectureSupport {
    subject;
    doc /* The MongoDB C++ driver shall function correctly on strictly aligned big-endian architectures */
    attribute id : String = "REQ-146";
    attribute big_endian_architecture : Boolean;
    attribute strict_alignment_required : Boolean;
    attribute functionality_correct : Boolean;
    stakeholder developer : Developer;
    require constraint BigEndianFunctionality { big_endian_architecture == true and strict_alignment_required == true implies functionality_correct == true }
    }

  requirement def EvalNolockOptionSupport {
    subject;
    doc /* The DBClientWithCommands::eval function shall support the nolock option parameter */
    attribute id : String = "REQ-174";
    attribute function_name : String = "DBClientWithCommands::eval";
    attribute nolock_option_supported : Boolean;
    attribute option_parameter_name : String = "nolock";
    stakeholder developer : Developer;
    require constraint NolockOptionAvailable { nolock_option_supported == true }
    }

  requirement def BSONLibraryProductionReadiness {
    subject;
    doc /* The C++11 BSON library shall be brought to a production-ready shippable state */
    attribute id : String = "REQ-185";
    attribute production_ready : Boolean;
    attribute shippable_state : Boolean;
    attribute meets_production_standards : Boolean;
    stakeholder developer : Developer;
    stakeholder customer : Customer;
    require constraint ProductionReadiness { production_ready == true and shippable_state == true and meets_production_standards == true }
    }

  requirement def DollarKeyValidationConfiguration {
    subject;
    doc /* The bsoncxx validator shall support dollar key validation configuration */
    attribute id : String = "REQ-183";
    attribute supports_dollar_key_validation : Boolean;
    attribute dollar_key_config_available : Boolean;
    stakeholder developer : Developer;
    require constraint DollarKeyValidation { supports_dollar_key_validation == true and dollar_key_config_available == true }
    }

  requirement def UTF8ValidationConfiguration {
    subject;
    doc /* The bsoncxx validator shall support UTF-8 validation configuration */
    attribute id : String = "REQ-182";
    attribute supports_utf8_validation : Boolean;
    attribute utf8_config_available : Boolean;
    stakeholder developer : Developer;
    require constraint UTF8Validation { supports_utf8_validation == true and utf8_config_available == true }
    }

  requirement def ValidationSuccessReturn {
    subject;
    doc /* The bsoncxx validation method shall return an engaged std::optional<document::view> on successful validation */
    attribute id : String = "REQ-180";
    attribute returns_engaged_optional : Boolean;
    attribute returns_document_view : Boolean;
    stakeholder developer : Developer;
    require constraint EngagedOptionalReturn { returns_engaged_optional == true and returns_document_view == true }
    }

  requirement def DotKeyValidationConfiguration {
    subject;
    doc /* The bsoncxx validator shall support dot key validation configuration */
    attribute id : String = "REQ-184";
    attribute supports_dot_key_validation : Boolean;
    attribute dot_key_config_available : Boolean;
    stakeholder developer : Developer;
    require constraint DotKeyValidation { supports_dot_key_validation == true and dot_key_config_available == true }
    }

  requirement def GCCVersionSupport {
    subject;
    doc /* The compiler support system shall support GCC version 4.8.2 */
    attribute id : String = "REQ-257";
    attribute gcc_version_target : String = "4.8.2";
    attribute compiler_support_enabled : Boolean;
    attribute version_compatibility_verified : Boolean;
    stakeholder developer : Developer;
    require constraint GCCVersionCompatibility { gcc_version_target == "4.8.2" implies compiler_support_enabled == true and version_compatibility_verified == true }
    }

  requirement def Decimal128DecodingErrorMessages {
    subject;
    doc /* The BSON library shall provide user-friendly error messages when decoding fails for Decimal128 BSONElements */
    attribute id : String = "REQ-280";
    attribute error_message_provided : Boolean;
    attribute decoding_failed : Boolean;
    attribute element_type : String = "Decimal128";
    attribute message_user_friendly : Boolean;
    stakeholder developer : Developer;
    require constraint ErrorMessageOnFailure { decoding_failed == true implies error_message_provided == true }
    require constraint UserFriendlyMessage { error_message_provided == true implies message_user_friendly == true }
    }

  requirement def Decimal128FormatValidation {
    subject;
    doc /* The BSON library shall detect invalid Decimal128 format during BSONElement decoding operations */
    attribute id : String = "REQ-281";
    attribute format_validation_enabled : Boolean;
    attribute invalid_format_detected : Boolean;
    attribute decoding_operation_active : Boolean;
    attribute element_type : String = "Decimal128";
    stakeholder developer : Developer;
    require constraint ValidationDuringDecoding { decoding_operation_active == true implies format_validation_enabled == true }
    require constraint InvalidFormatDetection { format_validation_enabled == true and decoding_operation_active == true implies invalid_format_detected == true }
    }

  requirement def Decimal128ErrorContextInformation {
    subject;
    doc /* The BSON library shall include specific error context information when Decimal128 BSONElement decoding fails */
    attribute id : String = "REQ-282";
    attribute context_information_included : Boolean;
    attribute error_context_specific : Boolean;
    attribute decoding_failed : Boolean;
    attribute element_type : String = "Decimal128";
    stakeholder developer : Developer;
    require constraint ContextOnFailure { decoding_failed == true implies context_information_included == true }
    require constraint SpecificContext { context_information_included == true implies error_context_specific == true }
    }

  requirement def GenericInternalErrorCode {
    subject;
    doc /* The bsoncxx library shall provide a generic internal error code for situations where an error occurred but specific error information is unavailable */
    attribute id : String = "REQ-304";
    attribute error_code_provided : Boolean;
    attribute specific_error_info_available : Boolean;
    attribute generic_error_code_used : Boolean;
    stakeholder developer : Developer;
    require constraint GenericErrorCodeCheck { specific_error_info_available == false implies generic_error_code_used == true }
    }

  requirement def CDriverVersionRequirement {
    subject;
    doc /* The MongoDB C++ driver shall require C driver version 1.10.0 or higher */
    attribute id : String = "REQ-425";
    attribute min_c_driver_version : String = "1.10.0";
    attribute version_requirement_type : String = "minimum";
    attribute version_requirement_met : Boolean;
    stakeholder developer : Developer;
    require constraint VersionRequirementCheck { min_c_driver_version == "1.10.0" and version_requirement_type == "minimum" implies version_requirement_met == true }
    }

  requirement def MongoDBVersionSupport {
    subject;
    doc /* The MongoDB C++ driver shall not support MongoDB version 2.6 */
    attribute id : String = "REQ-415";
    attribute unsupported_version : String = "2.6";
    attribute version_supported : Boolean = false;
    stakeholder developer : Developer;
    require constraint VersionSupportRestrictionCheck { unsupported_version == "2.6" implies version_supported == false }
    }

  requirement def CDriverVersionRequirement_REQ559 {
    subject;
    doc /* The driver shall require C driver version 1.17.0-beta2 or later */
    attribute id : String = "REQ-559";
    attribute min_c_driver_version : String = "1.17.0-beta2";
    attribute version_requirement_enforced : Boolean = true;
    attribute later_versions_accepted : Boolean = true;
    stakeholder developer : Developer;
    require constraint VersionRequirement { min_c_driver_version == "1.17.0-beta2" implies version_requirement_enforced == true and later_versions_accepted == true }
    }

  #refinement dependency from SystemRequirements::DocumentationWikiMigration to SystemRequirements::DocumentationMigration;
  #refinement dependency from SystemRequirements::DocumentationReadmeMigration to SystemRequirements::DocumentationMigration;
  #refinement dependency from SystemRequirements::WindowsDebugDLL to SystemRequirements::WindowsDLLVersions;
  #refinement dependency from SystemRequirements::WindowsReleaseDLL to SystemRequirements::WindowsDLLVersions;
  #refinement dependency from SystemRequirements::DLLNameDifferentiation to SystemRequirements::WindowsDLLVersions;
  #refinement dependency from SystemRequirements::VersionHeaderRework to SystemRequirements::VersionFilesRework;
  #refinement dependency from SystemRequirements::BuildInfoRework to SystemRequirements::VersionFilesRework;
  #refinement dependency from SystemRequirements::MutableBSONImplementation to SystemRequirements::MutableBSONInterface;
  #derivation dependency from SystemRequirements::PreprocessorVersionMacros to SystemRequirements::ProgrammaticVersionInfo;
  #derivation dependency from SystemRequirements::ConfigHeaderInclusion to SystemRequirements::ConfigHeaderGeneration;
  #trace dependency from SystemRequirements::DocumentationStandardsUpdate to SystemRequirements::DocumentationMigration;
  #trace dependency from SystemRequirements::SignalHandlingRemoval to SystemRequirements::ExitCallsRemoval;
  #trace dependency from SystemRequirements::SignalHandlingRemoval to SystemRequirements::DebuggerSupportRemoval;
  #trace dependency from SystemRequirements::ExitCallsRemoval to SystemRequirements::DebuggerSupportRemoval;
  #trace dependency from SystemRequirements::WindowsCallingConvention to SystemRequirements::WindowsRuntimeFlag;
  #trace dependency from SystemRequirements::ProgrammaticVersionInfo to SystemRequirements::VersionFilesRework;
  #trace dependency from SystemRequirements::ListenFilesRemoval to SystemRequirements::ShardingDirectoryRemoval;
  #trace dependency from SystemRequirements::PrecompiledHeaderRemoval to SystemRequirements::BSONBuilderBaseRemoval;
  #trace dependency from SystemRequirements::BSONHeaderReachability to SystemRequirements::DBClientHeaderReachability;
  #refinement dependency from SystemRequirements::ClientInitializationSSLOptions to SystemRequirements::ClientInitializationPortOption;
  #refinement dependency from SystemRequirements::FromJsonTypeParameter to SystemRequirements::FromJsonArraySupport;
  #trace dependency from SystemRequirements::FromJsonArraySupport to SystemRequirements::BSONArrayJsonOutput;
  #refinement dependency from SystemRequirements::BSONArrayBuilderMethods to SystemRequirements::MutableBSONImplementation;
  #refinement dependency from SystemRequirements::BSONArrayBuilderAppendRegex to SystemRequirements::BSONArrayBuilderMethods;
  #refinement dependency from SystemRequirements::AppendRegexParameterConsistency to SystemRequirements::BSONArrayBuilderAppendRegex;
  #trace dependency from SystemRequirements::DeferredIsMasterCalls to DatabaseOperationsRequirements::MessageSizeDetermination;
  #trace dependency from SystemRequirements::ServerVersionPopulationTiming to SystemRequirements::DeferredIsMasterCalls;
  #trace dependency from SystemRequirements::BSONArrayBuilderAppendRegex to SystemRequirements::BSONArrayJsonOutput;
  #refinement dependency from SystemRequirements::ClientInitLoggingOptions to DocumentationRequirements::ClientInitializeDocumentation;
  #trace dependency from SystemRequirements::ConnectionStringValidation to SystemRequirements::DeprecatedConnectionStringParsing;
  #trace dependency from SystemRequirements::BSONIntegerEndianConversion to SystemRequirements::BSONDoubleEndianConversion;
  #trace dependency from SystemRequirements::BSONMemcpyUsage to SystemRequirements::BSONStrictAliasingCompliance;
  #trace dependency from SystemRequirements::BSONIntegerEndianConversion to SystemRequirements::MutableBSONInterface;
  #trace dependency from SystemRequirements::EvalNolockOptionSupport to DatabaseOperationsRequirements::SparseIndexSupport;
  #trace dependency from SystemRequirements::EvalNolockOptionSupport to DatabaseOperationsRequirements::EnsureIndexOverload;
  #derivation dependency from SystemRequirements::ValidationSuccessReturn to ClientDriverRequirements::DocumentValidationMethod;
  #trace dependency from SystemRequirements::UTF8ValidationConfiguration to ClientDriverRequirements::DocumentValidationMethod;
  #trace dependency from SystemRequirements::DollarKeyValidationConfiguration to ClientDriverRequirements::DocumentValidationMethod;
  #trace dependency from SystemRequirements::DotKeyValidationConfiguration to ClientDriverRequirements::DocumentValidationMethod;
  #trace dependency from SystemRequirements::ValidationSuccessReturn to ClientDriverRequirements::ValidBSONOutput;
  #trace dependency from SystemRequirements::BSONLibraryProductionReadiness to SystemRequirements::MutableBSONInterface;
  #trace dependency from SystemRequirements::BSONLibraryProductionReadiness to SystemRequirements::MutableBSONImplementation;
  #refinement dependency from SystemRequirements::Decimal128FormatValidation to SystemRequirements::Decimal128DecodingErrorMessages;
  #refinement dependency from SystemRequirements::Decimal128ErrorContextInformation to SystemRequirements::Decimal128DecodingErrorMessages;
  #trace dependency from SystemRequirements::Decimal128DecodingErrorMessages to ClientDriverRequirements::MalformedJSONHandling;
  #trace dependency from SystemRequirements::Decimal128FormatValidation to ClientDriverRequirements::MalformedJSONHandling;
  #trace dependency from SystemRequirements::Decimal128DecodingErrorMessages to SystemRequirements::BSONLibraryProductionReadiness;
  }

package BuildSystemRequirements {
  private import Requirements::*;
  public import ScalarValues::*;
  public import ModelingMetadata::*;
  public import RequirementDerivation::*;

  metadata def <trace> Trace { :>> annotatedElement : SysML::Dependency; }
  part def Developer;
  part def SystemOperator;
  part def User;
  part def Administrator;
  part def Customer;
  part def SystemAdmin;

  requirement def ClientExampleAlias {
    subject;
    doc /* The build system shall provide a 'smokeClient' alias that executes client examples against a running mongod instance */
    attribute id : String = "REQ-032";
    attribute alias_provided : Boolean;
    attribute alias_name : String = "smokeClient";
    attribute target_instance : String = "running mongod";
    attribute execution_type : String = "client examples";
    stakeholder developer : Developer;
    require constraint AliasProvisionCheck { alias_provided == true and alias_name == "smokeClient" }
    }

  requirement def CompilerTesting {
    subject;
    doc /* The Travis-CI integration shall test the driver under both clang and gcc compilers */
    attribute id : String = "REQ-030";
    attribute clang_testing_enabled : Boolean;
    attribute gcc_testing_enabled : Boolean;
    attribute compiler_count : Integer = 2;
    stakeholder developer : Developer;
    require constraint BothCompilersTested { clang_testing_enabled == true and gcc_testing_enabled == true }
    }

  requirement def ClangCompilerTesting {
    subject;
    doc /* The Travis-CI integration shall test the driver under clang compiler */
    attribute id : String = "REQ-030.1";
    attribute clang_testing_active : Boolean;
    attribute compiler_name : String = "clang";
    attribute integration_platform : String = "Travis-CI";
    stakeholder developer : Developer;
    require constraint ClangTestingActive { compiler_name == "clang" implies clang_testing_active == true }
    }

  requirement def GccCompilerTesting {
    subject;
    doc /* The Travis-CI integration shall test the driver under gcc compiler */
    attribute id : String = "REQ-030.2";
    attribute gcc_testing_active : Boolean;
    attribute compiler_name : String = "gcc";
    attribute integration_platform : String = "Travis-CI";
    stakeholder developer : Developer;
    require constraint GccTestingActive { compiler_name == "gcc" implies gcc_testing_active == true }
    }

  requirement def UnitTestAlias {
    subject;
    doc /* The build system shall provide a 'smokeCppUnittests' alias that executes unit tests */
    attribute id : String = "REQ-031";
    attribute alias_provided : Boolean;
    attribute alias_name : String = "smokeCppUnittests";
    attribute test_type : String = "unit tests";
    stakeholder developer : Developer;
    require constraint UnitTestAliasProvision { alias_provided == true and alias_name == "smokeCppUnittests" }
    }

  requirement def TravisCIIntegration {
    subject;
    doc /* The build system shall integrate with Travis-CI for automated testing */
    attribute id : String = "REQ-029";
    attribute travis_ci_integrated : Boolean;
    attribute testing_automated : Boolean;
    attribute ci_platform : String = "Travis-CI";
    stakeholder developer : Developer;
    require constraint TravisCIIntegrationActive { travis_ci_integrated == true implies testing_automated == true }
    }

  requirement def SharedLibraryDefault {
    subject;
    doc /* The C++ client driver build system shall default to building a shared library as the primary output */
    attribute id : String = "REQ-039";
    attribute default_output_type : String = "shared_library";
    attribute is_primary_output : Boolean;
    attribute shared_library_built : Boolean;
    stakeholder developer : Developer;
    require constraint DefaultSharedLibrary { default_output_type == "shared_library" and is_primary_output == true implies shared_library_built == true }
    }

  requirement def StaticLibraryOnRequest {
    subject;
    doc /* The C++ client driver build system shall only build the static library when explicitly requested by the user */
    attribute id : String = "REQ-041";
    attribute user_requested_static : Boolean;
    attribute static_library_built : Boolean;
    attribute explicit_request_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint StaticOnlyWhenRequested { user_requested_static == false implies static_library_built == false }
    require constraint ExplicitRequestRequired { static_library_built == true implies user_requested_static == true }
    }

  requirement def PlatformLibraryExtensions {
    subject;
    doc /* The C++ client driver build system shall generate platform-appropriate shared library extensions (.so on Linux, .dylib on macOS, .dll on Windows) */
    attribute id : String = "REQ-040";
    attribute linux_extension : String = ".so";
    attribute macos_extension : String = ".dylib";
    attribute windows_extension : String = ".dll";
    attribute generated_extension : String;
    attribute target_platform : String;
    stakeholder developer : Developer;
    require constraint LinuxExtension { target_platform == "Linux" implies generated_extension == linux_extension }
    require constraint MacOSExtension { target_platform == "macOS" implies generated_extension == macos_extension }
    require constraint WindowsExtension { target_platform == "Windows" implies generated_extension == windows_extension }
    }

  requirement def ClangVersionSupport {
    subject;
    doc /* The CI system shall support Clang version 3.4 for build testing */
    attribute id : String = "REQ-044";
    attribute required_clang_version : String = "3.4";
    attribute supported_clang_version : String;
    attribute build_testing_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint ClangVersionMatch { supported_clang_version == required_clang_version }
    require constraint BuildTestingEnabled { supported_clang_version == "3.4" implies build_testing_enabled == true }
    }

  requirement def TravisCIModernCompilers {
    subject;
    doc /* The Travis-CI platform shall execute builds using the configured modern compilers */
    attribute id : String = "REQ-045";
    attribute platform_name : String = "Travis-CI";
    attribute modern_compilers_configured : Boolean;
    attribute build_execution_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint ModernCompilerExecution { modern_compilers_configured == true implies build_execution_enabled == true }
    require constraint PlatformVerification { platform_name == "Travis-CI" and build_execution_enabled == true }
    }

  requirement def GccVersionSupport {
    subject;
    doc /* The CI system shall support GCC version 4.8 for build testing */
    attribute id : String = "REQ-043";
    attribute required_gcc_version : String = "4.8";
    attribute supported_gcc_version : String;
    attribute build_testing_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint GccVersionMatch { supported_gcc_version == required_gcc_version }
    require constraint BuildTestingEnabled { supported_gcc_version == "4.8" implies build_testing_enabled == true }
    }

  requirement def StaticExecutablePlacement {
    subject;
    doc /* The C++ driver build system shall not place statically linked executables in the root of the source tree */
    attribute id : String = "REQ-049";
    attribute static_executables_in_root : Boolean;
    attribute proper_executable_placement : Boolean;
    stakeholder developer : Developer;
    require constraint NoExecutablesInRoot { static_executables_in_root == false and proper_executable_placement == true }
    }

  requirement def ExampleLinkingVerification {
    subject;
    doc /* The C++ driver build system shall verify that examples link correctly against library artifacts */
    attribute id : String = "REQ-053";
    attribute example_linking_verified : Boolean;
    attribute linking_errors_detected : Boolean;
    stakeholder developer : Developer;
    require constraint ExampleLinkingSuccess { example_linking_verified == true and linking_errors_detected == false }
    }

  requirement def BuildArtifactsPlacement {
    subject;
    doc /* The C++ driver build system shall place all build artifacts under the 'build' directory */
    attribute id : String = "REQ-046";
    attribute target_directory : String = "build";
    attribute artifacts_in_target : Boolean;
    stakeholder developer : Developer;
    require constraint ArtifactsInBuildDirectory { artifacts_in_target == true }
    }

  requirement def TestLinkingVerification {
    subject;
    doc /* The C++ driver build system shall verify that tests link correctly against library artifacts */
    attribute id : String = "REQ-052";
    attribute test_linking_verified : Boolean;
    attribute linking_errors_detected : Boolean;
    stakeholder developer : Developer;
    require constraint TestLinkingSuccess { test_linking_verified == true and linking_errors_detected == false }
    }

  requirement def DirectLibraryLinking {
    subject;
    doc /* The C++ driver build system shall link directly with .a and dylib files without using libdeps */
    attribute id : String = "REQ-051";
    attribute uses_libdeps : Boolean;
    attribute direct_linking_enabled : Boolean;
    attribute supported_extensions : String = ".a,.dylib";
    stakeholder developer : Developer;
    require constraint DirectLinkingWithoutLibdeps { uses_libdeps == false and direct_linking_enabled == true }
    }

  requirement def SharedClientDirectoryPrevention {
    subject;
    doc /* The C++ driver build system shall not create the 'sharedclient' directory in the root of the source tree */
    attribute id : String = "REQ-048";
    attribute sharedclient_directory_created : Boolean;
    attribute root_directory_clean : Boolean;
    stakeholder developer : Developer;
    require constraint NoSharedClientInRoot { sharedclient_directory_created == false and root_directory_clean == true }
    }

  requirement def SconsDirectoryPrevention {
    subject;
    doc /* The C++ driver build system shall not create the .scons directory in the root of the source tree */
    attribute id : String = "REQ-047";
    attribute scons_directory_created : Boolean;
    attribute root_directory_clean : Boolean;
    stakeholder developer : Developer;
    require constraint NoSconsInRoot { scons_directory_created == false and root_directory_clean == true }
    }

  requirement def LibmongoclientPlacement {
    subject;
    doc /* The C++ driver build system shall not place the libmongoclient binary in the root of the source tree */
    attribute id : String = "REQ-050";
    attribute libmongoclient_in_root : Boolean;
    attribute proper_binary_placement : Boolean;
    stakeholder developer : Developer;
    require constraint NoLibmongoclientInRoot { libmongoclient_in_root == false and proper_binary_placement == true }
    }

  requirement def AtomicsMacroPlacement {
    subject;
    doc /* The driver build system shall place atomics selection macros in config.h header file instead of CPPDEFINES */
    attribute id : String = "REQ-067";
    attribute target_header_file : String = "config.h";
    attribute source_location : String = "CPPDEFINES";
    attribute macros_placed_correctly : Boolean;
    attribute build_system_active : Boolean;
    stakeholder developer : Developer;
    require constraint MacroPlacementCorrectness { build_system_active == true implies macros_placed_correctly == true }
    }

  requirement def DuplicateIDCheckSuppression {
    subject;
    doc /* The build system shall suppress duplicate ID checks when building on the 26compat branch */
    attribute id : String = "REQ-102";
    attribute target_branch : String = "26compat";
    attribute duplicate_checks_suppressed : Boolean;
    stakeholder developer : Developer;
    require constraint SuppressChecksOn26Compat { target_branch == "26compat" implies duplicate_checks_suppressed == true }
    }

  requirement def TcmallocSupportRemoval {
    subject;
    doc /* The build system shall remove all tcmalloc support from the 26compat branch */
    attribute id : String = "REQ-103";
    attribute target_branch : String = "26compat";
    attribute tcmalloc_support_removed : Boolean;
    stakeholder developer : Developer;
    require constraint RemoveTcmallocOn26Compat { target_branch == "26compat" implies tcmalloc_support_removed == true }
    }

  requirement def MSVCVersionVariable {
    subject;
    doc /* The SCons build system shall accept MSVC_VERSION as a command line variable */
    attribute id : String = "REQ-124";
    attribute variable_name : String = "MSVC_VERSION";
    attribute command_line_variable_supported : Boolean;
    stakeholder developer : Developer;
    require constraint VariableSupport { variable_name == "MSVC_VERSION" implies command_line_variable_supported == true }
    }

  requirement def TargetArchVariable {
    subject;
    doc /* The SCons build system shall accept TARGET_ARCH as a command line variable */
    attribute id : String = "REQ-123";
    attribute variable_name : String = "TARGET_ARCH";
    attribute command_line_variable_supported : Boolean;
    stakeholder developer : Developer;
    require constraint VariableSupport { variable_name == "TARGET_ARCH" implies command_line_variable_supported == true }
    }

  requirement def MachODllPathSupport {
    subject;
    doc /* The SCons build system shall support the --dllpath option on Mach-O platforms using DYLD_LIBRARY_PATH */
    attribute id : String = "REQ-106";
    attribute platform_type : String = "Mach-O";
    attribute environment_variable : String = "DYLD_LIBRARY_PATH";
    attribute option_name : String = "--dllpath";
    attribute option_supported : Boolean;
    stakeholder developer : Developer;
    require constraint MachODllPathOption { platform_type == "Mach-O" and option_name == "--dllpath" implies option_supported == true }
    }

  requirement def DefaultTargetBuild {
    subject;
    doc /* The SCons build system shall provide a default target that builds the most commonly used components */
    attribute id : String = "REQ-116";
    attribute target_name : String = "default";
    attribute builds_common_components : Boolean;
    attribute default_target_available : Boolean;
    stakeholder developer : Developer;
    require constraint DefaultTargetProvision { target_name == "default" implies builds_common_components == true and default_target_available == true }
    }

  requirement def HostArchVariable {
    subject;
    doc /* The SCons build system shall accept HOST_ARCH as a command line variable */
    attribute id : String = "REQ-122";
    attribute variable_name : String = "HOST_ARCH";
    attribute command_line_variable_supported : Boolean;
    stakeholder developer : Developer;
    require constraint VariableSupport { variable_name == "HOST_ARCH" implies command_line_variable_supported == true }
    }

  requirement def MSVCScriptVariable {
    subject;
    doc /* The SCons build system shall accept MSVC_USE_SCRIPT as a command line variable */
    attribute id : String = "REQ-125";
    attribute variable_name : String = "MSVC_USE_SCRIPT";
    attribute command_line_variable_supported : Boolean;
    stakeholder developer : Developer;
    require constraint VariableSupport { variable_name == "MSVC_USE_SCRIPT" implies command_line_variable_supported == true }
    }

  requirement def PlatformVersionOverride {
    subject;
    doc /* The SCons build system shall allow overriding the target platform version */
    attribute id : String = "REQ-120";
    attribute version_override_supported : Boolean;
    attribute target_platform_configurable : Boolean;
    stakeholder developer : Developer;
    require constraint VersionOverrideCapability { version_override_supported == true and target_platform_configurable == true }
    }

  requirement def MacOSPlatformTargeting {
    subject;
    doc /* The SCons build system shall target the current platform by default on macOS */
    attribute id : String = "REQ-119";
    attribute operating_system : String = "macOS";
    attribute uses_current_platform : Boolean;
    attribute default_targeting_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint MacOSCurrentPlatformTargeting { operating_system == "macOS" implies uses_current_platform == true and default_targeting_enabled == true }
    }

  requirement def ELFDllPathSupport {
    subject;
    doc /* The SCons build system shall support the --dllpath option on ELF platforms using LD_LIBRARY_PATH */
    attribute id : String = "REQ-105";
    attribute platform_type : String = "ELF";
    attribute environment_variable : String = "LD_LIBRARY_PATH";
    attribute option_name : String = "--dllpath";
    attribute option_supported : Boolean;
    stakeholder developer : Developer;
    require constraint ELFDllPathOption { platform_type == "ELF" and option_name == "--dllpath" implies option_supported == true }
    }

  requirement def AllTargetBuild {
    subject;
    doc /* The SCons 'all' target shall build all buildable components */
    attribute id : String = "REQ-117";
    attribute target_name : String = "all";
    attribute builds_all_components : Boolean;
    attribute all_target_available : Boolean;
    stakeholder developer : Developer;
    require constraint AllTargetProvision { target_name == "all" implies builds_all_components == true and all_target_available == true }
    }

  requirement def CXXFlagsEnvironmentSupport {
    subject;
    doc /* The scons build system shall support CXXFLAGS environment variable for custom C++ compiler options */
    attribute id : String = "REQ-165";
    attribute environment_variable_name : String = "CXXFLAGS";
    attribute supports_custom_options : Boolean = true;
    attribute compiler_type : String = "C++";
    stakeholder developer : Developer;
    require constraint CXXFlagsSupport { environment_variable_name == "CXXFLAGS" and supports_custom_options == true and compiler_type == "C++" }
    }

  requirement def LDFlagsEnvironmentSupport {
    subject;
    doc /* The scons build system shall support LDFLAGS environment variable for custom linker options */
    attribute id : String = "REQ-163";
    attribute environment_variable_name : String = "LDFLAGS";
    attribute supports_custom_options : Boolean = true;
    attribute linker_options_supported : Boolean = true;
    stakeholder developer : Developer;
    require constraint LDFlagsSupport { environment_variable_name == "LDFLAGS" and supports_custom_options == true and linker_options_supported == true }
    }

  requirement def CFlagsEnvironmentSupport {
    subject;
    doc /* The scons build system shall support CFLAGS environment variable for custom compiler options */
    attribute id : String = "REQ-164";
    attribute environment_variable_name : String = "CFLAGS";
    attribute supports_custom_options : Boolean = true;
    attribute compiler_type : String = "C";
    stakeholder developer : Developer;
    require constraint CFlagsSupport { environment_variable_name == "CFLAGS" and supports_custom_options == true and compiler_type == "C" }
    }

  requirement def SconsVariableQuoting {
    subject;
    doc /* The scons script shall properly quote the $PYTHON variable in src/SConscript.client to handle directory paths with spaces */
    attribute id : String = "REQ-173";
    attribute python_variable_quoted : Boolean;
    attribute directory_path_contains_spaces : Boolean;
    attribute script_file_path : String = "src/SConscript.client";
    attribute variable_name : String = "$PYTHON";
    stakeholder developer : Developer;
    require constraint QuoteVariableForSpaces { directory_path_contains_spaces == true implies python_variable_quoted == true }
    }

  requirement def PythonPathSpaceHandling {
    subject;
    doc /* The build system shall handle Python installation paths containing spaces without aborting the build process */
    attribute id : String = "REQ-172";
    attribute python_path_contains_spaces : Boolean;
    attribute build_process_aborted : Boolean;
    attribute path_handling_successful : Boolean;
    stakeholder developer : Developer;
    require constraint PreventBuildAbortOnSpaces { python_path_contains_spaces == true implies build_process_aborted == false }
    require constraint EnsureSuccessfulHandling { python_path_contains_spaces == true implies path_handling_successful == true }
    }

  requirement def OptionalMNMLSTCUsage {
    subject;
    doc /* The C++14 driver shall allow optional use of MNMLSTC library for polyfills */
    attribute id : String = "REQ-187";
    attribute allows_optional_mnmlstc : Boolean;
    attribute optional_polyfill_support : Boolean;
    stakeholder developer : Developer;
    require constraint OptionalMNMLSTCSupport { allows_optional_mnmlstc == true and optional_polyfill_support == true }
    }

  requirement def MNMLSTCConfigurationVariable {
    subject;
    doc /* The driver shall provide a LIBMONGOCXX_USING_PRIVATE_MNMLSTC configuration header variable when using embedded MNMLSTC */
    attribute id : String = "REQ-190";
    attribute provides_config_variable : Boolean;
    attribute variable_name_correct : Boolean;
    attribute indicates_embedded_usage : Boolean;
    stakeholder developer : Developer;
    require constraint ConfigurationVariableProvision { provides_config_variable == true and variable_name_correct == true and indicates_embedded_usage == true }
    }

  requirement def EmbeddedMNMLSTCInstallation {
    subject;
    doc /* The embedded MNMLSTC headers shall be installed within the driver's include directory to avoid conflicts with system copies */
    attribute id : String = "REQ-189";
    attribute installed_in_driver_include : Boolean;
    attribute avoids_system_conflicts : Boolean;
    stakeholder developer : Developer;
    require constraint EmbeddedInstallation { installed_in_driver_include == true and avoids_system_conflicts == true }
    }

  requirement def MNMLSTCLibraryFlexibility {
    subject;
    doc /* The driver build system shall support using either system-installed or embedded MNMLSTC library */
    attribute id : String = "REQ-188";
    attribute supports_system_installed : Boolean;
    attribute supports_embedded_library : Boolean;
    attribute build_system_flexible : Boolean;
    stakeholder developer : Developer;
    require constraint MNMLSTCFlexibility { supports_system_installed == true and supports_embedded_library == true and build_system_flexible == true }
    }

  requirement def MNMLSTCLibraryUsage {
    subject;
    doc /* The C++11 driver shall use MNMLSTC library for C++11 polyfills */
    attribute id : String = "REQ-186";
    attribute uses_mnmlstc_library : Boolean;
    attribute provides_cpp11_polyfills : Boolean;
    stakeholder developer : Developer;
    require constraint MNMLSTCUsage { uses_mnmlstc_library == true and provides_cpp11_polyfills == true }
    }

  requirement def PreventTestExecutionOnInvalidSetup {
    subject;
    doc /* The test framework shall prevent individual test execution when the test suite setup state is invalid */
    attribute id : String = "REQ-210";
    attribute setup_state_invalid : Boolean;
    attribute individual_test_execution_prevented : Boolean;
    stakeholder developer : Developer;
    require constraint PreventExecutionOnInvalidSetup { setup_state_invalid == true implies individual_test_execution_prevented == true }
    }

  requirement def TestSuiteTerminationOnSetupFailure {
    subject;
    doc /* The test framework shall terminate the read_preference_tests test suite execution when SetUpTestCase fails */
    attribute id : String = "REQ-208";
    attribute test_suite_name : String = "read_preference_tests";
    attribute setup_case_failed : Boolean;
    attribute suite_execution_terminated : Boolean;
    stakeholder developer : Developer;
    require constraint TerminateSuiteOnSetupFailure { setup_case_failed == true implies suite_execution_terminated == true }
    }

  requirement def AbortCallOnSetupFailure {
    subject;
    doc /* The test framework shall call std::abort when SetUpTestCase fails in read_preference_tests */
    attribute id : String = "REQ-209";
    attribute test_suite_name : String = "read_preference_tests";
    attribute setup_case_failed : Boolean;
    attribute abort_called : Boolean;
    stakeholder developer : Developer;
    require constraint CallAbortOnSetupFailure { setup_case_failed == true implies abort_called == true }
    }

  requirement def PedanticCompilationSupport {
    subject;
    doc /* The C++ driver source code shall compile without errors when using g++ with the '-pedantic-errors' flag */
    attribute id : String = "REQ-213";
    attribute compiler_name : String = "g++";
    attribute compiler_flag : String = "-pedantic-errors";
    attribute compilation_successful : Boolean;
    attribute error_count : Integer;
    stakeholder developer : Developer;
    require constraint PedanticCompilationSuccess { compilation_successful == true and error_count == 0 }
    }

  requirement def CMakeWindowsPlatformSupport {
    subject;
    doc /* The CMake configuration shall support finding libbson and libmongoc on Windows platforms */
    attribute id : String = "REQ-239";
    attribute windows_platform_supported : Boolean;
    attribute libbson_found : Boolean;
    attribute libmongoc_found : Boolean;
    stakeholder developer : Developer;
    require constraint WindowsLibraryDiscovery { windows_platform_supported == true implies (libbson_found == true and libmongoc_found == true) }
    }

  requirement def VisualStudioCompilationSupport {
    subject;
    doc /* The MongoDB C++ driver shall compile successfully under Visual Studio 2015 without alignment errors */
    attribute id : String = "REQ-226";
    attribute compiler_version : String = "Visual Studio 2015";
    attribute alignment_errors_allowed : Boolean = false;
    attribute compilation_successful : Boolean;
    stakeholder developer : Developer;
    require constraint VS2015CompilationSuccess { alignment_errors_allowed == false implies compilation_successful == true }
    }

  requirement def EvergreenBSONTestExecution {
    subject;
    doc /* The Evergreen build system shall execute bsoncxx unit tests as part of the build process */
    attribute id : String = "REQ-230";
    attribute build_system : String = "Evergreen";
    attribute unit_tests_executed : Boolean;
    attribute test_suite : String = "bsoncxx";
    stakeholder developer : Developer;
    require constraint EvergreenTestExecution { build_system == "Evergreen" implies unit_tests_executed == true }
    }

  requirement def TravisBSONTestExecution {
    subject;
    doc /* The Travis CI build system shall execute bsoncxx unit tests as part of the build process */
    attribute id : String = "REQ-231";
    attribute build_system : String = "Travis CI";
    attribute unit_tests_executed : Boolean;
    attribute test_suite : String = "bsoncxx";
    stakeholder developer : Developer;
    require constraint TravisTestExecution { build_system == "Travis CI" implies unit_tests_executed == true }
    }

  requirement def BoostPolyfillSupport {
    subject;
    doc /* The MongoDB C++ driver shall support using Boost libraries to provide stdx polyfills */
    attribute id : String = "REQ-232";
    attribute boost_libraries_supported : Boolean;
    attribute stdx_polyfills_provided : Boolean;
    stakeholder developer : Developer;
    require constraint BoostLibraryPolyfillSupport { boost_libraries_supported == true implies stdx_polyfills_provided == true }
    }

  requirement def CMakeDriverDiscoveryAlternative {
    subject;
    doc /* The CMake configuration shall provide an alternative mechanism to find the C driver without using pkg-config */
    attribute id : String = "REQ-238";
    attribute pkg_config_required : Boolean = false;
    attribute alternative_mechanism_provided : Boolean;
    attribute c_driver_found : Boolean;
    stakeholder developer : Developer;
    require constraint AlternativeDiscoveryMechanism { pkg_config_required == false implies (alternative_mechanism_provided == true and c_driver_found == true) }
    }

  requirement def SOVersionStabilityIndication {
    subject;
    doc /* The MongoDB C++ driver 3.0.0 release shall set an SOVERSION that explicitly indicates no stable ABI is expected */
    attribute id : String = "REQ-228";
    attribute release_version : String = "3.0.0";
    attribute stable_abi_expected : Boolean = false;
    attribute soversion_set : Boolean;
    stakeholder developer : Developer;
    stakeholder systemAdmin : SystemAdmin;
    require constraint SOVersionIndicatesInstability { stable_abi_expected == false implies soversion_set == true }
    }

  requirement def MSVCBoostLibraryDefault {
    subject;
    doc /* The build system shall default to boost library when building with MSVC compiler on VS2015 */
    attribute id : String = "REQ-252";
    attribute msvc_version_target : String = "VS2015";
    attribute boost_library_enabled : Boolean;
    attribute default_configuration_applied : Boolean;
    stakeholder developer : Developer;
    require constraint BoostDefaultConfiguration { msvc_version_target == "VS2015" implies boost_library_enabled == true }
    }

  requirement def CMakeCompilerVersionEnforcement {
    subject;
    doc /* The CMake configuration system shall enforce minimum compiler version requirements */
    attribute id : String = "REQ-259";
    attribute minimum_version_checks : Integer;
    attribute compiler_validation_enabled : Boolean;
    attribute version_enforcement_active : Boolean;
    stakeholder developer : Developer;
    require constraint VersionEnforcementActive { compiler_validation_enabled == true and version_enforcement_active == true }
    }

  requirement def CMakePolyfillValidation {
    subject;
    doc /* The CMake configuration system shall prevent specification of invalid polyfill option combinations */
    attribute id : String = "REQ-254";
    attribute polyfill_options_count : Integer;
    attribute invalid_combinations_detected : Integer;
    attribute validation_rules_enforced : Boolean;
    stakeholder developer : Developer;
    require constraint InvalidCombinationPrevention { invalid_combinations_detected > 0 implies validation_rules_enforced == true }
    }

  requirement def B64HeaderPrivateRelocation {
    subject;
    doc /* The build system shall move b64_ntop.h to the private subdirectory */
    attribute id : String = "REQ-256";
    attribute source_location : String;
    attribute target_directory : String = "private";
    attribute relocation_completed : Boolean;
    stakeholder developer : Developer;
    require constraint HeaderRelocationComplete { target_directory == "private" and relocation_completed == true }
    }

  requirement def B64HeaderInstallationPrevention {
    subject;
    doc /* The build system shall not install b64_ntop.h header file as it is for internal use only */
    attribute id : String = "REQ-255";
    attribute header_file_name : String = "b64_ntop.h";
    attribute installation_prevented : Boolean;
    attribute internal_use_only : Boolean;
    stakeholder developer : Developer;
    require constraint HeaderInstallationPrevented { header_file_name == "b64_ntop.h" implies installation_prevented == true and internal_use_only == true }
    }

  requirement def ClangFormatProductionSupport {
    subject;
    doc /* The build system shall implement production-ready clang-format support with stability guarantees */
    attribute id : String = "REQ-269";
    attribute clang_format_version : String;
    attribute stability_guarantees : Boolean;
    attribute production_readiness : Boolean;
    stakeholder developer : Developer;
    require constraint ProductionReadyClangFormat { stability_guarantees == true and production_readiness == true }
    }

  requirement def FindLibMongoCCaseSensitivity {
    subject;
    doc /* The FindLibMongoC cmake helper shall use the correct case-sensitive include path 'libmongoc-1.0' instead of 'libMONGOC-1.0' */
    attribute id : String = "REQ-290";
    attribute cmake_helper_name : String = "FindLibMongoC";
    attribute correct_include_path : String = "libmongoc-1.0";
    attribute incorrect_include_path : String = "libMONGOC-1.0";
    attribute uses_correct_case : Boolean;
    stakeholder developer : Developer;
    require constraint CorrectCasePath { uses_correct_case == true }
    }

  requirement def TestInfrastructureAccessibility {
    subject;
    doc /* The test infrastructure shall be accessible through the mongocxx::test_util namespace after migration */
    attribute id : String = "REQ-299";
    attribute accessible_namespace : String = "mongocxx::test_util";
    attribute infrastructure_accessible : Boolean;
    attribute migration_completed : Boolean;
    stakeholder developer : Developer;
    require constraint AccessibilityAfterMigration { migration_completed == true implies infrastructure_accessible == true }
    }

  requirement def TestUtilDirectoryCreation {
    subject;
    doc /* The build system shall create a new src/mongocxx/test_util/ directory to contain common test infrastructure */
    attribute id : String = "REQ-297";
    attribute target_directory : String = "src/mongocxx/test_util/";
    attribute directory_created : Boolean;
    attribute contains_test_infrastructure : Boolean;
    stakeholder developer : Developer;
    require constraint DirectoryCreatedAndContainsInfrastructure { directory_created == true and contains_test_infrastructure == true }
    }

  requirement def NamespaceRenaming {
    subject;
    doc /* The build system shall rename the mongocxx::mock namespace to mongocxx::test_util */
    attribute id : String = "REQ-296";
    attribute source_namespace : String = "mongocxx::mock";
    attribute target_namespace : String = "mongocxx::test_util";
    attribute renaming_completed : Boolean;
    stakeholder developer : Developer;
    require constraint RenamingCompleted { renaming_completed == true }
    }

  requirement def MockDirectoryRemoval {
    subject;
    doc /* The build system shall remove the src/mongocxx/mock/ directory after namespace migration */
    attribute id : String = "REQ-298";
    attribute source_directory : String = "src/mongocxx/mock/";
    attribute directory_removed : Boolean;
    attribute migration_completed : Boolean;
    stakeholder developer : Developer;
    require constraint RemovalAfterMigration { migration_completed == true implies directory_removed == true }
    }

  requirement def CMakeBuildSharedLibsSupport {
    subject;
    doc /* The build system shall support the BUILD_SHARED_LIBS CMake option for library type selection */
    attribute id : String = "REQ-332";
    attribute build_shared_libs_option_supported : Boolean;
    attribute cmake_option_name : String = "BUILD_SHARED_LIBS";
    attribute option_value_accepted : Boolean;
    stakeholder developer : Developer;
    require constraint CMakeOptionSupportCheck { (cmake_option_name == "BUILD_SHARED_LIBS" and build_shared_libs_option_supported == true) implies option_value_accepted == true }
    }

  requirement def ExplicitSSLEnablementWithValidation {
    subject;
    doc /* The build system shall support explicit SSL enablement with error if underlying C driver lacks SSL support */
    attribute id : String = "REQ-343";
    attribute ssl_explicitly_enabled : Boolean;
    attribute c_driver_ssl_available : Boolean;
    attribute error_raised_on_mismatch : Boolean;
    stakeholder developer : Developer;
    require constraint SSLEnablementValidationCheck { (ssl_explicitly_enabled == true and c_driver_ssl_available == false) implies error_raised_on_mismatch == true }
    }

  requirement def AutomaticSSLConfiguration {
    subject;
    doc /* The build system shall support automatic SSL configuration based on underlying C driver SSL availability */
    attribute id : String = "REQ-345";
    attribute ssl_auto_configured : Boolean;
    attribute c_driver_ssl_availability : Boolean;
    attribute ssl_config_matches_driver : Boolean;
    stakeholder developer : Developer;
    require constraint AutoSSLConfigurationCheck { ssl_auto_configured == true implies ssl_config_matches_driver == true }
    }

  requirement def SharedLibraryOnlyConfiguration {
    subject;
    doc /* The build system shall allow users to configure whether to build shared libraries only */
    attribute id : String = "REQ-331";
    attribute shared_only_enabled : Boolean;
    attribute library_type_configured : String;
    stakeholder developer : Developer;
    require constraint SharedOnlyConfigurationCheck { shared_only_enabled == true implies library_type_configured == "shared" }
    }

  requirement def ExplicitSSLDisablement {
    subject;
    doc /* The build system shall support explicit SSL disablement even when underlying C driver offers SSL support */
    attribute id : String = "REQ-344";
    attribute ssl_explicitly_disabled : Boolean;
    attribute c_driver_ssl_available : Boolean;
    attribute ssl_disabled_successfully : Boolean;
    stakeholder developer : Developer;
    require constraint SSLDisablementCheck { ssl_explicitly_disabled == true implies ssl_disabled_successfully == true }
    }

  requirement def IndependentSSLConfiguration {
    subject;
    doc /* The build system shall allow SSL configuration to be specified independently of the C driver SSL support */
    attribute id : String = "REQ-342";
    attribute ssl_config_independent : Boolean;
    attribute c_driver_ssl_status : String;
    attribute ssl_configuration_specified : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint SSLIndependence { ssl_configuration_specified == true implies ssl_config_independent == true }
    }

  requirement def StaticLibraryOnlyConfiguration {
    subject;
    doc /* The build system shall allow users to configure whether to build static libraries only */
    attribute id : String = "REQ-330";
    attribute static_only_enabled : Boolean;
    attribute library_type_configured : String;
    stakeholder developer : Developer;
    require constraint StaticOnlyConfiguration { static_only_enabled == true implies library_type_configured == "static" }
    }

  requirement def CppSeventeenMinGWSupport {
    subject;
    doc /* The build system shall support compilation with C++17 standard using MinGW 7.2 compiler */
    attribute id : String = "REQ-351";
    attribute cpp_standard_version : String = "17";
    attribute compiler_name : String = "MinGW";
    attribute compiler_version : String = "7.2";
    attribute compilation_supported : Boolean;
    stakeholder developer : Developer;
    require constraint CompilerVersionCheck { compiler_version == "7.2" and compilation_supported == true }
    require constraint CppStandardCheck { cpp_standard_version == "17" implies compilation_supported == true }
    }

  requirement def BsonCxxPolyExperimentalFlag {
    subject;
    doc /* The build system shall support BSONCXX_POLY_USE_STD_EXPERIMENTAL=1 flag for experimental STL features */
    attribute id : String = "REQ-353";
    attribute flag_name : String = "BSONCXX_POLY_USE_STD_EXPERIMENTAL";
    attribute flag_value : String = "1";
    attribute experimental_stl_enabled : Boolean;
    attribute flag_supported : Boolean;
    stakeholder developer : Developer;
    require constraint FlagValueCheck { flag_value == "1" implies flag_supported == true }
    require constraint ExperimentalFeatureCheck { flag_supported == true implies experimental_stl_enabled == true }
    }

  requirement def CMakeCppStandardParameter {
    subject;
    doc /* The build system shall accept CMAKE_CXX_STANDARD=17 parameter to enable C++17 compilation */
    attribute id : String = "REQ-352";
    attribute cmake_parameter_name : String = "CMAKE_CXX_STANDARD";
    attribute parameter_value : String = "17";
    attribute parameter_accepted : Boolean;
    attribute cpp_compilation_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint ParameterAcceptanceCheck { parameter_value == "17" implies parameter_accepted == true }
    require constraint CompilationEnableCheck { parameter_accepted == true implies cpp_compilation_enabled == true }
    }

  requirement def BsoncxxStaticCMakeConfigFiles {
    subject;
    doc /* The bsoncxx build system shall provide static-only CMake config files */
    attribute id : String = "REQ-390";
    attribute static_cmake_config_provided : Boolean;
    attribute cmake_config_files_static_only : Boolean;
    stakeholder developer : Developer;
    require constraint StaticCMakeConfigProvision { static_cmake_config_provided == true and cmake_config_files_static_only == true }
    }

  requirement def BsoncxxStaticLibraryNaming {
    subject;
    doc /* The bsoncxx static library shall be named bsoncxx-static */
    attribute id : String = "REQ-388";
    attribute library_name : String = "bsoncxx-static";
    attribute actual_library_name : String;
    stakeholder developer : Developer;
    require constraint StaticLibraryNaming { actual_library_name == library_name }
    }

  requirement def MongocxxStaticLibraryNaming {
    subject;
    doc /* The mongocxx static library shall be named mongocxx-static */
    attribute id : String = "REQ-376";
    attribute library_name : String = "mongocxx-static";
    attribute actual_library_name : String;
    stakeholder developer : Developer;
    require constraint StaticLibraryNaming { actual_library_name == library_name }
    }

  requirement def MongocxxStaticPkgConfigFiles {
    subject;
    doc /* The mongocxx build system shall provide static-only pkg-config files */
    attribute id : String = "REQ-377";
    attribute static_pkg_config_provided : Boolean;
    attribute pkg_config_files_static_only : Boolean;
    stakeholder developer : Developer;
    require constraint StaticPkgConfigProvision { static_pkg_config_provided == true and pkg_config_files_static_only == true }
    }

  requirement def BsoncxxStaticLibraryDependency {
    subject;
    doc /* The bsoncxx library shall depend on bson-static-1.0 when BUILD_SHARED_LIBS is OFF */
    attribute id : String = "REQ-381";
    attribute build_shared_libs_off : Boolean;
    attribute depends_on_bson_static : Boolean;
    attribute dependency_name : String = "bson-static-1.0";
    stakeholder developer : Developer;
    require constraint StaticLibraryDependency { build_shared_libs_off == true implies depends_on_bson_static == true }
    }

  requirement def CMakeConfigTestInclusion {
    subject;
    doc /* The build system shall include tests for installed CMake config files */
    attribute id : String = "REQ-375";
    attribute cmake_config_tests_included : Boolean;
    attribute config_files_validated : Boolean;
    stakeholder developer : Developer;
    require constraint CMakeConfigTestValidation { cmake_config_tests_included == true implies config_files_validated == true }
    }

  requirement def PkgConfigTestInclusion {
    subject;
    doc /* The build system shall include tests for installed pkg-config files */
    attribute id : String = "REQ-374";
    attribute test_files_included : Boolean;
    attribute pkg_config_files_tested : Boolean;
    stakeholder developer : Developer;
    require constraint PkgConfigTestValidation { test_files_included == true implies pkg_config_files_tested == true }
    }

  requirement def BsoncxxSharedLibraryDependency {
    subject;
    doc /* The bsoncxx library shall depend on bson-1.0 when BUILD_SHARED_LIBS is ON */
    attribute id : String = "REQ-380";
    attribute build_shared_libs_on : Boolean;
    attribute depends_on_bson_shared : Boolean;
    attribute dependency_name : String = "bson-1.0";
    stakeholder developer : Developer;
    require constraint SharedLibraryDependency { build_shared_libs_on == true implies depends_on_bson_shared == true }
    }

  requirement def BsoncxxStaticPkgConfigFiles {
    subject;
    doc /* The bsoncxx build system shall provide static-only pkg-config files */
    attribute id : String = "REQ-389";
    attribute static_pkg_config_provided : Boolean;
    attribute pkg_config_files_static_only : Boolean;
    stakeholder developer : Developer;
    require constraint StaticPkgConfigProvision { static_pkg_config_provided == true and pkg_config_files_static_only == true }
    }

  requirement def MongocxxStaticCMakeConfigFiles {
    subject;
    doc /* The mongocxx build system shall provide static-only CMake config files */
    attribute id : String = "REQ-378";
    attribute static_cmake_config_provided : Boolean;
    attribute cmake_config_files_static_only : Boolean;
    stakeholder developer : Developer;
    require constraint StaticCMakeConfigProvision { static_cmake_config_provided == true and cmake_config_files_static_only == true }
    }

  requirement def MongocxxStaticLibraryDependency {
    subject;
    doc /* The mongocxx library shall depend on mongoc-static-1.0 when BUILD_SHARED_LIBS is OFF */
    attribute id : String = "REQ-379";
    attribute build_shared_libs_off : Boolean;
    attribute depends_on_mongoc_static : Boolean;
    attribute dependency_name : String = "mongoc-static-1.0";
    stakeholder developer : Developer;
    require constraint StaticLibraryDependency { build_shared_libs_off == true implies depends_on_mongoc_static == true }
    }

  requirement def CMakeCDriverBuild {
    subject;
    doc /* The MongoDB C++ driver build system shall use CMake to build the C Driver on Evergreen */
    attribute id : String = "REQ-416";
    attribute build_tool : String = "CMake";
    attribute target_component : String = "C Driver";
    attribute platform : String = "Evergreen";
    attribute build_system_configured : Boolean;
    stakeholder developer : Developer;
    require constraint CMakeBuildSystemCheck { build_tool == "CMake" and target_component == "C Driver" and platform == "Evergreen" implies build_system_configured == true }
    }

  requirement def FedoraPermissions {
    subject;
    doc /* The C++ Driver package shall follow Fedora packaging guidelines for permissions */
    attribute id : String = "REQ-442.2";
    attribute permissions_correct : Boolean;
    attribute security_context_proper : Boolean;
    attribute file_ownership_correct : Boolean;
    stakeholder developer : Developer;
    stakeholder systemAdmin : SystemAdmin;
    require constraint PermissionsCompliance { permissions_correct == true and security_context_proper == true and file_ownership_correct == true }
    }

  requirement def RedHatFilePlacement {
    subject;
    doc /* The C++ Driver package shall follow RedHat packaging guidelines for file placement */
    attribute id : String = "REQ-443.1";
    attribute file_placement_correct : Boolean;
    attribute filesystem_hierarchy_compliant : Boolean;
    attribute redhat_path_standards_met : Boolean;
    stakeholder developer : Developer;
    stakeholder systemAdmin : SystemAdmin;
    require constraint FilePlacementCompliance { file_placement_correct == true and filesystem_hierarchy_compliant == true and redhat_path_standards_met == true }
    }

  requirement def RedHatPermissions {
    subject;
    doc /* The C++ Driver package shall follow RedHat packaging guidelines for permissions */
    attribute id : String = "REQ-443.2";
    attribute permissions_correct : Boolean;
    attribute security_context_proper : Boolean;
    attribute file_ownership_correct : Boolean;
    stakeholder developer : Developer;
    stakeholder systemAdmin : SystemAdmin;
    require constraint PermissionsCompliance { permissions_correct == true and security_context_proper == true and file_ownership_correct == true }
    }

  requirement def DnfInstallability {
    subject;
    doc /* The C++ Driver package shall be installable using dnf package manager on Fedora systems */
    attribute id : String = "REQ-444";
    attribute dnf_installable : Boolean;
    attribute package_manager : String = "dnf";
    attribute installation_successful : Boolean;
    stakeholder developer : Developer;
    stakeholder systemAdmin : SystemAdmin;
    require constraint DnfInstallationSuccess { dnf_installable == true implies installation_successful == true }
    require constraint PackageManagerCorrect { package_manager == "dnf" }
    }

  requirement def FedoraPackageCompatibility {
    subject;
    doc /* The build system shall generate a C++ Driver package compatible with Fedora package management standards */
    attribute id : String = "REQ-438";
    attribute fedora_standards_compliant : Boolean;
    attribute package_format : String = "rpm";
    attribute fedora_version_support : String = "current";
    stakeholder developer : Developer;
    stakeholder systemAdmin : SystemAdmin;
    require constraint FedoraStandardsCompliance { fedora_standards_compliant == true and package_format == "rpm" and fedora_version_support == "current" }
    }

  requirement def RedHatPackagingGuidelines {
    subject;
    doc /* The C++ Driver package shall follow RedHat packaging guidelines for file placement and permissions */
    attribute id : String = "REQ-443";
    attribute redhat_guidelines_compliant : Boolean;
    attribute file_placement_correct : Boolean;
    attribute permissions_correct : Boolean;
    stakeholder developer : Developer;
    stakeholder systemAdmin : SystemAdmin;
    require constraint RedHatGuidelinesCompliance { redhat_guidelines_compliant == true and file_placement_correct == true and permissions_correct == true }
    }

  requirement def RedHatPackageCompatibility {
    subject;
    doc /* The build system shall generate a C++ Driver package compatible with RedHat package management standards */
    attribute id : String = "REQ-439";
    attribute redhat_standards_compliant : Boolean;
    attribute package_format : String = "rpm";
    attribute rhel_version_support : String = "current";
    stakeholder developer : Developer;
    stakeholder systemAdmin : SystemAdmin;
    require constraint RedHatStandardsCompliance { redhat_standards_compliant == true and package_format == "rpm" and rhel_version_support == "current" }
    }

  requirement def FedoraFilePlacement {
    subject;
    doc /* The C++ Driver package shall follow Fedora packaging guidelines for file placement */
    attribute id : String = "REQ-442.1";
    attribute file_placement_correct : Boolean;
    attribute filesystem_hierarchy_compliant : Boolean;
    attribute fedora_path_standards_met : Boolean;
    stakeholder developer : Developer;
    stakeholder systemAdmin : SystemAdmin;
    require constraint FilePlacementCompliance { file_placement_correct == true and filesystem_hierarchy_compliant == true and fedora_path_standards_met == true }
    }

  requirement def RedHatDependencyInclusion {
    subject;
    doc /* The C++ Driver package shall include all required runtime dependencies for RedHat systems */
    attribute id : String = "REQ-441";
    attribute runtime_dependencies_included : Boolean;
    attribute dependency_resolution_method : String = "automatic";
    attribute rhel_repo_compatible : Boolean;
    stakeholder developer : Developer;
    stakeholder systemAdmin : SystemAdmin;
    require constraint DependencyInclusion { runtime_dependencies_included == true and dependency_resolution_method == "automatic" and rhel_repo_compatible == true }
    }

  requirement def YumInstallability {
    subject;
    doc /* The C++ Driver package shall be installable using yum package manager on RedHat systems */
    attribute id : String = "REQ-445";
    attribute yum_installable : Boolean;
    attribute package_manager : String = "yum";
    attribute installation_successful : Boolean;
    stakeholder developer : Developer;
    stakeholder systemAdmin : SystemAdmin;
    require constraint YumInstallationSuccess { yum_installable == true implies installation_successful == true }
    require constraint PackageManagerCorrect { package_manager == "yum" }
    }

  requirement def FedoraPackagingGuidelines {
    subject;
    doc /* The C++ Driver package shall follow Fedora packaging guidelines for file placement and permissions */
    attribute id : String = "REQ-442";
    attribute fedora_guidelines_compliant : Boolean;
    attribute file_placement_correct : Boolean;
    attribute permissions_correct : Boolean;
    stakeholder developer : Developer;
    stakeholder systemAdmin : SystemAdmin;
    require constraint FedoraGuidelinesCompliance { fedora_guidelines_compliant == true and file_placement_correct == true and permissions_correct == true }
    }

  requirement def FedoraDependencyInclusion {
    subject;
    doc /* The C++ Driver package shall include all required runtime dependencies for Fedora systems */
    attribute id : String = "REQ-440";
    attribute runtime_dependencies_included : Boolean;
    attribute dependency_resolution_method : String = "automatic";
    attribute fedora_repo_compatible : Boolean;
    stakeholder developer : Developer;
    stakeholder systemAdmin : SystemAdmin;
    require constraint DependencyInclusion { runtime_dependencies_included == true and dependency_resolution_method == "automatic" and fedora_repo_compatible == true }
    }

  requirement def EvergreenBacktraceLogging {
    subject;
    doc /* The test framework shall log backtraces when test failures occur on Evergreen */
    attribute id : String = "REQ-473";
    attribute backtrace_logging_enabled : Boolean;
    attribute test_failure_detected : Boolean;
    attribute backtrace_logged : Boolean;
    attribute evergreen_environment : Boolean;
    stakeholder developer : Developer;
    require constraint BacktraceOnFailure { test_failure_detected == true implies backtrace_logged == true }
    assume constraint EvergreenEnvironment { evergreen_environment == true }
    }

  requirement def EvergreenMongoDBSupport {
    subject;
    doc /* The Evergreen test matrix shall include MongoDB 4.0 */
    attribute id : String = "REQ-467";
    attribute mongodb_version_included : String = "4.0";
    attribute test_matrix_configured : Boolean;
    attribute mongodb_support_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint MongoDBVersionInclusion { mongodb_version_included == "4.0" and test_matrix_configured == true and mongodb_support_enabled == true }
    }

  requirement def CppDriverVersionRequirement {
    subject;
    doc /* The C++ Driver shall require libbson and libmongoc version 1.13.0 or higher */
    attribute id : String = "REQ-451";
    attribute required_libbson_version : String = "1.13.0";
    attribute required_libmongoc_version : String = "1.13.0";
    attribute actual_libbson_version : String;
    attribute actual_libmongoc_version : String;
    attribute version_requirement_met : Boolean;
    stakeholder developer : Developer;
    require constraint VersionRequirements { required_libbson_version == "1.13.0" and required_libmongoc_version == "1.13.0" implies version_requirement_met == true }
    }

  requirement def SessionTestAPIUsage {
    subject;
    doc /* The session tests shall use the C++ Driver's command monitoring API instead of libmongoc's API */
    attribute id : String = "REQ-479";
    attribute cpp_driver_api_used : Boolean;
    attribute libmongoc_api_avoided : Boolean;
    attribute command_monitoring_implemented : Boolean;
    attribute session_tests_updated : Boolean;
    stakeholder developer : Developer;
    require constraint APITransition { cpp_driver_api_used == true and libmongoc_api_avoided == true and command_monitoring_implemented == true and session_tests_updated == true }
    }

  requirement def BulkWriteTestConsistency {
    subject;
    doc /* The spec tests shall use consistent format for bulk write operations across all test suites */
    attribute id : String = "REQ-478";
    attribute bulk_write_format_consistent : Boolean;
    attribute test_suites_compliant : Boolean;
    attribute format_standardized : Boolean;
    stakeholder developer : Developer;
    require constraint FormatConsistency { bulk_write_format_consistent == true and test_suites_compliant == true and format_standardized == true }
    }

  requirement def LibmongocScriptExecution {
    subject;
    doc /* The build system shall call required libmongoc scripts before building with cmake to generate proper version numbers */
    attribute id : String = "REQ-450";
    attribute scripts_called : Boolean;
    attribute version_numbers_generated : Boolean;
    attribute cmake_build_initiated : Boolean;
    stakeholder developer : Developer;
    require constraint ScriptExecutionSequence { cmake_build_initiated == true implies (scripts_called == true and version_numbers_generated == true) }
    }

  requirement def DebianPackageNameMetadata {
    subject;
    doc /* The Debian package shall include proper metadata with package name */
    attribute id : String = "REQ-503.1";
    attribute package_name_specified : Boolean;
    attribute package_name_valid : Boolean;
    stakeholder systemAdmin : SystemAdmin;
    stakeholder user : User;
    require constraint PackageNameRequirement { package_name_specified == true and package_name_valid == true }
    }

  requirement def DebianPackageDescriptionMetadata {
    subject;
    doc /* The Debian package shall include proper metadata with description information */
    attribute id : String = "REQ-503.3";
    attribute description_specified : Boolean;
    attribute description_informative : Boolean;
    stakeholder systemAdmin : SystemAdmin;
    stakeholder user : User;
    require constraint DescriptionRequirement { description_specified == true and description_informative == true }
    }

  requirement def DebianPackageGeneration {
    subject;
    doc /* The build system shall generate a Debian package for the C++ Driver that conforms to Debian packaging standards */
    attribute id : String = "REQ-501";
    attribute conforms_to_standards : Boolean;
    attribute package_generated : Boolean;
    stakeholder developer : Developer;
    stakeholder systemAdmin : SystemAdmin;
    require constraint PackageGenerationRequirement { package_generated == true and conforms_to_standards == true }
    }

  requirement def DebianPackageMaintainerMetadata {
    subject;
    doc /* The Debian package shall include proper metadata with maintainer information */
    attribute id : String = "REQ-503.4";
    attribute maintainer_specified : Boolean;
    attribute maintainer_contact_valid : Boolean;
    stakeholder systemAdmin : SystemAdmin;
    stakeholder user : User;
    require constraint MaintainerRequirement { maintainer_specified == true and maintainer_contact_valid == true }
    }

  requirement def DebianPackageMetadata {
    subject;
    doc /* The Debian package shall include proper metadata including package name, version, description, and maintainer information */
    attribute id : String = "REQ-503";
    attribute package_name_present : Boolean;
    attribute version_info_present : Boolean;
    attribute description_present : Boolean;
    attribute maintainer_info_present : Boolean;
    attribute metadata_complete : Boolean;
    stakeholder systemAdmin : SystemAdmin;
    stakeholder user : User;
    require constraint MetadataCompletenessRequirement { package_name_present == true and version_info_present == true and description_present == true and maintainer_info_present == true implies metadata_complete == true }
    }

  requirement def DebianPackageOperationsHandling {
    subject;
    doc /* The Debian package shall properly handle installation, upgrade, and removal operations without system corruption */
    attribute id : String = "REQ-505";
    attribute installation_safe : Boolean;
    attribute upgrade_safe : Boolean;
    attribute removal_safe : Boolean;
    attribute no_system_corruption : Boolean;
    stakeholder systemAdmin : SystemAdmin;
    require constraint SafeOperationsRequirement { installation_safe == true and upgrade_safe == true and removal_safe == true implies no_system_corruption == true }
    }

  requirement def DebianPackageVersionMetadata {
    subject;
    doc /* The Debian package shall include proper metadata with version information */
    attribute id : String = "REQ-503.2";
    attribute version_specified : Boolean;
    attribute version_format_valid : Boolean;
    stakeholder systemAdmin : SystemAdmin;
    stakeholder user : User;
    require constraint VersionRequirement { version_specified == true and version_format_valid == true }
    }

  requirement def DebianPackageInstallability {
    subject;
    doc /* The Debian package shall be installable using standard Debian package management tools (dpkg, apt) */
    attribute id : String = "REQ-504";
    attribute dpkg_compatible : Boolean;
    attribute apt_compatible : Boolean;
    attribute installation_successful : Boolean;
    stakeholder systemAdmin : SystemAdmin;
    stakeholder user : User;
    require constraint InstallabilityRequirement { dpkg_compatible == true and apt_compatible == true implies installation_successful == true }
    }

  requirement def DebianPackageLibrariesInclusion {
    subject;
    doc /* The Debian package shall include all necessary C++ Driver runtime libraries and dependencies */
    attribute id : String = "REQ-502";
    attribute runtime_libraries_included : Boolean;
    attribute dependencies_included : Boolean;
    attribute all_necessary_components_present : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint LibrariesInclusionRequirement { runtime_libraries_included == true and dependencies_included == true implies all_necessary_components_present == true }
    }

  requirement def CMakeStaticLibraryFlags {
    subject;
    doc /* The build system shall provide CMake flags to build static libraries */
    attribute id : String = "REQ-529.2";
    attribute static_library_cmake_flag : Boolean;
    attribute static_library_build_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint StaticLibraryFlagEnablement { static_library_cmake_flag == true implies static_library_build_enabled == true }
    }

  requirement def CMakeLibraryBuildFlags {
    subject;
    doc /* The build system shall provide CMake flags to build both shared and static libraries */
    attribute id : String = "REQ-529";
    attribute shared_library_flag_available : Boolean;
    attribute static_library_flag_available : Boolean;
    attribute both_library_types_supported : Boolean;
    stakeholder developer : Developer;
    require constraint BothLibraryTypesSupport { (shared_library_flag_available == true and static_library_flag_available == true) implies both_library_types_supported == true }
    }

  requirement def DocumentationFilesInstallation {
    subject;
    doc /* The installation shall copy COPYING and THIRD_PARTY_NOTICES files to $PREFIX/share/doc/mongo-cxx-driver */
    attribute id : String = "REQ-540";
    attribute copying_file_installed : Boolean;
    attribute third_party_notices_installed : Boolean;
    attribute installation_path_correct : Boolean;
    attribute target_directory : String = "$PREFIX/share/doc/mongo-cxx-driver";
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint DocumentationFilesComplete { (copying_file_installed == true and third_party_notices_installed == true) implies installation_path_correct == true }
    }

  requirement def CMakeSharedLibraryFlags {
    subject;
    doc /* The build system shall provide CMake flags to build shared libraries */
    attribute id : String = "REQ-529.1";
    attribute shared_library_cmake_flag : Boolean;
    attribute shared_library_build_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint SharedLibraryFlagEnablement { shared_library_cmake_flag == true implies shared_library_build_enabled == true }
    }

  requirement def UninstallTargetProvision {
    subject;
    doc /* The build system shall provide an uninstall target */
    attribute id : String = "REQ-543";
    attribute uninstall_target_available : Boolean;
    attribute build_system_supports_uninstall : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint UninstallTargetSupport { uninstall_target_available == true implies build_system_supports_uninstall == true }
    }

  requirement def CMakeTargetExport {
    subject;
    doc /* The driver shall export CMake targets for use as subprojects */
    attribute id : String = "REQ-530";
    attribute cmake_targets_exported : Boolean;
    attribute subproject_support_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint CMakeTargetSubprojectSupport { cmake_targets_exported == true implies subproject_support_enabled == true }
    }

  requirement def Catch2HeaderUpdate {
    subject;
    doc /* The testing framework shall be updated to use Catch2 header file */
    attribute id : String = "REQ-551";
    attribute framework_type : String = "testing";
    attribute header_file : String = "Catch2";
    attribute framework_updated : Boolean = true;
    stakeholder developer : Developer;
    require constraint FrameworkUpdate { framework_type == "testing" and header_file == "Catch2" implies framework_updated == true }
    }

  #refinement dependency from BuildSystemRequirements::ClangCompilerTesting to BuildSystemRequirements::CompilerTesting;
  #refinement dependency from BuildSystemRequirements::GccCompilerTesting to BuildSystemRequirements::CompilerTesting;
  #refinement dependency from BuildSystemRequirements::CompilerTesting to BuildSystemRequirements::TravisCIIntegration;
  #trace dependency from BuildSystemRequirements::UnitTestAlias to BuildSystemRequirements::TravisCIIntegration;
  #trace dependency from BuildSystemRequirements::ClientExampleAlias to BuildSystemRequirements::TravisCIIntegration;
  #refinement dependency from BuildSystemRequirements::SharedLibraryDefault to SystemRequirements::WindowsDLLVersions;
  #refinement dependency from BuildSystemRequirements::PlatformLibraryExtensions to BuildSystemRequirements::SharedLibraryDefault;
  #trace dependency from BuildSystemRequirements::StaticLibraryOnRequest to BuildSystemRequirements::SharedLibraryDefault;
  #trace dependency from BuildSystemRequirements::StaticLibraryOnRequest to SystemRequirements::DynamicBoostOption;
  #refinement dependency from BuildSystemRequirements::GccVersionSupport to BuildSystemRequirements::CompilerTesting;
  #refinement dependency from BuildSystemRequirements::ClangVersionSupport to BuildSystemRequirements::CompilerTesting;
  #refinement dependency from BuildSystemRequirements::TravisCIModernCompilers to BuildSystemRequirements::TravisCIIntegration;
  #trace dependency from BuildSystemRequirements::GccVersionSupport to BuildSystemRequirements::GccCompilerTesting;
  #trace dependency from BuildSystemRequirements::ClangVersionSupport to BuildSystemRequirements::ClangCompilerTesting;
  #trace dependency from BuildSystemRequirements::TravisCIModernCompilers to BuildSystemRequirements::CompilerTesting;
  #refinement dependency from BuildSystemRequirements::TestLinkingVerification to BuildSystemRequirements::SharedLibraryDefault;
  #refinement dependency from BuildSystemRequirements::ExampleLinkingVerification to BuildSystemRequirements::SharedLibraryDefault;
  #trace dependency from BuildSystemRequirements::BuildArtifactsPlacement to BuildSystemRequirements::SconsDirectoryPrevention;
  #trace dependency from BuildSystemRequirements::BuildArtifactsPlacement to BuildSystemRequirements::SharedClientDirectoryPrevention;
  #trace dependency from BuildSystemRequirements::BuildArtifactsPlacement to BuildSystemRequirements::StaticExecutablePlacement;
  #trace dependency from BuildSystemRequirements::BuildArtifactsPlacement to BuildSystemRequirements::LibmongoclientPlacement;
  #trace dependency from BuildSystemRequirements::TestLinkingVerification to BuildSystemRequirements::ExampleLinkingVerification;
  #trace dependency from BuildSystemRequirements::DirectLibraryLinking to BuildSystemRequirements::SharedLibraryDefault;
  #refinement dependency from BuildSystemRequirements::AtomicsMacroPlacement to SystemRequirements::ConfigHeaderGeneration;
  #trace dependency from BuildSystemRequirements::AtomicsMacroPlacement to SystemRequirements::ODRViolationPrevention;
  #trace dependency from BuildSystemRequirements::DuplicateIDCheckSuppression to BuildSystemRequirements::TcmallocSupportRemoval;
  #trace dependency from BuildSystemRequirements::DuplicateIDCheckSuppression to SystemRequirements::WindowsCallingConvention;
  #trace dependency from BuildSystemRequirements::TcmallocSupportRemoval to SystemRequirements::WindowsRuntimeFlag;
  #trace dependency from BuildSystemRequirements::DuplicateIDCheckSuppression to BuildSystemRequirements::TravisCIIntegration;
  #trace dependency from BuildSystemRequirements::TcmallocSupportRemoval to SystemRequirements::SignalHandlingRemoval;
  #trace dependency from BuildSystemRequirements::ELFDllPathSupport to BuildSystemRequirements::MachODllPathSupport;
  #trace dependency from BuildSystemRequirements::DefaultTargetBuild to BuildSystemRequirements::AllTargetBuild;
  #trace dependency from BuildSystemRequirements::MacOSPlatformTargeting to BuildSystemRequirements::PlatformVersionOverride;
  #trace dependency from BuildSystemRequirements::HostArchVariable to BuildSystemRequirements::TargetArchVariable;
  #trace dependency from BuildSystemRequirements::MSVCVersionVariable to BuildSystemRequirements::MSVCScriptVariable;
  #trace dependency from BuildSystemRequirements::ELFDllPathSupport to BuildSystemRequirements::SharedLibraryDefault;
  #trace dependency from BuildSystemRequirements::LDFlagsEnvironmentSupport to BuildSystemRequirements::HostArchVariable;
  #trace dependency from BuildSystemRequirements::CFlagsEnvironmentSupport to BuildSystemRequirements::HostArchVariable;
  #trace dependency from BuildSystemRequirements::CXXFlagsEnvironmentSupport to BuildSystemRequirements::HostArchVariable;
  #refinement dependency from BuildSystemRequirements::SconsVariableQuoting to BuildSystemRequirements::PythonPathSpaceHandling;
  #trace dependency from BuildSystemRequirements::PythonPathSpaceHandling to BuildSystemRequirements::LDFlagsEnvironmentSupport;
  #refinement dependency from BuildSystemRequirements::AbortCallOnSetupFailure to BuildSystemRequirements::TestSuiteTerminationOnSetupFailure;
  #refinement dependency from BuildSystemRequirements::TestSuiteTerminationOnSetupFailure to BuildSystemRequirements::PreventTestExecutionOnInvalidSetup;
  #trace dependency from BuildSystemRequirements::AbortCallOnSetupFailure to BuildSystemRequirements::PreventTestExecutionOnInvalidSetup;
  #trace dependency from BuildSystemRequirements::PedanticCompilationSupport to SystemRequirements::BSONStrictAliasingCompliance;
  #trace dependency from BuildSystemRequirements::EvergreenBSONTestExecution to BuildSystemRequirements::TravisBSONTestExecution;
  #trace dependency from BuildSystemRequirements::CMakeDriverDiscoveryAlternative to BuildSystemRequirements::CMakeWindowsPlatformSupport;
  #derivation dependency from BuildSystemRequirements::B64HeaderPrivateRelocation to BuildSystemRequirements::B64HeaderInstallationPrevention;
  #trace dependency from BuildSystemRequirements::MSVCBoostLibraryDefault to SystemRequirements::DynamicBoostOption;
  #trace dependency from BuildSystemRequirements::CMakePolyfillValidation to BuildSystemRequirements::CMakeCompilerVersionEnforcement;
  #trace dependency from BuildSystemRequirements::ClangFormatProductionSupport to BuildSystemRequirements::SharedLibraryDefault;
  #refinement dependency from BuildSystemRequirements::TestUtilDirectoryCreation to BuildSystemRequirements::NamespaceRenaming;
  #refinement dependency from BuildSystemRequirements::MockDirectoryRemoval to BuildSystemRequirements::NamespaceRenaming;
  #derivation dependency from BuildSystemRequirements::TestInfrastructureAccessibility to BuildSystemRequirements::NamespaceRenaming;
  #trace dependency from BuildSystemRequirements::TestUtilDirectoryCreation to BuildSystemRequirements::MockDirectoryRemoval;
  #refinement dependency from BuildSystemRequirements::StaticLibraryOnlyConfiguration to BuildSystemRequirements::StaticLibraryOnRequest;
  #refinement dependency from BuildSystemRequirements::SharedLibraryOnlyConfiguration to BuildSystemRequirements::SharedLibraryDefault;
  #refinement dependency from BuildSystemRequirements::CMakeBuildSharedLibsSupport to BuildSystemRequirements::PlatformLibraryExtensions;
  #trace dependency from BuildSystemRequirements::IndependentSSLConfiguration to SystemRequirements::ClientInitializationSSLOptions;
  #trace dependency from BuildSystemRequirements::ExplicitSSLEnablementWithValidation to SystemRequirements::ClientInitializationSSLOptions;
  #trace dependency from BuildSystemRequirements::ExplicitSSLDisablement to SystemRequirements::ClientInitializationSSLOptions;
  #trace dependency from BuildSystemRequirements::AutomaticSSLConfiguration to SystemRequirements::ClientInitializationSSLOptions;
  #refinement dependency from BuildSystemRequirements::CMakeCppStandardParameter to BuildSystemRequirements::CppSeventeenMinGWSupport;
  #refinement dependency from BuildSystemRequirements::BsonCxxPolyExperimentalFlag to BuildSystemRequirements::CppSeventeenMinGWSupport;
  #trace dependency from BuildSystemRequirements::CppSeventeenMinGWSupport to BuildSystemRequirements::HostArchVariable;
  #trace dependency from BuildSystemRequirements::CMakeCppStandardParameter to BuildSystemRequirements::MSVCVersionVariable;
  #trace dependency from BuildSystemRequirements::PkgConfigTestInclusion to BuildSystemRequirements::CMakeConfigTestInclusion;
  #trace dependency from BuildSystemRequirements::MongocxxStaticLibraryNaming to BuildSystemRequirements::BsoncxxStaticLibraryNaming;
  #trace dependency from BuildSystemRequirements::MongocxxStaticPkgConfigFiles to BuildSystemRequirements::BsoncxxStaticPkgConfigFiles;
  #trace dependency from BuildSystemRequirements::MongocxxStaticCMakeConfigFiles to BuildSystemRequirements::BsoncxxStaticCMakeConfigFiles;
  #trace dependency from BuildSystemRequirements::MongocxxStaticLibraryDependency to BuildSystemRequirements::BsoncxxStaticLibraryDependency;
  #trace dependency from BuildSystemRequirements::PkgConfigTestInclusion to BuildSystemRequirements::TestLinkingVerification;
  #trace dependency from BuildSystemRequirements::MongocxxStaticLibraryNaming to BuildSystemRequirements::StaticLibraryOnRequest;
  #refinement dependency from BuildSystemRequirements::FedoraFilePlacement to BuildSystemRequirements::FedoraPackagingGuidelines;
  #refinement dependency from BuildSystemRequirements::FedoraPermissions to BuildSystemRequirements::FedoraPackagingGuidelines;
  #refinement dependency from BuildSystemRequirements::RedHatFilePlacement to BuildSystemRequirements::RedHatPackagingGuidelines;
  #refinement dependency from BuildSystemRequirements::RedHatPermissions to BuildSystemRequirements::RedHatPackagingGuidelines;
  #trace dependency from BuildSystemRequirements::FedoraPackageCompatibility to BuildSystemRequirements::RedHatPackageCompatibility;
  #trace dependency from BuildSystemRequirements::FedoraDependencyInclusion to BuildSystemRequirements::RedHatDependencyInclusion;
  #trace dependency from BuildSystemRequirements::DnfInstallability to BuildSystemRequirements::YumInstallability;
  #trace dependency from BuildSystemRequirements::FedoraPackagingGuidelines to BuildSystemRequirements::RedHatPackagingGuidelines;
  #trace dependency from BuildSystemRequirements::FedoraPackageCompatibility to BuildSystemRequirements::SharedLibraryDefault;
  #trace dependency from BuildSystemRequirements::RedHatPackageCompatibility to BuildSystemRequirements::SharedLibraryDefault;
  #trace dependency from BuildSystemRequirements::FedoraDependencyInclusion to BuildSystemRequirements::PlatformLibraryExtensions;
  #trace dependency from BuildSystemRequirements::RedHatDependencyInclusion to BuildSystemRequirements::PlatformLibraryExtensions;
  #refinement dependency from BuildSystemRequirements::DebianPackageLibrariesInclusion to BuildSystemRequirements::DebianPackageGeneration;
  #refinement dependency from BuildSystemRequirements::DebianPackageMetadata to BuildSystemRequirements::DebianPackageGeneration;
  #refinement dependency from BuildSystemRequirements::DebianPackageNameMetadata to BuildSystemRequirements::DebianPackageMetadata;
  #refinement dependency from BuildSystemRequirements::DebianPackageVersionMetadata to BuildSystemRequirements::DebianPackageMetadata;
  #refinement dependency from BuildSystemRequirements::DebianPackageDescriptionMetadata to BuildSystemRequirements::DebianPackageMetadata;
  #refinement dependency from BuildSystemRequirements::DebianPackageMaintainerMetadata to BuildSystemRequirements::DebianPackageMetadata;
  #refinement dependency from BuildSystemRequirements::DebianPackageInstallability to BuildSystemRequirements::DebianPackageGeneration;
  #refinement dependency from BuildSystemRequirements::DebianPackageOperationsHandling to BuildSystemRequirements::DebianPackageGeneration;
  #trace dependency from BuildSystemRequirements::DebianPackageGeneration to BuildSystemRequirements::FedoraPackageCompatibility;
  #trace dependency from BuildSystemRequirements::DebianPackageGeneration to BuildSystemRequirements::RedHatPackageCompatibility;
  #trace dependency from BuildSystemRequirements::DebianPackageLibrariesInclusion to BuildSystemRequirements::FedoraDependencyInclusion;
  #trace dependency from BuildSystemRequirements::DebianPackageLibrariesInclusion to BuildSystemRequirements::RedHatDependencyInclusion;
  #trace dependency from BuildSystemRequirements::DebianPackageInstallability to BuildSystemRequirements::DnfInstallability;
  #trace dependency from BuildSystemRequirements::DebianPackageInstallability to BuildSystemRequirements::YumInstallability;
  #refinement dependency from BuildSystemRequirements::CMakeSharedLibraryFlags to BuildSystemRequirements::CMakeLibraryBuildFlags;
  #refinement dependency from BuildSystemRequirements::CMakeStaticLibraryFlags to BuildSystemRequirements::CMakeLibraryBuildFlags;
  #trace dependency from BuildSystemRequirements::CMakeTargetExport to BuildSystemRequirements::CMakeLibraryBuildFlags;
  #trace dependency from BuildSystemRequirements::UninstallTargetProvision to BuildSystemRequirements::CMakeLibraryBuildFlags;
  #trace dependency from BuildSystemRequirements::CMakeTargetExport to BuildSystemRequirements::CMakeCDriverBuild;
  #trace dependency from BuildSystemRequirements::UninstallTargetProvision to BuildSystemRequirements::CMakeCDriverBuild;
  #trace dependency from BuildSystemRequirements::DocumentationFilesInstallation to DocumentationRequirements::CDriverFunctionDocumentation;
  }

package CodebaseCleanupRequirements {
  private import Requirements::*;
  public import ScalarValues::*;
  public import ModelingMetadata::*;
  public import RequirementDerivation::*;

  metadata def <trace> Trace { :>> annotatedElement : SysML::Dependency; }
  part def Developer;
  part def SystemOperator;
  part def User;
  part def Administrator;
  part def Customer;
  part def SystemAdmin;

  requirement def SynchronizationFilesExclusion {
    subject;
    doc /* The driver source code shall exclude synchronization.cpp and synchronization.h files */
    attribute id : String = "REQ-033";
    attribute cpp_file_excluded : Boolean;
    attribute header_file_excluded : Boolean;
    attribute cpp_filename : String = "synchronization.cpp";
    attribute header_filename : String = "synchronization.h";
    stakeholder developer : Developer;
    require constraint SynchronizationFilesExcluded { cpp_file_excluded == true and header_file_excluded == true }
    }

  requirement def ThreadPoolFilesExclusion {
    subject;
    doc /* The driver source code shall exclude thread_pool.cpp and thread_pool.h files */
    attribute id : String = "REQ-034";
    attribute cpp_file_excluded : Boolean;
    attribute header_file_excluded : Boolean;
    attribute cpp_filename : String = "thread_pool.cpp";
    attribute header_filename : String = "thread_pool.h";
    stakeholder developer : Developer;
    require constraint ThreadPoolFilesExcluded { cpp_file_excluded == true and header_file_excluded == true }
    }

  requirement def IntrusiveCounterFilesExclusion {
    subject;
    doc /* The driver source code shall exclude intrusive_counter.cpp and intrusive_counter.h files */
    attribute id : String = "REQ-035";
    attribute cpp_file_excluded : Boolean;
    attribute header_file_excluded : Boolean;
    attribute cpp_filename : String = "intrusive_counter.cpp";
    attribute header_filename : String = "intrusive_counter.h";
    stakeholder developer : Developer;
    require constraint IntrusiveCounterFilesExcluded { cpp_file_excluded == true and header_file_excluded == true }
    }

  requirement def HexdumpReplacement {
    subject;
    doc /* The driver shall replace hexdump usage in sock.cpp with alternative implementation */
    attribute id : String = "REQ-113";
    attribute source_filename : String = "sock.cpp";
    attribute function_name : String = "hexdump";
    attribute alternative_implemented : Boolean;
    attribute hexdump_usage_removed : Boolean;
    stakeholder developer : Developer;
    require constraint ReplacementComplete { alternative_implemented == true and hexdump_usage_removed == true }
    }

  requirement def StaticObserverRemoval {
    subject;
    doc /* The driver shall remove the StaticObserver class from ReplicaSetMonitor */
    attribute id : String = "REQ-107";
    attribute class_name : String = "StaticObserver";
    attribute parent_component : String = "ReplicaSetMonitor";
    attribute class_removed : Boolean;
    stakeholder developer : Developer;
    require constraint ClassRemoval { class_name == "StaticObserver" and parent_component == "ReplicaSetMonitor" implies class_removed == true }
    }

  requirement def GoodiesHeaderRemoval {
    subject;
    doc /* The driver shall remove the goodies.h header file */
    attribute id : String = "REQ-112";
    attribute header_filename : String = "goodies.h";
    attribute header_removed : Boolean;
    stakeholder developer : Developer;
    require constraint HeaderRemoval { header_filename == "goodies.h" implies header_removed == true }
    }

  requirement def PeriodicTaskRunnerRemoval {
    subject;
    doc /* The driver shall remove the PeriodicTaskRunner component when the connection pool is removed */
    attribute id : String = "REQ-104";
    attribute component_name : String = "PeriodicTaskRunner";
    attribute component_removed : Boolean;
    attribute connection_pool_removed : Boolean;
    stakeholder developer : Developer;
    require constraint ComponentRemovalDependency { connection_pool_removed == true implies component_removed == true }
    }

  requirement def LogMacroRemoval {
    subject;
    doc /* The driver shall remove the LOG macro from its codebase */
    attribute id : String = "REQ-132";
    attribute macro_name : String = "LOG";
    attribute macro_removed : Boolean;
    stakeholder developer : Developer;
    require constraint MacroRemoval { macro_name == "LOG" implies macro_removed == true }
    }

  requirement def NDEBUGMacroUsage {
    subject;
    doc /* The driver shall use NDEBUG macro instead of _DEBUG for debug mode detection */
    attribute id : String = "REQ-126";
    attribute preferred_macro : String = "NDEBUG";
    attribute deprecated_macro : String = "_DEBUG";
    attribute macro_migration_complete : Boolean;
    stakeholder developer : Developer;
    require constraint MacroMigration { preferred_macro == "NDEBUG" and deprecated_macro == "_DEBUG" implies macro_migration_complete == true }
    }

  requirement def MongoBoTypedefRemoval {
    subject;
    doc /* The MongoDB C++ driver shall remove the mongo::bo typedef */
    attribute id : String = "REQ-157";
    attribute typedef_name : String = "mongo::bo";
    attribute removal_required : Boolean = true;
    attribute namespace_scope : String = "mongo";
    stakeholder developer : Developer;
    require constraint BoTypedefRemoval { typedef_name == "mongo::bo" and removal_required == true }
    }

  requirement def ThreadNameSupportRemoval {
    subject;
    doc /* The MongoDB C++ driver shall remove thread name support functionality */
    attribute id : String = "REQ-162";
    attribute functionality_name : String = "thread_name_support";
    attribute removal_required : Boolean = true;
    attribute feature_type : String = "functionality";
    stakeholder developer : Developer;
    require constraint ThreadNameFunctionalityRemoval { functionality_name == "thread_name_support" and removal_required == true }
    }

  requirement def MongoBobTypedefRemoval {
    subject;
    doc /* The MongoDB C++ driver shall remove the mongo::bob typedef */
    attribute id : String = "REQ-158";
    attribute typedef_name : String = "mongo::bob";
    attribute removal_required : Boolean = true;
    attribute namespace_scope : String = "mongo";
    stakeholder developer : Developer;
    require constraint BobTypedefRemoval { typedef_name == "mongo::bob" and removal_required == true }
    }

  requirement def MongoBeTypedefRemoval {
    subject;
    doc /* The MongoDB C++ driver shall remove the mongo::be typedef */
    attribute id : String = "REQ-159";
    attribute typedef_name : String = "mongo::be";
    attribute removal_required : Boolean = true;
    attribute namespace_scope : String = "mongo";
    stakeholder developer : Developer;
    require constraint BeTypedefRemoval { typedef_name == "mongo::be" and removal_required == true }
    }

  requirement def PImplVisibilityTagging {
    subject;
    doc /* PImpl idiom implementation classes shall be tagged with private visibility to exclude them from the ABI */
    attribute id : String = "REQ-194";
    attribute pimpl_classes_tagged : Boolean;
    attribute excluded_from_abi : Boolean;
    attribute private_visibility_applied : Boolean;
    stakeholder developer : Developer;
    require constraint PImplTagging { pimpl_classes_tagged == true and excluded_from_abi == true and private_visibility_applied == true }
    }

  requirement def PrivateVisibilityTagging {
    subject;
    doc /* All private methods and types within ABI-visible classes shall be tagged with private visibility macros */
    attribute id : String = "REQ-193";
    attribute private_methods_tagged : Boolean;
    attribute private_types_tagged : Boolean;
    attribute uses_visibility_macros : Boolean;
    stakeholder developer : Developer;
    require constraint PrivateTagging { private_methods_tagged == true and private_types_tagged == true and uses_visibility_macros == true }
    }

  requirement def NoexceptSpecifierMarking {
    subject;
    doc /* Methods identified as non-throwing shall be marked with noexcept specifier */
    attribute id : String = "REQ-196";
    attribute non_throwing_methods_marked : Boolean;
    attribute noexcept_specifier_applied : Boolean;
    attribute methods_properly_marked : Boolean;
    stakeholder developer : Developer;
    require constraint NoexceptMarking { non_throwing_methods_marked == true and noexcept_specifier_applied == true and methods_properly_marked == true }
    }

  requirement def NoexceptMethodAudit {
    subject;
    doc /* The C++11 driver shall be audited to identify methods that should be marked with noexcept */
    attribute id : String = "REQ-195";
    attribute audit_completed : Boolean;
    attribute methods_identified : Boolean;
    attribute noexcept_candidates_found : Boolean;
    stakeholder developer : Developer;
    require constraint NoexceptAudit { audit_completed == true and methods_identified == true and noexcept_candidates_found == true }
    }

  requirement def AtomicWordHeaderCleanup {
    subject;
    doc /* The atomic_word_cxx11.h header file shall not contain extraneous semicolons that trigger pedantic compiler warnings */
    attribute id : String = "REQ-214";
    attribute header_filename : String = "atomic_word_cxx11.h";
    attribute extraneous_semicolons_present : Boolean;
    attribute pedantic_warnings_triggered : Boolean;
    stakeholder developer : Developer;
    require constraint NoExtraneousSemicolons { extraneous_semicolons_present == false }
    require constraint NoWarningsTriggered { extraneous_semicolons_present == true implies pedantic_warnings_triggered == true }
    }

  requirement def InlineMacroRelocation {
    subject;
    doc /* The BSONCXX_INLINE and MONGOCXX_INLINE macros shall be moved to a dedicated compiler header */
    attribute id : String = "REQ-247";
    attribute bsoncxx_inline_moved : Boolean;
    attribute mongocxx_inline_moved : Boolean;
    attribute dedicated_header_created : Boolean;
    stakeholder developer : Developer;
    require constraint MacroRelocationComplete { dedicated_header_created == true implies (bsoncxx_inline_moved == true and mongocxx_inline_moved == true) }
    }

  requirement def ConstReferenceParameterUsage {
    subject;
    doc /* The mongoc_error.hpp file shall use const reference parameters instead of value parameters for bson_error_t types */
    attribute id : String = "REQ-227";
    attribute file_name : String = "mongoc_error.hpp";
    attribute const_reference_used : Boolean;
    attribute value_parameters_used : Boolean = false;
    attribute parameter_type : String = "bson_error_t";
    stakeholder developer : Developer;
    require constraint ParameterTypeCorrectness { const_reference_used == true and value_parameters_used == false }
    }

  requirement def InsertManyTestUpdate {
    subject;
    doc /* The insert_many test in test/collection.cpp shall be updated to current implementation standards */
    attribute id : String = "REQ-229";
    attribute test_file : String = "test/collection.cpp";
    attribute test_name : String = "insert_many";
    attribute updated_to_standards : Boolean;
    stakeholder developer : Developer;
    require constraint TestUpdatedToStandards { updated_to_standards == true }
    }

  requirement def DeprecatedMethodRemoval {
    subject;
    doc /* All MongoDB C++ driver classes shall remove deprecated implementation methods */
    attribute id : String = "REQ-234";
    attribute deprecated_methods_removed : Boolean;
    attribute driver_classes_updated : Boolean;
    stakeholder developer : Developer;
    require constraint DeprecatedMethodsRemoved { deprecated_methods_removed == true and driver_classes_updated == true }
    }

  requirement def IncludeOrderingMaintenance {
    subject;
    doc /* The codebase shall maintain proper include ordering across all C++ headers and source files */
    attribute id : String = "REQ-266";
    attribute total_cpp_files : Integer;
    attribute include_ordering_violations : Integer;
    attribute ordering_compliance_percentage : Real;
    stakeholder developer : Developer;
    require constraint OrderingCompliance { include_ordering_violations == 0 }
    }

  requirement def HeaderIncludeDiscipline {
    subject;
    doc /* The codebase shall follow proper header include discipline across all C++ headers and source files */
    attribute id : String = "REQ-265";
    attribute cpp_header_files : Integer;
    attribute cpp_source_files : Integer;
    attribute include_discipline_compliance : Real;
    attribute min_compliance_threshold : Real;
    stakeholder developer : Developer;
    require constraint DisciplineCompliance { include_discipline_compliance >= min_compliance_threshold }
    }

  requirement def SourceFileHeaderOrdering {
    subject;
    doc /* Each C++ source file shall include its corresponding header file as the first include statement */
    attribute id : String = "REQ-265.2";
    attribute source_files_checked : Integer;
    attribute first_include_violations : Integer;
    attribute header_ordering_compliance : Real;
    stakeholder developer : Developer;
    require constraint FirstIncludeCompliance { first_include_violations == 0 }
    }

  requirement def SystemHeaderOrdering {
    subject;
    doc /* C++ header files shall include system headers before project headers */
    attribute id : String = "REQ-265.4";
    attribute header_files_with_includes : Integer;
    attribute system_header_ordering_violations : Integer;
    attribute header_ordering_compliance : Real;
    stakeholder developer : Developer;
    require constraint SystemHeaderFirst { system_header_ordering_violations == 0 }
    }

  requirement def MinimalHeaderIncludes {
    subject;
    doc /* Each C++ header file shall include only the minimum necessary headers required for its interface declaration */
    attribute id : String = "REQ-265.1";
    attribute header_files_analyzed : Integer;
    attribute unnecessary_includes_removed : Integer;
    attribute minimal_include_compliance : Real;
    attribute min_compliance_threshold : Real;
    stakeholder developer : Developer;
    require constraint MinimalIncludeCompliance { minimal_include_compliance >= min_compliance_threshold }
    }

  requirement def CopyrightHeaderInclusion {
    subject;
    doc /* All files checked into git shall include appropriate copyright headers */
    attribute id : String = "REQ-267";
    attribute git_tracked_files : Integer;
    attribute files_with_copyright : Integer;
    attribute copyright_compliance_percentage : Real;
    stakeholder developer : Developer;
    require constraint CopyrightCompliance { files_with_copyright == git_tracked_files }
    }

  requirement def ForwardDeclarationUsage {
    subject;
    doc /* C++ header files shall use forward declarations instead of includes when only pointer or reference types are needed */
    attribute id : String = "REQ-265.3";
    attribute forward_declaration_opportunities : Integer;
    attribute forward_declarations_implemented : Integer;
    attribute include_reduction_percentage : Real;
    stakeholder developer : Developer;
    require constraint ForwardDeclarationImplemented { forward_declarations_implemented >= forward_declaration_opportunities }
    }

  requirement def CallingConventionMacroTagging {
    subject;
    doc /* All free functions shall be tagged with calling convention macros to enforce cdecl convention on Windows */
    attribute id : String = "REQ-270";
    attribute free_functions_count : Integer;
    attribute tagged_functions : Integer;
    attribute windows_cdecl_compliance : Real;
    stakeholder developer : Developer;
    require constraint CallingConventionTagged { tagged_functions >= free_functions_count }
    }

  requirement def ClangFormatExamplesDirectory {
    subject;
    doc /* The clang_format.py tool shall format all source files in the examples/ directory */
    attribute id : String = "REQ-283";
    attribute tool_name : String = "clang_format.py";
    attribute target_directory : String = "examples/";
    attribute all_source_files_formatted : Boolean;
    stakeholder developer : Developer;
    require constraint ExamplesFormatted { all_source_files_formatted == true }
    }

  requirement def NewlineOutputOptimization {
    subject;
    doc /* The system shall use '\n' instead of std::endl for output operations to avoid unnecessary buffer flushes */
    attribute id : String = "REQ-286";
    attribute uses_newline_character : Boolean;
    attribute avoids_std_endl : Boolean;
    attribute prevents_unnecessary_flushes : Boolean;
    stakeholder developer : Developer;
    require constraint OptimizedOutput { uses_newline_character == true and avoids_std_endl == true and prevents_unnecessary_flushes == true }
    }

  requirement def LibbsonScopedConstructorExclusion {
    subject;
    doc /* The libbson.hh file shall not contain explicit scoped_bson_t constructor with document::view_or_value parameter */
    attribute id : String = "REQ-355";
    attribute target_file : String = "libbson.hh";
    attribute constructor_type : String = "scoped_bson_t";
    attribute parameter_type : String = "document::view_or_value";
    attribute explicit_constructor_present : Boolean;
    stakeholder developer : Developer;
    require constraint ConstructorExclusionCheck { explicit_constructor_present == false }
    }

  requirement def CatchHeaderLineComment {
    subject;
    doc /* The catch.hpp file shall have line 823 commented out to resolve pointer-integer comparison error */
    attribute id : String = "REQ-357";
    attribute target_file : String = "catch.hpp";
    attribute line_number : Integer = 823;
    attribute line_commented : Boolean;
    attribute comparison_error_resolved : Boolean;
    stakeholder developer : Developer;
    require constraint LineCommentedCheck { line_number == 823 implies line_commented == true }
    require constraint ErrorResolutionCheck { line_commented == true implies comparison_error_resolved == true }
    }

  requirement def LibbsonInitMethodExclusion {
    subject;
    doc /* The libbson.hh file shall not contain init_from_static method with document::view_or_value parameter */
    attribute id : String = "REQ-356";
    attribute target_file : String = "libbson.hh";
    attribute method_name : String = "init_from_static";
    attribute parameter_type : String = "document::view_or_value";
    attribute method_present : Boolean;
    stakeholder developer : Developer;
    require constraint MethodExclusionCheck { method_present == false }
    }

  requirement def FunctorHeaderInclusion {
    subject;
    doc /* The functor.hpp file shall include the functional header for STL function support */
    attribute id : String = "REQ-354";
    attribute target_file : String = "functor.hpp";
    attribute required_header : String = "functional";
    attribute header_included : Boolean;
    attribute stl_support_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint HeaderInclusionCheck { header_included == true }
    require constraint STLSupportCheck { header_included == true implies stl_support_enabled == true }
    }

  requirement def DeprecationWarningMacroRemoval {
    subject;
    doc /* The BSONCXX_SUPPRESS_DEPRECATION_WARNINGS_BEGIN macro shall be removed from test files */
    attribute id : String = "REQ-361";
    attribute macro_instances_found : Integer;
    attribute test_files_processed : Integer;
    attribute macro_name : String = "BSONCXX_SUPPRESS_DEPRECATION_WARNINGS_BEGIN";
    stakeholder developer : Developer;
    require constraint MacroRemovalComplete { macro_instances_found == 0 }
    }

  requirement def TestFileDeprecatedMethodsProhibition {
    subject;
    doc /* The test files shall not use deprecated methods */
    attribute id : String = "REQ-360";
    attribute deprecated_methods_count : Integer;
    attribute test_files_scanned : Integer;
    stakeholder developer : Developer;
    require constraint NoDeprecatedMethods { deprecated_methods_count == 0 }
    }

  requirement def LibmongocDeprecatedFunctionAvoidance {
    subject;
    doc /* The MongoDB C++ driver shall not use functions deprecated in libmongoc 1.9.0 and older */
    attribute id : String = "REQ-422";
    attribute library_name : String = "libmongoc";
    attribute deprecated_version_threshold : String = "1.9.0";
    attribute uses_deprecated_functions : Boolean = false;
    stakeholder developer : Developer;
    require constraint DeprecatedFunctionAvoidanceCheck { library_name == "libmongoc" and deprecated_version_threshold == "1.9.0" implies uses_deprecated_functions == false }
    }

  requirement def OptionsEqualityOperatorRemoval {
    subject;
    doc /* All options classes shall have their operator== removed */
    attribute id : String = "REQ-459.1";
    attribute target_classes : String = "options";
    attribute specific_operator : String = "operator==";
    attribute removal_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint EqualityOperatorRemoval { target_classes == "options" and specific_operator == "operator==" and removal_required == true }
    }

  requirement def ClientPrivateMethodRemoval {
    subject;
    doc /* The client::client_t_from_client() private method shall be removed */
    attribute id : String = "REQ-480";
    attribute method_name : String = "client_t_from_client";
    attribute api_class : String = "client";
    attribute method_visibility : String = "private";
    attribute removal_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint PrivateMethodRemoval { method_name == "client_t_from_client" and api_class == "client" and removal_required == true }
    }

  requirement def CreateCollectionFieldsRemoval {
    subject;
    doc /* All strongly-typed fields in options::create_collection shall be removed */
    attribute id : String = "REQ-476.2";
    attribute target_class : String = "options::create_collection";
    attribute field_type : String = "strongly-typed";
    attribute removal_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint StronglyTypedFieldsRemoval { target_class == "options::create_collection" and field_type == "strongly-typed" and removal_required == true }
    }

  requirement def DatabaseModifyCollectionRemoval {
    subject;
    doc /* The database::modify_collection method shall be removed from the API */
    attribute id : String = "REQ-452";
    attribute method_name : String = "modify_collection";
    attribute api_class : String = "database";
    attribute removal_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint MethodRemoval { method_name == "modify_collection" and api_class == "database" and removal_required == true }
    }

  requirement def CreateCollectionFieldsDeprecationRemoval {
    subject;
    doc /* All strongly-typed fields in options::create_collection shall be deprecated and removed */
    attribute id : String = "REQ-476";
    attribute target_class : String = "options::create_collection";
    attribute field_type : String = "strongly-typed";
    attribute deprecation_required : Boolean = true;
    attribute removal_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint DeprecationAndRemoval { target_class == "options::create_collection" and field_type == "strongly-typed" and deprecation_required == true and removal_required == true }
    }

  requirement def DistinctHelperAlternatives {
    subject;
    doc /* The C++ driver shall consider alternatives to mongoc_cursor_new_from_command_reply for implementing the distinct helper */
    attribute id : String = "REQ-457";
    attribute target_function : String = "mongoc_cursor_new_from_command_reply";
    attribute helper_name : String = "distinct";
    attribute alternatives_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint AlternativesConsidered { target_function == "mongoc_cursor_new_from_command_reply" and helper_name == "distinct" and alternatives_required == true }
    }

  requirement def OptionsComparisonOperatorRemoval {
    subject;
    doc /* All options classes shall have their comparison operators removed */
    attribute id : String = "REQ-459";
    attribute target_classes : String = "options";
    attribute operator_type : String = "comparison";
    attribute removal_scope : String = "all";
    stakeholder developer : Developer;
    require constraint ComparisonOperatorRemoval { target_classes == "options" and operator_type == "comparison" and removal_scope == "all" }
    }

  requirement def AggregateUseCursorOptionRemoval {
    subject;
    doc /* The options::aggregate::use_cursor option shall be removed */
    attribute id : String = "REQ-474";
    attribute option_class : String = "options::aggregate";
    attribute option_name : String = "use_cursor";
    attribute removal_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint UseCursorOptionRemoval { option_class == "options::aggregate" and option_name == "use_cursor" and removal_required == true }
    }

  requirement def CreateViewMethodDeprecation {
    subject;
    doc /* The database::create_view method shall be marked as deprecated */
    attribute id : String = "REQ-477.1";
    attribute method_name : String = "create_view";
    attribute api_class : String = "database";
    attribute deprecation_marking : Boolean = true;
    stakeholder developer : Developer;
    require constraint DeprecationMarked { method_name == "create_view" and api_class == "database" implies deprecation_marking == true }
    }

  requirement def CreateCollectionFieldsDeprecation {
    subject;
    doc /* All strongly-typed fields in options::create_collection shall be deprecated */
    attribute id : String = "REQ-476.1";
    attribute target_class : String = "options::create_collection";
    attribute field_type : String = "strongly-typed";
    attribute deprecation_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint StronglyTypedFieldsDeprecated { target_class == "options::create_collection" and field_type == "strongly-typed" implies deprecation_required == true }
    }

  requirement def BulkWriteConstructorRemoval {
    subject;
    doc /* The public bulk_write constructor shall be removed */
    attribute id : String = "REQ-487";
    attribute constructor_class : String = "bulk_write";
    attribute visibility : String = "public";
    attribute removal_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint PublicConstructorRemoved { constructor_class == "bulk_write" and visibility == "public" implies removal_required == true }
    }

  requirement def CreateViewMethodRemoval {
    subject;
    doc /* The database::create_view method shall be removed from the codebase */
    attribute id : String = "REQ-477.2";
    attribute method_name : String = "create_view";
    attribute api_class : String = "database";
    attribute codebase_removal : Boolean = true;
    stakeholder developer : Developer;
    require constraint MethodRemovedFromCodebase { method_name == "create_view" and api_class == "database" implies codebase_removal == true }
    }

  requirement def CountHelperDeprecation {
    subject;
    doc /* The C++ driver shall deprecate the count() helper wrapper when mongoc_collection_count_with_opts is deprecated */
    attribute id : String = "REQ-458";
    attribute helper_method : String = "count";
    attribute dependency_function : String = "mongoc_collection_count_with_opts";
    attribute conditional_deprecation : Boolean = true;
    stakeholder developer : Developer;
    require constraint ConditionalDeprecation { helper_method == "count" and dependency_function == "mongoc_collection_count_with_opts" implies conditional_deprecation == true }
    }

  requirement def CountHelperMethodDeprecation {
    subject;
    doc /* The C++ driver shall deprecate the count() helper method */
    attribute id : String = "REQ-463";
    attribute method_name : String = "count";
    attribute method_type : String = "helper";
    attribute deprecation_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint CountHelperDeprecated { method_name == "count" and method_type == "helper" implies deprecation_required == true }
    }

  requirement def CollectionBulkWriteMethodRemoval {
    subject;
    doc /* The collection::bulk_write(bulk_write&) method shall be removed */
    attribute id : String = "REQ-482";
    attribute method_name : String = "bulk_write";
    attribute api_class : String = "collection";
    attribute parameter_type : String = "bulk_write&";
    attribute removal_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint SpecificMethodRemoval { method_name == "bulk_write" and api_class == "collection" and parameter_type == "bulk_write&" implies removal_required == true }
    }

  requirement def CreateViewMethodDeprecationRemoval {
    subject;
    doc /* The database::create_view method shall be deprecated and removed */
    attribute id : String = "REQ-477";
    attribute method_name : String = "create_view";
    attribute api_class : String = "database";
    attribute deprecation_required : Boolean = true;
    attribute removal_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint DeprecationAndRemoval { method_name == "create_view" and api_class == "database" implies (deprecation_required == true and removal_required == true) }
    }

  requirement def CursorCommandReplyOptsUsage {
    subject;
    doc /* The C++ driver shall use mongoc_cursor_new_from_command_reply_with_opts instead of the deprecated mongoc_cursor_new_from_command_reply */
    attribute id : String = "REQ-462";
    attribute preferred_function : String = "mongoc_cursor_new_from_command_reply_with_opts";
    attribute deprecated_function : String = "mongoc_cursor_new_from_command_reply";
    attribute replacement_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint FunctionReplacement { preferred_function == "mongoc_cursor_new_from_command_reply_with_opts" and deprecated_function == "mongoc_cursor_new_from_command_reply" implies replacement_required == true }
    }

  requirement def CursorCommandReplyMigration {
    subject;
    doc /* The C++ driver shall migrate from mongoc_cursor_new_from_command_reply to mongoc_cursor_new_from_command_reply_with_opts */
    attribute id : String = "REQ-456";
    attribute old_function : String = "mongoc_cursor_new_from_command_reply";
    attribute new_function : String = "mongoc_cursor_new_from_command_reply_with_opts";
    attribute migration_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint FunctionMigration { old_function == "mongoc_cursor_new_from_command_reply" and new_function == "mongoc_cursor_new_from_command_reply_with_opts" implies migration_required == true }
    }

  requirement def NonDeprecatedCDriverAPIUsage {
    subject;
    doc /* The driver shall use non-deprecated MongoDB C driver API functions */
    attribute id : String = "REQ-510";
    attribute deprecated_functions_count : Integer = 0;
    attribute api_compliance_verified : Boolean;
    stakeholder developer : Developer;
    require constraint DeprecatedAPIRestriction { deprecated_functions_count == 0 implies api_compliance_verified == true }
    }

  requirement def AlignedStorageCompilationFix {
    subject;
    doc /* The driver shall compile without std::aligned_storage build failures on Visual Studio 15.8+ */
    attribute id : String = "REQ-541";
    attribute visual_studio_min_version : String = "15.8";
    attribute compilation_successful : Boolean;
    attribute aligned_storage_errors_count : Integer = 0;
    stakeholder developer : Developer;
    require constraint AlignedStorageCompilationSuccess { aligned_storage_errors_count == 0 implies compilation_successful == true }
    }

  requirement def DeprecatedReplaceOneRemoval {
    subject;
    doc /* The driver shall remove deprecated collection::replace_one overloads */
    attribute id : String = "REQ-544";
    attribute deprecated_overloads_count : Integer = 0;
    attribute replace_one_methods_cleaned : Boolean;
    stakeholder developer : Developer;
    require constraint DeprecatedOverloadsRemoved { deprecated_overloads_count == 0 and replace_one_methods_cleaned == true }
    }

  requirement def GeoSearchDeprecation {
    subject;
    doc /* The driver shall deprecate geoSearch operations */
    attribute id : String = "REQ-557.2";
    attribute operation_name : String = "geoSearch";
    attribute operation_deprecated : Boolean = true;
    stakeholder developer : Developer;
    require constraint DeprecationStatus { operation_name == "geoSearch" implies operation_deprecated == true }
    }

  requirement def GeoOperationsDeprecation {
    subject;
    doc /* The driver shall deprecate geoHaystack and geoSearch operations */
    attribute id : String = "REQ-557";
    attribute geo_haystack_deprecated : Boolean = true;
    attribute geo_search_deprecated : Boolean = true;
    attribute operations_deprecated : Boolean = true;
    stakeholder developer : Developer;
    require constraint GeoOperationsDeprecationStatus { geo_haystack_deprecated == true and geo_search_deprecated == true implies operations_deprecated == true }
    }

  requirement def GeoHaystackDeprecation {
    subject;
    doc /* The driver shall deprecate geoHaystack operations */
    attribute id : String = "REQ-557.1";
    attribute operation_name : String = "geoHaystack";
    attribute operation_deprecated : Boolean = true;
    stakeholder developer : Developer;
    require constraint GeoHaystackDeprecationStatus { operation_name == "geoHaystack" implies operation_deprecated == true }
    }

  #trace dependency from CodebaseCleanupRequirements::SynchronizationFilesExclusion to CodebaseCleanupRequirements::ThreadPoolFilesExclusion;
  #trace dependency from CodebaseCleanupRequirements::SynchronizationFilesExclusion to CodebaseCleanupRequirements::IntrusiveCounterFilesExclusion;
  #trace dependency from CodebaseCleanupRequirements::ThreadPoolFilesExclusion to CodebaseCleanupRequirements::IntrusiveCounterFilesExclusion;
  #trace dependency from CodebaseCleanupRequirements::PeriodicTaskRunnerRemoval to CodebaseCleanupRequirements::StaticObserverRemoval;
  #trace dependency from CodebaseCleanupRequirements::GoodiesHeaderRemoval to CodebaseCleanupRequirements::LogMacroRemoval;
  #refinement dependency from CodebaseCleanupRequirements::MongoBoTypedefRemoval to SystemRequirements::BSONBuilderBaseRemoval;
  #refinement dependency from CodebaseCleanupRequirements::MongoBobTypedefRemoval to SystemRequirements::BSONBuilderBaseRemoval;
  #refinement dependency from CodebaseCleanupRequirements::MongoBeTypedefRemoval to SystemRequirements::BSONBuilderBaseRemoval;
  #trace dependency from CodebaseCleanupRequirements::ThreadNameSupportRemoval to SystemRequirements::SignalHandlingRemoval;
  #trace dependency from CodebaseCleanupRequirements::ThreadNameSupportRemoval to SystemRequirements::DebuggerSupportRemoval;
  #derivation dependency from CodebaseCleanupRequirements::NoexceptSpecifierMarking to CodebaseCleanupRequirements::NoexceptMethodAudit;
  #refinement dependency from CodebaseCleanupRequirements::AtomicWordHeaderCleanup to BuildSystemRequirements::PedanticCompilationSupport;
  #refinement dependency from CodebaseCleanupRequirements::MinimalHeaderIncludes to CodebaseCleanupRequirements::HeaderIncludeDiscipline;
  #refinement dependency from CodebaseCleanupRequirements::SourceFileHeaderOrdering to CodebaseCleanupRequirements::HeaderIncludeDiscipline;
  #refinement dependency from CodebaseCleanupRequirements::ForwardDeclarationUsage to CodebaseCleanupRequirements::HeaderIncludeDiscipline;
  #refinement dependency from CodebaseCleanupRequirements::SystemHeaderOrdering to CodebaseCleanupRequirements::HeaderIncludeDiscipline;
  #trace dependency from CodebaseCleanupRequirements::IncludeOrderingMaintenance to CodebaseCleanupRequirements::HeaderIncludeDiscipline;
  #derivation dependency from CodebaseCleanupRequirements::FunctorHeaderInclusion to BuildSystemRequirements::CppSeventeenMinGWSupport;
  #trace dependency from CodebaseCleanupRequirements::LibbsonScopedConstructorExclusion to CodebaseCleanupRequirements::LibbsonInitMethodExclusion;
  #trace dependency from CodebaseCleanupRequirements::CatchHeaderLineComment to BuildSystemRequirements::CppSeventeenMinGWSupport;
  #trace dependency from CodebaseCleanupRequirements::TestFileDeprecatedMethodsProhibition to CodebaseCleanupRequirements::DeprecationWarningMacroRemoval;
  #derivation dependency from CodebaseCleanupRequirements::CountHelperDeprecation to DatabaseOperationsRequirements::BulkWriteAPISupport;
  #refinement dependency from CodebaseCleanupRequirements::GeoHaystackDeprecation to CodebaseCleanupRequirements::GeoOperationsDeprecation;
  #refinement dependency from CodebaseCleanupRequirements::GeoSearchDeprecation to CodebaseCleanupRequirements::GeoOperationsDeprecation;
  }

package DatabaseOperationsRequirements {
  private import Requirements::*;
  public import ScalarValues::*;
  public import ModelingMetadata::*;
  public import RequirementDerivation::*;

  metadata def <trace> Trace { :>> annotatedElement : SysML::Dependency; }
  part def Developer;
  part def SystemOperator;
  part def User;
  part def Administrator;
  part def Customer;
  part def SystemAdmin;

  requirement def WeightsOptionSupport {
    subject;
    doc /* The new ensureIndex() overload shall support weights option for text indexes */
    attribute id : String = "REQ-027";
    attribute weights_option_supported : Boolean;
    attribute index_type : String = "text";
    attribute option_name : String = "weights";
    stakeholder developer : Developer;
    require constraint WeightsOptionForTextIndexes { index_type == "text" implies weights_option_supported == true }
    }

  requirement def DefaultLanguageSupport {
    subject;
    doc /* The new ensureIndex() overload shall support default_language option for text indexes */
    attribute id : String = "REQ-028";
    attribute default_language_supported : Boolean;
    attribute index_type : String = "text";
    attribute option_name : String = "default_language";
    stakeholder developer : Developer;
    require constraint DefaultLanguageForTextIndexes { index_type == "text" implies default_language_supported == true }
    }

  requirement def SparseIndexSupport {
    subject;
    doc /* The DBClientWithCommands::ensureIndex() method shall support a sparse option parameter to create sparse indexes */
    attribute id : String = "REQ-025";
    attribute sparse_option_supported : Boolean;
    attribute method_name : String = "ensureIndex";
    attribute class_name : String = "DBClientWithCommands";
    stakeholder developer : Developer;
    require constraint SparseOptionSupported { method_name == "ensureIndex" implies sparse_option_supported == true }
    }

  requirement def EnsureIndexOverload {
    subject;
    doc /* The DBClientWithCommands class shall provide an ensureIndex() overload that accepts a const BSONObj& options parameter */
    attribute id : String = "REQ-026";
    attribute overload_provided : Boolean;
    attribute parameter_type : String = "const BSONObj&";
    attribute parameter_name : String = "options";
    stakeholder developer : Developer;
    require constraint OverloadWithOptionsParameter { overload_provided == true and parameter_type == "const BSONObj&" }
    }

  requirement def TestSuiteConnPinning {
    subject;
    doc /* The test suite shall include a dbclient_rs_test ConnShouldNotPinIfHostMarkedAsFailed test case */
    attribute id : String = "REQ-038";
    attribute test_case_name : String = "ConnShouldNotPinIfHostMarkedAsFailed";
    attribute test_module : String = "dbclient_rs_test";
    attribute test_case_included : Boolean;
    stakeholder developer : Developer;
    require constraint TestCaseIncluded { test_case_name == "ConnShouldNotPinIfHostMarkedAsFailed" and test_module == "dbclient_rs_test" implies test_case_included == true }
    }

  requirement def GridFSChunkSizeLimit {
    subject;
    doc /* The GridFS implementation shall use a chunk size of 255 kilobytes or less */
    attribute id : String = "REQ-042";
    attribute max_chunk_size_kb : Real = 255.0;
    attribute measured_chunk_size_kb : Real;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint ChunkSizeLimit { measured_chunk_size_kb <= max_chunk_size_kb }
    }

  requirement def WriteCommandsSupport {
    subject;
    doc /* The C++ driver shall implement full support for write commands */
    attribute id : String = "REQ-066";
    attribute write_commands_implemented : Boolean;
    attribute full_support_available : Boolean;
    attribute command_compatibility : Boolean;
    stakeholder developer : Developer;
    require constraint WriteCommandsImplemented { write_commands_implemented == true and full_support_available == true }
    }

  requirement def BulkWriteAPISupport {
    subject;
    doc /* The C++ driver shall implement bulk write API as specified in the driver bulk update specification */
    attribute id : String = "REQ-063";
    attribute bulk_write_api_implemented : Boolean;
    attribute specification_compliant : Boolean;
    attribute bulk_operations_supported : Boolean;
    stakeholder developer : Developer;
    require constraint BulkAPICompliant { bulk_write_api_implemented == true and specification_compliant == true }
    }

  requirement def AggregationExplainSupport {
    subject;
    doc /* The C++ driver aggregation helper shall support explain functionality */
    attribute id : String = "REQ-056";
    attribute explain_functionality_available : Boolean;
    attribute aggregation_analysis_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint ExplainFunctionalitySupported { explain_functionality_available == true and aggregation_analysis_enabled == true }
    }

  requirement def CursorBatchSizeMethod {
    subject;
    doc /* The C++ driver Cursor shall provide a batchSize method */
    attribute id : String = "REQ-062";
    attribute batch_size_method_available : Boolean;
    attribute batch_size_configurable : Boolean;
    stakeholder developer : Developer;
    require constraint BatchSizeMethodProvided { batch_size_method_available == true and batch_size_configurable == true }
    }

  requirement def WriteConcernParameters {
    subject;
    doc /* The C++ driver shall accept write concern parameters directly in write methods */
    attribute id : String = "REQ-058";
    attribute write_concern_supported : Boolean;
    attribute direct_parameter_acceptance : Boolean;
    attribute write_methods_enhanced : Boolean;
    stakeholder developer : Developer;
    require constraint WriteConcernDirectAcceptance { write_concern_supported == true and direct_parameter_acceptance == true }
    }

  requirement def CursorLimitMethod {
    subject;
    doc /* The C++ driver Cursor shall provide a limit method */
    attribute id : String = "REQ-061";
    attribute limit_method_available : Boolean;
    attribute result_limiting_supported : Boolean;
    stakeholder developer : Developer;
    require constraint LimitMethodProvided { limit_method_available == true and result_limiting_supported == true }
    }

  requirement def AggregationReadPreference {
    subject;
    doc /* The C++ driver aggregation helper shall support read preference configuration */
    attribute id : String = "REQ-057";
    attribute read_preference_configurable : Boolean;
    attribute preference_options_available : Boolean;
    stakeholder developer : Developer;
    require constraint ReadPreferenceConfigurable { read_preference_configurable == true and preference_options_available == true }
    }

  requirement def InsertBatchSplitting {
    subject;
    doc /* The C++ driver shall automatically split insert batches that exceed maxMessageSizeBytes */
    attribute id : String = "REQ-059";
    attribute automatic_splitting_enabled : Boolean;
    attribute max_message_size_respected : Boolean;
    attribute batch_size_monitored : Boolean;
    stakeholder developer : Developer;
    require constraint AutomaticBatchSplitting { automatic_splitting_enabled == true and max_message_size_respected == true }
    }

  requirement def AggregationCursorOutput {
    subject;
    doc /* The C++ driver shall provide an aggregation helper that outputs results as a Cursor */
    attribute id : String = "REQ-055";
    attribute aggregation_helper_available : Boolean;
    attribute cursor_output_supported : Boolean;
    attribute results_accessible : Boolean;
    stakeholder developer : Developer;
    require constraint AggregationHelperWithCursor { aggregation_helper_available == true and cursor_output_supported == true }
    }

  requirement def MessageSizeDetermination {
    subject;
    doc /* The C++ driver shall determine maxMessageSizeBytes from db.isMaster() response */
    attribute id : String = "REQ-060";
    attribute max_message_size_bytes : Integer;
    attribute ismaster_response_parsed : Boolean;
    attribute size_limit_determined : Boolean;
    stakeholder developer : Developer;
    require constraint MessageSizeFromIsMaster { ismaster_response_parsed == true implies size_limit_determined == true }
    }

  requirement def BulkWriteReplaceSemantics {
    subject;
    doc /* The bulk write operations shall enforce replace semantics according to QA-447 test plan specifications */
    attribute id : String = "REQ-070";
    attribute test_plan_reference : String = "QA-447";
    attribute replace_semantics_enforced : Boolean;
    attribute test_plan_compliance : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint ReplaceSemanticCompliance { replace_semantics_enforced == true and test_plan_compliance == true }
    }

  requirement def GridFileChunkInserterLifecycle {
    subject;
    doc /* The GridFile incremental writing shall manage chunk inserter lifecycle properly to prevent resource leaks */
    attribute id : String = "REQ-074";
    attribute lifecycle_managed_properly : Boolean;
    attribute resource_leaks_prevented : Boolean;
    attribute chunk_inserter_cleanup : Boolean;
    stakeholder developer : Developer;
    require constraint LifecycleManagement { lifecycle_managed_properly == true and resource_leaks_prevented == true and chunk_inserter_cleanup == true }
    }

  requirement def ClientSideIdGeneration {
    subject;
    doc /* The driver shall automatically generate _id field client-side for insert operations */
    attribute id : String = "REQ-075";
    attribute id_field_name : String = "_id";
    attribute automatic_generation : Boolean;
    attribute client_side_generation : Boolean;
    attribute insert_operation_requested : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint AutomaticIdGeneration { insert_operation_requested == true implies automatic_generation == true and client_side_generation == true }
    }

  requirement def GridFSIncrementalWriting {
    subject;
    doc /* The GridFS shall support incremental writing of data to GridFile objects */
    attribute id : String = "REQ-073";
    attribute incremental_writing_supported : Boolean;
    attribute gridfile_objects_supported : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint IncrementalWritingSupport { incremental_writing_supported == true and gridfile_objects_supported == true }
    }

  requirement def BulkWriteResultMerging {
    subject;
    doc /* The driver shall support merging of bulk write results according to the Bulk Write Specification */
    attribute id : String = "REQ-071";
    attribute specification_reference : String = "Bulk Write Specification";
    attribute result_merging_supported : Boolean;
    attribute specification_compliance : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint ResultMergingCompliance { result_merging_supported == true and specification_compliance == true }
    }

  requirement def BulkWriteMergingCompliance {
    subject;
    doc /* The bulk write result merging shall conform to the Merging Results section of the driver-bulk-update specification */
    attribute id : String = "REQ-072";
    attribute specification_section : String = "Merging Results";
    attribute specification_document : String = "driver-bulk-update";
    attribute merging_compliance : Boolean;
    attribute merging_operation_performed : Boolean;
    stakeholder developer : Developer;
    require constraint MergingSpecificationCompliance { merging_operation_performed == true implies merging_compliance == true }
    }

  requirement def FireAndForgetIdAvailability {
    subject;
    doc /* The client-side _id generation shall be available for use immediately after fire-and-forget insert operations */
    attribute id : String = "REQ-076";
    attribute id_field_name : String = "_id";
    attribute immediate_availability : Boolean;
    attribute fire_and_forget_support : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint ImmediateIdAvailability { fire_and_forget_support == true implies immediate_availability == true }
    }

  requirement def BulkWriteUpdateSemantics {
    subject;
    doc /* The bulk write operations shall enforce update semantics according to QA-449 test plan specifications */
    attribute id : String = "REQ-069";
    attribute test_plan_reference : String = "QA-449";
    attribute update_semantics_enforced : Boolean;
    attribute test_plan_compliance : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint UpdateSemanticCompliance { update_semantics_enforced == true and test_plan_compliance == true }
    }

  requirement def SaveMethodUpsertBehavior {
    subject;
    doc /* The save() method shall perform an upsert operation when an _id field is present in the BSONObject */
    attribute id : String = "REQ-088";
    attribute performs_upsert_operation : Boolean;
    attribute id_field_required : Boolean = true;
    attribute operation_type : String = "upsert";
    attribute trigger_condition : String = "id_field_present";
    stakeholder developer : Developer;
    require constraint UpsertWhenIdPresent { id_field_required == true implies performs_upsert_operation == true }
    }

  requirement def QueryMaxTimeMSSupport {
    subject;
    doc /* All command helpers that accept mongo::Query shall support the maxTimeMS option */
    attribute id : String = "REQ-084";
    attribute supports_max_time_option : Boolean;
    attribute option_name : String = "maxTimeMS";
    attribute query_parameter_type : String = "mongo::Query";
    stakeholder developer : Developer;
    require constraint MaxTimeOptionSupport { query_parameter_type == "mongo::Query" implies supports_max_time_option == true }
    }

  requirement def SaveUpsertQueryCriteria {
    subject;
    doc /* The save() method upsert operation shall use the _id field value as the query criteria */
    attribute id : String = "REQ-089";
    attribute uses_id_as_criteria : Boolean;
    attribute query_field : String = "_id";
    attribute operation_type : String = "upsert";
    attribute criteria_source : String = "id_field_value";
    stakeholder developer : Developer;
    require constraint IdFieldCriteria { operation_type == "upsert" implies uses_id_as_criteria == true }
    }

  requirement def SaveMethodInsertBehavior {
    subject;
    doc /* The save() method shall insert the BSONObject when no _id field is present */
    attribute id : String = "REQ-087";
    attribute performs_insert_operation : Boolean;
    attribute id_field_required : Boolean = false;
    attribute operation_type : String = "insert";
    attribute trigger_condition : String = "no_id_field";
    stakeholder developer : Developer;
    require constraint InsertWhenNoId { id_field_required == false implies performs_insert_operation == true }
    }

  requirement def QueryMaxTimeMsMethod {
    subject;
    doc /* The mongo::Query class shall provide a maxTimeMs() method that accepts millisecond timeout values */
    attribute id : String = "REQ-085";
    attribute has_max_time_method : Boolean;
    attribute method_name : String = "maxTimeMs";
    attribute timeout_unit : String = "milliseconds";
    attribute parameter_type : String = "timeout_value";
    stakeholder developer : Developer;
    require constraint MaxTimeMethodAvailability { method_name == "maxTimeMs" and has_max_time_method == true }
    }

  requirement def GridFSListSlaveOkParameter {
    subject;
    doc /* The GridFS::list method shall accept a slaveOk boolean parameter with default value false */
    attribute id : String = "REQ-093";
    attribute has_slave_ok_parameter : Boolean;
    attribute parameter_type : String = "boolean";
    attribute default_value : Boolean = false;
    attribute method_name : String = "list";
    attribute class_name : String = "GridFS";
    stakeholder developer : Developer;
    require constraint SlaveOkParameterSupport { method_name == "list" and class_name == "GridFS" implies has_slave_ok_parameter == true }
    }

  requirement def CreateCollectionAutoIdSupport {
    subject;
    doc /* The createCollection helper shall support the auto-generated ID option parameter */
    attribute id : String = "REQ-083";
    attribute supports_auto_id_option : Boolean;
    attribute option_name : String = "auto_generated_id";
    attribute helper_method : String = "createCollection";
    stakeholder developer : Developer;
    require constraint AutoIdOptionSupport { helper_method == "createCollection" implies supports_auto_id_option == true }
    }

  requirement def ParallelScanSecondaryExecution {
    subject;
    doc /* The MongoDB C++ driver shall allow parallelCollectionScan commands to be executed against secondary replica set members */
    attribute id : String = "REQ-078";
    attribute supports_secondary_execution : Boolean;
    attribute command_type : String = "parallelCollectionScan";
    attribute target_member_type : String = "secondary";
    stakeholder developer : Developer;
    require constraint SecondaryExecutionSupport { command_type == "parallelCollectionScan" and target_member_type == "secondary" implies supports_secondary_execution == true }
    }

  requirement def GridFSFindFileSlaveOkParameter {
    subject;
    doc /* The GridFS::findFile method shall accept a slaveOk boolean parameter with default value false */
    attribute id : String = "REQ-092";
    attribute has_slave_ok_parameter : Boolean;
    attribute parameter_type : String = "boolean";
    attribute default_value : Boolean = false;
    attribute method_name : String = "findFile";
    attribute class_name : String = "GridFS";
    stakeholder developer : Developer;
    require constraint FindFileSlaveOkParameter { method_name == "findFile" and class_name == "GridFS" implies has_slave_ok_parameter == true }
    }

  requirement def DBClientFindAndModifyMethod {
    subject;
    doc /* The DBClientInterface shall provide a findAndModify() helper method */
    attribute id : String = "REQ-091";
    attribute has_find_and_modify_method : Boolean;
    attribute method_name : String = "findAndModify";
    attribute method_type : String = "helper";
    attribute interface_name : String = "DBClientInterface";
    stakeholder developer : Developer;
    require constraint FindAndModifyMethodAvailability { interface_name == "DBClientInterface" and method_type == "helper" implies has_find_and_modify_method == true }
    }

  requirement def DBClientSaveMethod {
    subject;
    doc /* The DBClientInterface shall provide a save() method that accepts a BSONObject parameter */
    attribute id : String = "REQ-086";
    attribute has_save_method : Boolean;
    attribute method_name : String = "save";
    attribute parameter_type : String = "BSONObject";
    attribute interface_name : String = "DBClientInterface";
    stakeholder developer : Developer;
    require constraint SaveMethodAvailability { interface_name == "DBClientInterface" and parameter_type == "BSONObject" implies has_save_method == true }
    }

  requirement def GridFileSlaveOkCaching {
    subject;
    doc /* The GridFile class shall cache the slaveOk setting for use in subsequent file operations */
    attribute id : String = "REQ-094";
    attribute caches_slave_ok_setting : Boolean;
    attribute setting_name : String = "slaveOk";
    attribute usage_scope : String = "subsequent_file_operations";
    attribute class_name : String = "GridFile";
    stakeholder developer : Developer;
    require constraint SlaveOkCachingBehavior { class_name == "GridFile" and setting_name == "slaveOk" implies caches_slave_ok_setting == true }
    }

  requirement def GridFileGetChunkSlaveOk {
    subject;
    doc /* The GridFile::getChunk method shall use the cached slaveOk setting for chunk retrieval operations */
    attribute id : String = "REQ-095";
    attribute uses_cached_slave_ok : Boolean;
    attribute method_name : String = "getChunk";
    attribute operation_type : String = "chunk_retrieval";
    attribute setting_source : String = "cached";
    attribute class_name : String = "GridFile";
    stakeholder developer : Developer;
    require constraint CachedSlaveOkUsage { method_name == "getChunk" and setting_source == "cached" implies uses_cached_slave_ok == true }
    }

  requirement def TextSearchSecondaryExecution {
    subject;
    doc /* The MongoDB C++ driver shall allow text search commands to be executed against secondary replica set members */
    attribute id : String = "REQ-077";
    attribute supports_secondary_execution : Boolean;
    attribute command_type : String = "text_search";
    attribute target_member_type : String = "secondary";
    stakeholder developer : Developer;
    require constraint TextSearchSecondarySupport { command_type == "text_search" and target_member_type == "secondary" implies supports_secondary_execution == true }
    }

  requirement def GridFileWriteSlaveOk {
    subject;
    doc /* The GridFile::write method shall use the cached slaveOk setting for write-related query operations */
    attribute id : String = "REQ-096";
    attribute uses_cached_slave_ok : Boolean;
    attribute method_name : String = "write";
    attribute operation_type : String = "write_related_query";
    attribute setting_source : String = "cached";
    attribute class_name : String = "GridFile";
    stakeholder developer : Developer;
    require constraint WriteMethodCachedSlaveOk { method_name == "write" and setting_source == "cached" implies uses_cached_slave_ok == true }
    }

  requirement def CreateCollectionPowerOf2Support {
    subject;
    doc /* The createCollection helper shall support the powerOf2Sizes option parameter */
    attribute id : String = "REQ-082";
    attribute supports_power_of_2_option : Boolean;
    attribute option_name : String = "powerOf2Sizes";
    attribute helper_method : String = "createCollection";
    stakeholder developer : Developer;
    require constraint PowerOf2OptionSupport { helper_method == "createCollection" and option_name == "powerOf2Sizes" implies supports_power_of_2_option == true }
    }

  requirement def DatabaseCommandReadPreference {
    subject;
    doc /* The MongoDB C++ driver shall support read preference specification for database commands */
    attribute id : String = "REQ-090";
    attribute supports_read_preference : Boolean;
    attribute command_scope : String = "database_commands";
    attribute preference_type : String = "read_preference";
    stakeholder developer : Developer;
    require constraint ReadPreferenceSupport { command_scope == "database_commands" and preference_type == "read_preference" implies supports_read_preference == true }
    }

  requirement def CountOperationHints {
    subject;
    doc /* The count operation shall support query hints */
    attribute id : String = "REQ-115";
    attribute operation_name : String = "count";
    attribute query_hints_supported : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint CountHintsSupport { operation_name == "count" implies query_hints_supported == true }
    }

  requirement def GeospatialQuerySupport {
    subject;
    doc /* The driver shall provide API support for geospatial queries */
    attribute id : String = "REQ-121";
    attribute query_type : String = "geospatial";
    attribute api_support_provided : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint GeospatialAPISupport { query_type == "geospatial" implies api_support_provided == true }
    }

  requirement def ListDatabasesFilterSupport {
    subject;
    doc /* The list_databases method shall support a filter parameter */
    attribute id : String = "REQ-496";
    attribute filterSupported : Boolean;
    attribute methodName : String = "list_databases";
    attribute parameterName : String = "filter";
    stakeholder developer : Developer;
    require constraint FilterParameterSupport { methodName == "list_databases" implies filterSupported == true }
    }

  requirement def DocumentCountHelpersVersionSupport {
    subject;
    doc /* The estimatedDocumentCount() and countDocuments() helpers shall support MongoDB 2.6 and higher */
    attribute id : String = "REQ-466";
    attribute minMongoDBVersion : String = "2.6";
    attribute estimatedDocumentCountSupported : Boolean;
    attribute countDocumentsSupported : Boolean;
    stakeholder developer : Developer;
    require constraint VersionSupport { minMongoDBVersion == "2.6" and estimatedDocumentCountSupported == true and countDocumentsSupported == true }
    }

  requirement def CountDocumentsVersionSupport {
    subject;
    doc /* The countDocuments() helper shall support MongoDB 2.6 and higher */
    attribute id : String = "REQ-466.2";
    attribute minMongoDBVersion : String = "2.6";
    attribute helperName : String = "countDocuments";
    attribute versionSupported : Boolean;
    stakeholder developer : Developer;
    require constraint CountDocumentsVersionSupport { minMongoDBVersion == "2.6" and helperName == "countDocuments" implies versionSupported == true }
    }

  requirement def ListCollectionsNameOnlySupport {
    subject;
    doc /* The listCollections command shall support the nameOnly option */
    attribute id : String = "REQ-472";
    attribute nameOnlySupported : Boolean;
    attribute commandName : String = "listCollections";
    attribute optionName : String = "nameOnly";
    stakeholder developer : Developer;
    require constraint NameOnlyOptionSupport { commandName == "listCollections" and optionName == "nameOnly" implies nameOnlySupported == true }
    }

  requirement def EstimatedDocumentCountVersionSupport {
    subject;
    doc /* The estimatedDocumentCount() helper shall support MongoDB 2.6 and higher */
    attribute id : String = "REQ-466.1";
    attribute minMongoDBVersion : String = "2.6";
    attribute helperName : String = "estimatedDocumentCount";
    attribute versionSupported : Boolean;
    stakeholder developer : Developer;
    require constraint VersionCompatibility { helperName == "estimatedDocumentCount" and minMongoDBVersion == "2.6" implies versionSupported == true }
    }

  #refinement dependency from DatabaseOperationsRequirements::SparseIndexSupport to DatabaseOperationsRequirements::EnsureIndexOverload;
  #refinement dependency from DatabaseOperationsRequirements::WeightsOptionSupport to DatabaseOperationsRequirements::EnsureIndexOverload;
  #refinement dependency from DatabaseOperationsRequirements::DefaultLanguageSupport to DatabaseOperationsRequirements::EnsureIndexOverload;
  #trace dependency from DatabaseOperationsRequirements::EnsureIndexOverload to SystemRequirements::MutableBSONInterface;
  #trace dependency from DatabaseOperationsRequirements::EnsureIndexOverload to SystemRequirements::MutableBSONImplementation;
  #trace dependency from DatabaseOperationsRequirements::TestSuiteConnPinning to BuildSystemRequirements::ClientExampleAlias;
  #derivation dependency from DatabaseOperationsRequirements::MessageSizeDetermination to DatabaseOperationsRequirements::InsertBatchSplitting;
  #trace dependency from DatabaseOperationsRequirements::AggregationCursorOutput to DatabaseOperationsRequirements::AggregationExplainSupport;
  #trace dependency from DatabaseOperationsRequirements::AggregationCursorOutput to DatabaseOperationsRequirements::AggregationReadPreference;
  #trace dependency from DatabaseOperationsRequirements::CursorLimitMethod to DatabaseOperationsRequirements::CursorBatchSizeMethod;
  #refinement dependency from DatabaseOperationsRequirements::BulkWriteUpdateSemantics to DatabaseOperationsRequirements::BulkWriteAPISupport;
  #refinement dependency from DatabaseOperationsRequirements::BulkWriteReplaceSemantics to DatabaseOperationsRequirements::BulkWriteAPISupport;
  #refinement dependency from DatabaseOperationsRequirements::BulkWriteResultMerging to DatabaseOperationsRequirements::BulkWriteAPISupport;
  #refinement dependency from DatabaseOperationsRequirements::BulkWriteMergingCompliance to DatabaseOperationsRequirements::BulkWriteResultMerging;
  #derivation dependency from DatabaseOperationsRequirements::FireAndForgetIdAvailability to DatabaseOperationsRequirements::ClientSideIdGeneration;
  #trace dependency from DatabaseOperationsRequirements::BulkWriteUpdateSemantics to DatabaseOperationsRequirements::BulkWriteReplaceSemantics;
  #trace dependency from DatabaseOperationsRequirements::GridFSIncrementalWriting to DatabaseOperationsRequirements::GridFileChunkInserterLifecycle;
  #trace dependency from DatabaseOperationsRequirements::GridFSIncrementalWriting to DatabaseOperationsRequirements::GridFSChunkSizeLimit;
  #refinement dependency from DatabaseOperationsRequirements::QueryMaxTimeMsMethod to DatabaseOperationsRequirements::QueryMaxTimeMSSupport;
  #refinement dependency from DatabaseOperationsRequirements::SaveMethodInsertBehavior to DatabaseOperationsRequirements::DBClientSaveMethod;
  #refinement dependency from DatabaseOperationsRequirements::SaveMethodUpsertBehavior to DatabaseOperationsRequirements::DBClientSaveMethod;
  #refinement dependency from DatabaseOperationsRequirements::SaveUpsertQueryCriteria to DatabaseOperationsRequirements::SaveMethodUpsertBehavior;
  #refinement dependency from DatabaseOperationsRequirements::GridFileGetChunkSlaveOk to DatabaseOperationsRequirements::GridFileSlaveOkCaching;
  #refinement dependency from DatabaseOperationsRequirements::GridFileWriteSlaveOk to DatabaseOperationsRequirements::GridFileSlaveOkCaching;
  #derivation dependency from DatabaseOperationsRequirements::GridFileSlaveOkCaching to DatabaseOperationsRequirements::GridFSFindFileSlaveOkParameter;
  #derivation dependency from DatabaseOperationsRequirements::GridFileSlaveOkCaching to DatabaseOperationsRequirements::GridFSListSlaveOkParameter;
  #trace dependency from DatabaseOperationsRequirements::TextSearchSecondaryExecution to DatabaseOperationsRequirements::ParallelScanSecondaryExecution;
  #trace dependency from DatabaseOperationsRequirements::CreateCollectionPowerOf2Support to DatabaseOperationsRequirements::CreateCollectionAutoIdSupport;
  #trace dependency from DatabaseOperationsRequirements::GridFSFindFileSlaveOkParameter to DatabaseOperationsRequirements::GridFSListSlaveOkParameter;
  #trace dependency from DatabaseOperationsRequirements::TextSearchSecondaryExecution to DatabaseOperationsRequirements::DatabaseCommandReadPreference;
  #trace dependency from DatabaseOperationsRequirements::DBClientSaveMethod to DatabaseOperationsRequirements::DBClientFindAndModifyMethod;
  #trace dependency from DatabaseOperationsRequirements::ListCollectionsNameOnlySupport to ClientDriverRequirements::DatabaseListCollectionsMethod;
  }

package DocumentationRequirements {
  private import Requirements::*;
  public import ScalarValues::*;
  public import ModelingMetadata::*;
  public import RequirementDerivation::*;

  metadata def <trace> Trace { :>> annotatedElement : SysML::Dependency; }
  part def Developer;
  part def SystemOperator;
  part def User;
  part def Administrator;
  part def Customer;
  part def SystemAdmin;

  requirement def ClientInitializeDocumentation {
    subject;
    doc /* The driver shall provide clear documentation for mongo::client::initialize() usage requirements */
    attribute id : String = "REQ-110";
    attribute function_name : String = "mongo::client::initialize";
    attribute documentation_provided : Boolean;
    attribute documentation_clarity : String = "clear";
    attribute usage_requirements_documented : Boolean;
    stakeholder developer : Developer;
    require constraint ClearDocumentationProvision { documentation_provided == true and documentation_clarity == "clear" and usage_requirements_documented == true }
    }

  requirement def DriverDocumentationSeparation {
    subject;
    doc /* The C++ driver documentation shall clearly distinguish between legacy driver and 26compat driver with separate sections */
    attribute id : String = "REQ-155";
    attribute legacy_section_required : Boolean = true;
    attribute compat_section_required : Boolean = true;
    attribute sections_separated : Boolean = true;
    attribute driver_types_distinguished : Boolean = true;
    stakeholder developer : Developer;
    require constraint DocumentationSeparation { legacy_section_required == true and compat_section_required == true and sections_separated == true and driver_types_distinguished == true }
    }

  requirement def BSONTypedefDocumentation {
    subject;
    doc /* The breaking changes documentation shall include information about removed BSON typedefs */
    attribute id : String = "REQ-160";
    attribute breaking_changes_documented : Boolean = true;
    attribute bson_typedef_removal_documented : Boolean = true;
    attribute documentation_type : String = "breaking_changes";
    stakeholder developer : Developer;
    require constraint TypedefRemovalDocumented { breaking_changes_documented == true and bson_typedef_removal_documented == true }
    }

  requirement def CDriverFunctionDocumentation {
    subject;
    doc /* The C driver API documentation shall include function documentation in addition to type documentation */
    attribute id : String = "REQ-154";
    attribute function_documentation_included : Boolean = true;
    attribute type_documentation_included : Boolean = true;
    attribute api_coverage_complete : Boolean = true;
    attribute driver_type : String = "C";
    stakeholder developer : Developer;
    require constraint CompleteFunctionDocumentation { function_documentation_included == true and type_documentation_included == true and api_coverage_complete == true }
    }

  requirement def CompatDriverAPIReference {
    subject;
    doc /* The C++ driver API documentation shall include comprehensive API reference for 26compat driver */
    attribute id : String = "REQ-156";
    attribute api_reference_comprehensive : Boolean = true;
    attribute compat_driver_covered : Boolean = true;
    attribute driver_version : String = "26compat";
    attribute documentation_complete : Boolean = true;
    stakeholder developer : Developer;
    require constraint ComprehensiveCompatAPIReference { api_reference_comprehensive == true and compat_driver_covered == true and documentation_complete == true }
    }

  requirement def BreatheAPIDocumentation {
    subject;
    doc /* The driver documentation shall be enhanced using Breathe for C++ API documentation integration */
    attribute id : String = "REQ-192";
    attribute uses_breathe_integration : Boolean;
    attribute cpp_api_documented : Boolean;
    attribute documentation_integrated : Boolean;
    stakeholder developer : Developer;
    stakeholder customer : Customer;
    require constraint BreatheIntegration { uses_breathe_integration == true and cpp_api_documented == true and documentation_integrated == true }
    }

  requirement def SphinxDocumentationEnhancement {
    subject;
    doc /* The driver documentation shall be enhanced using Sphinx documentation generator */
    attribute id : String = "REQ-191";
    attribute uses_sphinx_generator : Boolean;
    attribute documentation_enhanced : Boolean;
    stakeholder developer : Developer;
    stakeholder customer : Customer;
    require constraint SphinxEnhancement { uses_sphinx_generator == true and documentation_enhanced == true }
    }

  requirement def SCRAMDefaultMechanismDocumentation {
    subject;
    doc /* The C++ driver documentation shall specify that SCRAM-SHA-1 is the default authorization mechanism in MongoDB */
    attribute id : String = "REQ-215";
    attribute default_auth_mechanism : String = "SCRAM-SHA-1";
    attribute documentation_specifies_default : Boolean;
    attribute mongodb_platform : String = "MongoDB";
    stakeholder developer : Developer;
    require constraint DefaultMechanismSpecified { default_auth_mechanism == "SCRAM-SHA-1" implies documentation_specifies_default == true }
    }

  requirement def SSLCompilationWarning {
    subject;
    doc /* The C++ driver documentation shall warn users that the --ssl compilation option is required when using SCRAM-SHA-1 authentication */
    attribute id : String = "REQ-216";
    attribute required_compilation_option : String = "--ssl";
    attribute auth_mechanism : String = "SCRAM-SHA-1";
    attribute warning_documented : Boolean;
    stakeholder developer : Developer;
    require constraint SSLWarningForSCRAM { auth_mechanism == "SCRAM-SHA-1" implies warning_documented == true }
    }

  requirement def CyrusSASLVersionSpecification {
    subject;
    doc /* The C++ driver documentation shall specify the required version of Cyrus SASL library for SASL authentication support */
    attribute id : String = "REQ-211";
    attribute required_library : String = "Cyrus SASL";
    attribute documentation_includes_version : Boolean;
    attribute sasl_authentication_supported : Boolean;
    stakeholder developer : Developer;
    require constraint VersionDocumentedForSASL { sasl_authentication_supported == true implies documentation_includes_version == true }
    }

  requirement def CyrusSASLDownloadLocation {
    subject;
    doc /* The C++ driver documentation shall include the Cyrus SASL library download location (http://cyrusimap.web.cmu.edu/) in the build instructions */
    attribute id : String = "REQ-212";
    attribute download_url : String = "http://cyrusimap.web.cmu.edu/";
    attribute build_instructions_include_url : Boolean;
    attribute library_name : String = "Cyrus SASL";
    stakeholder developer : Developer;
    require constraint DownloadLocationIncluded { library_name == "Cyrus SASL" implies build_instructions_include_url == true }
    }

  requirement def BSONArrayViewIteratorDocumentation {
    subject;
    doc /* The documentation system shall provide doxygen documentation for bsoncxx::array::view iterator classes */
    attribute id : String = "REQ-261";
    attribute iterator_classes_count : Integer;
    attribute documented_methods : Integer;
    attribute iterator_documentation_coverage : Real;
    stakeholder developer : Developer;
    require constraint DocumentationCoverage { documented_methods >= iterator_classes_count }
    }

  requirement def DriverExceptionHandlingExample {
    subject;
    doc /* The documentation system shall provide an example demonstrating graceful handling of driver exceptions */
    attribute id : String = "REQ-268";
    attribute exception_types_covered : Integer;
    attribute example_completeness : Real;
    attribute error_handling_scenarios : Integer;
    attribute min_scenarios_required : Integer;
    stakeholder developer : Developer;
    require constraint ExceptionHandlingCoverage { error_handling_scenarios >= min_scenarios_required and exception_types_covered > 0 }
    }

  requirement def BSONDocumentViewIteratorDocumentation {
    subject;
    doc /* The documentation system shall provide doxygen documentation for bsoncxx::document::view iterator classes */
    attribute id : String = "REQ-264";
    attribute view_iterator_classes : Integer;
    attribute iterator_methods_documented : Integer;
    attribute view_documentation_coverage : Real;
    stakeholder developer : Developer;
    require constraint ViewIteratorDocumentation { iterator_methods_documented >= view_iterator_classes }
    }

  requirement def BSONDocumentElementDocumentation {
    subject;
    doc /* The documentation system shall provide doxygen documentation for bsoncxx::document::element class */
    attribute id : String = "REQ-263";
    attribute element_methods_count : Integer;
    attribute documented_element_methods : Integer;
    attribute element_api_completeness : Real;
    stakeholder developer : Developer;
    require constraint ElementDocumentationComplete { documented_element_methods >= element_methods_count }
    }

  requirement def BSONArrayElementDocumentation {
    subject;
    doc /* The documentation system shall provide doxygen documentation for bsoncxx::array::element class */
    attribute id : String = "REQ-260";
    attribute class_methods_documented : Integer;
    attribute documentation_completeness : Real;
    attribute api_coverage_percentage : Real;
    attribute min_coverage_threshold : Real;
    stakeholder developer : Developer;
    require constraint ArrayElementDocumentationCoverage { api_coverage_percentage >= min_coverage_threshold and class_methods_documented > 0 }
    }

  requirement def TODODocumentationLinksReplacement {
    subject;
    doc /* The documentation system shall replace all TODO comments referencing missing documentation links with actual hyperlinks to published documentation */
    attribute id : String = "REQ-251";
    attribute todo_comments_count : Integer;
    attribute hyperlinks_created : Integer;
    attribute documentation_coverage : Real;
    stakeholder developer : Developer;
    require constraint TODOLinksReplaced { hyperlinks_created >= todo_comments_count }
    }

  requirement def DoxygenRelatesTagsInclusion {
    subject;
    doc /* The documentation system shall include doxygen 'relates' tags for all free relational operators to associate them with their corresponding classes */
    attribute id : String = "REQ-253";
    attribute free_operators_count : Integer;
    attribute relates_tags_added : Integer;
    attribute operator_class_associations : Integer;
    stakeholder developer : Developer;
    require constraint RelatesTagsComplete { relates_tags_added >= free_operators_count and operator_class_associations >= free_operators_count }
    }

  requirement def BSONBuilderStreamContextDocumentation {
    subject;
    doc /* The documentation system shall provide doxygen documentation for bsoncxx::builder stream context classes */
    attribute id : String = "REQ-262";
    attribute stream_context_classes : Integer;
    attribute documented_stream_methods : Integer;
    attribute builder_api_coverage : Real;
    stakeholder developer : Developer;
    require constraint StreamContextDocumentation { documented_stream_methods >= stream_context_classes }
    }

  requirement def APIPortalDocumentationLinks {
    subject;
    doc /* The MongoDB API documentation portal at http://api.mongodb.org/ shall include links to the C++11 driver API documentation */
    attribute id : String = "REQ-276";
    attribute api_portal_url : String = "http://api.mongodb.org/";
    attribute target_documentation : String = "C++11 driver API documentation";
    attribute portal_links_present : Boolean;
    stakeholder developer : Developer;
    require constraint PortalLinksRequired { portal_links_present == true }
    }

  requirement def EcosystemDriversDocumentationLinks {
    subject;
    doc /* The MongoDB ecosystem drivers documentation at https://docs.mongodb.org/ecosystem/drivers/ shall include links to the C++11 driver API documentation */
    attribute id : String = "REQ-275";
    attribute documentation_portal : String = "https://docs.mongodb.org/ecosystem/drivers/";
    attribute target_api_docs : String = "C++11 driver API documentation";
    attribute links_included : Boolean;
    stakeholder developer : Developer;
    require constraint EcosystemLinksRequired { links_included == true }
    }

  requirement def BSONStreamBuilderAdapterExample {
    subject;
    doc /* The bsoncxx documentation shall include an example demonstrating the use of custom adapters with the stream builder's callable overload for iterator pairs */
    attribute id : String = "REQ-271";
    attribute documentation_type : String = "bsoncxx";
    attribute example_topic : String = "custom adapters";
    attribute builder_feature : String = "stream builder callable overload";
    attribute iterator_support : String = "iterator pairs";
    attribute example_included : Boolean;
    stakeholder developer : Developer;
    require constraint AdapterExampleRequired { example_included == true }
    }

  requirement def BulkOpSourceCodeComments {
    subject;
    doc /* The source code comments for bulk operation initializer methods shall accurately reflect their respective functionality without reversal of descriptions */
    attribute id : String = "REQ-279";
    attribute comments_accurate : Boolean;
    attribute descriptions_reversed : Boolean;
    attribute source_comments_content : String;
    stakeholder developer : Developer;
    require constraint AccurateCommentsWithoutReversal { comments_accurate == true and descriptions_reversed == false }
    }

  requirement def OrderedBulkOpDocumentation {
    subject;
    doc /* The documentation system shall display correct descriptions for the initializeOrderedBulkOp() method indicating it creates ordered bulk operations */
    attribute id : String = "REQ-278";
    attribute method_name : String = "initializeOrderedBulkOp";
    attribute operation_type : String = "ordered";
    attribute description_accurate : Boolean;
    attribute displayed_description : String;
    stakeholder developer : Developer;
    require constraint OrderedMethodDocumentationAccuracy { method_name == "initializeOrderedBulkOp" and operation_type == "ordered" implies description_accurate == true }
    }

  requirement def UnorderedBulkOpDocumentation {
    subject;
    doc /* The documentation system shall display correct descriptions for the initializeUnorderedBulkOp() method indicating it creates unordered bulk operations */
    attribute id : String = "REQ-277";
    attribute method_name : String = "initializeUnorderedBulkOp";
    attribute operation_type : String = "unordered";
    attribute description_accurate : Boolean;
    attribute displayed_description : String;
    stakeholder developer : Developer;
    require constraint UnorderedMethodDocumentationAccuracy { method_name == "initializeUnorderedBulkOp" and operation_type == "unordered" implies description_accurate == true }
    }

  requirement def ClientHeaderGrammarCorrectness {
    subject;
    doc /* The API documentation in mongocxx/client.hpp shall be free of grammatical errors */
    attribute id : String = "REQ-285";
    attribute header_file : String = "mongocxx/client.hpp";
    attribute grammatical_errors_count : Integer = 0;
    attribute documentation_quality_acceptable : Boolean;
    stakeholder developer : Developer;
    require constraint NoGrammaticalErrors { grammatical_errors_count == 0 and documentation_quality_acceptable == true }
    }

  requirement def LongLivedInstanceExample {
    subject;
    doc /* The documentation shall include an example demonstrating how to manage a long-lived instance object */
    attribute id : String = "REQ-287";
    attribute example_included : Boolean;
    attribute demonstrates_long_lived_management : Boolean;
    stakeholder developer : Developer;
    require constraint LongLivedExampleProvided { example_included == true and demonstrates_long_lived_management == true }
    }

  requirement def CursorAccessExamples {
    subject;
    doc /* The documentation shall include examples for accessing data using cursors */
    attribute id : String = "REQ-294";
    attribute cursor_examples_included : Boolean;
    attribute data_access_demonstrated : Boolean;
    stakeholder developer : Developer;
    require constraint CursorExamplesProvided { cursor_examples_included == true and data_access_demonstrated == true }
    }

  requirement def ContributingCommitConventions {
    subject;
    doc /* The CONTRIBUTING.md file shall include commit naming conventions */
    attribute id : String = "REQ-289";
    attribute file_name : String = "CONTRIBUTING.md";
    attribute commit_conventions_included : Boolean;
    stakeholder developer : Developer;
    require constraint CommitConventionsIncluded { commit_conventions_included == true }
    }

  requirement def InsertOneExceptionDocumentation {
    subject;
    doc /* The insert_one() function documentation shall correctly specify mongocxx::write_exception as the thrown exception type */
    attribute id : String = "REQ-284";
    attribute exception_type_specified : String = "mongocxx::write_exception";
    attribute documentation_accurate : Boolean;
    stakeholder developer : Developer;
    require constraint AccurateExceptionDocumentation { documentation_accurate == true }
    }

  requirement def WindowsTestInstructions {
    subject;
    doc /* The documentation system shall include Windows-specific test instructions for the C++ driver */
    attribute id : String = "REQ-302";
    attribute platform_target : String = "Windows";
    attribute driver_type : String = "C++";
    attribute instruction_type : String = "test";
    attribute documentation_included : Boolean;
    stakeholder developer : Developer;
    require constraint WindowsTestDocumentationCheck { (platform_target == "Windows" and driver_type == "C++" and instruction_type == "test") implies documentation_included == true }
    }

  requirement def MongocxxConfigurationGuide {
    subject;
    doc /* The documentation system shall include a mongocxx configuration guide */
    attribute id : String = "REQ-317";
    attribute component_name : String = "mongocxx";
    attribute guide_type : String = "configuration";
    attribute documentation_included : Boolean;
    stakeholder developer : Developer;
    require constraint ConfigurationGuideCheck { (component_name == "mongocxx" and guide_type == "configuration") implies documentation_included == true }
    }

  requirement def WindowsConfigureInstructions {
    subject;
    doc /* The documentation system shall include Windows-specific configure instructions for the C++ driver */
    attribute id : String = "REQ-300";
    attribute platform_target : String = "Windows";
    attribute driver_type : String = "C++";
    attribute instruction_type : String = "configure";
    attribute documentation_included : Boolean;
    stakeholder developer : Developer;
    require constraint WindowsConfigureDocumentationCheck { (platform_target == "Windows" and driver_type == "C++" and instruction_type == "configure") implies documentation_included == true }
    }

  requirement def WindowsBuildInstructions {
    subject;
    doc /* The documentation system shall include Windows-specific build instructions for the C++ driver */
    attribute id : String = "REQ-301";
    attribute platform_target : String = "Windows";
    attribute driver_type : String = "C++";
    attribute instruction_type : String = "build";
    attribute documentation_included : Boolean;
    stakeholder developer : Developer;
    require constraint WindowsDocumentation { platform_target == "Windows" and driver_type == "C++" and instruction_type == "build" implies documentation_included == true }
    }

  requirement def BSONCXXPolySystemMNMLSTCDocumentation {
    subject;
    doc /* The installation documentation shall document the BSONCXX_POLY_USE_SYSTEM_MNMLSTC option */
    attribute id : String = "REQ-362";
    attribute option_name : String = "BSONCXX_POLY_USE_SYSTEM_MNMLSTC";
    attribute documentation_section : String = "installation";
    attribute option_documented : Boolean;
    stakeholder developer : Developer;
    require constraint OptionDocumentationRequired { option_name == "BSONCXX_POLY_USE_SYSTEM_MNMLSTC" implies option_documented == true }
    }

  requirement def GridFSDownloadExampleInclusion {
    subject;
    doc /* The examples directory shall include a GridFS download example */
    attribute id : String = "REQ-400";
    attribute example_type : String = "GridFS download";
    attribute directory_name : String = "examples";
    attribute example_included : Boolean;
    stakeholder developer : Developer;
    require constraint DownloadExampleInclusion { example_type == "GridFS download" and directory_name == "examples" implies example_included == true }
    }

  requirement def BoostHeaderOnlyDependencyDocumentation {
    subject;
    doc /* The installation guide shall clarify that the driver's dependency on Boost is header-only */
    attribute id : String = "REQ-391";
    attribute dependency_name : String = "Boost";
    attribute dependency_type : String = "header-only";
    attribute clarification_provided : Boolean;
    stakeholder developer : Developer;
    require constraint BoostDependencyClarification { dependency_name == "Boost" and dependency_type == "header-only" implies clarification_provided == true }
    }

  requirement def GridFSUploadExampleInclusion {
    subject;
    doc /* The examples directory shall include a GridFS upload example */
    attribute id : String = "REQ-399";
    attribute example_type : String = "GridFS upload";
    attribute directory_name : String = "examples";
    attribute example_included : Boolean;
    stakeholder developer : Developer;
    require constraint UploadExampleInclusion { example_type == "GridFS upload" and directory_name == "examples" implies example_included == true }
    }

  requirement def CollectionNameMethodDocumentation {
    subject;
    doc /* The collection::name() method documentation shall not guarantee null-termination of returned string */
    attribute id : String = "REQ-393";
    attribute method_name : String = "collection::name()";
    attribute null_termination_guaranteed : Boolean = false;
    attribute documentation_updated : Boolean;
    stakeholder developer : Developer;
    require constraint NullTerminationDocumentation { method_name == "collection::name()" and null_termination_guaranteed == false implies documentation_updated == true }
    }

  requirement def SessionThreadSafetySpecification {
    subject;
    doc /* The MongoDB C++ driver documentation shall specify that sessions are not thread safe */
    attribute id : String = "REQ-429";
    attribute topic : String = "sessions";
    attribute thread_safe : Boolean = false;
    attribute specification_included : Boolean;
    stakeholder developer : Developer;
    require constraint ThreadSafetySpecificationCheck { topic == "sessions" and thread_safe == false implies specification_included == true }
    }

  requirement def SessionDedicatedPage {
    subject;
    doc /* The MongoDB C++ driver documentation shall include a dedicated page about sessions */
    attribute id : String = "REQ-428";
    attribute page_topic : String = "sessions";
    attribute page_type : String = "dedicated";
    attribute page_included : Boolean;
    stakeholder developer : Developer;
    require constraint DedicatedPageInclusionCheck { page_topic == "sessions" and page_type == "dedicated" implies page_included == true }
    }

  requirement def TLSProtocolInstructions {
    subject;
    doc /* The MongoDB C++ driver documentation shall include instructions for using the latest TLS protocols */
    attribute id : String = "REQ-423";
    attribute protocol_type : String = "TLS";
    attribute protocol_version : String = "latest";
    attribute instructions_included : Boolean;
    stakeholder developer : Developer;
    require constraint TLSInstructionsInclusionCheck { protocol_type == "TLS" and protocol_version == "latest" implies instructions_included == true }
    }

  requirement def SessionUsageExample {
    subject;
    doc /* The MongoDB C++ driver documentation shall include an example demonstrating session usage */
    attribute id : String = "REQ-427";
    attribute example_type : String = "session usage";
    attribute example_included : Boolean;
    stakeholder developer : Developer;
    require constraint SessionExampleInclusionCheck { example_type == "session usage" implies example_included == true }
    }

  requirement def ContributingPageRewrite {
    subject;
    doc /* The Contributing page shall be rewritten with proper title and contribution guidelines */
    attribute id : String = "REQ-453";
    attribute page_rewritten : Boolean;
    attribute proper_title_included : Boolean;
    attribute guidelines_included : Boolean;
    stakeholder developer : Developer;
    require constraint PageRewriteComplete { page_rewritten == true and proper_title_included == true and guidelines_included == true }
    }

  requirement def ElementBoolDocumentation {
    subject;
    doc /* The element::bool() documentation shall clearly state that it returns true for valid elements and false for invalid elements */
    attribute id : String = "REQ-449";
    attribute documentation_clarity : Boolean;
    attribute return_value_specification : Boolean;
    attribute valid_element_behavior : Boolean;
    attribute invalid_element_behavior : Boolean;
    stakeholder developer : Developer;
    require constraint DocumentationClarity { documentation_clarity == true and return_value_specification == true and valid_element_behavior == true and invalid_element_behavior == true }
    }

  requirement def ContributingPageGuidelines {
    subject;
    doc /* The Contributing page shall include contribution guidelines */
    attribute id : String = "REQ-453.2";
    attribute guidelines_present : Boolean;
    attribute guidelines_completeness : String;
    stakeholder developer : Developer;
    require constraint GuidelinesPresent { guidelines_present == true }
    }

  requirement def ContributingPageTitle {
    subject;
    doc /* The Contributing page shall have a proper title */
    attribute id : String = "REQ-453.1";
    attribute proper_title_present : Boolean;
    attribute title_quality : String;
    stakeholder developer : Developer;
    require constraint ProperTitlePresent { proper_title_present == true }
    }

  requirement def ConnectionStringPrecedenceDocumentation {
    subject;
    doc /* The driver documentation shall document connection string and URI option precedence rules */
    attribute id : String = "REQ-518";
    attribute documentation_scope : String = "driver documentation";
    attribute connection_string_rules_documented : Boolean;
    attribute uri_option_precedence_documented : Boolean;
    attribute precedence_rules_complete : Boolean;
    stakeholder developer : Developer;
    require constraint PrecedenceDocumentationComplete { (connection_string_rules_documented == true and uri_option_precedence_documented == true) implies precedence_rules_complete == true }
    }

  requirement def ThreadSafetyDocumentationExample {
    subject;
    doc /* The thread-safety.md documentation shall demonstrate the use of mongocxx::pool */
    attribute id : String = "REQ-546";
    attribute documentation_file : String = "thread-safety.md";
    attribute required_example_class : String = "mongocxx::pool";
    attribute example_demonstrated : Boolean;
    stakeholder developer : Developer;
    require constraint PoolExampleDemonstration { documentation_file == "thread-safety.md" implies example_demonstrated == true }
    }

  requirement def InstallationGuideSpellingAccuracy {
    subject;
    doc /* The installation guide shall contain correct spelling for all technical terms and phrases */
    attribute id : String = "REQ-506";
    attribute documentation_type : String = "installation guide";
    attribute spelling_accuracy_required : Boolean = true;
    attribute technical_terms_checked : Boolean;
    attribute phrases_checked : Boolean;
    stakeholder developer : Developer;
    require constraint SpellingAccuracyVerification { (technical_terms_checked == true and phrases_checked == true) implies spelling_accuracy_required == true }
    }

  requirement def FindAllowDiskUseDocumentation {
    subject;
    doc /* The allowDiskUse option for find operations shall be documented as supported only on MongoDB 4.4 and later */
    attribute id : String = "REQ-552";
    attribute option_name : String = "allowDiskUse";
    attribute operation_type : String = "find";
    attribute min_mongodb_version : String = "4.4";
    attribute documentation_updated : Boolean = true;
    stakeholder developer : Developer;
    require constraint DocumentationVersionRequirement { option_name == "allowDiskUse" and operation_type == "find" and min_mongodb_version == "4.4" implies documentation_updated == true }
    }

  #trace dependency from DocumentationRequirements::ClientInitializeDocumentation to SystemRequirements::ClientShutdownThreadManagement;
  #trace dependency from DocumentationRequirements::CDriverFunctionDocumentation to DocumentationRequirements::CompatDriverAPIReference;
  #trace dependency from DocumentationRequirements::DriverDocumentationSeparation to DocumentationRequirements::CompatDriverAPIReference;
  #trace dependency from DocumentationRequirements::BSONTypedefDocumentation to CodebaseCleanupRequirements::MongoBoTypedefRemoval;
  #trace dependency from DocumentationRequirements::BSONTypedefDocumentation to CodebaseCleanupRequirements::MongoBobTypedefRemoval;
  #trace dependency from DocumentationRequirements::BSONTypedefDocumentation to CodebaseCleanupRequirements::MongoBeTypedefRemoval;
  #refinement dependency from DocumentationRequirements::CyrusSASLVersionSpecification to ClientDriverRequirements::SCRAMAuthenticationFailureDetection;
  #refinement dependency from DocumentationRequirements::CyrusSASLDownloadLocation to DocumentationRequirements::CyrusSASLVersionSpecification;
  #refinement dependency from DocumentationRequirements::SSLCompilationWarning to DocumentationRequirements::SCRAMDefaultMechanismDocumentation;
  #trace dependency from DocumentationRequirements::SCRAMDefaultMechanismDocumentation to ClientDriverRequirements::SCRAMDefaultVerification;
  #trace dependency from DocumentationRequirements::SSLCompilationWarning to ClientDriverRequirements::SSLCompilationErrorMessage;
  #trace dependency from DocumentationRequirements::TODODocumentationLinksReplacement to SystemRequirements::DocumentationMigration;
  #trace dependency from DocumentationRequirements::DoxygenRelatesTagsInclusion to DocumentationRequirements::CompatDriverAPIReference;
  #trace dependency from DocumentationRequirements::BSONArrayElementDocumentation to DocumentationRequirements::CompatDriverAPIReference;
  #trace dependency from DocumentationRequirements::BSONStreamBuilderAdapterExample to DocumentationRequirements::DriverExceptionHandlingExample;
  #trace dependency from DocumentationRequirements::EcosystemDriversDocumentationLinks to DocumentationRequirements::CompatDriverAPIReference;
  #trace dependency from DocumentationRequirements::APIPortalDocumentationLinks to DocumentationRequirements::CompatDriverAPIReference;
  #trace dependency from DocumentationRequirements::EcosystemDriversDocumentationLinks to DocumentationRequirements::APIPortalDocumentationLinks;
  #refinement dependency from DocumentationRequirements::UnorderedBulkOpDocumentation to DocumentationRequirements::TODODocumentationLinksReplacement;
  #refinement dependency from DocumentationRequirements::OrderedBulkOpDocumentation to DocumentationRequirements::TODODocumentationLinksReplacement;
  #trace dependency from DocumentationRequirements::BulkOpSourceCodeComments to DocumentationRequirements::TODODocumentationLinksReplacement;
  #trace dependency from DocumentationRequirements::UnorderedBulkOpDocumentation to ClientDriverRequirements::BulkWriteParameterTypeReplacement;
  #trace dependency from DocumentationRequirements::OrderedBulkOpDocumentation to ClientDriverRequirements::BulkWriteParameterTypeReplacement;
  #trace dependency from DocumentationRequirements::BulkOpSourceCodeComments to ClientDriverRequirements::BulkWriteParameterTypeReplacement;
  #trace dependency from DocumentationRequirements::UnorderedBulkOpDocumentation to DocumentationRequirements::OrderedBulkOpDocumentation;
  #trace dependency from DocumentationRequirements::UnorderedBulkOpDocumentation to DocumentationRequirements::BulkOpSourceCodeComments;
  #trace dependency from DocumentationRequirements::OrderedBulkOpDocumentation to DocumentationRequirements::BulkOpSourceCodeComments;
  #trace dependency from DocumentationRequirements::InsertOneExceptionDocumentation to DocumentationRequirements::ClientHeaderGrammarCorrectness;
  #trace dependency from DocumentationRequirements::LongLivedInstanceExample to DocumentationRequirements::CursorAccessExamples;
  #refinement dependency from DocumentationRequirements::WindowsConfigureInstructions to BuildSystemRequirements::CMakeCompilerVersionEnforcement;
  #refinement dependency from DocumentationRequirements::WindowsBuildInstructions to BuildSystemRequirements::SharedLibraryDefault;
  #refinement dependency from DocumentationRequirements::WindowsTestInstructions to BuildSystemRequirements::TestUtilDirectoryCreation;
  #trace dependency from DocumentationRequirements::GridFSUploadExampleInclusion to DocumentationRequirements::GridFSDownloadExampleInclusion;
  #trace dependency from DocumentationRequirements::SessionUsageExample to DocumentationRequirements::SessionDedicatedPage;
  #trace dependency from DocumentationRequirements::TLSProtocolInstructions to DocumentationRequirements::CyrusSASLDownloadLocation;
  #trace dependency from DocumentationRequirements::InstallationGuideSpellingAccuracy to DocumentationRequirements::ConnectionStringPrecedenceDocumentation;
  #trace dependency from DocumentationRequirements::ConnectionStringPrecedenceDocumentation to DocumentationRequirements::EcosystemDriversDocumentationLinks;
  #derivation dependency from DocumentationRequirements::FindAllowDiskUseDocumentation to ClientDriverRequirements::FindAllowDiskUseSupport;
  }

package ClientDriverRequirements {
  private import Requirements::*;
  public import ScalarValues::*;
  public import ModelingMetadata::*;
  public import RequirementDerivation::*;

  metadata def <trace> Trace { :>> annotatedElement : SysML::Dependency; }
  part def Developer;
  part def SystemOperator;
  part def User;
  part def Administrator;
  part def Customer;
  part def SystemAdmin;

  requirement def SCRAMAuthenticationPrevention {
    subject;
    doc /* The DBClient shall prevent SCRAM-SHA-1 authentication attempts when the driver was not compiled with SSL support */
    attribute id : String = "REQ-135";
    attribute authentication_method : String = "SCRAM-SHA-1";
    attribute ssl_support_compiled : Boolean;
    attribute authentication_attempt_prevented : Boolean;
    attribute driver_ssl_enabled : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint PreventAuthWithoutSSL { ssl_support_compiled == false implies authentication_attempt_prevented == true }
    }

  requirement def SCRAMAuthenticationFailureDetection {
    subject;
    doc /* The DBClient shall detect when SCRAM-SHA-1 authentication fails due to missing SSL compilation flag */
    attribute id : String = "REQ-133";
    attribute authentication_method : String = "SCRAM-SHA-1";
    attribute ssl_compilation_enabled : Boolean;
    attribute authentication_failure_detected : Boolean;
    attribute failure_cause_identified : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint DetectSSLFailure { ssl_compilation_enabled == false implies authentication_failure_detected == true }
    require constraint IdentifyFailureCause { authentication_failure_detected == true implies failure_cause_identified == true }
    }

  requirement def SSLCompilationErrorMessage {
    subject;
    doc /* The DBClient shall display an error message indicating that --ssl compilation flag is required when SCRAM-SHA-1 authentication fails due to missing SSL support */
    attribute id : String = "REQ-134";
    attribute required_compilation_flag : String = "--ssl";
    attribute error_message_displayed : Boolean;
    attribute ssl_support_missing : Boolean;
    attribute authentication_method : String = "SCRAM-SHA-1";
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint DisplayErrorWhenSSLMissing { ssl_support_missing == true implies error_message_displayed == true }
    }

  requirement def SCRAMDefaultVerification {
    subject;
    doc /* The MongoDB C++ driver integration test suite shall verify that SCRAM-SHA-1 is the default authentication mechanism when wire version is 3 or higher */
    attribute id : String = "REQ-144";
    attribute wire_version : Integer;
    attribute min_wire_version : Integer = 3;
    attribute default_auth_mechanism : String = "SCRAM-SHA-1";
    attribute verification_completed : Boolean;
    stakeholder developer : Developer;
    require constraint WireVersionCheck { wire_version >= min_wire_version implies verification_completed == true }
    }

  requirement def ListCollectionsCursorSupport {
    subject;
    doc /* The MongoDB C++ driver shall support cursor functionality in the listCollections command */
    attribute id : String = "REQ-141";
    attribute cursor_supported : Boolean;
    attribute listCollections_available : Boolean;
    stakeholder developer : Developer;
    require constraint CursorInListCollections { listCollections_available == true implies cursor_supported == true }
    }

  requirement def ServerChangesIntegration {
    subject;
    doc /* The MongoDB C++ driver shall incorporate all server changes from version 2.8.0-rc2 to 2.8.0-rc3 */
    attribute id : String = "REQ-137";
    attribute source_version : String = "2.8.0-rc2";
    attribute target_version : String = "2.8.0-rc3";
    attribute changes_integrated : Boolean;
    stakeholder developer : Developer;
    require constraint VersionUpgradeIntegration { changes_integrated == true }
    }

  requirement def UnixSocketStringAcceptance {
    subject;
    doc /* The ConnectionString class shall accept UNIX socket format strings in the form mongodb:///tmp/mongodb-27017.sock */
    attribute id : String = "REQ-138";
    attribute socket_format : String = "mongodb:///tmp/mongodb-27017.sock";
    attribute unix_socket_accepted : Boolean;
    stakeholder developer : Developer;
    require constraint UnixSocketFormatAcceptance { unix_socket_accepted == true }
    }

  requirement def ClientExamplePortParameter {
    subject;
    doc /* The MongoDB C++ driver client examples shall accept port arguments as command line parameters */
    attribute id : String = "REQ-145.2";
    attribute port_parameter_accepted : Boolean;
    attribute command_line_parsing_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint PortParameterSupport { command_line_parsing_enabled == true implies port_parameter_accepted == true }
    }

  requirement def SSLShutdownStability {
    subject;
    doc /* The MongoDB C++ driver shall not generate SIGABRT signals during shutdown when SSL is enabled */
    attribute id : String = "REQ-140";
    attribute ssl_enabled : Boolean;
    attribute sigabrt_generated : Boolean;
    attribute shutdown_completed : Boolean;
    stakeholder developer : Developer;
    require constraint NoSigabrtOnSSLShutdown { ssl_enabled == true and shutdown_completed == true implies sigabrt_generated == false }
    }

  requirement def DefaultAuthMechanismProvision {
    subject;
    doc /* The ConnectionString class shall provide a default authentication mechanism when authMechanism is not explicitly specified */
    attribute id : String = "REQ-143";
    attribute authMechanism_specified : Boolean;
    attribute default_mechanism_provided : Boolean;
    stakeholder developer : Developer;
    require constraint DefaultMechanismWhenNotSpecified { authMechanism_specified == false implies default_mechanism_provided == true }
    }

  requirement def ClientExampleHostParameter {
    subject;
    doc /* The MongoDB C++ driver client examples shall accept host arguments as command line parameters */
    attribute id : String = "REQ-145.1";
    attribute host_parameter_accepted : Boolean;
    attribute command_line_parsing_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint HostParameterSupport { command_line_parsing_enabled == true implies host_parameter_accepted == true }
    }

  requirement def DefaultAuthSourceHandling {
    subject;
    doc /* The ConnectionString class shall use the specified database as the default authSource when authSource is not explicitly provided */
    attribute id : String = "REQ-142";
    attribute authSource_provided : Boolean;
    attribute database_specified : Boolean;
    attribute default_authSource_used : Boolean;
    stakeholder developer : Developer;
    require constraint DatabaseAsDefaultAuthSource { authSource_provided == false and database_specified == true implies default_authSource_used == true }
    }

  requirement def UnixSocketConstructorStability {
    subject;
    doc /* The ConnectionString constructor shall not trigger assertion failures when processing UNIX socket format strings */
    attribute id : String = "REQ-139";
    attribute assertion_failure_triggered : Boolean;
    attribute unix_socket_processed : Boolean;
    stakeholder developer : Developer;
    require constraint NoAssertionFailureOnUnixSocket { unix_socket_processed == true implies assertion_failure_triggered == false }
    }

  requirement def ClientExampleParameterSupport {
    subject;
    doc /* The MongoDB C++ driver client examples shall accept both host and port arguments as command line parameters */
    attribute id : String = "REQ-145";
    attribute host_parameter_accepted : Boolean;
    attribute port_parameter_accepted : Boolean;
    attribute command_line_parsing_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint BothParametersSupported { command_line_parsing_enabled == true implies host_parameter_accepted == true and port_parameter_accepted == true }
    }

  requirement def ListIndexesCursorSupport {
    subject;
    doc /* The MongoDB C++ driver shall support cursor functionality in the listIndexes command */
    attribute id : String = "REQ-136";
    attribute cursor_supported : Boolean;
    attribute listIndexes_available : Boolean;
    stakeholder developer : Developer;
    require constraint CursorInListIndexes { listIndexes_available == true implies cursor_supported == true }
    }

  requirement def MaxTimeMSParameterSupport {
    subject;
    doc /* The system shall support the $maxTimeMS parameter for database operations */
    attribute id : String = "REQ-147";
    attribute parameter_supported : Boolean;
    attribute parameter_name : String = "maxTimeMS";
    attribute database_operation_requested : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint ParameterSupportForOperations { database_operation_requested == true implies parameter_supported == true }
    }

  requirement def TimeoutErrorResponse {
    subject;
    doc /* The system shall return a timeout error when a database operation is terminated due to $maxTimeMS expiration */
    attribute id : String = "REQ-150";
    attribute error_type : String = "timeout_error";
    attribute operation_terminated_by_timeout : Boolean;
    attribute error_returned : Boolean;
    stakeholder developer : Developer;
    require constraint TimeoutTerminationImpliesError { operation_terminated_by_timeout == true implies error_returned == true }
    }

  requirement def DatabaseOperationTermination {
    subject;
    doc /* The system shall terminate database operations that exceed the specified $maxTimeMS timeout value */
    attribute id : String = "REQ-149";
    attribute timeout_value_ms : Integer;
    attribute operation_duration_ms : Integer;
    attribute operation_terminated : Boolean;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint TerminateOnTimeout { operation_duration_ms > timeout_value_ms implies operation_terminated == true }
    }

  requirement def MaxTimeMSParameterRejection {
    subject;
    doc /* The system shall reject $maxTimeMS parameter values that are zero or negative */
    attribute id : String = "REQ-151";
    attribute max_invalid_value : Integer = 0;
    attribute parameter_rejected : Boolean;
    attribute input_value : Integer;
    stakeholder developer : Developer;
    require constraint RejectInvalidValues { input_value <= max_invalid_value implies parameter_rejected == true }
    }

  requirement def MaxTimeMSParameterValidation {
    subject;
    doc /* The system shall accept $maxTimeMS parameter values as positive integers representing milliseconds */
    attribute id : String = "REQ-148";
    attribute min_valid_value : Integer = 1;
    attribute parameter_unit : String = "milliseconds";
    attribute parameter_type : String = "positive_integer";
    attribute input_value : Integer;
    attribute parameter_accepted : Boolean;
    stakeholder developer : Developer;
    require constraint AcceptValidValues { input_value >= min_valid_value implies parameter_accepted == true }
    }

  requirement def OIDGenerationErrorMessage {
    subject;
    doc /* The MongoDB C++ driver shall provide a clear error message when OID::gen() is called without prior client::initialize() invocation */
    attribute id : String = "REQ-152";
    attribute error_message_clear : Boolean = true;
    attribute initialization_check_required : Boolean = true;
    attribute function_name : String = "OID::gen()";
    attribute prerequisite_function : String = "client::initialize()";
    stakeholder developer : Developer;
    require constraint ErrorMessageOnMissingInit { initialization_check_required == true implies error_message_clear == true }
    }

  requirement def CreateIndexErrorMessage {
    subject;
    doc /* The MongoDB C++ driver shall provide a clear error message when createIndex() is called without prior client::initialize() invocation */
    attribute id : String = "REQ-153";
    attribute error_message_clear : Boolean = true;
    attribute initialization_check_required : Boolean = true;
    attribute function_name : String = "createIndex()";
    attribute prerequisite_function : String = "client::initialize()";
    stakeholder developer : Developer;
    require constraint CreateIndexErrorOnMissingInit { initialization_check_required == true implies error_message_clear == true }
    }

  requirement def DBClientCursorValidation {
    subject;
    doc /* The MongoDB C++ driver shall validate dbclientcursor pointer for null before usage in all internal iteration operations */
    attribute id : String = "REQ-166";
    attribute null_pointer_validation : Boolean = true;
    attribute pointer_type : String = "dbclientcursor";
    attribute validation_scope : String = "internal_iteration_operations";
    attribute validation_timing : String = "before_usage";
    stakeholder developer : Developer;
    require constraint NullPointerValidation { null_pointer_validation == true and validation_timing == "before_usage" }
    }

  requirement def CopyDbAuthenticationSupport {
    subject;
    doc /* The CopyDb helper shall support authentication mechanisms */
    attribute id : String = "REQ-161";
    attribute authentication_supported : Boolean = true;
    attribute helper_name : String = "CopyDb";
    attribute mechanism_support_required : Boolean = true;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint AuthenticationMechanismSupport { mechanism_support_required == true implies authentication_supported == true }
    }

  requirement def JSONInputAcceptance {
    subject;
    doc /* The BSON creation method shall accept valid JSON strings as input */
    attribute id : String = "REQ-168";
    attribute accepts_valid_json : Boolean;
    attribute input_format : String = "JSON";
    attribute input_validation_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint ValidJSONAcceptance { input_format == "JSON" and input_validation_enabled == true implies accepts_valid_json == true }
    }

  requirement def MalformedJSONHandling {
    subject;
    doc /* The BSON creation method shall handle malformed JSON input gracefully by returning an appropriate error */
    attribute id : String = "REQ-170";
    attribute handles_malformed_input : Boolean;
    attribute returns_error_response : Boolean;
    attribute graceful_error_handling : Boolean;
    stakeholder developer : Developer;
    require constraint GracefulErrorHandling { handles_malformed_input == true and returns_error_response == true and graceful_error_handling == true }
    }

  requirement def BSONFromJSONMethod {
    subject;
    doc /* The system shall provide a method to create BSON objects from JSON formatted text strings */
    attribute id : String = "REQ-167";
    attribute method_available : Boolean;
    attribute supports_json_input : Boolean;
    attribute creates_bson_output : Boolean;
    stakeholder developer : Developer;
    require constraint MethodCapability { method_available == true and supports_json_input == true and creates_bson_output == true }
    }

  requirement def ValidBSONOutput {
    subject;
    doc /* The BSON creation method shall return a valid BSON object when provided with well-formed JSON input */
    attribute id : String = "REQ-169";
    attribute returns_valid_bson : Boolean;
    attribute input_well_formed : Boolean;
    attribute output_format : String = "BSON";
    stakeholder developer : Developer;
    require constraint ValidOutputFromValidInput { input_well_formed == true implies returns_valid_bson == true and output_format == "BSON" }
    }

  requirement def LoggingAPIExport {
    subject;
    doc /* The compiled library shall export logging API functions to enable external applications to intercept mongo driver logs */
    attribute id : String = "REQ-171";
    attribute api_functions_exported : Boolean;
    attribute external_access_enabled : Boolean;
    attribute log_interception_supported : Boolean;
    stakeholder developer : Developer;
    require constraint APIExportComplete { api_functions_exported == true and external_access_enabled == true and log_interception_supported == true }
    }

  requirement def BSONObjLifetimeExplicit {
    subject;
    doc /* The C++11 driver shall make BSONObj lifetime explicit to users */
    attribute id : String = "REQ-197.1";
    attribute lifetime_explicit_to_users : Boolean;
    attribute explicit_lifetime_semantics : Boolean;
    stakeholder developer : Developer;
    require constraint LifetimeExplicitness { lifetime_explicit_to_users == true and explicit_lifetime_semantics == true }
    }

  requirement def ClientOptionsRetrieval {
    subject;
    doc /* The C++ driver client shall provide a function to retrieve the client options used to create the client instance */
    attribute id : String = "REQ-177";
    attribute options_retrieval_function_available : Boolean;
    attribute original_options_preserved : Boolean;
    stakeholder developer : Developer;
    require constraint OptionsRetrievalCapability { options_retrieval_function_available == true and original_options_preserved == true }
    }

  requirement def ValidationFailureErrorField {
    subject;
    doc /* The bsoncxx validation method shall set error field in validator on validation failure */
    attribute id : String = "REQ-181.2";
    attribute sets_error_field : Boolean;
    attribute error_field_in_validator : Boolean;
    stakeholder developer : Developer;
    require constraint ErrorFieldSetting { sets_error_field == true and error_field_in_validator == true }
    }

  requirement def BSONObjLifetimeVisible {
    subject;
    doc /* The C++11 driver shall make BSONObj lifetime visible to users through the API design */
    attribute id : String = "REQ-197.2";
    attribute lifetime_visible_through_api : Boolean;
    attribute api_design_shows_lifetime : Boolean;
    stakeholder developer : Developer;
    require constraint LifetimeVisibility { lifetime_visible_through_api == true and api_design_shows_lifetime == true }
    }

  requirement def BSONObjLifetimeManagement {
    subject;
    doc /* The C++11 driver shall make BSONObj lifetime explicit and visible to users through the API design */
    attribute id : String = "REQ-197";
    attribute lifetime_explicit : Boolean;
    attribute lifetime_visible_in_api : Boolean;
    stakeholder developer : Developer;
    require constraint LifetimeManagement { lifetime_explicit == true and lifetime_visible_in_api == true }
    }

  requirement def ClientURIRetrieval {
    subject;
    doc /* The C++ driver client shall provide a function to retrieve the URI used to create the client instance */
    attribute id : String = "REQ-176";
    attribute uri_retrieval_function_available : Boolean;
    attribute original_uri_preserved : Boolean;
    stakeholder developer : Developer;
    require constraint URIRetrievalCapability { uri_retrieval_function_available == true and original_uri_preserved == true }
    }

  requirement def ValidationFailureOptionalReturn {
    subject;
    doc /* The bsoncxx validation method shall return an unengaged std::optional on validation failure */
    attribute id : String = "REQ-181.1";
    attribute returns_unengaged_optional : Boolean;
    attribute failure_returns_empty : Boolean;
    stakeholder developer : Developer;
    require constraint UnengagedOptionalReturn { returns_unengaged_optional == true and failure_returns_empty == true }
    }

  requirement def CommandHelperFunction {
    subject;
    doc /* The C++ driver shall provide a command helper function that allows users to execute arbitrary MongoDB commands not covered by existing helper methods */
    attribute id : String = "REQ-175";
    attribute supports_arbitrary_commands : Boolean;
    attribute helper_function_available : Boolean;
    stakeholder developer : Developer;
    require constraint CommandHelperSupport { supports_arbitrary_commands == true and helper_function_available == true }
    }

  requirement def ValidationFailureHandling {
    subject;
    doc /* The bsoncxx validation method shall handle validation failure appropriately */
    attribute id : String = "REQ-181";
    attribute handles_validation_failure : Boolean;
    attribute failure_handling_appropriate : Boolean;
    stakeholder developer : Developer;
    require constraint FailureHandling { handles_validation_failure == true and failure_handling_appropriate == true }
    }

  requirement def DocumentValidationMethod {
    subject;
    doc /* The bsoncxx library shall provide a document validation method that accepts a trivial_buffer and validator configuration */
    attribute id : String = "REQ-179";
    attribute validation_method_available : Boolean;
    attribute accepts_trivial_buffer : Boolean;
    attribute accepts_validator_config : Boolean;
    stakeholder developer : Developer;
    require constraint ValidationMethodProvision { validation_method_available == true and accepts_trivial_buffer == true and accepts_validator_config == true }
    }

  requirement def UnderlyingCHandleAccess {
    subject;
    doc /* Each C++ driver object that wraps an underlying mongoc driver object shall expose access to that underlying C handle */
    attribute id : String = "REQ-178";
    attribute c_handle_exposed : Boolean;
    attribute wrapper_object_provides_access : Boolean;
    stakeholder developer : Developer;
    require constraint CHandleAccess { c_handle_exposed == true and wrapper_object_provides_access == true }
    }

  requirement def CursorLifetimeSemantics {
    subject;
    doc /* The cursor next() function shall return BSONObj with clearly defined lifetime semantics that are apparent from the function signature */
    attribute id : String = "REQ-198";
    attribute returns_bsonobj : Boolean;
    attribute lifetime_semantics_clear : Boolean;
    attribute semantics_apparent_in_signature : Boolean;
    stakeholder developer : Developer;
    require constraint CursorLifetimeClarity { returns_bsonobj == true and lifetime_semantics_clear == true and semantics_apparent_in_signature == true }
    }

  requirement def PipelineViewMethod {
    subject;
    doc /* The mongocxx::pipeline class shall provide a view() method that returns a read-only view of the pipeline */
    attribute id : String = "REQ-205";
    attribute method_name : String = "view";
    attribute class_name : String = "pipeline";
    attribute namespace_name : String = "mongocxx";
    attribute access_type : String = "read-only";
    attribute return_description : String = "pipeline view";
    attribute method_provided : Boolean;
    stakeholder developer : Developer;
    require constraint ViewMethodProvided { method_name == "view" and class_name == "pipeline" implies method_provided == true }
    require constraint ReadOnlyAccess { method_provided == true implies access_type == "read-only" }
    }

  requirement def PipelineViewStringConversion {
    subject;
    doc /* The mongocxx::pipeline view() method shall enable conversion to string representation for display purposes */
    attribute id : String = "REQ-206";
    attribute method_name : String = "view";
    attribute class_name : String = "pipeline";
    attribute conversion_target : String = "string representation";
    attribute purpose : String = "display";
    attribute conversion_enabled : Boolean = true;
    stakeholder developer : Developer;
    require constraint ConversionCapability { conversion_enabled == true and purpose == "display" implies conversion_target == "string representation" }
    }

  requirement def DatabaseListCollectionsMethod {
    subject;
    doc /* The database class shall implement the list_collections() method as documented in the API specification */
    attribute id : String = "REQ-203";
    attribute method_name : String = "list_collections";
    attribute class_name : String = "database";
    attribute api_compliance_required : Boolean = true;
    attribute documentation_reference : String = "API specification";
    attribute method_implemented : Boolean;
    stakeholder developer : Developer;
    require constraint MethodImplementation { api_compliance_required == true implies method_implemented == true }
    require constraint APICompliance { method_implemented == true implies documentation_reference == "API specification" }
    }

  requirement def BSONFromJSONConstruction {
    subject;
    doc /* The bsoncxx library shall provide a from_json method that constructs a document::value from a JSON input string_view */
    attribute id : String = "REQ-199";
    attribute method_name : String = "from_json";
    attribute input_type : String = "string_view";
    attribute output_type : String = "document::value";
    attribute library_namespace : String = "bsoncxx";
    attribute method_available : Boolean;
    stakeholder developer : Developer;
    require constraint FromJSONMethodAvailable { library_namespace == "bsoncxx" implies method_available == true }
    require constraint InputOutputMapping { method_available == true and input_type == "string_view" implies output_type == "document::value" }
    }

  requirement def DatabaseCommandReplyInitialization {
    subject;
    doc /* The database::command method shall properly initialize the scoped_bson_t reply object to prevent empty response documents */
    attribute id : String = "REQ-202";
    attribute method_name : String = "command";
    attribute class_name : String = "database";
    attribute reply_object_type : String = "scoped_bson_t";
    attribute initialization_required : Boolean = true;
    attribute empty_response_prevented : Boolean;
    stakeholder developer : Developer;
    require constraint ProperInitialization { initialization_required == true implies empty_response_prevented == true }
    require constraint ReplyObjectType { initialization_required == true implies reply_object_type == "scoped_bson_t" }
    }

  requirement def ClientListDatabasesMethod {
    subject;
    doc /* The client class shall provide a list_databases() method to enumerate available databases */
    attribute id : String = "REQ-204";
    attribute method_name : String = "list_databases";
    attribute class_name : String = "client";
    attribute operation_type : String = "enumeration";
    attribute target_resource : String = "databases";
    attribute method_provided : Boolean;
    stakeholder developer : Developer;
    require constraint ListDatabasesMethodProvided { class_name == "client" implies method_provided == true }
    require constraint EnumerationOperation { method_provided == true and operation_type == "enumeration" implies target_resource == "databases" }
    }

  requirement def DocumentViewNonEmptyDetection {
    subject;
    doc /* The bsoncxx::document::view empty() method shall return false when the underlying document contains one or more fields */
    attribute id : String = "REQ-201";
    attribute method_name : String = "empty";
    attribute return_type : String = "Boolean";
    attribute expected_return_value : Boolean = false;
    attribute min_field_count : Integer = 1;
    attribute actual_field_count : Integer;
    stakeholder developer : Developer;
    require constraint NonEmptyDetection { actual_field_count >= min_field_count implies expected_return_value == false }
    }

  requirement def DocumentViewEmptyDetection {
    subject;
    doc /* The bsoncxx::document::view class shall provide an empty() method that returns true when the underlying document contains no fields */
    attribute id : String = "REQ-200";
    attribute method_name : String = "empty";
    attribute return_type : String = "Boolean";
    attribute class_name : String = "document::view";
    attribute expected_return_value : Boolean = true;
    attribute field_count : Integer = 0;
    stakeholder developer : Developer;
    require constraint EmptyDetection { field_count == 0 implies expected_return_value == true }
    require constraint MethodReturnType { method_name == "empty" implies return_type == "Boolean" }
    }

  requirement def BulkWriteParameterTypeReplacement {
    subject;
    doc /* The mongocxx::bulk_write API shall replace the boolean parameter for ordered/unordered operations with an enumerated type */
    attribute id : String = "REQ-207";
    attribute api_name : String = "bulk_write";
    attribute namespace_name : String = "mongocxx";
    attribute old_parameter_type : String = "Boolean";
    attribute new_parameter_type : String = "enumerated type";
    attribute parameter_purpose : String = "ordered/unordered operations";
    attribute type_replacement_completed : Boolean;
    stakeholder developer : Developer;
    require constraint ParameterTypeReplacement { old_parameter_type == "Boolean" implies type_replacement_completed == true }
    require constraint NewParameterType { type_replacement_completed == true implies new_parameter_type == "enumerated type" }
    }

  requirement def UnacknowledgedWriteConcernCompliance {
    subject;
    doc /* The database driver shall comply with the MongoDB specification for unacknowledged write concerns */
    attribute id : String = "REQ-217";
    attribute mongodb_spec_compliant : Boolean;
    attribute unacknowledged_write_supported : Boolean;
    attribute write_concern_level : String;
    stakeholder developer : Developer;
    require constraint SpecComplianceForUnacknowledged { unacknowledged_write_supported == true implies mongodb_spec_compliant == true }
    }

  requirement def FilteredIndexCreationSupport {
    subject;
    doc /* The database driver shall support creation of filtered (partial) indexes */
    attribute id : String = "REQ-220";
    attribute filtered_index_supported : Boolean;
    attribute partial_index_supported : Boolean;
    attribute index_creation_available : Boolean;
    attribute filter_expression_supported : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint FilteredIndexCapability { index_creation_available == true implies filtered_index_supported == true and partial_index_supported == true }
    require constraint FilterExpressionSupport { filtered_index_supported == true implies filter_expression_supported == true }
    }

  requirement def ConstantTimeHashComparison {
    subject;
    doc /* The database driver shall use constant-time hash comparison functions for security-sensitive operations */
    attribute id : String = "REQ-221";
    attribute constant_time_comparison_used : Boolean;
    attribute security_sensitive_operations_protected : Boolean;
    attribute hash_comparison_function_type : String = "constant-time";
    attribute timing_attack_resistant : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint ConstantTimeForSecurity { security_sensitive_operations_protected == true implies constant_time_comparison_used == true }
    require constraint TimingAttackResistance { constant_time_comparison_used == true implies timing_attack_resistant == true }
    }

  requirement def BypassDocumentValidationSupport {
    subject;
    doc /* The database driver shall support the bypassDocumentValidation option for write operations */
    attribute id : String = "REQ-219";
    attribute bypass_validation_supported : Boolean;
    attribute write_operations_supported : Boolean;
    attribute bypass_option_name : String = "bypassDocumentValidation";
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint BypassValidationForWrites { write_operations_supported == true implies bypass_validation_supported == true }
    }

  requirement def FindAndModifyWriteConcernSupport {
    subject;
    doc /* The findAndModify operation shall accept a write concern parameter */
    attribute id : String = "REQ-218";
    attribute write_concern_parameter_accepted : Boolean;
    attribute findAndModify_operation_available : Boolean;
    attribute write_concern_parameter_name : String = "writeConcern";
    stakeholder developer : Developer;
    require constraint WriteConcernParameterAcceptance { findAndModify_operation_available == true implies write_concern_parameter_accepted == true }
    }

  requirement def PrimaryNodeStepdownDetection {
    subject;
    doc /* The system shall detect when a primary node has stepped down during replica set operations */
    attribute id : String = "REQ-223";
    attribute primary_stepdown_detected : Boolean;
    attribute replica_set_operation_active : Boolean;
    attribute primary_node_available : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint StepdownDetectionDuringOperations { replica_set_operation_active == true and primary_node_available == false implies primary_stepdown_detected == true }
    }

  requirement def ReplicaSetRetryLogic {
    subject;
    doc /* The system shall implement retry logic for database queries that fail due to replica set primary node changes */
    attribute id : String = "REQ-225";
    attribute retry_logic_implemented : Boolean;
    attribute primary_node_changed : Boolean;
    attribute query_failed : Boolean;
    attribute query_retry_attempted : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint RetryOnPrimaryChange { query_failed == true and primary_node_changed == true implies query_retry_attempted == true }
    require constraint RetryLogicAvailable { retry_logic_implemented == true }
    }

  requirement def NullPointerCursorHandling {
    subject;
    doc /* The system shall handle NULL pointer returns from database cursors when primary node connectivity is lost */
    attribute id : String = "REQ-224";
    attribute null_pointer_returned : Boolean;
    attribute primary_connectivity_lost : Boolean;
    attribute cursor_handled_safely : Boolean;
    stakeholder developer : Developer;
    require constraint SafeNullHandling { null_pointer_returned == true and primary_connectivity_lost == true implies cursor_handled_safely == true }
    }

  requirement def NetworkErrorQueryRetry {
    subject;
    doc /* The system shall automatically retry a query when a network error occurs during database operation execution */
    attribute id : String = "REQ-222";
    attribute retry_enabled : Boolean;
    attribute network_error_detected : Boolean;
    attribute query_retried : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint AutoRetryOnNetworkError { network_error_detected == true and retry_enabled == true implies query_retried == true }
    }

  requirement def DatabaseObjectCopySupport {
    subject;
    doc /* The MongoDB C++ driver shall allow copying of database objects */
    attribute id : String = "REQ-241";
    attribute database_copying_allowed : Boolean;
    attribute copy_operations_supported : Boolean;
    stakeholder developer : Developer;
    require constraint CopyingCapability { database_copying_allowed == true and copy_operations_supported == true }
    }

  requirement def CollModValidationHelper {
    subject;
    doc /* The MongoDB C++ driver shall provide a collMod helper that accepts document validation rules */
    attribute id : String = "REQ-249";
    attribute collmod_helper_provided : Boolean;
    attribute validation_rules_accepted : Boolean;
    attribute document_validation_supported : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint CollModHelperCapability { collmod_helper_provided == true implies (validation_rules_accepted == true and document_validation_supported == true) }
    }

  requirement def GetMoreMaxAwaitTimeSupport {
    subject;
    doc /* The getMore command shall support the maxAwaitTimeMS option */
    attribute id : String = "REQ-250";
    attribute getmore_command_supported : Boolean;
    attribute max_await_time_option_supported : Boolean;
    attribute option_name : String = "maxAwaitTimeMS";
    stakeholder developer : Developer;
    require constraint GetMoreOptionSupport { getmore_command_supported == true implies max_await_time_option_supported == true }
    }

  requirement def DatabaseCommandMethodRename {
    subject;
    doc /* The database class shall rename the command method to run_command */
    attribute id : String = "REQ-243";
    attribute method_renamed : Boolean;
    attribute old_method_name : String = "command";
    attribute new_method_name : String = "run_command";
    stakeholder developer : Developer;
    require constraint MethodRenamed { method_renamed == true }
    }

  requirement def BoostStdxPolyfillSupport {
    subject;
    doc /* The MongoDB C++ driver shall support Boost optional and string_ref types as stdx polyfills */
    attribute id : String = "REQ-233";
    attribute boost_optional_supported : Boolean;
    attribute boost_string_ref_supported : Boolean;
    attribute stdx_polyfills_provided : Boolean;
    stakeholder developer : Developer;
    require constraint BoostPolyfillCapability { stdx_polyfills_provided == true implies (boost_optional_supported == true and boost_string_ref_supported == true) }
    }

  requirement def BSONErrorCategoryImplementation {
    subject;
    doc /* The bsoncxx library shall implement a bsoncxx error category for exception handling */
    attribute id : String = "REQ-237";
    attribute bsoncxx_error_category_implemented : Boolean;
    attribute exception_handling_supported : Boolean;
    stakeholder developer : Developer;
    require constraint ErrorCategoryImplementation { bsoncxx_error_category_implemented == true implies exception_handling_supported == true }
    }

  requirement def CollectionRenameSupport {
    subject;
    doc /* The MongoDB C++ driver shall provide functionality to rename collections */
    attribute id : String = "REQ-248";
    attribute rename_functionality_provided : Boolean;
    attribute collection_operations_supported : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint RenameCapability { rename_functionality_provided == true implies collection_operations_supported == true }
    }

  requirement def LibbsonErrorCategoryImplementation {
    subject;
    doc /* The bsoncxx library shall implement a libbson error category for exception handling */
    attribute id : String = "REQ-236";
    attribute libbson_error_category_implemented : Boolean;
    attribute exception_handling_supported : Boolean;
    stakeholder developer : Developer;
    require constraint LibbsonErrorCategoryImplementation { libbson_error_category_implemented == true implies exception_handling_supported == true }
    }

  requirement def BSONDocumentViewOrValueVariant {
    subject;
    doc /* The MongoDB C++ driver shall provide a variant type for bson document view_or_value */
    attribute id : String = "REQ-246";
    attribute variant_type_provided : Boolean;
    attribute variant_name : String = "view_or_value";
    attribute document_type : String = "bson";
    stakeholder developer : Developer;
    require constraint DocumentVariantTypeProvided { variant_type_provided == true }
    }

  requirement def BSONRawPointerAccess {
    subject;
    doc /* The BSON library shall provide accessor methods to get raw pointer access to BSON documents */
    attribute id : String = "REQ-240";
    attribute accessor_methods_provided : Boolean;
    attribute raw_pointer_access_available : Boolean;
    attribute document_type : String = "BSON";
    stakeholder developer : Developer;
    require constraint RawPointerAccessCapability { accessor_methods_provided == true implies raw_pointer_access_available == true }
    }

  requirement def ChronoTimeoutSupport {
    subject;
    doc /* The MongoDB C++ driver shall support specifying timeouts using std::chrono types */
    attribute id : String = "REQ-242";
    attribute chrono_timeout_supported : Boolean;
    attribute std_chrono_types_accepted : Boolean;
    stakeholder developer : Developer;
    require constraint ChronoTimeoutCapability { chrono_timeout_supported == true and std_chrono_types_accepted == true }
    }

  requirement def BSONExceptionImplementation {
    subject;
    doc /* The bsoncxx library shall implement a bsoncxx::exception class that inherits from std::system_error */
    attribute id : String = "REQ-235";
    attribute exception_class_implemented : Boolean;
    attribute inherits_system_error : Boolean;
    attribute class_name : String = "bsoncxx::exception";
    stakeholder developer : Developer;
    require constraint ExceptionClassInheritance { exception_class_implemented == true implies inherits_system_error == true }
    }

  requirement def NullTerminatedStringEnforcement {
    subject;
    doc /* The string variant type shall ensure only null-terminated strings are passed to the C driver */
    attribute id : String = "REQ-245";
    attribute null_terminated_enforced : Boolean;
    attribute c_driver_compatibility : Boolean;
    stakeholder developer : Developer;
    require constraint NullTerminatedStringCompliance { null_terminated_enforced == true implies c_driver_compatibility == true }
    }

  requirement def BoostOptionalPolyfillSupport {
    subject;
    doc /* The MongoDB C++ driver shall support Boost optional types as stdx polyfills */
    attribute id : String = "REQ-233.1";
    attribute boost_optional_supported : Boolean;
    attribute stdx_polyfill_provided : Boolean;
    stakeholder developer : Developer;
    require constraint BoostOptionalPolyfillCapability { boost_optional_supported == true implies stdx_polyfill_provided == true }
    }

  requirement def StringViewOrValueVariant {
    subject;
    doc /* The MongoDB C++ driver shall provide a variant type for string_view_or_value */
    attribute id : String = "REQ-244";
    attribute variant_type_provided : Boolean;
    attribute variant_name : String = "string_view_or_value";
    stakeholder developer : Developer;
    require constraint StringVariantTypeProvided { variant_type_provided == true }
    }

  requirement def BoostStringRefPolyfillSupport {
    subject;
    doc /* The MongoDB C++ driver shall support Boost string_ref types as stdx polyfills */
    attribute id : String = "REQ-233.2";
    attribute boost_string_ref_supported : Boolean;
    attribute stdx_polyfill_provided : Boolean;
    stakeholder developer : Developer;
    require constraint BoostStringRefPolyfillCapability { boost_string_ref_supported == true implies stdx_polyfill_provided == true }
    }

  requirement def WriteConcernFsyncPropertyExclusion {
    subject;
    doc /* The WriteConcern class shall not include an fsync property */
    attribute id : String = "REQ-258";
    attribute writeconcern_class_properties : Integer;
    attribute fsync_property_excluded : Boolean;
    attribute class_interface_compliance : Boolean;
    stakeholder developer : Developer;
    require constraint FsyncPropertyExcluded { fsync_property_excluded == true and class_interface_compliance == true }
    }

  requirement def AggregationSampleOperatorSupport {
    subject;
    doc /* The aggregation pipeline shall support the $sample operator for random document sampling */
    attribute id : String = "REQ-274";
    attribute pipeline_component : String = "aggregation pipeline";
    attribute operator_name : String = "$sample";
    attribute sampling_type : String = "random document sampling";
    attribute operator_supported : Boolean;
    stakeholder developer : Developer;
    require constraint SampleOperatorSupported { operator_supported == true }
    }

  requirement def DocumentElementOperatorBehavior {
    subject;
    doc /* The bsoncxx::document::element operator[] function shall return an invalid element when called on an element that is neither a document nor an array */
    attribute id : String = "REQ-272";
    attribute function_name : String = "bsoncxx::document::element operator[]";
    attribute invalid_element_types : String = "neither document nor array";
    attribute return_type : String = "invalid element";
    attribute operator_called : Boolean;
    attribute element_is_document : Boolean;
    attribute element_is_array : Boolean;
    attribute returns_invalid_element : Boolean;
    stakeholder developer : Developer;
    require constraint InvalidElementReturn { (operator_called == true and element_is_document == false and element_is_array == false) implies returns_invalid_element == true }
    }

  requirement def ArrayOperatorElementRetrieval {
    subject;
    doc /* The bsoncxx::document::array operator[] function shall return an invalid element when a matching element is not found */
    attribute id : String = "REQ-273";
    attribute function_name : String = "bsoncxx::document::array operator[]";
    attribute search_condition : String = "matching element not found";
    attribute return_behavior : String = "invalid element";
    attribute element_found : Boolean;
    attribute returns_invalid_element : Boolean;
    stakeholder developer : Developer;
    require constraint ElementNotFoundBehavior { element_found == false implies returns_invalid_element == true }
    }

  requirement def ConnectionStatusCheck {
    subject;
    doc /* The system shall provide a method to check MongoDB connection status without performing actual database operations */
    attribute id : String = "REQ-293";
    attribute performs_database_operations : Boolean = false;
    attribute connection_status_available : Boolean;
    stakeholder developer : Developer;
    require constraint StatusCheckWithoutOperations { performs_database_operations == false and connection_status_available == true }
    }

  requirement def OptionsMethodChaining {
    subject;
    doc /* The mongocxx::options setter methods shall return a self-reference to enable method chaining */
    attribute id : String = "REQ-291";
    attribute returns_self_reference : Boolean;
    attribute method_chaining_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint SelfReferenceEnablesChaining { returns_self_reference == true implies method_chaining_enabled == true }
    }

  requirement def DatabaseCollectionErrorModes {
    subject;
    doc /* The Database::has_collection method shall provide distinct error modes for connection failures versus collection absence */
    attribute id : String = "REQ-292";
    attribute connection_failure_mode_distinct : Boolean;
    attribute collection_absence_mode_distinct : Boolean;
    attribute error_modes_distinguishable : Boolean;
    stakeholder developer : Developer;
    require constraint DistinctErrorModes { connection_failure_mode_distinct == true and collection_absence_mode_distinct == true and error_modes_distinguishable == true }
    }

  requirement def CoreBuilderAppendOverload {
    subject;
    doc /* The core builder shall provide an append overload that accepts document::view parameters */
    attribute id : String = "REQ-295";
    attribute accepts_document_view : Boolean;
    attribute append_overload_available : Boolean;
    stakeholder developer : Developer;
    require constraint DocumentViewOverload { accepts_document_view == true and append_overload_available == true }
    }

  requirement def LookupPipelineOperatorSupport {
    subject;
    doc /* The C++ driver shall support the $lookup pipeline operator */
    attribute id : String = "REQ-288";
    attribute operator_name : String = "$lookup";
    attribute operator_supported : Boolean;
    stakeholder developer : Developer;
    require constraint LookupOperatorSupported { operator_supported == true }
    }

  requirement def ReadConcernLinearizableSupport {
    subject;
    doc /* The driver shall support readConcern level 'linearizable' for read operations */
    attribute id : String = "REQ-333";
    attribute linearizable_level_supported : Boolean;
    attribute read_operations_compatible : Boolean;
    stakeholder developer : Developer;
    require constraint LinearizableSupportCheck { linearizable_level_supported == true and read_operations_compatible == true }
    }

  requirement def WriteConcernErrorHandling {
    subject;
    doc /* The driver shall handle writeConcernError field in command responses */
    attribute id : String = "REQ-340";
    attribute write_concern_error_handled : Boolean;
    attribute command_response_processed : Boolean;
    stakeholder developer : Developer;
    require constraint ErrorHandlingCheck { command_response_processed == true implies write_concern_error_handled == true }
    }

  requirement def MongoDBX509NoUsername {
    subject;
    doc /* The authentication system shall not require a username for MONGODB-X509 authentication */
    attribute id : String = "REQ-308";
    attribute auth_mechanism : String = "MONGODB-X509";
    attribute username_required : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint X509NoUsernameCheck { auth_mechanism == "MONGODB-X509" implies username_required == false }
    }

  requirement def DistinctCommandCollationSupport {
    subject;
    doc /* The distinct command helper shall support collation option when server version supports it */
    attribute id : String = "REQ-325";
    attribute collation_option_supported : Boolean;
    attribute server_version_checked : Boolean;
    stakeholder developer : Developer;
    require constraint CollationSupportCheck { server_version_checked == true implies collation_option_supported == true }
    }

  requirement def CreateCollectionGetterMethods {
    subject;
    doc /* The options::create_collection class shall provide getter methods for all configuration options */
    attribute id : String = "REQ-312";
    attribute getter_methods_available : Boolean;
    attribute all_options_accessible : Boolean;
    stakeholder developer : Developer;
    require constraint GetterMethodsCheck { getter_methods_available == true and all_options_accessible == true }
    }

  requirement def DropIndexesCommandWriteConcernSupport {
    subject;
    doc /* The dropIndexes command shall support writeConcern option when server version 3.4 or greater */
    attribute id : String = "REQ-339";
    attribute write_concern_supported : Boolean;
    attribute min_server_version : String = "3.4";
    attribute server_version_checked : Boolean;
    stakeholder developer : Developer;
    require constraint WriteConcernSupportCheck { server_version_checked == true implies write_concern_supported == true }
    }

  requirement def DropCommandWriteConcernSupport {
    subject;
    doc /* The drop command shall support writeConcern option when server version 3.4 or greater */
    attribute id : String = "REQ-337";
    attribute write_concern_supported : Boolean;
    attribute min_server_version : String = "3.4";
    attribute server_version_checked : Boolean;
    stakeholder developer : Developer;
    require constraint WriteConcernSupportCheck { server_version_checked == true implies write_concern_supported == true }
    }

  requirement def HandshakeDriverVersion {
    subject;
    doc /* The driver shall include driver version in the MongoDB handshake when connecting */
    attribute id : String = "REQ-319";
    attribute driver_version_included : Boolean;
    attribute handshake_contains_version : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint DriverVersionInclusionCheck { driver_version_included == true and handshake_contains_version == true }
    }

  requirement def CreateViewGetterMethods {
    subject;
    doc /* The options::create_view class shall provide getter methods for all configuration options */
    attribute id : String = "REQ-313";
    attribute getter_methods_available : Boolean;
    attribute all_options_accessible : Boolean;
    stakeholder developer : Developer;
    require constraint GetterMethodsCheck { getter_methods_available == true and all_options_accessible == true }
    }

  requirement def CreateCommandWriteConcernSupport {
    subject;
    doc /* The create command shall support writeConcern option when server version 3.4 or greater */
    attribute id : String = "REQ-335";
    attribute write_concern_supported : Boolean;
    attribute min_server_version : String = "3.4";
    attribute server_version_checked : Boolean;
    stakeholder developer : Developer;
    require constraint WriteConcernSupportCheck { server_version_checked == true implies write_concern_supported == true }
    }

  requirement def DropDatabaseCommandWriteConcernSupport {
    subject;
    doc /* The dropDatabase command shall support writeConcern option when server version 3.4 or greater */
    attribute id : String = "REQ-338";
    attribute write_concern_supported : Boolean;
    attribute min_server_version : String = "3.4";
    attribute server_version_checked : Boolean;
    stakeholder developer : Developer;
    require constraint WriteConcernSupportCheck { server_version_checked == true implies write_concern_supported == true }
    }

  requirement def CountCommandCollationSupport {
    subject;
    doc /* The count command helper shall support collation option when server version supports it */
    attribute id : String = "REQ-324";
    attribute collation_option_supported : Boolean;
    attribute server_version_checked : Boolean;
    stakeholder developer : Developer;
    require constraint CollationSupportCheck { server_version_checked == true implies collation_option_supported == true }
    }

  requirement def HandshakeApplicationName {
    subject;
    doc /* The driver shall include application name in the MongoDB handshake when connecting */
    attribute id : String = "REQ-318";
    attribute application_name_included : Boolean;
    attribute handshake_contains_app_name : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint ApplicationNameInclusionCheck { application_name_included == true and handshake_contains_app_name == true }
    }

  requirement def CollectionFindOneCollationError {
    subject;
    doc /* The collection::find_one() method shall fail with an error when collation is specified and the server lacks collation support */
    attribute id : String = "REQ-306";
    attribute collation_specified : Boolean;
    attribute server_supports_collation : Boolean;
    attribute error_raised : Boolean;
    stakeholder developer : Developer;
    require constraint CollationErrorCheck { (collation_specified == true and server_supports_collation == false) implies error_raised == true }
    }

  requirement def RemoveCommandCollationSupport {
    subject;
    doc /* The remove command helper shall support collation option when server version supports it */
    attribute id : String = "REQ-328";
    attribute collation_option_supported : Boolean;
    attribute server_version_checked : Boolean;
    stakeholder developer : Developer;
    require constraint CollationSupportCheck { server_version_checked == true implies collation_option_supported == true }
    }

  requirement def CreateIndexesCommandCollationSupport {
    subject;
    doc /* The createIndexes command helper shall support collation option when server version supports it */
    attribute id : String = "REQ-322";
    attribute collation_option_supported : Boolean;
    attribute server_version_checked : Boolean;
    stakeholder developer : Developer;
    require constraint CollationSupportCheck { server_version_checked == true implies collation_option_supported == true }
    }

  requirement def AggregationPipelineBuilderMethods34 {
    subject;
    doc /* The aggregation pipeline class shall provide builder methods for MongoDB 3.4 stages including $addFields, $bucket, $bucketAuto, $count, $collStats, $facet, $graphLookup, $replaceRoot, and $sortByCount */
    attribute id : String = "REQ-309";
    attribute addfields_method_available : Boolean;
    attribute bucket_method_available : Boolean;
    attribute bucketauto_method_available : Boolean;
    attribute count_method_available : Boolean;
    attribute collstats_method_available : Boolean;
    attribute facet_method_available : Boolean;
    attribute graphlookup_method_available : Boolean;
    attribute replaceroot_method_available : Boolean;
    attribute sortbycount_method_available : Boolean;
    stakeholder developer : Developer;
    require constraint AllBuilderMethodsAvailable { addfields_method_available == true and bucket_method_available == true and bucketauto_method_available == true and count_method_available == true and collstats_method_available == true and facet_method_available == true and graphlookup_method_available == true and replaceroot_method_available == true and sortbycount_method_available == true }
    }

  requirement def AggregateOutWriteConcernSupport {
    subject;
    doc /* The aggregate command with $out shall support writeConcern option when server version 3.4 or greater */
    attribute id : String = "REQ-334";
    attribute write_concern_supported : Boolean;
    attribute min_server_version : String = "3.4";
    attribute server_version_checked : Boolean;
    stakeholder developer : Developer;
    require constraint WriteConcernSupportCheck { server_version_checked == true implies write_concern_supported == true }
    }

  requirement def FindOptionsReplaceModifiers {
    subject;
    doc /* The options::find class shall provide new top-level find options to replace modifiers functionality */
    attribute id : String = "REQ-316";
    attribute top_level_options_available : Boolean;
    attribute modifiers_replaced : Boolean;
    stakeholder developer : Developer;
    require constraint ModifiersReplacementCheck { top_level_options_available == true and modifiers_replaced == true }
    }

  requirement def MaxStalenessSecondsMinimum {
    subject;
    doc /* The driver shall enforce a minimum value of 90 seconds for maxStalenessSeconds parameter */
    attribute id : String = "REQ-303";
    attribute min_staleness_seconds : Real = 90.0;
    attribute configured_staleness_seconds : Real;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint MinimumStalenessCheck { configured_staleness_seconds >= min_staleness_seconds }
    }

  requirement def FindAndModifyCommandCollationSupport {
    subject;
    doc /* The findAndModify command helper shall support collation option when server version supports it */
    attribute id : String = "REQ-327";
    attribute collation_option_supported : Boolean;
    attribute server_version_checked : Boolean;
    stakeholder developer : Developer;
    require constraint CollationSupportCheck { server_version_checked == true implies collation_option_supported == true }
    }

  requirement def UpdateCommandCollationSupport {
    subject;
    doc /* The update command helper shall support collation option when server version supports it */
    attribute id : String = "REQ-329";
    attribute collation_option_supported : Boolean;
    attribute server_version_checked : Boolean;
    stakeholder developer : Developer;
    require constraint CollationSupportCheck { server_version_checked == true implies collation_option_supported == true }
    }

  requirement def FindCommandCollationSupport {
    subject;
    doc /* The find command helper shall support collation option when server version supports it */
    attribute id : String = "REQ-326";
    attribute collation_option_supported : Boolean;
    attribute server_version_checked : Boolean;
    stakeholder developer : Developer;
    require constraint CollationSupportCheck { server_version_checked == true implies collation_option_supported == true }
    }

  requirement def CreateIndexesCommandWriteConcernSupport {
    subject;
    doc /* The createIndexes command shall support writeConcern option when server version 3.4 or greater */
    attribute id : String = "REQ-336";
    attribute write_concern_supported : Boolean;
    attribute min_server_version : String = "3.4";
    attribute server_version_checked : Boolean;
    stakeholder developer : Developer;
    require constraint WriteConcernSupportCheck { server_version_checked == true implies write_concern_supported == true }
    }

  requirement def ValidationCriteriaGetterMethods {
    subject;
    doc /* The validation_criteria class shall provide getter methods for all validation options */
    attribute id : String = "REQ-314";
    attribute getter_methods_available : Boolean;
    attribute all_validation_options_accessible : Boolean;
    stakeholder developer : Developer;
    require constraint ValidationGetterMethodsCheck { getter_methods_available == true and all_validation_options_accessible == true }
    }

  requirement def CreateCommandCollationSupport {
    subject;
    doc /* The create command helper shall support collation option when server version supports it */
    attribute id : String = "REQ-321";
    attribute collation_option_supported : Boolean;
    attribute server_version_checked : Boolean;
    stakeholder developer : Developer;
    require constraint CollationSupportCheck { server_version_checked == true implies collation_option_supported == true }
    }

  requirement def WriteConcernErrorRaising {
    subject;
    doc /* The driver shall raise appropriate errors when writeConcernError field is present */
    attribute id : String = "REQ-340.2";
    attribute error_raised_when_present : Boolean;
    attribute appropriate_error_type : Boolean;
    stakeholder developer : Developer;
    require constraint ErrorRaisingCheck { error_raised_when_present == true and appropriate_error_type == true }
    }

  requirement def AggregateCommandCollationSupport {
    subject;
    doc /* The aggregate command helper shall support collation option when server version supports it */
    attribute id : String = "REQ-323";
    attribute collation_option_supported : Boolean;
    attribute server_version_checked : Boolean;
    stakeholder developer : Developer;
    require constraint CollationSupportCheck { server_version_checked == true implies collation_option_supported == true }
    }

  requirement def WriteConcernErrorFieldCheck {
    subject;
    doc /* The driver shall check for writeConcernError field in command responses */
    attribute id : String = "REQ-340.1";
    attribute write_concern_error_field_checked : Boolean;
    attribute response_field_inspected : Boolean;
    stakeholder developer : Developer;
    require constraint ErrorFieldCheckingCheck { response_field_inspected == true implies write_concern_error_field_checked == true }
    }

  requirement def PipelineUnwindOverload {
    subject;
    doc /* The pipeline::unwind() method shall provide an overload that accepts includeArrayIndex and preserveNullAndEmptyArrays options */
    attribute id : String = "REQ-311";
    attribute unwind_overload_available : Boolean;
    attribute include_array_index_supported : Boolean;
    attribute preserve_null_empty_arrays_supported : Boolean;
    stakeholder developer : Developer;
    require constraint UnwindOverloadCheck { unwind_overload_available == true and include_array_index_supported == true and preserve_null_empty_arrays_supported == true }
    }

  requirement def AggregationPipelineGeoNearIndexStats {
    subject;
    doc /* The aggregation pipeline class shall provide builder methods for $geoNear and $indexStats stages */
    attribute id : String = "REQ-310";
    attribute geonear_method_available : Boolean;
    attribute indexstats_method_available : Boolean;
    stakeholder developer : Developer;
    require constraint GeoNearIndexStatsMethodsCheck { geonear_method_available == true and indexstats_method_available == true }
    }

  requirement def Decimal128TypeSupport {
    subject;
    doc /* The driver shall implement Decimal128 type support according to the specification */
    attribute id : String = "REQ-341";
    attribute decimal128_type_implemented : Boolean;
    attribute specification_compliant : Boolean;
    stakeholder developer : Developer;
    require constraint Decimal128Implementation { decimal128_type_implemented == true and specification_compliant == true }
    }

  requirement def CollectionFindCollationError {
    subject;
    doc /* The collection::find() method shall fail with an error when collation is specified and the server lacks collation support */
    attribute id : String = "REQ-305";
    attribute collation_specified : Boolean;
    attribute server_supports_collation : Boolean;
    attribute error_raised : Boolean;
    stakeholder developer : Developer;
    require constraint CollationErrorHandling { collation_specified == true and server_supports_collation == false implies error_raised == true }
    }

  requirement def CollectionFindOneAndCollationError {
    subject;
    doc /* The collection::find_one_and_*() methods shall fail with an error when collation is specified and the server lacks collation support */
    attribute id : String = "REQ-307";
    attribute collation_specified : Boolean;
    attribute server_supports_collation : Boolean;
    attribute error_raised : Boolean;
    stakeholder developer : Developer;
    require constraint FindOneCollationErrorHandling { collation_specified == true and server_supports_collation == false implies error_raised == true }
    }

  requirement def ConfigurableStalenessLimits {
    subject;
    doc /* The driver shall support user-configurable limits on acceptable member staleness */
    attribute id : String = "REQ-320";
    attribute staleness_limits_configurable : Boolean;
    attribute user_can_set_limits : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint StalenessConfiguration { staleness_limits_configurable == true and user_can_set_limits == true }
    }

  requirement def ValidationCriteriaMethodChaining {
    subject;
    doc /* The validation_criteria class setter methods shall support method chaining */
    attribute id : String = "REQ-315";
    attribute method_chaining_supported : Boolean;
    attribute setter_returns_reference : Boolean;
    stakeholder developer : Developer;
    require constraint MethodChainingSupport { method_chaining_supported == true implies setter_returns_reference == true }
    }

  requirement def ConnectionPoolReadConcernReset {
    subject;
    doc /* The connection pool shall reset client read concern to the pool's default value when a client is returned to the pool */
    attribute id : String = "REQ-347";
    attribute pool_default_read_concern : String;
    attribute client_read_concern : String;
    attribute reset_performed : Boolean;
    stakeholder developer : Developer;
    require constraint ReadConcernResetVerification { reset_performed == true implies client_read_concern == pool_default_read_concern }
    }

  requirement def AcquiredClientWriteConcernMatch {
    subject;
    doc /* The client acquired from a connection pool shall have write concern matching the pool's configured default value */
    attribute id : String = "REQ-350";
    attribute pool_configured_default_write_concern : String;
    attribute acquired_client_write_concern : String;
    attribute write_concern_matches : Boolean;
    stakeholder developer : Developer;
    require constraint WriteConcernMatchVerification { write_concern_matches == true implies acquired_client_write_concern == pool_configured_default_write_concern }
    }

  requirement def ConnectionPoolConfigurationValidation {
    subject;
    doc /* The connection pool shall validate that returned clients have their configuration options reset before making them available for reacquisition */
    attribute id : String = "REQ-349";
    attribute validation_performed : Boolean;
    attribute configuration_reset_verified : Boolean;
    attribute client_available_for_reacquisition : Boolean;
    stakeholder developer : Developer;
    require constraint ValidationBeforeReacquisition { client_available_for_reacquisition == true implies validation_performed == true and configuration_reset_verified == true }
    }

  requirement def ConnectionPoolReadPreferenceReset {
    subject;
    doc /* The connection pool shall reset client read preference to the pool's default value when a client is returned to the pool */
    attribute id : String = "REQ-348";
    attribute pool_default_read_preference : String;
    attribute client_read_preference : String;
    attribute reset_performed : Boolean;
    stakeholder developer : Developer;
    require constraint ReadPreferenceResetVerification { reset_performed == true implies client_read_preference == pool_default_read_preference }
    }

  requirement def ConnectionPoolWriteConcernReset {
    subject;
    doc /* The connection pool shall reset client write concern to the pool's default value when a client is returned to the pool */
    attribute id : String = "REQ-346";
    attribute pool_default_write_concern : String;
    attribute client_write_concern : String;
    attribute reset_performed : Boolean;
    stakeholder developer : Developer;
    require constraint WriteConcernResetVerification { reset_performed == true implies client_write_concern == pool_default_write_concern }
    }

  requirement def GridFSFindMethodTesting {
    subject;
    doc /* The GridFS integration tests shall include tests for bucket::find() method */
    attribute id : String = "REQ-387";
    attribute test_category : String = "GridFS integration";
    attribute method_name : String = "bucket::find()";
    attribute test_inclusion_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint FindMethodTestInclusion { method_name == "bucket::find()" implies test_inclusion_required == true }
    }

  requirement def BasicArrayMovability {
    subject;
    doc /* The bsoncxx::builder::basic::array class shall be movable */
    attribute id : String = "REQ-397";
    attribute class_name : String = "bsoncxx::builder::basic::array";
    attribute capability : String = "movable";
    attribute support_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint MovabilitySupport { capability == "movable" implies support_required == true }
    }

  requirement def BasicDocumentMovability {
    subject;
    doc /* The bsoncxx::builder::basic::document class shall be movable */
    attribute id : String = "REQ-395";
    attribute class_name : String = "bsoncxx::builder::basic::document";
    attribute capability : String = "movable";
    attribute support_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint MovabilitySupport { capability == "movable" implies support_required == true }
    }

  requirement def GridFSDownloaderFileLengthAccessor {
    subject;
    doc /* The gridfs::downloader class shall provide a file length accessor method */
    attribute id : String = "REQ-398";
    attribute class_name : String = "gridfs::downloader";
    attribute method_type : String = "file length accessor";
    attribute provides_method : Boolean = true;
    stakeholder developer : Developer;
    require constraint FileLengthAccessorProvision { method_type == "file length accessor" implies provides_method == true }
    }

  requirement def GridFSUploadFromStreamTesting {
    subject;
    doc /* The GridFS integration tests shall include tests for bucket::upload_from_stream() method */
    attribute id : String = "REQ-383";
    attribute test_category : String = "GridFS integration";
    attribute method_name : String = "bucket::upload_from_stream()";
    attribute test_inclusion_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint UploadFromStreamTestInclusion { method_name == "bucket::upload_from_stream()" implies test_inclusion_required == true }
    }

  requirement def CppSeventeenOptionalSupport {
    subject;
    doc /* The C++ driver shall support non-experimental use of std::optional in C++17 mode */
    attribute id : String = "REQ-358";
    attribute cpp_standard : String = "C++17";
    attribute feature_name : String = "std::optional";
    attribute experimental_flag : Boolean = false;
    stakeholder developer : Developer;
    require constraint NonExperimentalOptionalSupport { cpp_standard == "C++17" and feature_name == "std::optional" implies experimental_flag == false }
    }

  requirement def IndexOptionsCastOperator {
    subject;
    doc /* The mongocxx::options::index class shall provide a cast operator to bsoncxx::document::value */
    attribute id : String = "REQ-367";
    attribute source_class : String = "mongocxx::options::index";
    attribute target_type : String = "bsoncxx::document::value";
    attribute operator_type : String = "cast";
    attribute cast_operator_provided : Boolean;
    stakeholder developer : Developer;
    require constraint CastOperatorProvision { operator_type == "cast" and target_type == "bsoncxx::document::value" implies cast_operator_provided == true }
    }

  requirement def GridFSLargeFileDownloadTesting {
    subject;
    doc /* The GridFS integration tests shall include download tests for files larger than 4 GB */
    attribute id : String = "REQ-373";
    attribute test_category : String = "GridFS integration";
    attribute operation_type : String = "download";
    attribute min_file_size_gb : Real = 4.0;
    attribute test_inclusion_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint LargeFileDownloadTestInclusion { operation_type == "download" and min_file_size_gb >= 4.0 implies test_inclusion_required == true }
    }

  requirement def IndexAPIBSONDocumentAcceptance {
    subject;
    doc /* The index-related API methods shall accept BSON documents instead of mongocxx::options::index objects */
    attribute id : String = "REQ-366";
    attribute accepted_input_type : String = "BSON documents";
    attribute replaced_input_type : String = "mongocxx::options::index objects";
    attribute api_category : String = "index-related";
    attribute bson_documents_accepted : Boolean;
    stakeholder developer : Developer;
    require constraint BSONDocumentAcceptance { api_category == "index-related" implies bson_documents_accepted == true }
    }

  requirement def GridFSUploadFromStreamWithIdTesting {
    subject;
    doc /* The GridFS integration tests shall include tests for bucket::upload_from_stream_with_id() method */
    attribute id : String = "REQ-384";
    attribute test_category : String = "GridFS integration";
    attribute method_name : String = "bucket::upload_from_stream_with_id()";
    attribute test_inclusion_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint UploadFromStreamWithIdTestInclusion { method_name == "bucket::upload_from_stream_with_id()" implies test_inclusion_required == true }
    }

  requirement def IndexViewDummyImplementation {
    subject;
    doc /* The driver shall provide a dummy implementation of index_view class */
    attribute id : String = "REQ-365";
    attribute class_name : String = "index_view";
    attribute implementation_type : String = "dummy";
    attribute provides_implementation : Boolean = true;
    stakeholder developer : Developer;
    require constraint DummyImplementationProvision { implementation_type == "dummy" implies provides_implementation == true }
    }

  requirement def NonMaterializedViewIndexHints {
    subject;
    doc /* The non-materialized views shall support index hints */
    attribute id : String = "REQ-371";
    attribute view_type : String = "non-materialized";
    attribute feature_name : String = "index hints";
    attribute support_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint IndexHintSupport { view_type == "non-materialized" and feature_name == "index hints" implies support_required == true }
    }

  requirement def GridFSDownloadToStreamTesting {
    subject;
    doc /* The GridFS integration tests shall include tests for bucket::download_to_stream() method */
    attribute id : String = "REQ-385";
    attribute test_category : String = "GridFS integration";
    attribute method_name : String = "bucket::download_to_stream()";
    attribute test_inclusion_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint DownloadToStreamTestInclusion { method_name == "bucket::download_to_stream()" implies test_inclusion_required == true }
    }

  requirement def IndexModelClassImplementation {
    subject;
    doc /* The driver shall implement an index_model class */
    attribute id : String = "REQ-364";
    attribute class_name : String = "index_model";
    attribute implementation_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint IndexModelImplementation { class_name == "index_model" implies implementation_required == true }
    }

  requirement def CompressedMessageWriteSupport {
    subject;
    doc /* The driver shall support writing OP_COMPRESSED messages */
    attribute id : String = "REQ-369";
    attribute message_type : String = "OP_COMPRESSED";
    attribute operation_type : String = "writing";
    attribute support_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint CompressedWriteSupport { message_type == "OP_COMPRESSED" and operation_type == "writing" implies support_required == true }
    }

  requirement def GridFSDeleteFileTesting {
    subject;
    doc /* The GridFS integration tests shall include tests for bucket::delete_file() method */
    attribute id : String = "REQ-386";
    attribute test_category : String = "GridFS integration";
    attribute method_name : String = "bucket::delete_file()";
    attribute test_inclusion_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint DeleteFileTestInclusion { method_name == "bucket::delete_file()" implies test_inclusion_required == true }
    }

  requirement def IndexViewImplementationReplacement {
    subject;
    doc /* The index view implementation shall replace the dummy implementation with actual functionality */
    attribute id : String = "REQ-363";
    attribute implementation_type : String = "actual";
    attribute replaces_dummy : Boolean = true;
    attribute component_name : String = "index_view";
    stakeholder developer : Developer;
    require constraint ActualImplementationReplacement { implementation_type == "actual" implies replaces_dummy == true }
    }

  requirement def ScopedBsonTInitMethod {
    subject;
    doc /* The scoped_bson_t class shall provide a bson_for_init method that internally calls flag_init */
    attribute id : String = "REQ-392";
    attribute class_name : String = "scoped_bson_t";
    attribute method_name : String = "bson_for_init";
    attribute internal_call : String = "flag_init";
    attribute method_provided : Boolean;
    stakeholder developer : Developer;
    require constraint InitMethodProvision { method_name == "bson_for_init" and internal_call == "flag_init" implies method_provided == true }
    }

  requirement def CppSeventeenStringViewSupport {
    subject;
    doc /* The C++ driver shall support non-experimental use of string_view in C++17 mode */
    attribute id : String = "REQ-359";
    attribute cpp_standard : String = "C++17";
    attribute feature_name : String = "string_view";
    attribute experimental_flag : Boolean = false;
    stakeholder developer : Developer;
    require constraint NonExperimentalStringViewSupport { cpp_standard == "C++17" and feature_name == "string_view" implies experimental_flag == false }
    }

  requirement def CompressedMessageReadSupport {
    subject;
    doc /* The driver shall support reading OP_COMPRESSED messages */
    attribute id : String = "REQ-368";
    attribute message_type : String = "OP_COMPRESSED";
    attribute operation_type : String = "reading";
    attribute support_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint CompressedReadSupport { message_type == "OP_COMPRESSED" and operation_type == "reading" implies support_required == true }
    }

  requirement def GridFSLargeFileUploadTesting {
    subject;
    doc /* The GridFS integration tests shall include upload tests for files larger than 4 GB */
    attribute id : String = "REQ-372";
    attribute test_category : String = "GridFS integration";
    attribute operation_type : String = "upload";
    attribute min_file_size_gb : Real = 4.0;
    attribute test_inclusion_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint LargeFileUploadTestInclusion { operation_type == "upload" and min_file_size_gb >= 4.0 implies test_inclusion_required == true }
    }

  requirement def BasicDocumentCopyability {
    subject;
    doc /* The bsoncxx::builder::basic::document class shall be copyable */
    attribute id : String = "REQ-394";
    attribute class_name : String = "bsoncxx::builder::basic::document";
    attribute capability : String = "copyable";
    attribute support_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint CopyabilitySupport { capability == "copyable" implies support_required == true }
    }

  requirement def GridFSOpenUploadStreamWithIdTesting {
    subject;
    doc /* The GridFS integration tests shall include tests for bucket::open_upload_stream_with_id() method */
    attribute id : String = "REQ-382";
    attribute test_category : String = "GridFS integration";
    attribute method_name : String = "bucket::open_upload_stream_with_id()";
    attribute test_inclusion_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint OpenUploadStreamWithIdTestInclusion { method_name == "bucket::open_upload_stream_with_id()" implies test_inclusion_required == true }
    }

  requirement def AggregationIndexHintSupport {
    subject;
    doc /* The aggregation operations shall support index hints */
    attribute id : String = "REQ-370";
    attribute operation_category : String = "aggregation";
    attribute feature_name : String = "index hints";
    attribute support_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint AggregationIndexHintSupport { operation_category == "aggregation" and feature_name == "index hints" implies support_required == true }
    }

  requirement def BasicArrayCopyability {
    subject;
    doc /* The bsoncxx::builder::basic::array class shall be copyable */
    attribute id : String = "REQ-396";
    attribute class_name : String = "bsoncxx::builder::basic::array";
    attribute capability : String = "copyable";
    attribute support_required : Boolean = true;
    attribute copy_operation_successful : Boolean;
    stakeholder developer : Developer;
    require constraint CopyabilitySupport { support_required == true implies copy_operation_successful == true }
    }

  requirement def SessionTimeoutConfiguration {
    subject;
    doc /* The system shall use the parsed localLogicalSessionTimeoutMinutes value to configure client session timeout behavior */
    attribute id : String = "REQ-406";
    attribute timeout_minutes : Real;
    attribute session_timeout_configured : Boolean;
    attribute client_session_active : Boolean;
    stakeholder developer : Developer;
    require constraint TimeoutConfigurationTrigger { timeout_minutes > 0.0 implies session_timeout_configured == true }
    }

  requirement def DNSTXTRecordQuery {
    subject;
    doc /* The system shall query DNS TXT records to retrieve connection options when using DNS seedlist discovery */
    attribute id : String = "REQ-402";
    attribute txt_record_queried : Boolean;
    attribute seedlist_discovery_active : Boolean;
    attribute connection_options_retrieved : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint SeedlistTriggersTXTQuery { seedlist_discovery_active == true implies txt_record_queried == true }
    require constraint TXTQueryRetrievesOptions { txt_record_queried == true implies connection_options_retrieved == true }
    }

  requirement def SessionTimeoutFieldParsing {
    subject;
    doc /* The system shall parse the localLogicalSessionTimeoutMinutes field from MongoDB isMaster command responses */
    attribute id : String = "REQ-405";
    attribute field_name : String = "localLogicalSessionTimeoutMinutes";
    attribute ismaster_response_received : Boolean;
    attribute field_parsed_successfully : Boolean;
    attribute parsed_timeout_value : Real;
    stakeholder developer : Developer;
    require constraint ResponseTriggersParsing { ismaster_response_received == true implies field_parsed_successfully == true }
    require constraint ParsedValueValid { field_parsed_successfully == true implies parsed_timeout_value >= 0.0 }
    }

  requirement def MissingFieldHandling {
    subject;
    doc /* The system shall handle missing localLogicalSessionTimeoutMinutes field in isMaster responses gracefully */
    attribute id : String = "REQ-407";
    attribute field_missing : Boolean;
    attribute graceful_handling_enabled : Boolean;
    attribute default_behavior_applied : Boolean;
    stakeholder developer : Developer;
    require constraint MissingFieldTriggersGracefulHandling { field_missing == true implies graceful_handling_enabled == true }
    require constraint GracefulHandlingAppliesDefault { graceful_handling_enabled == true implies default_behavior_applied == true }
    }

  requirement def DNSSRVDomainValidation {
    subject;
    doc /* The system shall validate that DNS SRV records point to hosts within the same domain as the connection string hostname */
    attribute id : String = "REQ-403";
    attribute connection_hostname : String;
    attribute srv_target_hostname : String;
    attribute domain_validation_passed : Boolean;
    attribute hostnames_provided : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint HostnamesProvidedTriggersValidation { hostnames_provided == true implies domain_validation_passed == true }
    }

  requirement def DNSSRVRecordDiscovery {
    subject;
    doc /* The system shall implement DNS SRV record discovery for MongoDB connection strings using the mongodb+srv:// scheme */
    attribute id : String = "REQ-401";
    attribute connection_scheme : String = "mongodb+srv://";
    attribute srv_record_type : String = "_mongodb._tcp";
    attribute discovery_enabled : Boolean;
    attribute scheme_matches : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint SchemeTriggersDiscovery { scheme_matches == true implies discovery_enabled == true }
    }

  requirement def DNSLookupFallback {
    subject;
    doc /* The system shall fall back to the original hostname if DNS SRV record lookup fails during seedlist discovery */
    attribute id : String = "REQ-404";
    attribute srv_lookup_failed : Boolean;
    attribute fallback_to_original : Boolean;
    attribute original_hostname : String;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    }

  requirement def DatabaseGetSessionMethod {
    subject;
    doc /* The MongoDB C++ driver database class shall provide a get_session method */
    attribute id : String = "REQ-431";
    attribute class_name : String = "database";
    attribute method_name : String = "get_session";
    attribute method_provided : Boolean;
    stakeholder developer : Developer;
    require constraint MethodProvisionCheck { class_name == "database" implies method_provided == true }
    }

  requirement def ChangeStreamClusterTimeProperty {
    subject;
    doc /* The MongoDB C++ driver shall include a clusterTime property in the static type for change stream documents */
    attribute id : String = "REQ-412";
    attribute property_name : String = "clusterTime";
    attribute document_type : String = "change stream documents";
    attribute type_category : String = "static";
    attribute property_included : Boolean;
    stakeholder developer : Developer;
    require constraint PropertyInclusionCheck { document_type == "change stream documents" and type_category == "static" implies property_included == true }
    }

  requirement def BulkWriteMethodDeprecation {
    subject;
    doc /* The MongoDB C++ driver shall deprecate the collection::bulk_write(bulk_write&) method */
    attribute id : String = "REQ-413";
    attribute method_signature : String = "collection::bulk_write(bulk_write&)";
    attribute deprecated_status : Boolean = true;
    stakeholder developer : Developer;
    require constraint DeprecationStatusCheck { method_signature == "collection::bulk_write(bulk_write&)" implies deprecated_status == true }
    }

  requirement def SessionOptionsClass {
    subject;
    doc /* The MongoDB C++ driver shall implement a session options class */
    attribute id : String = "REQ-436";
    attribute class_name : String = "session options";
    attribute class_implemented : Boolean;
    stakeholder developer : Developer;
    require constraint ClassImplementationCheck { class_name == "session options" implies class_implemented == true }
    }

  requirement def SessionOverloadParameterOrder {
    subject;
    doc /* The MongoDB C++ driver session overloads shall accept client_session as the first parameter */
    attribute id : String = "REQ-434";
    attribute parameter_name : String = "client_session";
    attribute parameter_position : Integer = 1;
    attribute first_parameter_accepted : Boolean;
    stakeholder developer : Developer;
    require constraint FirstParameterCheck { parameter_name == "client_session" and parameter_position == 1 implies first_parameter_accepted == true }
    }

  requirement def AutoIndexIdDeprecation {
    subject;
    doc /* The MongoDB C++ driver shall deprecate the autoIndexId parameter for collection creation commands */
    attribute id : String = "REQ-409";
    attribute parameter_name : String = "autoIndexId";
    attribute deprecated_status : Boolean;
    stakeholder developer : Developer;
    require constraint ParameterDeprecationCheck { parameter_name == "autoIndexId" implies deprecated_status == true }
    }

  requirement def BulkOperationUpdateOptsUsage {
    subject;
    doc /* The MongoDB C++ driver shall use mongoc_bulk_operation_update_with_opts instead of mongoc_bulk_operation_update */
    attribute id : String = "REQ-419";
    attribute required_function : String = "mongoc_bulk_operation_update_with_opts";
    attribute deprecated_function : String = "mongoc_bulk_operation_update";
    attribute uses_required_function : Boolean;
    stakeholder developer : Developer;
    require constraint RequiredFunctionUsageCheck { required_function == "mongoc_bulk_operation_update_with_opts" implies uses_required_function == true }
    }

  requirement def FindAndModifyOptsUsage {
    subject;
    doc /* The MongoDB C++ driver shall use mongoc_collection_find_and_modify_with_opts for findAndModify operations */
    attribute id : String = "REQ-411";
    attribute required_function : String = "mongoc_collection_find_and_modify_with_opts";
    attribute operation_type : String = "findAndModify";
    attribute uses_required_function : Boolean;
    stakeholder developer : Developer;
    require constraint FindAndModifyFunctionUsageCheck { operation_type == "findAndModify" implies uses_required_function == true }
    }

  requirement def ClientTemporaryMisusePrevention {
    subject;
    doc /* The MongoDB C++ driver shall prevent misuse of client temporaries that could lead to invalid cursor operations */
    attribute id : String = "REQ-437";
    attribute temporary_type : String = "client";
    attribute operation_type : String = "cursor operations";
    attribute misuse_prevention_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint MisusePrevention { temporary_type == "client" and operation_type == "cursor operations" implies misuse_prevention_enabled == true }
    }

  requirement def SessionClassImplementation {
    subject;
    doc /* The MongoDB C++ driver shall implement a session class that wraps the mongoc session implementation */
    attribute id : String = "REQ-435";
    attribute class_name : String = "session";
    attribute wrapped_implementation : String = "mongoc session";
    attribute class_implemented : Boolean;
    stakeholder developer : Developer;
    require constraint SessionClassWrapperCheck { class_name == "session" and wrapped_implementation == "mongoc session" implies class_implemented == true }
    }

  requirement def BulkWriteConstructorDeprecation {
    subject;
    doc /* The MongoDB C++ driver shall deprecate public bulk_write constructors */
    attribute id : String = "REQ-417";
    attribute constructor_visibility : String = "public";
    attribute deprecated_status : Boolean = true;
    stakeholder developer : Developer;
    require constraint ConstructorDeprecationCheck { constructor_visibility == "public" implies deprecated_status == true }
    }

  requirement def CausallyConsistentReads {
    subject;
    doc /* The MongoDB C++ driver shall support causally consistent reads */
    attribute id : String = "REQ-426";
    attribute consistency_type : String = "causally consistent";
    attribute read_support_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint ConsistentReadSupportCheck { consistency_type == "causally consistent" implies read_support_enabled == true }
    }

  requirement def ChangeStreamRetryPrevention {
    subject;
    doc /* The MongoDB C++ driver shall not retry the initial aggregate command for a change stream operation */
    attribute id : String = "REQ-408";
    attribute retry_enabled : Boolean;
    attribute operationType : String;
    attribute initial_command_executed : Boolean;
    stakeholder developer : Developer;
    require constraint RetryPreventionCheck { initial_command_executed == true implies retry_enabled == false }
    }

  requirement def BulkOperationInsertOptsUsage {
    subject;
    doc /* The MongoDB C++ driver shall use mongoc_bulk_operation_insert_with_opts instead of mongoc_bulk_operation_insert */
    attribute id : String = "REQ-418";
    attribute required_function : String = "mongoc_bulk_operation_insert_with_opts";
    attribute deprecated_function : String = "mongoc_bulk_operation_insert";
    attribute uses_required_function : Boolean;
    stakeholder developer : Developer;
    require constraint InsertOptsUsageCheck { required_function == "mongoc_bulk_operation_insert_with_opts" implies uses_required_function == true }
    }

  requirement def BulkOperationDeleteOptsUsage {
    subject;
    doc /* The MongoDB C++ driver shall use mongoc_bulk_operation_delete_with_opts instead of mongoc_bulk_operation_delete */
    attribute id : String = "REQ-420";
    attribute required_function : String = "mongoc_bulk_operation_delete_with_opts";
    attribute deprecated_function : String = "mongoc_bulk_operation_delete";
    attribute uses_required_function : Boolean;
    stakeholder developer : Developer;
    require constraint DeleteOptsUsageCheck { required_function == "mongoc_bulk_operation_delete_with_opts" implies uses_required_function == true }
    }

  requirement def SessionPIMPLPattern {
    subject;
    doc /* The MongoDB C++ driver session class shall implement the PIMPL (Pointer to Implementation) pattern */
    attribute id : String = "REQ-432";
    attribute class_name : String = "session";
    attribute design_pattern : String = "PIMPL";
    attribute pattern_implemented : Boolean;
    stakeholder developer : Developer;
    require constraint PIMPLPatternImplementationCheck { class_name == "session" and design_pattern == "PIMPL" implies pattern_implemented == true }
    }

  requirement def ImplicitSessionLeakPrevention {
    subject;
    doc /* The MongoDB C++ driver shall implement measures to decrease the likelihood of implicit session leaks */
    attribute id : String = "REQ-424";
    attribute leak_prevention_enabled : Boolean;
    attribute session_type : String = "implicit";
    stakeholder developer : Developer;
    require constraint LeakPreventionCheck { session_type == "implicit" implies leak_prevention_enabled == true }
    }

  requirement def BulkWriteExecuteMethod {
    subject;
    doc /* The MongoDB C++ driver shall provide a bulk_write::execute() method that takes no write concern parameter */
    attribute id : String = "REQ-414";
    attribute method_name : String = "bulk_write::execute()";
    attribute write_concern_parameter_count : Integer = 0;
    attribute method_provided : Boolean;
    stakeholder developer : Developer;
    require constraint ExecuteMethodProvisionCheck { method_name == "bulk_write::execute()" and write_concern_parameter_count == 0 implies method_provided == true }
    }

  requirement def SessionOverloadsForServerCommunication {
    subject;
    doc /* The MongoDB C++ driver shall provide session overloads for all member functions that communicate with the server */
    attribute id : String = "REQ-433";
    attribute overload_type : String = "session";
    attribute function_scope : String = "all member functions that communicate with the server";
    attribute overloads_provided : Boolean;
    stakeholder developer : Developer;
    require constraint SessionOverloadsProvisionCheck { overload_type == "session" and function_scope == "all member functions that communicate with the server" implies overloads_provided == true }
    }

  requirement def KerberosHostnameCanonicalization {
    subject;
    doc /* The MongoDB C++ driver shall implement updated algorithm for Kerberos hostname canonicalization */
    attribute id : String = "REQ-421";
    attribute authentication_mechanism : String = "Kerberos";
    attribute algorithm_status : String = "updated";
    attribute canonicalization_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint KerberosAlgorithmUpdateCheck { authentication_mechanism == "Kerberos" and algorithm_status == "updated" implies canonicalization_enabled == true }
    }

  requirement def CollectionGetSessionMethod {
    subject;
    doc /* The MongoDB C++ driver collection class shall provide a get_session method */
    attribute id : String = "REQ-430";
    attribute class_name : String = "collection";
    attribute method_name : String = "get_session";
    attribute method_provided : Boolean;
    stakeholder developer : Developer;
    require constraint CollectionMethodProvisionCheck { class_name == "collection" implies method_provided == true }
    }

  requirement def AutoIndexIdDefaultBehavior {
    subject;
    doc /* The MongoDB C++ driver shall not send autoIndexId: true by default in collection creation commands */
    attribute id : String = "REQ-410";
    attribute default_autoIndexId_value : Boolean = false;
    attribute sends_by_default : Boolean = false;
    stakeholder developer : Developer;
    require constraint DefaultBehaviorCheck { default_autoIndexId_value == false implies sends_by_default == false }
    }

  requirement def BulkWriteCreationMethod {
    subject;
    doc /* The collection::create_bulk_write method shall be the sole way to create bulk_write instances */
    attribute id : String = "REQ-488";
    attribute sole_creation_method : Boolean;
    attribute bulk_write_instance_creation : Boolean;
    stakeholder developer : Developer;
    require constraint SoleCreationMethod { bulk_write_instance_creation == true implies sole_creation_method == true }
    }

  requirement def ObjectIDHashFunction {
    subject;
    doc /* The C++ driver shall use 32-bit FNV-1a hash function instead of MD5 for ObjectID generation */
    attribute id : String = "REQ-470";
    attribute hash_function_type : String = "FNV-1a";
    attribute hash_bit_size : Integer = 32;
    attribute replaces_md5 : Boolean;
    stakeholder developer : Developer;
    require constraint HashFunctionSpecification { hash_function_type == "FNV-1a" and hash_bit_size == 32 and replaces_md5 == true }
    }

  requirement def NonMonitoringSocketHandshakeOnly {
    subject;
    doc /* Non-monitoring sockets shall perform normal handshake */
    attribute id : String = "REQ-485.1";
    attribute non_monitoring_socket : Boolean;
    attribute performs_handshake : Boolean;
    stakeholder developer : Developer;
    require constraint NonMonitoringHandshake { non_monitoring_socket == true implies performs_handshake == true }
    }

  requirement def SCRAMSHASpecificationUpdate {
    subject;
    doc /* The SCRAM-SHA-256 implementation and tests shall be updated according to specification changes */
    attribute id : String = "REQ-481";
    attribute implementation_updated : Boolean;
    attribute tests_updated : Boolean;
    attribute specification_compliant : Boolean;
    stakeholder developer : Developer;
    require constraint SpecificationCompliance { implementation_updated == true and tests_updated == true and specification_compliant == true }
    }

  requirement def CommandMonitoringAPIWrapper {
    subject;
    doc /* The C++ driver shall implement a command monitoring API that wraps the C driver's implementation */
    attribute id : String = "REQ-497";
    attribute command_monitoring_api : Boolean;
    attribute wraps_c_driver : Boolean;
    stakeholder developer : Developer;
    require constraint APIWrapsDriver { command_monitoring_api == true implies wraps_c_driver == true }
    }

  requirement def EstimatedDocumentCountHelper {
    subject;
    doc /* The C++ driver shall provide an estimatedDocumentCount() helper that returns an estimate using collection metadata */
    attribute id : String = "REQ-464";
    attribute helper_method_available : Boolean;
    attribute uses_collection_metadata : Boolean;
    stakeholder developer : Developer;
    require constraint HelperUsesMetadata { helper_method_available == true implies uses_collection_metadata == true }
    }

  requirement def DocumentViewFindOptimization {
    subject;
    doc /* The document::view::find method shall use bson_iter functions with length parameters to avoid strlen calls */
    attribute id : String = "REQ-492";
    attribute uses_length_parameters : Boolean;
    attribute avoids_strlen_calls : Boolean;
    stakeholder developer : Developer;
    require constraint OptimizationImplemented { uses_length_parameters == true and avoids_strlen_calls == true }
    }

  requirement def CreateCollectionArbitraryOptions {
    subject;
    doc /* The options::create_collection class shall accept arbitrary BSON document options instead of strongly-typed fields */
    attribute id : String = "REQ-475";
    attribute accepts_arbitrary_bson : Boolean;
    attribute replaces_typed_fields : Boolean;
    stakeholder developer : Developer;
    require constraint ArbitraryBSONAcceptance { accepts_arbitrary_bson == true and replaces_typed_fields == true }
    }

  requirement def ChangeStreamStartTimeOmission {
    subject;
    doc /* The ChangeStream implementation shall omit default startAtOperationTime when created */
    attribute id : String = "REQ-460";
    attribute omits_default_start_time : Boolean;
    attribute creation_time_handling : String;
    stakeholder developer : Developer;
    require constraint StartTimeOmission { omits_default_start_time == true }
    }

  requirement def SDAMEventsAPI {
    subject;
    doc /* The C++ driver shall provide an API for subscribing to SDAM events */
    attribute id : String = "REQ-499";
    attribute sdam_events_api : Boolean;
    attribute subscription_support : Boolean;
    stakeholder developer : Developer;
    require constraint SDAMSubscriptionAPI { sdam_events_api == true and subscription_support == true }
    }

  requirement def ChangeStreamsHelpers {
    subject;
    doc /* The C++ driver shall implement helpers for Change Streams follow-on work as specified in the updated specification */
    attribute id : String = "REQ-471.1";
    attribute helpers_implemented : Boolean;
    attribute specification_compliant : Boolean;
    stakeholder developer : Developer;
    require constraint HelpersSpecCompliant { helpers_implemented == true and specification_compliant == true }
    }

  requirement def SDAMEventsAPIWrapper {
    subject;
    doc /* The SDAM events API shall wrap the C driver's application performance monitoring implementation */
    attribute id : String = "REQ-500";
    attribute wraps_c_driver_apm : Boolean;
    attribute sdam_events_wrapped : Boolean;
    stakeholder developer : Developer;
    require constraint APMWrapping { wraps_c_driver_apm == true and sdam_events_wrapped == true }
    }

  requirement def MonitoringSocketAuthentication {
    subject;
    doc /* Monitoring-only sockets shall not authenticate */
    attribute id : String = "REQ-484";
    attribute monitoring_socket_type : Boolean;
    attribute authentication_disabled : Boolean;
    stakeholder developer : Developer;
    require constraint MonitoringNoAuth { monitoring_socket_type == true implies authentication_disabled == true }
    }

  requirement def ReadConcernAvailableSupport {
    subject;
    doc /* The C++ driver shall support the new readConcern level "available" */
    attribute id : String = "REQ-454";
    attribute available_level_supported : Boolean;
    attribute read_concern_level : String;
    stakeholder developer : Developer;
    require constraint AvailableLevelSupport { read_concern_level == "available" implies available_level_supported == true }
    }

  requirement def GridFSDownloaderReadOffset {
    subject;
    doc /* The mongocxx::gridfs::downloader class shall provide a read method that accepts an optional offset parameter for partial file retrieval */
    attribute id : String = "REQ-446";
    attribute supports_offset_parameter : Boolean;
    attribute partial_retrieval_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint OffsetParameterSupport { supports_offset_parameter == true and partial_retrieval_enabled == true }
    }

  requirement def ReadConcernTransactionInclusion {
    subject;
    doc /* The C++ driver shall include readConcern only in the initial command of a transaction */
    attribute id : String = "REQ-455";
    attribute initial_command_only : Boolean;
    attribute transaction_read_concern_included : Boolean;
    stakeholder developer : Developer;
    require constraint InitialCommandOnly { transaction_read_concern_included == true implies initial_command_only == true }
    }

  requirement def SASLPrepImplementation {
    subject;
    doc /* The C++ driver shall implement SASLPrep as defined in RFC 4013 */
    attribute id : String = "REQ-491";
    attribute saslprep_implemented : Boolean;
    attribute rfc_4013_compliant : Boolean;
    stakeholder developer : Developer;
    require constraint SASLPrepCompliance { saslprep_implemented == true and rfc_4013_compliant == true }
    }

  requirement def CursorsExplainOption {
    subject;
    doc /* The C++ driver shall provide an explain option for cursors */
    attribute id : String = "REQ-448.2";
    attribute cursor_explain_available : Boolean;
    stakeholder developer : Developer;
    require constraint ExplainOptionAvailable { cursor_explain_available == true }
    }

  requirement def BSONIterInitWithData {
    subject;
    doc /* The C++ driver shall use bson_iter_init_with_data function for iterator initialization with known key length */
    attribute id : String = "REQ-494";
    attribute uses_init_with_data : Boolean;
    attribute known_key_length_optimization : Boolean;
    stakeholder developer : Developer;
    require constraint InitWithDataUsage { uses_init_with_data == true and known_key_length_optimization == true }
    }

  requirement def UserCommandsWriteClassification {
    subject;
    doc /* The C++ driver shall include createUser, updateUser, and dropUser in the list of commands that write */
    attribute id : String = "REQ-469";
    attribute create_user_writes : Boolean;
    attribute update_user_writes : Boolean;
    attribute drop_user_writes : Boolean;
    stakeholder developer : Developer;
    require constraint UserCommandsWriteClassification { create_user_writes == true and update_user_writes == true and drop_user_writes == true }
    }

  requirement def SCRAMLibrarySHA256Mode {
    subject;
    doc /* The SCRAM library shall be capable of operating in SHA-256 mode */
    attribute id : String = "REQ-490";
    attribute sha256_mode_capable : Boolean;
    attribute scram_library_support : Boolean;
    stakeholder developer : Developer;
    require constraint SHA256ModeCapability { scram_library_support == true implies sha256_mode_capable == true }
    }

  requirement def BSONIterKeyLenUsage {
    subject;
    doc /* The C++ driver shall use libbson function bson_iter_keylen instead of accessing bson_iter_t internals */
    attribute id : String = "REQ-493";
    attribute uses_bson_iter_keylen : Boolean;
    attribute avoids_internal_access : Boolean;
    stakeholder developer : Developer;
    require constraint ProperAPIUsage { uses_bson_iter_keylen == true and avoids_internal_access == true }
    }

  requirement def AuthenticationErrorSocketClosure {
    subject;
    doc /* Authentication errors on a socket shall close all non-monitoring sockets to the same server */
    attribute id : String = "REQ-486";
    attribute authentication_error_detected : Boolean;
    attribute closes_non_monitoring_sockets : Boolean;
    attribute same_server_scope : Boolean;
    stakeholder developer : Developer;
    require constraint ErrorTriggersSocketClosure { authentication_error_detected == true implies (closes_non_monitoring_sockets == true and same_server_scope == true) }
    }

  requirement def MonitoringSocketSCRAMNegotiation {
    subject;
    doc /* Monitoring-only sockets shall not send SCRAM mechanism negotiation in isMaster commands */
    attribute id : String = "REQ-483";
    attribute monitoring_socket_type : Boolean;
    attribute scram_negotiation_disabled : Boolean;
    stakeholder developer : Developer;
    require constraint MonitoringSocketRestriction { monitoring_socket_type == true implies scram_negotiation_disabled == true }
    }

  requirement def BypassDocumentValidationConditional {
    subject;
    doc /* The C++ driver shall only send bypassDocumentValidation parameter when its value is true */
    attribute id : String = "REQ-468";
    attribute conditional_parameter_sending : Boolean;
    attribute bypass_validation_value : Boolean;
    stakeholder developer : Developer;
    require constraint ConditionalParameterSending { bypass_validation_value == true implies conditional_parameter_sending == true }
    }

  requirement def ExplainOptionSupport {
    subject;
    doc /* The C++ driver shall provide an explain option for find operations and cursors */
    attribute id : String = "REQ-448";
    attribute find_operations_explain : Boolean;
    attribute cursors_explain : Boolean;
    stakeholder developer : Developer;
    require constraint ExplainOptionAvailability { find_operations_explain == true and cursors_explain == true }
    }

  requirement def CountDocumentsHelper {
    subject;
    doc /* The C++ driver shall provide a countDocuments() helper that counts documents matching a query filter using aggregation pipeline */
    attribute id : String = "REQ-465";
    attribute count_documents_helper : Boolean;
    attribute uses_aggregation_pipeline : Boolean;
    attribute supports_query_filter : Boolean;
    stakeholder developer : Developer;
    require constraint CountDocumentsImplementation { count_documents_helper == true implies (uses_aggregation_pipeline == true and supports_query_filter == true) }
    }

  requirement def NonMonitoringSocketHandshake {
    subject;
    doc /* Non-monitoring sockets shall perform normal handshake and authenticate when credentials are available */
    attribute id : String = "REQ-485";
    attribute non_monitoring_socket : Boolean;
    attribute performs_handshake : Boolean;
    attribute authenticates_with_credentials : Boolean;
    stakeholder developer : Developer;
    require constraint NonMonitoringSocketBehavior { non_monitoring_socket == true implies (performs_handshake == true and authenticates_with_credentials == true) }
    }

  requirement def ChangeStreamResumeOperationTime {
    subject;
    doc /* The ChangeStream implementation shall use operationTime of initial aggregate command as default startAtOperationTime when resuming */
    attribute id : String = "REQ-461";
    attribute uses_aggregate_operation_time : Boolean;
    attribute resume_start_time_source : String;
    stakeholder developer : Developer;
    require constraint OperationTimeUsage { resume_start_time_source == "aggregate_operation_time" implies uses_aggregate_operation_time == true }
    }

  requirement def ChangeStreamsFollowOnWork {
    subject;
    doc /* The C++ driver shall implement helpers and options for Change Streams follow-on work as specified in the updated specification */
    attribute id : String = "REQ-471";
    attribute helpers_implemented : Boolean;
    attribute options_implemented : Boolean;
    attribute specification_compliant : Boolean;
    stakeholder developer : Developer;
    require constraint ChangeStreamsImplementation { specification_compliant == true implies (helpers_implemented == true and options_implemented == true) }
    }

  requirement def NonMonitoringSocketCredentialAuth {
    subject;
    doc /* Non-monitoring sockets shall authenticate when credentials are available */
    attribute id : String = "REQ-485.2";
    attribute non_monitoring_socket : Boolean;
    attribute credentials_available : Boolean;
    attribute authenticates : Boolean;
    stakeholder developer : Developer;
    require constraint CredentialBasedAuthentication { non_monitoring_socket == true and credentials_available == true implies authenticates == true }
    }

  requirement def ChangeStreamsOptions {
    subject;
    doc /* The C++ driver shall implement options for Change Streams follow-on work as specified in the updated specification */
    attribute id : String = "REQ-471.2";
    attribute options_implemented : Boolean;
    attribute specification_compliant : Boolean;
    stakeholder developer : Developer;
    require constraint OptionsImplementationCompliance { specification_compliant == true implies options_implemented == true }
    }

  requirement def CommandMonitoringSpecificationTests {
    subject;
    doc /* The command monitoring API shall pass all specification tests */
    attribute id : String = "REQ-498";
    attribute passes_specification_tests : Boolean;
    attribute test_compliance_verified : Boolean;
    stakeholder developer : Developer;
    require constraint SpecificationTestCompliance { test_compliance_verified == true implies passes_specification_tests == true }
    }

  requirement def CRUDReplaceOptionsSupport {
    subject;
    doc /* The CRUD API shall support ReplaceOptions */
    attribute id : String = "REQ-495";
    attribute replace_options_supported : Boolean;
    attribute crud_api_enhanced : Boolean;
    stakeholder developer : Developer;
    require constraint ReplaceOptionsSupport { crud_api_enhanced == true implies replace_options_supported == true }
    }

  requirement def FindOperationsExplainOption {
    subject;
    doc /* The C++ driver shall provide an explain option for find operations */
    attribute id : String = "REQ-448.1";
    attribute find_explain_available : Boolean;
    stakeholder developer : Developer;
    require constraint FindExplainOptionProvided { find_explain_available == true }
    }

  requirement def GridFSDownloaderBackwardsCompatibility {
    subject;
    doc /* The mongocxx::gridfs::downloader read method shall maintain backwards compatibility by providing a default offset value of 0 */
    attribute id : String = "REQ-447";
    attribute default_offset_value : Integer = 0;
    attribute backwards_compatible : Boolean;
    stakeholder developer : Developer;
    require constraint BackwardsCompatibilityMaintained { default_offset_value == 0 implies backwards_compatible == true }
    }

  requirement def SCRAMSHA256Support {
    subject;
    doc /* The C++ driver shall support SCRAM-SHA-256 authentication as defined in RFC 7677 */
    attribute id : String = "REQ-489";
    attribute scram_sha256_supported : Boolean;
    attribute rfc_7677_compliant : Boolean;
    stakeholder developer : Developer;
    require constraint SCRAMSHA256Implementation { rfc_7677_compliant == true implies scram_sha256_supported == true }
    }

  requirement def UnifiedURIOptionsHandling {
    subject;
    doc /* The driver shall implement unified URI options handling */
    attribute id : String = "REQ-539";
    attribute unified_uri_options : Boolean;
    attribute options_handling_implemented : Boolean;
    stakeholder developer : Developer;
    require constraint UnifiedOptionsImplementation { unified_uri_options == true implies options_handling_implemented == true }
    }

  requirement def ConvenientTransactionAPI {
    subject;
    doc /* The driver shall implement a convenient API for transactions */
    attribute id : String = "REQ-538";
    attribute convenient_api_implemented : Boolean;
    attribute transaction_api_available : Boolean;
    stakeholder developer : Developer;
    require constraint ConvenientAPIAvailability { convenient_api_implemented == true implies transaction_api_available == true }
    }

  requirement def AggregateBatchSizeIgnore {
    subject;
    doc /* The driver shall ignore batchSize=0 for aggregate operations with $out */
    attribute id : String = "REQ-526";
    attribute batch_size_zero : Boolean;
    attribute aggregate_out_operation : Boolean;
    attribute batch_size_ignored : Boolean;
    stakeholder developer : Developer;
    require constraint BatchSizeIgnoreCondition { (batch_size_zero == true and aggregate_out_operation == true) implies batch_size_ignored == true }
    }

  requirement def StandaloneReadPreferenceRestriction {
    subject;
    doc /* The driver shall not send $readPreference to standalone MongoDB servers */
    attribute id : String = "REQ-515";
    attribute read_preference_sent : Boolean;
    attribute server_is_standalone : Boolean;
    stakeholder developer : Developer;
    require constraint StandaloneReadPreferenceBlock { server_is_standalone == true implies read_preference_sent == false }
    }

  requirement def UpdateCommandPipelineSupport {
    subject;
    doc /* The driver shall support specifying a pipeline for update commands */
    attribute id : String = "REQ-519";
    attribute pipeline_supported : Boolean;
    attribute update_command_enhanced : Boolean;
    stakeholder developer : Developer;
    require constraint PipelineUpdateSupport { pipeline_supported == true implies update_command_enhanced == true }
    }

  requirement def TransactionReadConcernIgnoreTest {
    subject;
    doc /* The driver tests shall verify that reads ignore database and collection readConcern within transactions */
    attribute id : String = "REQ-542";
    attribute reads_ignore_read_concern : Boolean;
    attribute within_transaction : Boolean;
    attribute test_verification_completed : Boolean;
    stakeholder developer : Developer;
    require constraint TransactionReadConcernVerification { (reads_ignore_read_concern == true and within_transaction == true) implies test_verification_completed == true }
    }

  requirement def TransactionSpecTestsResync {
    subject;
    doc /* The transaction spec tests shall be resynced for bulk write error reporting changes */
    attribute id : String = "REQ-523";
    attribute spec_tests_resynced : Boolean;
    attribute bulk_write_error_reporting : Boolean;
    stakeholder developer : Developer;
    require constraint SpecTestsResyncComplete { bulk_write_error_reporting == true implies spec_tests_resynced == true }
    }

  requirement def PostBatchResumeTokenSupport {
    subject;
    doc /* The driver shall support postBatchResumeToken in change streams */
    attribute id : String = "REQ-524";
    attribute post_batch_resume_token_supported : Boolean;
    attribute change_streams_enhanced : Boolean;
    stakeholder developer : Developer;
    require constraint PostBatchTokenEnhancement { post_batch_resume_token_supported == true implies change_streams_enhanced == true }
    }

  requirement def RetryWritesErrorMessage {
    subject;
    doc /* The driver shall raise an actionable error message when retryWrites fails due to using an unsupported storage engine */
    attribute id : String = "REQ-511";
    attribute actionable_error_raised : Boolean;
    attribute storage_engine_detected : Boolean;
    attribute retry_writes_failed : Boolean;
    stakeholder developer : Developer;
    require constraint RetryWritesErrorHandling { (retry_writes_failed == true and storage_engine_detected == true) implies actionable_error_raised == true }
    }

  requirement def DatabaseAggregateHelper {
    subject;
    doc /* The driver shall provide a database aggregate helper function */
    attribute id : String = "REQ-531";
    attribute database_aggregate_helper_provided : Boolean;
    attribute helper_function_available : Boolean;
    stakeholder developer : Developer;
    require constraint DatabaseHelperAvailability { database_aggregate_helper_provided == true implies helper_function_available == true }
    }

  requirement def ManualCursorConstruction {
    subject;
    doc /* The mongocxx::cursor instances shall be constructible manually by users */
    attribute id : String = "REQ-509";
    attribute manual_construction_supported : Boolean;
    attribute user_constructible : Boolean;
    stakeholder developer : Developer;
    require constraint ManualCursorConstructibility { manual_construction_supported == true implies user_constructible == true }
    }

  requirement def AggregateOutPrimaryServer {
    subject;
    doc /* The driver shall send aggregate commands with $out to a primary server */
    attribute id : String = "REQ-533";
    attribute aggregate_out_command : Boolean;
    attribute sent_to_primary : Boolean;
    stakeholder developer : Developer;
    require constraint AggregateOutPrimaryRouting { aggregate_out_command == true implies sent_to_primary == true }
    }

  requirement def AdditionalRetryableWriteErrors {
    subject;
    doc /* The driver shall consider additional error types as retryable for write operations */
    attribute id : String = "REQ-545";
    attribute additional_error_types_considered : Boolean;
    attribute write_operations_retryable : Boolean;
    stakeholder developer : Developer;
    require constraint AdditionalErrorTypesRetryability { additional_error_types_considered == true implies write_operations_retryable == true }
    }

  requirement def CommitTransactionMaxTimeMS {
    subject;
    doc /* Applications shall be able to set maxTimeMS for commitTransaction operations */
    attribute id : String = "REQ-516";
    attribute max_time_ms_settable : Boolean;
    attribute commit_transaction_timeout : Boolean;
    stakeholder developer : Developer;
    require constraint MaxTimeMSCommitTransactionSupport { max_time_ms_settable == true implies commit_transaction_timeout == true }
    }

  requirement def CommitTransactionMajorityWriteConcern {
    subject;
    doc /* The driver shall use majority write concern when retrying commitTransaction */
    attribute id : String = "REQ-527";
    attribute majority_write_concern_used : Boolean;
    attribute commit_transaction_retry : Boolean;
    stakeholder developer : Developer;
    require constraint MajorityWriteConcernRetry { commit_transaction_retry == true implies majority_write_concern_used == true }
    }

  requirement def RetryableWritesDefaultEnabled {
    subject;
    doc /* The driver shall enable retryable writes by default */
    attribute id : String = "REQ-525";
    attribute retryable_writes_enabled : Boolean;
    attribute default_configuration : Boolean;
    stakeholder developer : Developer;
    require constraint RetryableWritesDefaultConfiguration { default_configuration == true implies retryable_writes_enabled == true }
    }

  requirement def TransactionTestsRunOnSyntax {
    subject;
    doc /* The transaction tests shall use runOn syntax to specify test requirements */
    attribute id : String = "REQ-517";
    attribute transaction_runon_syntax : Boolean;
    attribute test_requirements_specified : Boolean;
    stakeholder developer : Developer;
    require constraint TransactionRunOnSyntaxUsage { transaction_runon_syntax == true implies test_requirements_specified == true }
    }

  requirement def ShardedTransactionsRecoveryToken {
    subject;
    doc /* The driver shall support sharded transactions recovery token */
    attribute id : String = "REQ-534";
    attribute recovery_token_supported : Boolean;
    attribute sharded_transactions_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint ShardedTransactionRecoverySupport { recovery_token_supported == true implies sharded_transactions_enabled == true }
    }

  requirement def AggregationOutMajorityReadConcern {
    subject;
    doc /* The driver shall support majority read concern level for Aggregation $out operations */
    attribute id : String = "REQ-522";
    attribute majority_read_concern_supported : Boolean;
    attribute aggregation_out_operation : Boolean;
    stakeholder developer : Developer;
    require constraint MajorityReadConcernAggregationOut { aggregation_out_operation == true implies majority_read_concern_supported == true }
    }

  requirement def TransactionTestsSession1APM {
    subject;
    doc /* The transaction tests shall include session1 in APM expectations */
    attribute id : String = "REQ-532";
    attribute session1_included : Boolean;
    attribute apm_expectations_updated : Boolean;
    stakeholder developer : Developer;
    require constraint Session1APMInclusion { session1_included == true implies apm_expectations_updated == true }
    }

  requirement def MongoDB42Testing {
    subject;
    doc /* The driver shall be tested against MongoDB 4.2 in the Evergreen CI system */
    attribute id : String = "REQ-514";
    attribute mongodb_version : String = "4.2";
    attribute evergreen_ci_testing : Boolean;
    attribute testing_completed : Boolean;
    stakeholder developer : Developer;
    require constraint MongoDB42EvergreenTesting { evergreen_ci_testing == true implies testing_completed == true }
    }

  requirement def CRUDTestsRunOnSyntax {
    subject;
    doc /* The CRUD tests shall use runOn syntax to specify test requirements */
    attribute id : String = "REQ-513";
    attribute runon_syntax_used : Boolean;
    attribute test_requirements_specified : Boolean;
    stakeholder developer : Developer;
    require constraint CRUDRunOnSyntaxUsage { runon_syntax_used == true implies test_requirements_specified == true }
    }

  requirement def RetryableWritesNetworkErrorTests {
    subject;
    doc /* The retryable writes network error tests shall require mongos 4.2 or higher */
    attribute id : String = "REQ-520";
    attribute mongos_version_required : String = "4.2";
    attribute network_error_tests_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint MongosVersionRequirement { mongos_version_required == "4.2" implies network_error_tests_enabled == true }
    }

  requirement def PipelineExtensionSupport {
    subject;
    doc /* The mongocxx::pipeline class shall support extension with aggregation stages not known at compile time */
    attribute id : String = "REQ-507";
    attribute supports_runtime_stages : Boolean;
    attribute pipeline_extensible : Boolean;
    stakeholder developer : Developer;
    require constraint PipelineRuntimeExtensibility { supports_runtime_stages == true implies pipeline_extensible == true }
    }

  requirement def ReadConcernEscapeHatch {
    subject;
    doc /* The driver shall provide an escape hatch for read concern options not explicitly supported */
    attribute id : String = "REQ-508";
    attribute escape_hatch_available : Boolean;
    attribute unsupported_options_handled : Boolean;
    stakeholder developer : Developer;
    require constraint ReadConcernEscapeHatchSupport { escape_hatch_available == true implies unsupported_options_handled == true }
    }

  requirement def ChangeStreamStartAfterOption {
    subject;
    doc /* The driver shall support 'startAfter' option for the $changeStream stage */
    attribute id : String = "REQ-528";
    attribute start_after_option_supported : Boolean;
    attribute change_stream_stage_enhanced : Boolean;
    stakeholder developer : Developer;
    require constraint StartAfterOptionSupport { start_after_option_supported == true implies change_stream_stage_enhanced == true }
    }

  requirement def RetryableReadOperationsSupport {
    subject;
    doc /* The driver shall support retryable read operations */
    attribute id : String = "REQ-536";
    attribute retryable_reads_supported : Boolean;
    attribute read_operations_retryable : Boolean;
    stakeholder developer : Developer;
    require constraint RetryableReadSupport { retryable_reads_supported == true implies read_operations_retryable == true }
    }

  requirement def MongosPinningShardedTransactions {
    subject;
    doc /* The driver shall support mongos pinning for sharded transactions */
    attribute id : String = "REQ-537";
    attribute mongos_pinning_supported : Boolean;
    attribute sharded_transactions_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint MongosPinningSupport { mongos_pinning_supported == true implies sharded_transactions_enabled == true }
    }

  requirement def OperatingSystemRequirements {
    subject;
    doc /* The driver shall support operating system requirements as specified in DRIVERS-674 */
    attribute id : String = "REQ-512";
    attribute drivers_674_compliance : Boolean;
    attribute os_requirements_met : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint ComplianceRequirement { drivers_674_compliance == true implies os_requirements_met == true }
    }

  requirement def ConnectionsPrimaryStepdownSurvival {
    subject;
    doc /* The driver connections shall survive primary stepdown events */
    attribute id : String = "REQ-535";
    attribute connections_survive_stepdown : Boolean;
    attribute primary_stepdown_occurred : Boolean;
    stakeholder developer : Developer;
    require constraint StepdownSurvival { primary_stepdown_occurred == true implies connections_survive_stepdown == true }
    }

  requirement def UnacknowledgedUpdateHintError {
    subject;
    doc /* The driver shall raise an error when hint is specified for unacknowledged update operations using OP_MSG or OP_UPDATE */
    attribute id : String = "REQ-568";
    attribute hint_parameter_specified : Boolean;
    attribute unacknowledged_update : Boolean;
    attribute op_msg_protocol : Boolean;
    attribute op_update_protocol : Boolean;
    attribute error_raised : Boolean = true;
    stakeholder developer : Developer;
    require constraint HintErrorCondition { hint_parameter_specified == true and unacknowledged_update == true and (op_msg_protocol == true or op_update_protocol == true) implies error_raised == true }
    }

  requirement def CreateIndexesCommitQuorumSupport {
    subject;
    doc /* The createIndexes command shall support the commitQuorum option on MongoDB 4.4 and later */
    attribute id : String = "REQ-554";
    attribute command_name : String = "createIndexes";
    attribute option_name : String = "commitQuorum";
    attribute min_mongodb_version : String = "4.4";
    attribute version_support_enabled : Boolean = true;
    stakeholder developer : Developer;
    require constraint CommitQuorumSupport { command_name == "createIndexes" and option_name == "commitQuorum" implies version_support_enabled == true }
    }

  requirement def ChangeStreamRepeatedResumeRestriction {
    subject;
    doc /* The change stream shall not repeatedly resume when getMore receives the same error */
    attribute id : String = "REQ-564";
    attribute operation_name : String = "getMore";
    attribute repeated_resume_prevented : Boolean = true;
    attribute same_error_handling : Boolean = true;
    stakeholder developer : Developer;
    require constraint RepeatedResumeRestriction { operation_name == "getMore" and same_error_handling == true implies repeated_resume_prevented == true }
    }

  requirement def MongoDBAwsAuthenticationSupport {
    subject;
    doc /* The driver shall support MONGODB-AWS authentication mechanism */
    attribute id : String = "REQ-573";
    attribute authentication_mechanism : String = "MONGODB-AWS";
    attribute mechanism_supported : Boolean = true;
    attribute aws_authentication_enabled : Boolean = true;
    stakeholder developer : Developer;
    require constraint AwsAuthenticationSupport { authentication_mechanism == "MONGODB-AWS" implies mechanism_supported == true and aws_authentication_enabled == true }
    }

  requirement def ServerHedgedReadsSupport {
    subject;
    doc /* The driver shall support server hedged reads functionality */
    attribute id : String = "REQ-562";
    attribute functionality_name : String = "hedged_reads";
    attribute server_support_enabled : Boolean = true;
    attribute hedged_reads_supported : Boolean = true;
    stakeholder developer : Developer;
    require constraint HedgedReadsSupport { functionality_name == "hedged_reads" implies server_support_enabled == true and hedged_reads_supported == true }
    }

  requirement def URICertificateRevocationOption {
    subject;
    doc /* The URI options shall include an option to disable certificate revocation checking */
    attribute id : String = "REQ-561";
    attribute option_type : String = "certificate_revocation_checking";
    attribute disable_option_available : Boolean = true;
    attribute revocation_checking_disabled : Boolean;
    stakeholder developer : Developer;
    require constraint RevocationOptionAvailability { option_type == "certificate_revocation_checking" implies disable_option_available == true }
    }

  requirement def CommitQuorumValueAcceptance {
    subject;
    doc /* The commitQuorum option shall accept integer values, 'majority', 'votingMembers', and custom write concern strings */
    attribute id : String = "REQ-555";
    attribute option_name : String = "commitQuorum";
    attribute integer_values_accepted : Boolean = true;
    attribute majority_value_accepted : Boolean = true;
    attribute voting_members_value_accepted : Boolean = true;
    attribute custom_write_concern_accepted : Boolean = true;
    stakeholder developer : Developer;
    require constraint CommitQuorumValueSupport { option_name == "commitQuorum" implies integer_values_accepted == true and majority_value_accepted == true and voting_members_value_accepted == true and custom_write_concern_accepted == true }
    }

  requirement def ChangeStreamCursorNotFoundResumption {
    subject;
    doc /* The change stream driver shall treat CursorNotFound errors as resumable errors that allow stream continuation */
    attribute id : String = "REQ-547";
    attribute error_type : String = "CursorNotFound";
    attribute resumable_error : Boolean = true;
    attribute stream_continuation_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint CursorNotFoundResumption { error_type == "CursorNotFound" implies resumable_error == true and stream_continuation_enabled == true }
    }

  requirement def BSONVariadicMakeValueHelper {
    subject;
    doc /* The BSON library shall provide a variadic make_value helper function to create owning bson_value::value instances */
    attribute id : String = "REQ-548";
    attribute function_name : String = "make_value";
    attribute variadic_support : Boolean = true;
    attribute owning_instance_creation : Boolean = true;
    stakeholder developer : Developer;
    require constraint VariadicMakeValueSupport { function_name == "make_value" implies variadic_support == true and owning_instance_creation == true }
    }

  requirement def FLETestsAdminDatabaseRestriction {
    subject;
    doc /* The FLE tests shall not use the admin database for collection operations */
    attribute id : String = "REQ-553";
    attribute test_type : String = "FLE";
    attribute admin_database_usage : Boolean = false;
    attribute collection_operations_restricted : Boolean = true;
    stakeholder developer : Developer;
    require constraint AdminDatabaseRestriction { test_type == "FLE" implies admin_database_usage == false and collection_operations_restricted == true }
    }

  requirement def BSONTypeStructConversions {
    subject;
    doc /* The BSON library shall provide conversions from b_type struct to bson_value_t */
    attribute id : String = "REQ-560";
    attribute source_type : String = "b_type";
    attribute target_type : String = "bson_value_t";
    attribute conversion_provided : Boolean = true;
    stakeholder developer : Developer;
    require constraint TypeConversionSupport { source_type == "b_type" and target_type == "bson_value_t" implies conversion_provided == true }
    }

  requirement def AggregationMergeOperatorSupport {
    subject;
    doc /* The driver shall support finer-grained updates from aggregation via $merge operator */
    attribute id : String = "REQ-575";
    attribute operator_name : String = "$merge";
    attribute finer_grained_updates : Boolean = true;
    attribute aggregation_support_enabled : Boolean = true;
    stakeholder developer : Developer;
    require constraint MergeOperatorSupport { operator_name == "$merge" implies finer_grained_updates == true and aggregation_support_enabled == true }
    }

  requirement def FindAllowDiskUseSupport {
    subject;
    doc /* The find operations shall support allowDiskUse option */
    attribute id : String = "REQ-572";
    attribute operation_name : String = "find";
    attribute allow_disk_use_supported : Boolean = true;
    attribute option_name : String = "allowDiskUse";
    stakeholder developer : Developer;
    require constraint AllowDiskUseSupport { operation_name == "find" and option_name == "allowDiskUse" implies allow_disk_use_supported == true }
    }

  requirement def ClientTopologyRecoveryTime {
    subject;
    doc /* The driver shall reduce client time to recovery on topology changes */
    attribute id : String = "REQ-566";
    attribute recovery_time_reduced : Boolean = true;
    attribute topology_change_handling : Boolean = true;
    attribute client_recovery_optimized : Boolean = true;
    stakeholder developer : Developer;
    require constraint RecoveryTimeOptimization { topology_change_handling == true implies recovery_time_reduced == true and client_recovery_optimized == true }
    }

  requirement def ZstandardCompressionSupport {
    subject;
    doc /* The driver shall support Zstandard compression algorithm */
    attribute id : String = "REQ-577";
    attribute compression_algorithm : String = "Zstandard";
    attribute algorithm_supported : Boolean = true;
    attribute compression_enabled : Boolean = true;
    stakeholder developer : Developer;
    require constraint ZstandardSupport { compression_algorithm == "Zstandard" implies algorithm_supported == true and compression_enabled == true }
    }

  requirement def EncryptKeyIdBsonValueParameter {
    subject;
    doc /* The options::encrypt::key_id() method shall accept a bson_value parameter instead of bsoncxx::types::b_binary */
    attribute id : String = "REQ-549";
    attribute method_name : String = "key_id";
    attribute parameter_type : String = "bson_value";
    attribute legacy_parameter_type : String = "bsoncxx::types::b_binary";
    stakeholder developer : Developer;
    require constraint ParameterTypeUpdate { method_name == "key_id" implies parameter_type == "bson_value" }
    }

  requirement def URIClassGetterMethods {
    subject;
    doc /* The mongocxx::uri class shall provide getter methods for all URI options supported in libmongoc */
    attribute id : String = "REQ-556";
    attribute class_name : String = "mongocxx::uri";
    attribute libmongoc_options_supported : Boolean = true;
    attribute getter_methods_provided : Boolean = true;
    stakeholder developer : Developer;
    require constraint GetterMethodsSupport { class_name == "mongocxx::uri" implies libmongoc_options_supported == true and getter_methods_provided == true }
    }

  requirement def ClientSideFieldLevelEncryption {
    subject;
    doc /* The driver shall support Client-side Field Level Encryption functionality */
    attribute id : String = "REQ-578";
    attribute functionality_name : String = "Client-side Field Level Encryption";
    attribute encryption_supported : Boolean = true;
    attribute field_level_encryption_enabled : Boolean = true;
    stakeholder developer : Developer;
    require constraint FieldLevelEncryptionSupport { functionality_name == "Client-side Field Level Encryption" implies encryption_supported == true and field_level_encryption_enabled == true }
    }

  requirement def RetryableTransactionTestErrorLabels {
    subject;
    doc /* The retryable transaction tests shall include explicit RetryableWriteError error labels */
    attribute id : String = "REQ-558";
    attribute test_type : String = "retryable_transaction";
    attribute error_label : String = "RetryableWriteError";
    attribute explicit_labels_included : Boolean = true;
    stakeholder developer : Developer;
    require constraint ErrorLabelInclusion { test_type == "retryable_transaction" and error_label == "RetryableWriteError" implies explicit_labels_included == true }
    }

  requirement def FindAndModifyUpdateHintSupport {
    subject;
    doc /* The findAndModify update operations shall support hint parameter for query optimization */
    attribute id : String = "REQ-570";
    attribute operation_type : String = "findAndModify_update";
    attribute hint_parameter_supported : Boolean = true;
    attribute query_optimization_enabled : Boolean = true;
    stakeholder developer : Developer;
    require constraint UpdateHintSupport { operation_type == "findAndModify_update" implies hint_parameter_supported == true and query_optimization_enabled == true }
    }

  requirement def FindAndModifyReplaceHintSupport {
    subject;
    doc /* The findAndModify replace operations shall support hint parameter for query optimization */
    attribute id : String = "REQ-571";
    attribute operation_type : String = "findAndModify_replace";
    attribute hint_parameter_supported : Boolean = true;
    attribute query_optimization_enabled : Boolean = true;
    stakeholder developer : Developer;
    require constraint ReplaceHintSupport { operation_type == "findAndModify_replace" implies hint_parameter_supported == true and query_optimization_enabled == true }
    }

  requirement def DeleteCommandHintSupport {
    subject;
    doc /* The delete command shall support hint parameter for query optimization */
    attribute id : String = "REQ-565";
    attribute command_name : String = "delete";
    attribute hint_parameter_supported : Boolean = true;
    attribute query_optimization_enabled : Boolean = true;
    stakeholder developer : Developer;
    require constraint DeleteHintSupport { command_name == "delete" implies hint_parameter_supported == true and query_optimization_enabled == true }
    }

  requirement def UpdateOperationsHintSupport {
    subject;
    doc /* The update operations shall support hint parameter for query optimization */
    attribute id : String = "REQ-574";
    attribute operation_type : String = "update";
    attribute hint_parameter_supported : Boolean = true;
    attribute query_optimization_enabled : Boolean = true;
    stakeholder developer : Developer;
    require constraint UpdateHintSupport { operation_type == "update" implies hint_parameter_supported == true and query_optimization_enabled == true }
    }

  requirement def WriteConcernErrorInfoPropagation {
    subject;
    doc /* The driver shall propagate the WriteConcernError errInfo object in error responses */
    attribute id : String = "REQ-563";
    attribute error_type : String = "WriteConcernError";
    attribute errinfo_object_propagated : Boolean = true;
    attribute error_response_enhanced : Boolean = true;
    stakeholder developer : Developer;
    require constraint ErrorInfoPropagation { error_type == "WriteConcernError" implies errinfo_object_propagated == true and error_response_enhanced == true }
    }

  requirement def EncryptClassKeyIdGetter {
    subject;
    doc /* The mongocxx::options::encrypt class shall provide a key_id getter method */
    attribute id : String = "REQ-550";
    attribute class_name : String = "mongocxx::options::encrypt";
    attribute getter_method_name : String = "key_id";
    attribute method_provided : Boolean = true;
    stakeholder developer : Developer;
    require constraint KeyIdGetterMethod { class_name == "mongocxx::options::encrypt" and getter_method_name == "key_id" implies method_provided == true }
    }

  requirement def BSONElementArrayKeyFunction {
    subject;
    doc /* The bsoncxx::element::array class shall expose a key() function */
    attribute id : String = "REQ-569";
    attribute class_name : String = "bsoncxx::element::array";
    attribute key_function_exposed : Boolean = true;
    attribute function_name : String = "key";
    stakeholder developer : Developer;
    require constraint KeyFunctionExposure { class_name == "bsoncxx::element::array" and function_name == "key" implies key_function_exposed == true }
    }

  requirement def ReplicaSetDiscoveryConfiguration {
    subject;
    doc /* The driver shall unify behavior around configuration for replica set discovery */
    attribute id : String = "REQ-567";
    attribute configuration_unified : Boolean = true;
    attribute replica_set_discovery : Boolean = true;
    attribute behavior_consistency : Boolean = true;
    stakeholder developer : Developer;
    require constraint ConfigurationUnification { replica_set_discovery == true implies configuration_unified == true and behavior_consistency == true }
    }

  requirement def ChangeStreamGetMoreRetry {
    subject;
    doc /* The driver shall retry getMore operations immediately after a change stream resume */
    attribute id : String = "REQ-576";
    attribute operation_name : String = "getMore";
    attribute immediate_retry : Boolean = true;
    attribute change_stream_resume_triggered : Boolean;
    stakeholder developer : Developer;
    require constraint GetMoreRetryAfterResume { operation_name == "getMore" and change_stream_resume_triggered == true implies immediate_retry == true }
    }

  #refinement dependency from ClientDriverRequirements::SSLCompilationErrorMessage to ClientDriverRequirements::SCRAMAuthenticationFailureDetection;
  #derivation dependency from ClientDriverRequirements::SCRAMAuthenticationPrevention to ClientDriverRequirements::SCRAMAuthenticationFailureDetection;
  #trace dependency from ClientDriverRequirements::SSLCompilationErrorMessage to ClientDriverRequirements::SCRAMAuthenticationPrevention;
  #trace dependency from ClientDriverRequirements::SCRAMAuthenticationFailureDetection to SystemRequirements::ClientInitializationSSLOptions;
  #refinement dependency from ClientDriverRequirements::ClientExampleHostParameter to ClientDriverRequirements::ClientExampleParameterSupport;
  #refinement dependency from ClientDriverRequirements::ClientExamplePortParameter to ClientDriverRequirements::ClientExampleParameterSupport;
  #refinement dependency from ClientDriverRequirements::UnixSocketConstructorStability to ClientDriverRequirements::UnixSocketStringAcceptance;
  #trace dependency from ClientDriverRequirements::ListIndexesCursorSupport to ClientDriverRequirements::ListCollectionsCursorSupport;
  #trace dependency from ClientDriverRequirements::DefaultAuthSourceHandling to ClientDriverRequirements::DefaultAuthMechanismProvision;
  #trace dependency from ClientDriverRequirements::DefaultAuthMechanismProvision to ClientDriverRequirements::SCRAMDefaultVerification;
  #trace dependency from ClientDriverRequirements::SCRAMAuthenticationFailureDetection to ClientDriverRequirements::SCRAMDefaultVerification;
  #trace dependency from ClientDriverRequirements::SSLShutdownStability to ClientDriverRequirements::SCRAMAuthenticationFailureDetection;
  #refinement dependency from ClientDriverRequirements::MaxTimeMSParameterValidation to ClientDriverRequirements::MaxTimeMSParameterSupport;
  #refinement dependency from ClientDriverRequirements::DatabaseOperationTermination to ClientDriverRequirements::MaxTimeMSParameterSupport;
  #refinement dependency from ClientDriverRequirements::TimeoutErrorResponse to ClientDriverRequirements::MaxTimeMSParameterSupport;
  #refinement dependency from ClientDriverRequirements::MaxTimeMSParameterRejection to ClientDriverRequirements::MaxTimeMSParameterSupport;
  #derivation dependency from ClientDriverRequirements::TimeoutErrorResponse to ClientDriverRequirements::DatabaseOperationTermination;
  #trace dependency from ClientDriverRequirements::MaxTimeMSParameterSupport to DatabaseOperationsRequirements::QueryMaxTimeMSSupport;
  #trace dependency from ClientDriverRequirements::MaxTimeMSParameterSupport to DatabaseOperationsRequirements::QueryMaxTimeMsMethod;
  #refinement dependency from ClientDriverRequirements::OIDGenerationErrorMessage to DocumentationRequirements::ClientInitializeDocumentation;
  #refinement dependency from ClientDriverRequirements::CreateIndexErrorMessage to DocumentationRequirements::ClientInitializeDocumentation;
  #trace dependency from ClientDriverRequirements::CopyDbAuthenticationSupport to SystemRequirements::ClientInitializationPortOption;
  #trace dependency from ClientDriverRequirements::CopyDbAuthenticationSupport to SystemRequirements::ClientInitializationSSLOptions;
  #refinement dependency from ClientDriverRequirements::JSONInputAcceptance to ClientDriverRequirements::BSONFromJSONMethod;
  #refinement dependency from ClientDriverRequirements::ValidBSONOutput to ClientDriverRequirements::BSONFromJSONMethod;
  #refinement dependency from ClientDriverRequirements::MalformedJSONHandling to ClientDriverRequirements::BSONFromJSONMethod;
  #trace dependency from ClientDriverRequirements::BSONFromJSONMethod to SystemRequirements::FromJsonArraySupport;
  #trace dependency from ClientDriverRequirements::BSONFromJSONMethod to SystemRequirements::FromJsonTypeParameter;
  #trace dependency from ClientDriverRequirements::ValidBSONOutput to SystemRequirements::BSONArrayJsonOutput;
  #trace dependency from ClientDriverRequirements::LoggingAPIExport to SystemRequirements::ClientInitLoggingOptions;
  #trace dependency from ClientDriverRequirements::LoggingAPIExport to DocumentationRequirements::ClientInitializeDocumentation;
  #refinement dependency from ClientDriverRequirements::ValidationFailureOptionalReturn to ClientDriverRequirements::ValidationFailureHandling;
  #refinement dependency from ClientDriverRequirements::ValidationFailureErrorField to ClientDriverRequirements::ValidationFailureHandling;
  #refinement dependency from ClientDriverRequirements::BSONObjLifetimeExplicit to ClientDriverRequirements::BSONObjLifetimeManagement;
  #refinement dependency from ClientDriverRequirements::BSONObjLifetimeVisible to ClientDriverRequirements::BSONObjLifetimeManagement;
  #derivation dependency from ClientDriverRequirements::ValidationFailureHandling to ClientDriverRequirements::DocumentValidationMethod;
  #trace dependency from ClientDriverRequirements::ValidationFailureHandling to ClientDriverRequirements::MalformedJSONHandling;
  #trace dependency from ClientDriverRequirements::ClientURIRetrieval to SystemRequirements::ClientInitializationPortOption;
  #trace dependency from ClientDriverRequirements::ClientOptionsRetrieval to SystemRequirements::ClientInitializationPortOption;
  #trace dependency from ClientDriverRequirements::ClientOptionsRetrieval to SystemRequirements::ClientInitializationSSLOptions;
  #trace dependency from ClientDriverRequirements::CursorLifetimeSemantics to ClientDriverRequirements::BSONObjLifetimeManagement;
  #refinement dependency from ClientDriverRequirements::DocumentViewEmptyDetection to SystemRequirements::MutableBSONInterface;
  #refinement dependency from ClientDriverRequirements::DocumentViewNonEmptyDetection to SystemRequirements::MutableBSONInterface;
  #refinement dependency from ClientDriverRequirements::BSONFromJSONConstruction to ClientDriverRequirements::JSONInputAcceptance;
  #refinement dependency from ClientDriverRequirements::PipelineViewStringConversion to ClientDriverRequirements::PipelineViewMethod;
  #refinement dependency from ClientDriverRequirements::BulkWriteParameterTypeReplacement to DatabaseOperationsRequirements::BulkWriteAPISupport;
  #trace dependency from ClientDriverRequirements::DocumentViewEmptyDetection to ClientDriverRequirements::DocumentViewNonEmptyDetection;
  #trace dependency from ClientDriverRequirements::DatabaseListCollectionsMethod to ClientDriverRequirements::ClientListDatabasesMethod;
  #trace dependency from ClientDriverRequirements::BSONFromJSONConstruction to ClientDriverRequirements::ValidBSONOutput;
  #refinement dependency from ClientDriverRequirements::FindAndModifyWriteConcernSupport to DatabaseOperationsRequirements::WriteConcernParameters;
  #refinement dependency from ClientDriverRequirements::BypassDocumentValidationSupport to DatabaseOperationsRequirements::WriteCommandsSupport;
  #refinement dependency from ClientDriverRequirements::FilteredIndexCreationSupport to DatabaseOperationsRequirements::SparseIndexSupport;
  #derivation dependency from ClientDriverRequirements::UnacknowledgedWriteConcernCompliance to DatabaseOperationsRequirements::WriteConcernParameters;
  #trace dependency from ClientDriverRequirements::UnacknowledgedWriteConcernCompliance to DatabaseOperationsRequirements::BulkWriteAPISupport;
  #trace dependency from ClientDriverRequirements::FindAndModifyWriteConcernSupport to DatabaseOperationsRequirements::WriteCommandsSupport;
  #trace dependency from ClientDriverRequirements::BypassDocumentValidationSupport to DatabaseOperationsRequirements::BulkWriteAPISupport;
  #trace dependency from ClientDriverRequirements::FilteredIndexCreationSupport to DatabaseOperationsRequirements::WeightsOptionSupport;
  #trace dependency from ClientDriverRequirements::FilteredIndexCreationSupport to DatabaseOperationsRequirements::DefaultLanguageSupport;
  #trace dependency from ClientDriverRequirements::ConstantTimeHashComparison to SystemRequirements::ODRViolationPrevention;
  #refinement dependency from ClientDriverRequirements::ReplicaSetRetryLogic to ClientDriverRequirements::NetworkErrorQueryRetry;
  #derivation dependency from ClientDriverRequirements::NullPointerCursorHandling to ClientDriverRequirements::PrimaryNodeStepdownDetection;
  #trace dependency from ClientDriverRequirements::NetworkErrorQueryRetry to ClientDriverRequirements::PrimaryNodeStepdownDetection;
  #trace dependency from ClientDriverRequirements::NetworkErrorQueryRetry to ClientDriverRequirements::NullPointerCursorHandling;
  #trace dependency from ClientDriverRequirements::PrimaryNodeStepdownDetection to ClientDriverRequirements::DBClientCursorValidation;
  #trace dependency from ClientDriverRequirements::NullPointerCursorHandling to ClientDriverRequirements::DBClientCursorValidation;
  #refinement dependency from ClientDriverRequirements::BoostOptionalPolyfillSupport to ClientDriverRequirements::BoostStdxPolyfillSupport;
  #refinement dependency from ClientDriverRequirements::BoostStringRefPolyfillSupport to ClientDriverRequirements::BoostStdxPolyfillSupport;
  #trace dependency from ClientDriverRequirements::BoostStdxPolyfillSupport to BuildSystemRequirements::BoostPolyfillSupport;
  #trace dependency from ClientDriverRequirements::BoostStdxPolyfillSupport to BuildSystemRequirements::OptionalMNMLSTCUsage;
  #trace dependency from ClientDriverRequirements::BSONExceptionImplementation to ClientDriverRequirements::LibbsonErrorCategoryImplementation;
  #trace dependency from ClientDriverRequirements::BSONExceptionImplementation to ClientDriverRequirements::BSONErrorCategoryImplementation;
  #trace dependency from ClientDriverRequirements::LibbsonErrorCategoryImplementation to ClientDriverRequirements::BSONErrorCategoryImplementation;
  #trace dependency from ClientDriverRequirements::StringViewOrValueVariant to ClientDriverRequirements::NullTerminatedStringEnforcement;
  #trace dependency from ClientDriverRequirements::StringViewOrValueVariant to ClientDriverRequirements::BSONDocumentViewOrValueVariant;
  #trace dependency from ClientDriverRequirements::BSONRawPointerAccess to ClientDriverRequirements::DocumentValidationMethod;
  #trace dependency from ClientDriverRequirements::DocumentElementOperatorBehavior to ClientDriverRequirements::ArrayOperatorElementRetrieval;
  #trace dependency from ClientDriverRequirements::AggregationSampleOperatorSupport to DatabaseOperationsRequirements::AggregationCursorOutput;
  #trace dependency from ClientDriverRequirements::LookupPipelineOperatorSupport to ClientDriverRequirements::CommandHelperFunction;
  #trace dependency from ClientDriverRequirements::OptionsMethodChaining to ClientDriverRequirements::ClientURIRetrieval;
  #trace dependency from ClientDriverRequirements::OptionsMethodChaining to ClientDriverRequirements::ClientOptionsRetrieval;
  #trace dependency from ClientDriverRequirements::DatabaseCollectionErrorModes to ClientDriverRequirements::ConnectionStatusCheck;
  #trace dependency from ClientDriverRequirements::CoreBuilderAppendOverload to SystemRequirements::MutableBSONImplementation;
  #refinement dependency from ClientDriverRequirements::WriteConcernErrorFieldCheck to ClientDriverRequirements::WriteConcernErrorHandling;
  #refinement dependency from ClientDriverRequirements::WriteConcernErrorRaising to ClientDriverRequirements::WriteConcernErrorHandling;
  #trace dependency from ClientDriverRequirements::CreateCommandCollationSupport to ClientDriverRequirements::CollModValidationHelper;
  #trace dependency from ClientDriverRequirements::CreateIndexesCommandCollationSupport to DatabaseOperationsRequirements::SparseIndexSupport;
  #trace dependency from ClientDriverRequirements::AggregateCommandCollationSupport to DatabaseOperationsRequirements::AggregationExplainSupport;
  #trace dependency from ClientDriverRequirements::CountCommandCollationSupport to ClientDriverRequirements::CommandHelperFunction;
  #trace dependency from ClientDriverRequirements::DistinctCommandCollationSupport to ClientDriverRequirements::CommandHelperFunction;
  #trace dependency from ClientDriverRequirements::FindCommandCollationSupport to ClientDriverRequirements::CollectionFindCollationError;
  #trace dependency from ClientDriverRequirements::FindAndModifyCommandCollationSupport to ClientDriverRequirements::CollectionFindOneAndCollationError;
  #trace dependency from ClientDriverRequirements::AggregationPipelineBuilderMethods34 to DatabaseOperationsRequirements::AggregationExplainSupport;
  #trace dependency from ClientDriverRequirements::AggregationPipelineGeoNearIndexStats to DatabaseOperationsRequirements::AggregationExplainSupport;
  #trace dependency from ClientDriverRequirements::PipelineUnwindOverload to DatabaseOperationsRequirements::AggregationExplainSupport;
  #trace dependency from ClientDriverRequirements::CreateCollectionGetterMethods to ClientDriverRequirements::CollModValidationHelper;
  #trace dependency from ClientDriverRequirements::ValidationCriteriaGetterMethods to ClientDriverRequirements::DocumentValidationMethod;
  #trace dependency from ClientDriverRequirements::ValidationCriteriaMethodChaining to ClientDriverRequirements::OptionsMethodChaining;
  #trace dependency from ClientDriverRequirements::FindOptionsReplaceModifiers to ClientDriverRequirements::CollectionFindCollationError;
  #refinement dependency from ClientDriverRequirements::ConnectionPoolWriteConcernReset to DatabaseOperationsRequirements::WriteConcernParameters;
  #refinement dependency from ClientDriverRequirements::ConnectionPoolReadConcernReset to DatabaseOperationsRequirements::DatabaseCommandReadPreference;
  #refinement dependency from ClientDriverRequirements::ConnectionPoolReadPreferenceReset to DatabaseOperationsRequirements::AggregationReadPreference;
  #derivation dependency from ClientDriverRequirements::ConnectionPoolConfigurationValidation to ClientDriverRequirements::ConnectionPoolWriteConcernReset;
  #derivation dependency from ClientDriverRequirements::ConnectionPoolConfigurationValidation to ClientDriverRequirements::ConnectionPoolReadConcernReset;
  #derivation dependency from ClientDriverRequirements::ConnectionPoolConfigurationValidation to ClientDriverRequirements::ConnectionPoolReadPreferenceReset;
  #derivation dependency from ClientDriverRequirements::AcquiredClientWriteConcernMatch to ClientDriverRequirements::ConnectionPoolWriteConcernReset;
  #trace dependency from ClientDriverRequirements::ConnectionPoolReadConcernReset to ClientDriverRequirements::ConnectionPoolReadPreferenceReset;
  #trace dependency from ClientDriverRequirements::AcquiredClientWriteConcernMatch to ClientDriverRequirements::ConnectionPoolConfigurationValidation;
  #refinement dependency from ClientDriverRequirements::IndexViewImplementationReplacement to ClientDriverRequirements::IndexViewDummyImplementation;
  #trace dependency from ClientDriverRequirements::CppSeventeenOptionalSupport to ClientDriverRequirements::CppSeventeenStringViewSupport;
  #trace dependency from ClientDriverRequirements::IndexModelClassImplementation to ClientDriverRequirements::IndexViewDummyImplementation;
  #trace dependency from ClientDriverRequirements::IndexAPIBSONDocumentAcceptance to ClientDriverRequirements::IndexOptionsCastOperator;
  #trace dependency from ClientDriverRequirements::CompressedMessageReadSupport to ClientDriverRequirements::CompressedMessageWriteSupport;
  #trace dependency from ClientDriverRequirements::AggregationIndexHintSupport to ClientDriverRequirements::NonMaterializedViewIndexHints;
  #trace dependency from ClientDriverRequirements::GridFSLargeFileUploadTesting to ClientDriverRequirements::GridFSLargeFileDownloadTesting;
  #trace dependency from ClientDriverRequirements::GridFSOpenUploadStreamWithIdTesting to ClientDriverRequirements::GridFSUploadFromStreamTesting;
  #trace dependency from ClientDriverRequirements::GridFSUploadFromStreamTesting to ClientDriverRequirements::GridFSUploadFromStreamWithIdTesting;
  #trace dependency from ClientDriverRequirements::GridFSDownloadToStreamTesting to ClientDriverRequirements::GridFSDeleteFileTesting;
  #trace dependency from ClientDriverRequirements::BasicDocumentCopyability to ClientDriverRequirements::BasicDocumentMovability;
  #trace dependency from ClientDriverRequirements::BasicArrayCopyability to ClientDriverRequirements::BasicArrayMovability;
  #trace dependency from ClientDriverRequirements::GridFSLargeFileUploadTesting to BuildSystemRequirements::TestLinkingVerification;
  #refinement dependency from ClientDriverRequirements::DNSTXTRecordQuery to ClientDriverRequirements::DNSSRVRecordDiscovery;
  #refinement dependency from ClientDriverRequirements::DNSSRVDomainValidation to ClientDriverRequirements::DNSSRVRecordDiscovery;
  #refinement dependency from ClientDriverRequirements::DNSLookupFallback to ClientDriverRequirements::DNSSRVRecordDiscovery;
  #derivation dependency from ClientDriverRequirements::SessionTimeoutConfiguration to ClientDriverRequirements::SessionTimeoutFieldParsing;
  #trace dependency from ClientDriverRequirements::MissingFieldHandling to ClientDriverRequirements::SessionTimeoutFieldParsing;
  #trace dependency from ClientDriverRequirements::DNSSRVRecordDiscovery to SystemRequirements::ConnectionStringValidation;
  #trace dependency from ClientDriverRequirements::SessionTimeoutFieldParsing to SystemRequirements::DeferredIsMasterCalls;
  #trace dependency from ClientDriverRequirements::SessionTimeoutFieldParsing to SystemRequirements::ServerVersionPopulationTiming;
  #refinement dependency from ClientDriverRequirements::FindAndModifyOptsUsage to ClientDriverRequirements::FindAndModifyWriteConcernSupport;
  #refinement dependency from ClientDriverRequirements::BulkOperationInsertOptsUsage to DatabaseOperationsRequirements::WriteCommandsSupport;
  #refinement dependency from ClientDriverRequirements::BulkOperationUpdateOptsUsage to DatabaseOperationsRequirements::WriteCommandsSupport;
  #refinement dependency from ClientDriverRequirements::BulkOperationDeleteOptsUsage to DatabaseOperationsRequirements::WriteCommandsSupport;
  #refinement dependency from ClientDriverRequirements::BulkWriteExecuteMethod to ClientDriverRequirements::BulkWriteMethodDeprecation;
  #trace dependency from ClientDriverRequirements::AutoIndexIdDeprecation to ClientDriverRequirements::AutoIndexIdDefaultBehavior;
  #trace dependency from ClientDriverRequirements::BulkWriteMethodDeprecation to ClientDriverRequirements::BulkWriteConstructorDeprecation;
  #trace dependency from ClientDriverRequirements::BulkOperationInsertOptsUsage to ClientDriverRequirements::BulkOperationUpdateOptsUsage;
  #trace dependency from ClientDriverRequirements::BulkOperationInsertOptsUsage to ClientDriverRequirements::BulkOperationDeleteOptsUsage;
  #trace dependency from ClientDriverRequirements::BulkOperationUpdateOptsUsage to ClientDriverRequirements::BulkOperationDeleteOptsUsage;
  #trace dependency from ClientDriverRequirements::CollectionGetSessionMethod to ClientDriverRequirements::DatabaseGetSessionMethod;
  #trace dependency from ClientDriverRequirements::SessionOverloadsForServerCommunication to ClientDriverRequirements::SessionOverloadParameterOrder;
  #trace dependency from ClientDriverRequirements::SessionClassImplementation to ClientDriverRequirements::SessionOptionsClass;
  #refinement dependency from ClientDriverRequirements::GridFSDownloaderBackwardsCompatibility to ClientDriverRequirements::GridFSDownloaderReadOffset;
  #refinement dependency from ClientDriverRequirements::EstimatedDocumentCountHelper to CodebaseCleanupRequirements::CountHelperMethodDeprecation;
  #refinement dependency from ClientDriverRequirements::CountDocumentsHelper to CodebaseCleanupRequirements::CountHelperMethodDeprecation;
  #refinement dependency from ClientDriverRequirements::BulkWriteCreationMethod to CodebaseCleanupRequirements::BulkWriteConstructorRemoval;
  #refinement dependency from ClientDriverRequirements::SCRAMLibrarySHA256Mode to ClientDriverRequirements::SCRAMSHA256Support;
  #refinement dependency from ClientDriverRequirements::SASLPrepImplementation to ClientDriverRequirements::SCRAMSHA256Support;
  #refinement dependency from ClientDriverRequirements::ChangeStreamResumeOperationTime to ClientDriverRequirements::ChangeStreamStartTimeOmission;
  #refinement dependency from ClientDriverRequirements::CommandMonitoringSpecificationTests to ClientDriverRequirements::CommandMonitoringAPIWrapper;
  #refinement dependency from ClientDriverRequirements::SDAMEventsAPIWrapper to ClientDriverRequirements::SDAMEventsAPI;
  #derivation dependency from ClientDriverRequirements::BypassDocumentValidationConditional to ClientDriverRequirements::BypassDocumentValidationSupport;
  #trace dependency from ClientDriverRequirements::GridFSDownloaderReadOffset to DatabaseOperationsRequirements::GridFSFindFileSlaveOkParameter;
  #trace dependency from ClientDriverRequirements::GridFSDownloaderBackwardsCompatibility to DatabaseOperationsRequirements::GridFSListSlaveOkParameter;
  #trace dependency from ClientDriverRequirements::SCRAMSHA256Support to ClientDriverRequirements::SCRAMDefaultVerification;
  #trace dependency from ClientDriverRequirements::MonitoringSocketSCRAMNegotiation to SystemRequirements::DeferredIsMasterCalls;
  #trace dependency from ClientDriverRequirements::CRUDReplaceOptionsSupport to DatabaseOperationsRequirements::BulkWriteAPISupport;
  #trace dependency from ClientDriverRequirements::CRUDTestsRunOnSyntax to ClientDriverRequirements::TransactionTestsRunOnSyntax;
  #trace dependency from ClientDriverRequirements::RetryableWritesNetworkErrorTests to ClientDriverRequirements::MongoDB42Testing;
  #trace dependency from ClientDriverRequirements::TransactionSpecTestsResync to ClientDriverRequirements::TransactionTestsRunOnSyntax;
  #trace dependency from ClientDriverRequirements::TransactionTestsSession1APM to ClientDriverRequirements::TransactionTestsRunOnSyntax;
  #trace dependency from ClientDriverRequirements::RetryWritesErrorMessage to ClientDriverRequirements::OIDGenerationErrorMessage;
  #trace dependency from ClientDriverRequirements::RetryWritesErrorMessage to ClientDriverRequirements::CreateIndexErrorMessage;
  #derivation dependency from ClientDriverRequirements::CommitQuorumValueAcceptance to ClientDriverRequirements::CreateIndexesCommitQuorumSupport;
  #trace dependency from ClientDriverRequirements::ChangeStreamCursorNotFoundResumption to ClientDriverRequirements::ChangeStreamRepeatedResumeRestriction;
  #trace dependency from ClientDriverRequirements::ChangeStreamCursorNotFoundResumption to ClientDriverRequirements::ChangeStreamGetMoreRetry;
  #trace dependency from ClientDriverRequirements::ChangeStreamRepeatedResumeRestriction to ClientDriverRequirements::ChangeStreamGetMoreRetry;
  #trace dependency from ClientDriverRequirements::BSONVariadicMakeValueHelper to ClientDriverRequirements::BSONTypeStructConversions;
  #trace dependency from ClientDriverRequirements::EncryptKeyIdBsonValueParameter to ClientDriverRequirements::EncryptClassKeyIdGetter;
  #trace dependency from ClientDriverRequirements::DeleteCommandHintSupport to ClientDriverRequirements::FindAndModifyUpdateHintSupport;
  #trace dependency from ClientDriverRequirements::DeleteCommandHintSupport to ClientDriverRequirements::FindAndModifyReplaceHintSupport;
  #trace dependency from ClientDriverRequirements::DeleteCommandHintSupport to ClientDriverRequirements::UpdateOperationsHintSupport;
  #trace dependency from ClientDriverRequirements::FindAndModifyUpdateHintSupport to ClientDriverRequirements::FindAndModifyReplaceHintSupport;
  #trace dependency from ClientDriverRequirements::FindAndModifyUpdateHintSupport to ClientDriverRequirements::UpdateOperationsHintSupport;
  #trace dependency from ClientDriverRequirements::FindAndModifyReplaceHintSupport to ClientDriverRequirements::UpdateOperationsHintSupport;
  #trace dependency from ClientDriverRequirements::UnacknowledgedUpdateHintError to ClientDriverRequirements::UpdateOperationsHintSupport;
  #trace dependency from ClientDriverRequirements::URIClassGetterMethods to ClientDriverRequirements::URICertificateRevocationOption;
  #trace dependency from ClientDriverRequirements::FLETestsAdminDatabaseRestriction to ClientDriverRequirements::ClientSideFieldLevelEncryption;
  #trace dependency from ClientDriverRequirements::ClientTopologyRecoveryTime to ClientDriverRequirements::ReplicaSetDiscoveryConfiguration;
  }

package VersionManagementRequirements {
  private import Requirements::*;
  public import ScalarValues::*;

  part def Administrator;
  part def Customer;
  part def Developer;
  part def SystemAdmin;
  part def SystemOperator;
  part def User;

  requirement def CalcReleaseVersionScriptDependencyFreedom {
    subject;
    doc /* The calc_release_version.py script shall not require GitPython dependency */
    attribute id : String = "REQ-521";
    attribute script_name : String = "calc_release_version.py";
    attribute forbidden_dependency : String = "GitPython";
    attribute dependency_required : Boolean;
    stakeholder developer : Developer;
    require constraint GitPythonDependencyRestriction { script_name == "calc_release_version.py" implies dependency_required == false }
    }
  }