This example doesn't implement the callback itself (that could be just a line of code), only the documentation part.

/// tip

The actual callback is just an HTTP request.

	}

	// There are two possibilities:
	// - We use a KMS -> There must be non-empty key ID and a KMS data key.
	// - We use a K/V -> There must be no key ID and no KMS data key.
	// Otherwise, the caller has passed an invalid argument combination.
	if keyID == "" && len(kmsKey) != 0 {
		logger.CriticalIf(context.Background(), errors.New("The key ID must not be empty if a KMS data key is present"))
	}

        "//conditions:default": [],
    }),
    tags = [
        "no_cuda_asan",  # TODO(b/181771536)
        "no_windows",  # TODO(b/155444728)
    ],
    # We must ensure that the dependencies can be dynamically linked since
    # the shared library must be able to use core:framework.
    deps = [
        ":c_api",
        ":c_api_internal",
        ":c_test_util",
        ":test_op_kernel",
        ":tf_buffer",

    assert err.value.errors() == [
        {
            "type": "value_error",
            "loc": ("response", "name"),
            "msg": "Value error, name must end in A",
            "input": "modelX",
            "ctx": {"error": HasRepr("ValueError('name must end in A')")},
        }
    ]


def test_openapi_schema(client: TestClient):
    response = client.get("/openapi.json")

    /**
     * Creates a {@link Reader} to read from a file with the specified encoding.
     *
     * @param is
     *            the input stream (must not be {@literal null})
     * @param encoding
     *            the encoding of the input stream (must not be {@literal null} or empty)
     * @return a {@link Reader} to read from the file
     */

   * unequivocally demonstrate that funneling cannot be occurring. This is done bit-by-bit. For each
   * input bit(i) and output bit(j), two pairs of keys must be found with all bits identical except
   * bit(i). One pair must differ in output bit(j), and one pair must not. This proves that input
   * bit(i) can alter output bit(j).
   */
  static void checkNoFunnels(HashFunction function) {
    Random rand = new Random(0);

        }
        Type[] resolvedBounds = new TypeResolver(forDependants).resolveTypes(bounds);
        /*
         * We'd like to simply create our own TypeVariable with the newly resolved bounds. There's
         * just one problem: We want to interoperate properly with the platform's built-in
         * implementation of TypeVariable, but the behavior of the built-in implementation differs
         * across platforms:
         *

     * has a current project, its plugin repositories will be used as well.
     *
     * @param plugin The plugin for which to resolve a version, must not be {@code null}.
     * @param session The Maven session to use, must not be {@code null}.
     */
    public DefaultPluginVersionRequest(Plugin plugin, MavenSession session) {
        setGroupId(plugin.getGroupId());

        }
    }

    /**
     * Returns an input stream for reading the contents of the specified Zip file entry.
     *
     * @param file
     *            Zip file. Must not be {@literal null}.
     * @param entry
     *            Zip file entry. Must not be {@literal null}.
     * @return An input stream for reading the contents of the specified Zip file entry.
     */

            queryBuilder.must(QueryBuilders.termsQuery(FieldNames.ROLES, roles));
        } else {
            queryBuilder.must(QueryBuilders.termQuery(FieldNames.ROLES, SuggestConstants.DEFAULT_ROLE));
        }
        if (!fields.isEmpty()) {
            queryBuilder.must(QueryBuilders.termsQuery(FieldNames.FIELDS, fields));
        }
        if (!languages.isEmpty()) {