for _, endpoint := range etcdEndpoints {
		u, err := xnet.ParseHTTPURL(endpoint)
		if err != nil {
			return nil, false, err
		}
		if etcdSecure && u.Scheme == "http" {
			return nil, false, config.Errorf("all endpoints should be https or http: %s", endpoint)
		}
		// If one of the endpoint is https, we will use https directly.
		etcdSecure = etcdSecure || u.Scheme == "https"
	}

	return etcdEndpoints, etcdSecure, nil

# To get started with Dependabot version updates, you'll need to specify which
# package ecosystems to update and where the package manifests are located.
# Please see the documentation for all configuration options:
# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file

version: 2
updates:
  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:
      interval: "daily"

   *
   * <p>This method is equivalent to {@code fuzzyEquals(a, b, tolerance) ? 0 : Double.compare(a,
   * b)}. In particular, like {@link Double#compare(double, double)}, it treats all NaN values as
   * equal and greater than all other values (including {@link Double#POSITIVE_INFINITY}).
   *
   * <p>This is not a total ordering and is not suitable for use in {@link

        String response = checkGetMethod(searchBody, "").asString();

        final Map<String, Object> res = JsonPath.from(response).getMap("response");

        // Log all available stats fields for debugging
        logger.info("Available stats fields: {}", res.keySet());

        // Verify response contains meaningful data
        assertNotNull(res, "Stats response should not be null");

        // After cleanup, all regions should be released (but the count may not match exactly
        // if some regions were pooled rather than immediately released)
        assertTrue(bufferManager.getTotalReleased() > 0, "Some regions should be released during cleanup");
        assertEquals(allocatedBeforeCleanup, bufferManager.getTotalReleased(),
                "All allocated regions should eventually be released after cleanup");

<div class="screenshot">
<img src="/img/tutorial/separate-openapi-schemas/image03.png">
</div>

### Model for Input and Output in Docs { #model-for-input-and-output-in-docs }

And if you check all the available Schemas (JSON Schemas) in OpenAPI, you will see that there are two, one `Item-Input` and one `Item-Output`.

For `Item-Input`, `description` is **not required**, it doesn't have a red asterisk.

     * git trees at each tag.
     * <p>
     * If the supplied version is the very first in a new major series, then the method will look tag in the previous
     * major series. Otherwise, all git tags in the current major series will be inspected.
     *
     * @param gitWrapper used for git operations
     * @param version the git history is inspected relative to this version

               </NoncurrentVersionExpiration>
       </Rule>
       <Rule>
               <ID>delete-all-versions</ID>
               <Status>Enabled</Status>
               <Filter>
                       <Tag>
                       <Key>del-all</Key>
                       <Value>true</Value>
                       </Tag>
               </Filter>
               <Expiration>

    }

    params {
        param("defaultBranchName", "master")
        param("env.JAVA_HOME", javaHome(BuildToolBuildJvm, Os.LINUX))
    }

    steps {
        gradleWrapper {
            name = "Resolve all dependencies"
            tasks = "resolveAllDependencies"
            gradleParams =
                (
                    buildToolGradleParameters(isContinue = false) + listOf("--dependency-verification", "lenient")

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p4

type Pair[T1 interface{ M() }, T2 ~int] struct {
	f1 T1
	f2 T2
}

func NewPair[T1 interface{ M() }, T2 ~int](v1 T1, v2 T2) Pair[T1, T2] {
	return Pair[T1, T2]{f1: v1, f2: v2}
}

func (p Pair[X1, _]) First() X1 {
	return p.f1
}