return nil, errors.New("failed to set up idevicedebugserverproxy")
}

// findDeviceAppPath returns the device path to the app with the
// given bundle ID. It parses the output of ideviceinstaller -l -o xml,
// looking for the bundle ID and the corresponding Path value.
func findDeviceAppPath(bundleID string) (string, error) {
	cmd := idevCmd(exec.Command("ideviceinstaller", "-l", "-o", "xml"))
	out, err := cmd.CombinedOutput()
	if err != nil {

)

// WebhookCertPatcher listens for webhooks on specified revision and patches their CA bundles
type WebhookCertPatcher struct {
	// revision to patch webhooks for
	revision    string
	webhookName string

	queue controllers.Queue

	// File path to the x509 certificate bundle used by the webhook server
	// and patched into the webhook config.
	CABundleWatcher *keycertbundle.Watcher

    val repositoryPlugin = getRepository(REPO_NAME)

    // Deploy the bundles in the deployments test directory.
    repositoryPlugin.deployDirectory(testResourceDir / "deployments")
    repositoryPlugin.deployClassPath()
  }

  private fun createBndRun(workspace: Workspace): Bndrun {
    // Creating the run require string. It will always use the latest version of each bundle
    // available in the repository.
    val runRequireString =

[[sec:dependency-bundles]]
==== Dependency bundles

Because it's frequent that some dependencies are systematically used together in different projects, a version catalog offers the concept of a "dependency bundle".
A bundle is basically an alias for several dependencies.

        if (aliases.isEmpty()) {
            return;
        }
        writeTableHeader("bundles");
        for (String alias : aliases) {
            List<String> bundle = model.getBundle(alias).getComponents();
            writeLn(normalizeForToml(alias) + " = [" + bundle.stream()
                .map(TomlWriter::normalizeForToml)
                .map(TomlWriter::quoted)

    MLIRImportOptions options,
    std::unique_ptr<tensorflow::SavedModelBundle>* saved_model_bundle) {
  // Create local bundle if no one is provided to use.
  std::unique_ptr<tensorflow::SavedModelBundle> bundle;
  if (saved_model_bundle == nullptr) {
    bundle = std::make_unique<tensorflow::SavedModelBundle>();
  } else if (*saved_model_bundle == nullptr) {

                implementation("org.gradle.test:lib-ext") // intentional!
                constraints {
                    implementation(libs.bundles.myBundle)
                    implementation(libs.bundles.myBundle.ext)
                }
            }

            tasks.register<CheckDeps>("checkDeps") {
                files.from(configurations.compileClasspath)

            """${intro}  - Problem: In version catalog ${catalog}, a bundle with name '${bundle}' declares a dependency on '${aliasRef}' which doesn't exist.

    Reason: Bundles can only contain references to existing library aliases.

    Possible solutions:
      1. Make sure that the library alias '${aliasRef}' is declared.
      2. Remove '${aliasRef}' from bundle '${bundle}'.

    ${documentation}"""
        }
    }

* <a href="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js" class="external-link" target="_blank">`swagger-ui-bundle.js`</a>
* <a href="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css" class="external-link" target="_blank">`swagger-ui.css`</a>

And **ReDoc** uses the file:

* <a href="https://cdn.jsdelivr.net/npm/redoc@next/bundles/redoc.standalone.js" class="external-link" target="_blank">`redoc.standalone.js`</a>

				Sources: []v1.VolumeProjection{
					{
						ClusterTrustBundle: &v1.ClusterTrustBundleProjection{
							Name: utilptr.String("foo"),
							Path: "bundle.pem",
						},
					},
				},
				DefaultMode: utilptr.Int32(0644),
			},
			bundles: []runtime.Object{
				&certificatesv1alpha1.ClusterTrustBundle{
					ObjectMeta: metav1.ObjectMeta{
						Name: "foo",
					},