def _update_instance()

in src/providerhub/azext_providerhub/aaz/latest/providerhub/resource_type_registration/_update.py [0:0]


        def _update_instance(self, instance):
            _instance_value, _builder = self.new_content_builder(
                self.ctx.args,
                value=instance,
                typ=AAZObjectType
            )
            _builder.set_prop("kind", AAZStrType, ".kind")
            _builder.set_prop("properties", AAZObjectType)

            properties = _builder.get(".properties")
            if properties is not None:
                properties.set_prop("addResourceListTargetLocations", AAZBoolType, ".add_resource_list_target_locations")
                properties.set_prop("additionalOptions", AAZStrType, ".additional_options")
                properties.set_prop("allowEmptyRoleAssignments", AAZBoolType, ".allow_empty_role_assignments")
                properties.set_prop("allowedResourceNames", AAZListType, ".allowed_resource_names")
                properties.set_prop("allowedTemplateDeploymentReferenceActions", AAZListType, ".allowed_template_deployment_reference_actions")
                properties.set_prop("allowedUnauthorizedActions", AAZListType, ".allowed_unauthorized_actions")
                properties.set_prop("apiProfiles", AAZListType, ".api_profiles")
                properties.set_prop("asyncOperationResourceTypeName", AAZStrType, ".async_operation_resource_type_name")
                properties.set_prop("asyncTimeoutRules", AAZListType, ".async_timeout_rules")
                properties.set_prop("authorizationActionMappings", AAZListType, ".authorization_action_mappings")
                properties.set_prop("availabilityZoneRule", AAZObjectType, ".availability_zone_rule")
                properties.set_prop("capacityRule", AAZObjectType, ".capacity_rule")
                properties.set_prop("category", AAZStrType, ".category")
                properties.set_prop("checkNameAvailabilitySpecifications", AAZObjectType, ".check_name_availability_specifications")
                properties.set_prop("commonApiVersions", AAZListType, ".common_api_versions")
                properties.set_prop("crossTenantTokenValidation", AAZStrType, ".cross_tenant_token_validation")
                properties.set_prop("defaultApiVersion", AAZStrType, ".default_api_version")
                properties.set_prop("disallowedActionVerbs", AAZListType, ".disallowed_action_verbs")
                properties.set_prop("disallowedEndUserOperations", AAZListType, ".disallowed_end_user_operations")
                properties.set_prop("dstsConfiguration", AAZObjectType, ".dsts_configuration")
                properties.set_prop("enableAsyncOperation", AAZBoolType, ".enable_async_operation")
                properties.set_prop("enableThirdPartyS2S", AAZBoolType, ".enable_third_party_s2_s")
                properties.set_prop("endpoints", AAZListType, ".endpoints")
                properties.set_prop("extendedLocations", AAZListType, ".extended_locations")
                properties.set_prop("extensionOptions", AAZObjectType)
                properties.set_prop("featuresRule", AAZObjectType)
                properties.set_prop("frontdoorRequestMode", AAZStrType, ".frontdoor_request_mode")
                properties.set_prop("groupingTag", AAZStrType, ".grouping_tag")
                properties.set_prop("identityManagement", AAZObjectType, ".identity_management")
                properties.set_prop("isPureProxy", AAZBoolType, ".is_pure_proxy")
                properties.set_prop("legacyName", AAZStrType, ".legacy_name")
                properties.set_prop("legacyNames", AAZListType, ".legacy_names")
                properties.set_prop("legacyPolicy", AAZObjectType, ".legacy_policy")
                properties.set_prop("linkedAccessChecks", AAZListType, ".linked_access_checks")
                properties.set_prop("linkedNotificationRules", AAZListType, ".linked_notification_rules")
                properties.set_prop("linkedOperationRules", AAZListType, ".linked_operation_rules")
                properties.set_prop("loggingRules", AAZListType, ".logging_rules")
                properties.set_prop("managedResourceGroupConfiguration", AAZObjectType, ".managed_resource_group_configuration")
                properties.set_prop("management", AAZObjectType, ".management")
                properties.set_prop("manifestLink", AAZStrType, ".manifest_link")
                properties.set_prop("marketplaceOptions", AAZObjectType, ".marketplace_options")
                properties.set_prop("marketplaceType", AAZStrType, ".marketplace_type")
                properties.set_prop("metadata", AAZDictType, ".metadata")
                properties.set_prop("notifications", AAZListType, ".notifications")
                properties.set_prop("onBehalfOfTokens", AAZObjectType, ".on_behalf_of_tokens")
                properties.set_prop("openApiConfiguration", AAZObjectType, ".open_api_configuration")
                properties.set_prop("policyExecutionType", AAZStrType, ".policy_execution_type")
                properties.set_prop("privateEndpointConfiguration", AAZObjectType, ".private_endpoint_configuration")
                properties.set_prop("quotaRule", AAZObjectType, ".quota_rule")
                properties.set_prop("regionality", AAZStrType, ".regionality")
                properties.set_prop("requestHeaderOptions", AAZObjectType)
                properties.set_prop("requiredFeatures", AAZListType, ".required_features")
                properties.set_prop("resourceCache", AAZObjectType, ".resource_cache")
                properties.set_prop("resourceConcurrencyControlOptions", AAZDictType, ".resource_concurrency_control_options")
                properties.set_prop("resourceDeletionPolicy", AAZStrType, ".resource_deletion_policy")
                properties.set_prop("resourceGraphConfiguration", AAZObjectType, ".resource_graph_configuration")
                properties.set_prop("resourceManagementOptions", AAZObjectType, ".resource_management_options")
                properties.set_prop("resourceMovePolicy", AAZObjectType, ".resource_move_policy")
                properties.set_prop("resourceProviderAuthorizationRules", AAZObjectType, ".resource_provider_authorization_rules")
                properties.set_prop("resourceQueryManagement", AAZObjectType, ".resource_query_management")
                properties.set_prop("resourceSubType", AAZStrType, ".resource_sub_type")
                properties.set_prop("resourceTypeCommonAttributeManagement", AAZObjectType, ".resource_type_common_attribute_management")
                properties.set_prop("resourceValidation", AAZStrType, ".resource_validation")
                properties.set_prop("routingRule", AAZObjectType, ".routing_rule")
                properties.set_prop("routingType", AAZStrType, ".routing_type")
                properties.set_prop("serviceTreeInfos", AAZListType, ".service_tree_infos")
                properties.set_prop("skuLink", AAZStrType, ".sku_link")
                properties.set_prop("subscriptionLifecycleNotificationSpecifications", AAZObjectType)
                properties.set_prop("subscriptionStateRules", AAZListType, ".subscription_state_rules")
                properties.set_prop("supportsTags", AAZBoolType, ".supports_tags")
                properties.set_prop("swaggerSpecifications", AAZListType, ".swagger_specifications")
                properties.set_prop("templateDeploymentOptions", AAZObjectType, ".template_deployment_options")
                properties.set_prop("templateDeploymentPolicy", AAZObjectType, ".template_deployment_policy")
                properties.set_prop("throttlingRules", AAZListType, ".throttling_rules")
                _UpdateHelper._build_schema_token_auth_configuration_update(properties.set_prop("tokenAuthConfiguration", AAZObjectType, ".token_auth_configuration"))

            allowed_resource_names = _builder.get(".properties.allowedResourceNames")
            if allowed_resource_names is not None:
                allowed_resource_names.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.allowedResourceNames[]")
            if _elements is not None:
                _elements.set_prop("getActionVerb", AAZStrType, ".get_action_verb")
                _elements.set_prop("name", AAZStrType, ".name")

            allowed_template_deployment_reference_actions = _builder.get(".properties.allowedTemplateDeploymentReferenceActions")
            if allowed_template_deployment_reference_actions is not None:
                allowed_template_deployment_reference_actions.set_elements(AAZStrType, ".")

            allowed_unauthorized_actions = _builder.get(".properties.allowedUnauthorizedActions")
            if allowed_unauthorized_actions is not None:
                allowed_unauthorized_actions.set_elements(AAZStrType, ".")

            api_profiles = _builder.get(".properties.apiProfiles")
            if api_profiles is not None:
                api_profiles.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.apiProfiles[]")
            if _elements is not None:
                _elements.set_prop("apiVersion", AAZStrType, ".api_version")
                _elements.set_prop("profileVersion", AAZStrType, ".profile_version")

            async_timeout_rules = _builder.get(".properties.asyncTimeoutRules")
            if async_timeout_rules is not None:
                async_timeout_rules.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.asyncTimeoutRules[]")
            if _elements is not None:
                _elements.set_prop("actionName", AAZStrType, ".action_name")
                _elements.set_prop("timeout", AAZStrType, ".timeout")

            authorization_action_mappings = _builder.get(".properties.authorizationActionMappings")
            if authorization_action_mappings is not None:
                authorization_action_mappings.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.authorizationActionMappings[]")
            if _elements is not None:
                _elements.set_prop("desired", AAZStrType, ".desired")
                _elements.set_prop("original", AAZStrType, ".original")

            availability_zone_rule = _builder.get(".properties.availabilityZoneRule")
            if availability_zone_rule is not None:
                availability_zone_rule.set_prop("availabilityZonePolicy", AAZStrType, ".availability_zone_policy")

            capacity_rule = _builder.get(".properties.capacityRule")
            if capacity_rule is not None:
                capacity_rule.set_prop("capacityPolicy", AAZStrType, ".capacity_policy")
                capacity_rule.set_prop("skuAlias", AAZStrType, ".sku_alias")

            check_name_availability_specifications = _builder.get(".properties.checkNameAvailabilitySpecifications")
            if check_name_availability_specifications is not None:
                check_name_availability_specifications.set_prop("enableDefaultValidation", AAZBoolType, ".enable_default_validation")
                check_name_availability_specifications.set_prop("resourceTypesWithCustomValidation", AAZListType, ".resource_types_with_custom_validation")

            resource_types_with_custom_validation = _builder.get(".properties.checkNameAvailabilitySpecifications.resourceTypesWithCustomValidation")
            if resource_types_with_custom_validation is not None:
                resource_types_with_custom_validation.set_elements(AAZStrType, ".")

            common_api_versions = _builder.get(".properties.commonApiVersions")
            if common_api_versions is not None:
                common_api_versions.set_elements(AAZStrType, ".")

            disallowed_action_verbs = _builder.get(".properties.disallowedActionVerbs")
            if disallowed_action_verbs is not None:
                disallowed_action_verbs.set_elements(AAZStrType, ".")

            disallowed_end_user_operations = _builder.get(".properties.disallowedEndUserOperations")
            if disallowed_end_user_operations is not None:
                disallowed_end_user_operations.set_elements(AAZStrType, ".")

            dsts_configuration = _builder.get(".properties.dstsConfiguration")
            if dsts_configuration is not None:
                dsts_configuration.set_prop("serviceDnsName", AAZStrType, ".service_dns_name")
                dsts_configuration.set_prop("serviceName", AAZStrType, ".service_name", typ_kwargs={"flags": {"required": True}})

            endpoints = _builder.get(".properties.endpoints")
            if endpoints is not None:
                endpoints.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.endpoints[]")
            if _elements is not None:
                _elements.set_prop("apiVersion", AAZStrType, ".api_version")
                _elements.set_prop("apiVersions", AAZListType, ".api_versions")
                _elements.set_prop("dataBoundary", AAZStrType, ".data_boundary")
                _elements.set_prop("dstsConfiguration", AAZObjectType, ".dsts_configuration")
                _elements.set_prop("enabled", AAZBoolType, ".enabled")
                _elements.set_prop("endpointType", AAZStrType, ".endpoint_type")
                _elements.set_prop("endpointUri", AAZStrType, ".endpoint_uri")
                _elements.set_prop("extensions", AAZListType, ".extensions")
                _elements.set_prop("featuresRule", AAZObjectType, ".features_rule")
                _elements.set_prop("kind", AAZStrType, ".kind")
                _elements.set_prop("locations", AAZListType, ".locations")
                _elements.set_prop("requiredFeatures", AAZListType, ".required_features")
                _elements.set_prop("skuLink", AAZStrType, ".sku_link")
                _elements.set_prop("timeout", AAZStrType, ".timeout")
                _UpdateHelper._build_schema_token_auth_configuration_update(_elements.set_prop("tokenAuthConfiguration", AAZObjectType, ".token_auth_configuration"))
                _elements.set_prop("zones", AAZListType, ".zones")

            api_versions = _builder.get(".properties.endpoints[].apiVersions")
            if api_versions is not None:
                api_versions.set_elements(AAZStrType, ".")

            dsts_configuration = _builder.get(".properties.endpoints[].dstsConfiguration")
            if dsts_configuration is not None:
                dsts_configuration.set_prop("serviceDnsName", AAZStrType, ".service_dns_name")
                dsts_configuration.set_prop("serviceName", AAZStrType, ".service_name", typ_kwargs={"flags": {"required": True}})

            extensions = _builder.get(".properties.endpoints[].extensions")
            if extensions is not None:
                extensions.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.endpoints[].extensions[]")
            if _elements is not None:
                _elements.set_prop("endpointUri", AAZStrType, ".endpoint_uri")
                _elements.set_prop("extensionCategories", AAZListType, ".extension_categories")
                _elements.set_prop("timeout", AAZStrType, ".timeout")

            extension_categories = _builder.get(".properties.endpoints[].extensions[].extensionCategories")
            if extension_categories is not None:
                extension_categories.set_elements(AAZStrType, ".")

            features_rule = _builder.get(".properties.endpoints[].featuresRule")
            if features_rule is not None:
                features_rule.set_prop("requiredFeaturesPolicy", AAZStrType, ".required_features_policy", typ_kwargs={"flags": {"required": True}})

            locations = _builder.get(".properties.endpoints[].locations")
            if locations is not None:
                locations.set_elements(AAZStrType, ".")

            required_features = _builder.get(".properties.endpoints[].requiredFeatures")
            if required_features is not None:
                required_features.set_elements(AAZStrType, ".")

            zones = _builder.get(".properties.endpoints[].zones")
            if zones is not None:
                zones.set_elements(AAZStrType, ".")

            extended_locations = _builder.get(".properties.extendedLocations")
            if extended_locations is not None:
                extended_locations.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.extendedLocations[]")
            if _elements is not None:
                _elements.set_prop("supportedPolicy", AAZStrType, ".supported_policy")
                _elements.set_prop("type", AAZStrType, ".type")

            extension_options = _builder.get(".properties.extensionOptions")
            if extension_options is not None:
                extension_options.set_prop("resourceCreationBegin", AAZObjectType, ".resource_creation_begin")

            resource_creation_begin = _builder.get(".properties.extensionOptions.resourceCreationBegin")
            if resource_creation_begin is not None:
                resource_creation_begin.set_prop("request", AAZListType, ".request")
                resource_creation_begin.set_prop("response", AAZListType, ".response")

            request = _builder.get(".properties.extensionOptions.resourceCreationBegin.request")
            if request is not None:
                request.set_elements(AAZStrType, ".")

            response = _builder.get(".properties.extensionOptions.resourceCreationBegin.response")
            if response is not None:
                response.set_elements(AAZStrType, ".")

            features_rule = _builder.get(".properties.featuresRule")
            if features_rule is not None:
                features_rule.set_prop("requiredFeaturesPolicy", AAZStrType, ".required_features_policy", typ_kwargs={"flags": {"required": True}})

            identity_management = _builder.get(".properties.identityManagement")
            if identity_management is not None:
                identity_management.set_prop("applicationId", AAZStrType, ".application_id")
                identity_management.set_prop("applicationIds", AAZListType, ".application_ids")
                identity_management.set_prop("delegationAppIds", AAZListType, ".delegation_app_ids")
                identity_management.set_prop("type", AAZStrType, ".type")

            application_ids = _builder.get(".properties.identityManagement.applicationIds")
            if application_ids is not None:
                application_ids.set_elements(AAZStrType, ".")

            delegation_app_ids = _builder.get(".properties.identityManagement.delegationAppIds")
            if delegation_app_ids is not None:
                delegation_app_ids.set_elements(AAZStrType, ".")

            legacy_names = _builder.get(".properties.legacyNames")
            if legacy_names is not None:
                legacy_names.set_elements(AAZStrType, ".")

            legacy_policy = _builder.get(".properties.legacyPolicy")
            if legacy_policy is not None:
                legacy_policy.set_prop("disallowedConditions", AAZListType, ".disallowed_conditions")
                legacy_policy.set_prop("disallowedLegacyOperations", AAZListType, ".disallowed_legacy_operations")

            disallowed_conditions = _builder.get(".properties.legacyPolicy.disallowedConditions")
            if disallowed_conditions is not None:
                disallowed_conditions.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.legacyPolicy.disallowedConditions[]")
            if _elements is not None:
                _elements.set_prop("disallowedLegacyOperations", AAZListType, ".disallowed_legacy_operations")
                _elements.set_prop("feature", AAZStrType, ".feature")

            disallowed_legacy_operations = _builder.get(".properties.legacyPolicy.disallowedConditions[].disallowedLegacyOperations")
            if disallowed_legacy_operations is not None:
                disallowed_legacy_operations.set_elements(AAZStrType, ".")

            disallowed_legacy_operations = _builder.get(".properties.legacyPolicy.disallowedLegacyOperations")
            if disallowed_legacy_operations is not None:
                disallowed_legacy_operations.set_elements(AAZStrType, ".")

            linked_access_checks = _builder.get(".properties.linkedAccessChecks")
            if linked_access_checks is not None:
                linked_access_checks.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.linkedAccessChecks[]")
            if _elements is not None:
                _elements.set_prop("actionName", AAZStrType, ".action_name")
                _elements.set_prop("linkedAction", AAZStrType, ".linked_action")
                _elements.set_prop("linkedActionVerb", AAZStrType, ".linked_action_verb")
                _elements.set_prop("linkedProperty", AAZStrType, ".linked_property")
                _elements.set_prop("linkedType", AAZStrType, ".linked_type")

            linked_notification_rules = _builder.get(".properties.linkedNotificationRules")
            if linked_notification_rules is not None:
                linked_notification_rules.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.linkedNotificationRules[]")
            if _elements is not None:
                _elements.set_prop("actions", AAZListType, ".actions")
                _elements.set_prop("actionsOnFailedOperation", AAZListType, ".actions_on_failed_operation")
                _elements.set_prop("fastPathActions", AAZListType, ".fast_path_actions")
                _elements.set_prop("fastPathActionsOnFailedOperation", AAZListType, ".fast_path_actions_on_failed_operation")
                _elements.set_prop("linkedNotificationTimeout", AAZStrType, ".linked_notification_timeout")

            actions = _builder.get(".properties.linkedNotificationRules[].actions")
            if actions is not None:
                actions.set_elements(AAZStrType, ".")

            actions_on_failed_operation = _builder.get(".properties.linkedNotificationRules[].actionsOnFailedOperation")
            if actions_on_failed_operation is not None:
                actions_on_failed_operation.set_elements(AAZStrType, ".")

            fast_path_actions = _builder.get(".properties.linkedNotificationRules[].fastPathActions")
            if fast_path_actions is not None:
                fast_path_actions.set_elements(AAZStrType, ".")

            fast_path_actions_on_failed_operation = _builder.get(".properties.linkedNotificationRules[].fastPathActionsOnFailedOperation")
            if fast_path_actions_on_failed_operation is not None:
                fast_path_actions_on_failed_operation.set_elements(AAZStrType, ".")

            linked_operation_rules = _builder.get(".properties.linkedOperationRules")
            if linked_operation_rules is not None:
                linked_operation_rules.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.linkedOperationRules[]")
            if _elements is not None:
                _elements.set_prop("dependsOnTypes", AAZListType, ".depends_on_types")
                _elements.set_prop("linkedAction", AAZStrType, ".linked_action", typ_kwargs={"flags": {"required": True}})
                _elements.set_prop("linkedOperation", AAZStrType, ".linked_operation", typ_kwargs={"flags": {"required": True}})

            depends_on_types = _builder.get(".properties.linkedOperationRules[].dependsOnTypes")
            if depends_on_types is not None:
                depends_on_types.set_elements(AAZStrType, ".")

            logging_rules = _builder.get(".properties.loggingRules")
            if logging_rules is not None:
                logging_rules.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.loggingRules[]")
            if _elements is not None:
                _elements.set_prop("action", AAZStrType, ".action", typ_kwargs={"flags": {"required": True}})
                _elements.set_prop("detailLevel", AAZStrType, ".detail_level", typ_kwargs={"flags": {"required": True}})
                _elements.set_prop("direction", AAZStrType, ".direction", typ_kwargs={"flags": {"required": True}})
                _elements.set_prop("hiddenPropertyPaths", AAZObjectType, ".hidden_property_paths")

            hidden_property_paths = _builder.get(".properties.loggingRules[].hiddenPropertyPaths")
            if hidden_property_paths is not None:
                hidden_property_paths.set_prop("hiddenPathsOnRequest", AAZListType, ".hidden_paths_on_request")
                hidden_property_paths.set_prop("hiddenPathsOnResponse", AAZListType, ".hidden_paths_on_response")

            hidden_paths_on_request = _builder.get(".properties.loggingRules[].hiddenPropertyPaths.hiddenPathsOnRequest")
            if hidden_paths_on_request is not None:
                hidden_paths_on_request.set_elements(AAZStrType, ".")

            hidden_paths_on_response = _builder.get(".properties.loggingRules[].hiddenPropertyPaths.hiddenPathsOnResponse")
            if hidden_paths_on_response is not None:
                hidden_paths_on_response.set_elements(AAZStrType, ".")

            managed_resource_group_configuration = _builder.get(".properties.managedResourceGroupConfiguration")
            if managed_resource_group_configuration is not None:
                managed_resource_group_configuration.set_prop("applicationIds", AAZListType, ".application_ids")
                managed_resource_group_configuration.set_prop("denyAssignmentConfiguration", AAZObjectType, ".deny_assignment_configuration")
                managed_resource_group_configuration.set_prop("enabled", AAZBoolType, ".enabled")
                managed_resource_group_configuration.set_prop("resourceGroupLocationOverride", AAZStrType, ".resource_group_location_override")

            application_ids = _builder.get(".properties.managedResourceGroupConfiguration.applicationIds")
            if application_ids is not None:
                application_ids.set_elements(AAZStrType, ".")

            deny_assignment_configuration = _builder.get(".properties.managedResourceGroupConfiguration.denyAssignmentConfiguration")
            if deny_assignment_configuration is not None:
                deny_assignment_configuration.set_prop("enabled", AAZBoolType, ".enabled")
                deny_assignment_configuration.set_prop("notActions", AAZListType, ".not_actions")

            not_actions = _builder.get(".properties.managedResourceGroupConfiguration.denyAssignmentConfiguration.notActions")
            if not_actions is not None:
                not_actions.set_elements(AAZStrType, ".")

            management = _builder.get(".properties.management")
            if management is not None:
                management.set_prop("authorizationOwners", AAZListType, ".authorization_owners")
                management.set_prop("canaryManifestOwners", AAZListType, ".canary_manifest_owners")
                management.set_prop("errorResponseMessageOptions", AAZObjectType, ".error_response_message_options")
                management.set_prop("expeditedRolloutMetadata", AAZObjectType, ".expedited_rollout_metadata")
                management.set_prop("expeditedRolloutSubmitters", AAZListType, ".expedited_rollout_submitters")
                management.set_prop("incidentContactEmail", AAZStrType, ".incident_contact_email")
                management.set_prop("incidentRoutingService", AAZStrType, ".incident_routing_service")
                management.set_prop("incidentRoutingTeam", AAZStrType, ".incident_routing_team")
                management.set_prop("manifestOwners", AAZListType, ".manifest_owners")
                management.set_prop("pcCode", AAZStrType, ".pc_code")
                management.set_prop("profitCenterProgramId", AAZStrType, ".profit_center_program_id")
                management.set_prop("resourceAccessPolicy", AAZStrType, ".resource_access_policy")
                management.set_prop("resourceAccessRoles", AAZListType, ".resource_access_roles")
                management.set_prop("schemaOwners", AAZListType, ".schema_owners")
                management.set_prop("serviceTreeInfos", AAZListType, ".service_tree_infos")

            authorization_owners = _builder.get(".properties.management.authorizationOwners")
            if authorization_owners is not None:
                authorization_owners.set_elements(AAZStrType, ".")

            canary_manifest_owners = _builder.get(".properties.management.canaryManifestOwners")
            if canary_manifest_owners is not None:
                canary_manifest_owners.set_elements(AAZStrType, ".")

            error_response_message_options = _builder.get(".properties.management.errorResponseMessageOptions")
            if error_response_message_options is not None:
                error_response_message_options.set_prop("serverFailureResponseMessageType", AAZStrType, ".server_failure_response_message_type")

            expedited_rollout_metadata = _builder.get(".properties.management.expeditedRolloutMetadata")
            if expedited_rollout_metadata is not None:
                expedited_rollout_metadata.set_prop("enabled", AAZBoolType, ".enabled")
                expedited_rollout_metadata.set_prop("expeditedRolloutIntent", AAZStrType, ".expedited_rollout_intent")

            expedited_rollout_submitters = _builder.get(".properties.management.expeditedRolloutSubmitters")
            if expedited_rollout_submitters is not None:
                expedited_rollout_submitters.set_elements(AAZStrType, ".")

            manifest_owners = _builder.get(".properties.management.manifestOwners")
            if manifest_owners is not None:
                manifest_owners.set_elements(AAZStrType, ".")

            resource_access_roles = _builder.get(".properties.management.resourceAccessRoles")
            if resource_access_roles is not None:
                resource_access_roles.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.management.resourceAccessRoles[]")
            if _elements is not None:
                _elements.set_prop("actions", AAZListType, ".actions")
                _elements.set_prop("allowedGroupClaims", AAZListType, ".allowed_group_claims")

            actions = _builder.get(".properties.management.resourceAccessRoles[].actions")
            if actions is not None:
                actions.set_elements(AAZStrType, ".")

            allowed_group_claims = _builder.get(".properties.management.resourceAccessRoles[].allowedGroupClaims")
            if allowed_group_claims is not None:
                allowed_group_claims.set_elements(AAZStrType, ".")

            schema_owners = _builder.get(".properties.management.schemaOwners")
            if schema_owners is not None:
                schema_owners.set_elements(AAZStrType, ".")

            service_tree_infos = _builder.get(".properties.management.serviceTreeInfos")
            if service_tree_infos is not None:
                _UpdateHelper._build_schema_service_tree_info_update(service_tree_infos.set_elements(AAZObjectType, "."))

            marketplace_options = _builder.get(".properties.marketplaceOptions")
            if marketplace_options is not None:
                marketplace_options.set_prop("addOnPlanConversionAllowed", AAZBoolType, ".add_on_plan_conversion_allowed")

            metadata = _builder.get(".properties.metadata")
            if metadata is not None:
                metadata.set_elements(AAZFreeFormDictType, ".")

            _elements = _builder.get(".properties.metadata{}")
            if _elements is not None:
                _elements.set_anytype_elements(".")

            notifications = _builder.get(".properties.notifications")
            if notifications is not None:
                notifications.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.notifications[]")
            if _elements is not None:
                _elements.set_prop("notificationType", AAZStrType, ".notification_type")
                _elements.set_prop("skipNotifications", AAZStrType, ".skip_notifications")

            on_behalf_of_tokens = _builder.get(".properties.onBehalfOfTokens")
            if on_behalf_of_tokens is not None:
                on_behalf_of_tokens.set_prop("actionName", AAZStrType, ".action_name")
                on_behalf_of_tokens.set_prop("lifeTime", AAZStrType, ".life_time")

            open_api_configuration = _builder.get(".properties.openApiConfiguration")
            if open_api_configuration is not None:
                open_api_configuration.set_prop("validation", AAZObjectType, ".validation")

            validation = _builder.get(".properties.openApiConfiguration.validation")
            if validation is not None:
                validation.set_prop("allowNoncompliantCollectionResponse", AAZBoolType, ".allow_noncompliant_collection_response")

            private_endpoint_configuration = _builder.get(".properties.privateEndpointConfiguration")
            if private_endpoint_configuration is not None:
                private_endpoint_configuration.set_prop("groupConnectivityInformation", AAZListType, ".group_connectivity_information", typ_kwargs={"flags": {"required": True}})
                private_endpoint_configuration.set_prop("minApiVersion", AAZStrType, ".min_api_version", typ_kwargs={"flags": {"required": True}})

            group_connectivity_information = _builder.get(".properties.privateEndpointConfiguration.groupConnectivityInformation")
            if group_connectivity_information is not None:
                group_connectivity_information.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.privateEndpointConfiguration.groupConnectivityInformation[]")
            if _elements is not None:
                _elements.set_prop("groupId", AAZStrType, ".group_id", typ_kwargs={"flags": {"required": True}})
                _elements.set_prop("redirectMapId", AAZStrType, ".redirect_map_id")
                _elements.set_prop("requiredMembers", AAZListType, ".required_members", typ_kwargs={"flags": {"required": True}})
                _elements.set_prop("requiredZoneNames", AAZListType, ".required_zone_names", typ_kwargs={"flags": {"required": True}})

            required_members = _builder.get(".properties.privateEndpointConfiguration.groupConnectivityInformation[].requiredMembers")
            if required_members is not None:
                required_members.set_elements(AAZStrType, ".")

            required_zone_names = _builder.get(".properties.privateEndpointConfiguration.groupConnectivityInformation[].requiredZoneNames")
            if required_zone_names is not None:
                required_zone_names.set_elements(AAZStrType, ".")

            quota_rule = _builder.get(".properties.quotaRule")
            if quota_rule is not None:
                quota_rule.set_prop("locationRules", AAZListType, ".location_rules")
                quota_rule.set_prop("quotaPolicy", AAZStrType, ".quota_policy")
                quota_rule.set_prop("requiredFeatures", AAZListType, ".required_features")

            location_rules = _builder.get(".properties.quotaRule.locationRules")
            if location_rules is not None:
                location_rules.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.quotaRule.locationRules[]")
            if _elements is not None:
                _elements.set_prop("location", AAZStrType, ".location")
                _elements.set_prop("policy", AAZStrType, ".policy")
                _elements.set_prop("quotaId", AAZStrType, ".quota_id")

            required_features = _builder.get(".properties.quotaRule.requiredFeatures")
            if required_features is not None:
                required_features.set_elements(AAZStrType, ".")

            request_header_options = _builder.get(".properties.requestHeaderOptions")
            if request_header_options is not None:
                request_header_options.set_prop("optInHeaders", AAZStrType, ".opt_in_headers")
                request_header_options.set_prop("optOutHeaders", AAZStrType, ".opt_out_headers")

            required_features = _builder.get(".properties.requiredFeatures")
            if required_features is not None:
                required_features.set_elements(AAZStrType, ".")

            resource_cache = _builder.get(".properties.resourceCache")
            if resource_cache is not None:
                resource_cache.set_prop("enableResourceCache", AAZBoolType, ".enable_resource_cache")
                resource_cache.set_prop("resourceCacheExpirationTimespan", AAZStrType, ".resource_cache_expiration_timespan")

            resource_concurrency_control_options = _builder.get(".properties.resourceConcurrencyControlOptions")
            if resource_concurrency_control_options is not None:
                resource_concurrency_control_options.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.resourceConcurrencyControlOptions{}")
            if _elements is not None:
                _elements.set_prop("policy", AAZStrType, ".policy")

            resource_graph_configuration = _builder.get(".properties.resourceGraphConfiguration")
            if resource_graph_configuration is not None:
                resource_graph_configuration.set_prop("apiVersion", AAZStrType, ".api_version")
                resource_graph_configuration.set_prop("enabled", AAZBoolType, ".enabled")

            resource_management_options = _builder.get(".properties.resourceManagementOptions")
            if resource_management_options is not None:
                resource_management_options.set_prop("batchProvisioningSupport", AAZObjectType, ".batch_provisioning_support")
                resource_management_options.set_prop("deleteDependencies", AAZListType, ".delete_dependencies")
                resource_management_options.set_prop("nestedProvisioningSupport", AAZObjectType, ".nested_provisioning_support")

            batch_provisioning_support = _builder.get(".properties.resourceManagementOptions.batchProvisioningSupport")
            if batch_provisioning_support is not None:
                batch_provisioning_support.set_prop("supportedOperations", AAZStrType, ".supported_operations")

            delete_dependencies = _builder.get(".properties.resourceManagementOptions.deleteDependencies")
            if delete_dependencies is not None:
                delete_dependencies.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.resourceManagementOptions.deleteDependencies[]")
            if _elements is not None:
                _elements.set_prop("linkedProperty", AAZStrType, ".linked_property")
                _elements.set_prop("linkedType", AAZStrType, ".linked_type")
                _elements.set_prop("requiredFeatures", AAZListType, ".required_features")

            required_features = _builder.get(".properties.resourceManagementOptions.deleteDependencies[].requiredFeatures")
            if required_features is not None:
                required_features.set_elements(AAZStrType, ".")

            nested_provisioning_support = _builder.get(".properties.resourceManagementOptions.nestedProvisioningSupport")
            if nested_provisioning_support is not None:
                nested_provisioning_support.set_prop("minimumApiVersion", AAZStrType, ".minimum_api_version")

            resource_move_policy = _builder.get(".properties.resourceMovePolicy")
            if resource_move_policy is not None:
                resource_move_policy.set_prop("crossResourceGroupMoveEnabled", AAZBoolType, ".cross_resource_group_move_enabled")
                resource_move_policy.set_prop("crossSubscriptionMoveEnabled", AAZBoolType, ".cross_subscription_move_enabled")
                resource_move_policy.set_prop("validationRequired", AAZBoolType, ".validation_required")

            resource_provider_authorization_rules = _builder.get(".properties.resourceProviderAuthorizationRules")
            if resource_provider_authorization_rules is not None:
                resource_provider_authorization_rules.set_prop("asyncOperationPollingRules", AAZObjectType, ".async_operation_polling_rules")

            async_operation_polling_rules = _builder.get(".properties.resourceProviderAuthorizationRules.asyncOperationPollingRules")
            if async_operation_polling_rules is not None:
                async_operation_polling_rules.set_prop("additionalOptions", AAZStrType, ".additional_options")
                async_operation_polling_rules.set_prop("authorizationActions", AAZListType, ".authorization_actions")

            authorization_actions = _builder.get(".properties.resourceProviderAuthorizationRules.asyncOperationPollingRules.authorizationActions")
            if authorization_actions is not None:
                authorization_actions.set_elements(AAZStrType, ".")

            resource_query_management = _builder.get(".properties.resourceQueryManagement")
            if resource_query_management is not None:
                resource_query_management.set_prop("filterOption", AAZStrType, ".filter_option")

            resource_type_common_attribute_management = _builder.get(".properties.resourceTypeCommonAttributeManagement")
            if resource_type_common_attribute_management is not None:
                resource_type_common_attribute_management.set_prop("commonApiVersionsMergeMode", AAZStrType, ".common_api_versions_merge_mode")

            routing_rule = _builder.get(".properties.routingRule")
            if routing_rule is not None:
                routing_rule.set_prop("hostResourceType", AAZStrType, ".host_resource_type")

            service_tree_infos = _builder.get(".properties.serviceTreeInfos")
            if service_tree_infos is not None:
                _UpdateHelper._build_schema_service_tree_info_update(service_tree_infos.set_elements(AAZObjectType, "."))

            subscription_lifecycle_notification_specifications = _builder.get(".properties.subscriptionLifecycleNotificationSpecifications")
            if subscription_lifecycle_notification_specifications is not None:
                subscription_lifecycle_notification_specifications.set_prop("softDeleteTTL", AAZStrType, ".soft_delete_ttl")
                subscription_lifecycle_notification_specifications.set_prop("subscriptionStateOverrideActions", AAZListType, ".subscription_state_override_actions")

            subscription_state_override_actions = _builder.get(".properties.subscriptionLifecycleNotificationSpecifications.subscriptionStateOverrideActions")
            if subscription_state_override_actions is not None:
                subscription_state_override_actions.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.subscriptionLifecycleNotificationSpecifications.subscriptionStateOverrideActions[]")
            if _elements is not None:
                _elements.set_prop("action", AAZStrType, ".action", typ_kwargs={"flags": {"required": True}})
                _elements.set_prop("state", AAZStrType, ".state", typ_kwargs={"flags": {"required": True}})

            subscription_state_rules = _builder.get(".properties.subscriptionStateRules")
            if subscription_state_rules is not None:
                subscription_state_rules.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.subscriptionStateRules[]")
            if _elements is not None:
                _elements.set_prop("allowedActions", AAZListType, ".allowed_actions")
                _elements.set_prop("state", AAZStrType, ".state")

            allowed_actions = _builder.get(".properties.subscriptionStateRules[].allowedActions")
            if allowed_actions is not None:
                allowed_actions.set_elements(AAZStrType, ".")

            swagger_specifications = _builder.get(".properties.swaggerSpecifications")
            if swagger_specifications is not None:
                swagger_specifications.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.swaggerSpecifications[]")
            if _elements is not None:
                _elements.set_prop("apiVersions", AAZListType, ".api_versions")
                _elements.set_prop("swaggerSpecFolderUri", AAZStrType, ".swagger_spec_folder_uri")

            api_versions = _builder.get(".properties.swaggerSpecifications[].apiVersions")
            if api_versions is not None:
                api_versions.set_elements(AAZStrType, ".")

            template_deployment_options = _builder.get(".properties.templateDeploymentOptions")
            if template_deployment_options is not None:
                template_deployment_options.set_prop("preflightOptions", AAZListType, ".preflight_options")
                template_deployment_options.set_prop("preflightSupported", AAZBoolType, ".preflight_supported")

            preflight_options = _builder.get(".properties.templateDeploymentOptions.preflightOptions")
            if preflight_options is not None:
                preflight_options.set_elements(AAZStrType, ".")

            template_deployment_policy = _builder.get(".properties.templateDeploymentPolicy")
            if template_deployment_policy is not None:
                template_deployment_policy.set_prop("capabilities", AAZStrType, ".capabilities", typ_kwargs={"flags": {"required": True}})
                template_deployment_policy.set_prop("preflightNotifications", AAZStrType, ".preflight_notifications")
                template_deployment_policy.set_prop("preflightOptions", AAZStrType, ".preflight_options", typ_kwargs={"flags": {"required": True}})

            throttling_rules = _builder.get(".properties.throttlingRules")
            if throttling_rules is not None:
                throttling_rules.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.throttlingRules[]")
            if _elements is not None:
                _elements.set_prop("action", AAZStrType, ".action", typ_kwargs={"flags": {"required": True}})
                _elements.set_prop("applicationId", AAZListType, ".application_id")
                _elements.set_prop("metrics", AAZListType, ".metrics", typ_kwargs={"flags": {"required": True}})
                _elements.set_prop("requiredFeatures", AAZListType, ".required_features")

            application_id = _builder.get(".properties.throttlingRules[].applicationId")
            if application_id is not None:
                application_id.set_elements(AAZStrType, ".")

            metrics = _builder.get(".properties.throttlingRules[].metrics")
            if metrics is not None:
                metrics.set_elements(AAZObjectType, ".")

            _elements = _builder.get(".properties.throttlingRules[].metrics[]")
            if _elements is not None:
                _elements.set_prop("interval", AAZStrType, ".interval")
                _elements.set_prop("limit", AAZIntType, ".limit", typ_kwargs={"flags": {"required": True}})
                _elements.set_prop("type", AAZStrType, ".type", typ_kwargs={"flags": {"required": True}})

            required_features = _builder.get(".properties.throttlingRules[].requiredFeatures")
            if required_features is not None:
                required_features.set_elements(AAZStrType, ".")

            return _instance_value