},
  "author": "",
  "license": "",
  "devDependencies": {
    "@hey-api/openapi-ts": "^0.27.38",
    "typescript": "^4.6.2"
  }
}
```

After having that NPM `generate-client` script there, you can run it with:

<div class="termy">

```console
$ npm run generate-client

frontend-app@1.0.0 generate-client /home/user/code/frontend-app

 *       #contains}.
 *   <li>Terminology note: a range {@code a} is said to be the <i>maximal</i> range having property
 *       <i>P</i> if, for all ranges {@code b} also having property <i>P</i>, {@code a.encloses(b)}.
 *       Likewise, {@code a} is <i>minimal</i> when {@code b.encloses(a)} for all {@code b} having
 *       property <i>P</i>. See, for example, the definition of {@link #intersection intersection}.

Readme.md would be the same file on Windows. In this test, you would get a
warning for "readme.md" because it makes everything lowercase. There are
repeats of these filename(s) with different casing:
EOF
    find . | tr '[A-Z]' '[a-z]' | sort | uniq -d | tee $BATS_FILE_TMPDIR/repeats
    [[ ! -s $BATS_FILE_TMPDIR/repeats ]]
}

# It's unclear why, but running this on //tensorflow/... is faster than running

	RemovePod(pod *v1.Pod)

	// TranslatePodUID returns the actual UID of a pod. If the UID belongs to
	// a mirror pod, returns the UID of its static pod. Otherwise, returns the
	// original UID.
	//
	// All public-facing functions should perform this translation for UIDs
	// because user may provide a mirror pod UID, which is not recognized by
	// internal Kubelet functions.
	TranslatePodUID(uid types.UID) kubetypes.ResolvedPodUID

func (m MockEtcdClient) getVersion(endpoint string) (string, error) {
	for _, ev := range m.EndpointVersion {
		if ev.Endpoint == endpoint {
			return ev.Version, ev.Error
		}
	}
	// Never should happen, unless tests having a problem.
	return "", fmt.Errorf("No version found")
}

func (m *MockEtcdClient) Endpoints() []string {
	return m.getEndpoints()
}

// Status returns a mock status response.

		// will better follow the intent of the user. At one point CpuWeights were set, but this prevented limits from having any effect.

		// There are 3 parts to how this works:
		// Part one - Windows kernel
		//   cpuMaximum is documented at https://docs.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/resource-controls

	{
		Value:     &PointerAnonFields{},
		ExpectXML: `<PointerAnonFields></PointerAnonFields>`,
	},

	// Test that name casing matters
	{
		Value:     &NameCasing{Xy: "mixed", XY: "upper", XyA: "mixedA", XYA: "upperA"},
		ExpectXML: `<casing Xy="mixedA" XY="upperA"><Xy>mixed</Xy><XY>upper</XY></casing>`,
	},

	// Test the order in which the XML element name is chosen
	{
		Value: &NamePrecedence{

            }

            storedState.updates
                .filter { update ->
                    // Only loaded properties can be overridden.
                    // Mutated properties are taking precedence over overridden because the
                    // first ones defined in build logic, hence we want to restore it.
                    update !is SystemPropertyLoad || !overriddenSystemProperties.contains(update.key)

// Check that the `_quantization_method` attribute contains the quantization
// method in textproto format. The dot_general op quantization is explicitly
// disabled by having `_quantization_method = "no_quantization { }"`.
// DISABLE-ALL-DOT-GENERAL-SAME: _entry_function = @composite_dot_general_fn_1
// DISABLE-ALL-DOT-GENERAL-SAME: _original_entry_function

	}
	if obj.SerializeImagePulls == nil {
		// SerializeImagePulls is default to true when MaxParallelImagePulls
		// is not set, and false when MaxParallelImagePulls is set.
		// This is to save users from having to set both configs.
		if obj.MaxParallelImagePulls == nil || *obj.MaxParallelImagePulls < 2 {
			obj.SerializeImagePulls = utilpointer.Bool(true)
		} else {
			obj.SerializeImagePulls = utilpointer.Bool(false)
		}