*
     * @param pomRepositories The POM repositories to create the artifact repositories from, must not be {@code null}.
     * @param externalRepositories The external (and already mirrored) repositories to merge into the result list, may
     *            be {@code null}.
     * @param request The project building request holding further settings like repository settings, must not be
     *            {@code null}.

		}
	}

	json := jsoniter.ConfigCompatibleWithStandardLibrary
	if err := json.Unmarshal(data, &srvCfg); err != nil {
		return nil, err
	}

	// Add any missing entries
	return srvCfg.Merge(), nil
}

// ConfigSys - config system.
type ConfigSys struct{}

// Init - initializes config system from config.json.
func (sys *ConfigSys) Init(objAPI ObjectLayer) error {
	if objAPI == nil {

            versioning.setLatest(artifact.getBaseVersion());
        }

        metadata.setVersioning(versioning);

        return metadata;
    }

    @Override
    protected void merge(Metadata recessive) {
        Versioning versioning = metadata.getVersioning();
        versioning.setLastUpdatedTimestamp(timestamp);

        if (recessive.getVersioning() != null) {

        run: uv pip install -r requirements-tests.txt
      - name: Get coverage files
        uses: actions/download-artifact@v6
        with:
          pattern: coverage-*
          path: coverage
          merge-multiple: true
      - run: ls -la coverage
      - run: coverage combine coverage
      - run: coverage html --title "Coverage for ${{ github.sha }}"
      - name: Store coverage HTML

		Find(&result).Error

	if err != nil {
		t.Fatalf("failed to preload and find users: %v", err)
	}

	AssertEqual(t, result, users)
	AssertEqual(t, len(query), 2) // Check preload queries are merged

	if !regexp.MustCompile(`SELECT \* FROM .*tools.* WHERE .*IN.*`).MatchString(query[0]) {
		t.Fatalf("Expected first query to preload manager tools, got: %s", query[0])
	}
}

        buffer.append(checksumPolicy);
        buffer.append(", updates=");
        buffer.append(updatePolicy);
        buffer.append('}');
        return buffer.toString();
    }

    public void merge(ArtifactRepositoryPolicy policy) {
        if (policy != null && policy.isEnabled()) {
            setEnabled(true);

//
// If size resp. actualSize is unknown at the time of calling
// NewReader then it should be set to -1.
// When size is >=0 it *must* match the amount of data provided by r.
//
// NewReader may try merge the given size, MD5 and SHA256 values
// into src - if src is a Reader - to avoid computing the same
// checksums multiple times.
// NewReader enforces S3 compatibility strictly by ensuring caller

            XmlNode mojoConfiguration = mojoExecution.getConfiguration() != null
                    ? mojoExecution.getConfiguration().getDom()
                    : null;

            XmlNode mergedConfiguration = XmlService.merge(mojoConfiguration, pomConfiguration);

            mojoExecution.setConfiguration(mergedConfiguration);

            checkUnknownMojoConfigurationParameters(mojoExecution);
        }
    }

                        // MNG-2861: the artifact data has changed. If the available versions where previously
                        // retrieved, we need to update it.
                        // TODO shouldn't the versions be merged across relocations?
                        List<ArtifactVersion> available = artifact.getAvailableVersions();
                        if (available != null && !available.isEmpty()) {

    "DEFAULT": "Default Response",
}


def get_openapi_security_definitions(
    flat_dependant: Dependant,
) -> tuple[dict[str, Any], list[dict[str, Any]]]:
    security_definitions = {}
    # Use a dict to merge scopes for same security scheme
    operation_security_dict: dict[str, list[str]] = {}
    for security_dependency in flat_dependant._security_dependencies:
        security_definition = jsonable_encoder(