/**
 * Describes a client quota entity, which is a mapping of entity types to their names.
 */
public class ClientQuotaEntity {

    /**
     * The type of an entity entry.
     */
    public static final String USER = "user";
    public static final String CLIENT_ID = "client-id";

    /**
     * Constructs a quota entity for the given types and names. If a name is null,
     * then it is mapped to the built-in default entity name.
     *
     * @param entries maps entity type to its name
     */
    public ClientQuotaEntity(Map<String, String> entries);

    /**
     * @return map of entity type to its name
     */
    public Map<String, String> entries();
}

/**
 * Describes a component for applying a client quota filter.
 */
public class ClientQuotaFilterComponent {

    /**
     * Constructs and returns a filter component that exactly matches the provided entity
     * name for the entity type.
     *
     * @param entityType the entity type the filter component applies to
     * @param entityName the entity name that's matched exactly
     */
    public static ClientQuotaFilterComponent ofEntity(String entityType, String entityName);

    /**
     * Constructs and returns a filter component that matches the built-in default entity name
     * for the entity type.
     *
     * @param entityType the entity type the filter component applies to
     */
    public static ClientQuotaFilterComponent ofDefaultEntity(String entityType);

    /**
     * Constructs and returns a filter component that matches any specified name for the
     * entity type.
     *
     * @param entityType the entity type the filter component applies to
     */
    public static ClientQuotaFilterComponent ofEntityType(String entityType);

    /**
     * @return the component's entity type
     */
    public String entityType();

    /**
     * @return the optional match string, where:
     *         if present, the name that's matched exactly
     *         if empty, matches the default name
     *         if null, matches any specified name
     */
    public Optional<String> match();
}

/**
 * Describes a client quota entity filter.
 */
public class ClientQuotaFilter {

    /**
     * A filter to be applied to matching client quotas.
     *
     * @param components the components to filter on
     * @param strict whether the filter only includes specified components
     */
    private ClientQuotaFilter(Collection<ClientQuotaFilterComponent> components, boolean strict);

    /**
     * Constructs and returns a quota filter that matches all provided components. Matching entities
     * with entity types that are not specified by a component will also be included in the result.
     *
     * @param components the components for the filter
     */
    public static ClientQuotaFilter contains(Collection<ClientQuotaFilterComponent> components);

    /**
     * Constructs and returns a quota filter that matches all provided components. Matching entities
     * with entity types that are not specified by a component will *not* be included in the result.
     *
     * @param components the components for the filter
     */
    public static ClientQuotaFilter containsOnly(Collection<ClientQuotaFilterComponent> components);

    /**
     * Constructs and returns a quota filter that matches all configured entities.
     */
    public static ClientQuotaFilter all();

    /**
     * @return the filter's components
     */
    public Collection<ClientQuotaFilterComponent> components();

    /**
     * @return whether the filter is strict, i.e. only includes specified components
     */
    public boolean strict();
}

/**
 * Describes a configuration alteration to be made to a client quota entity.
 */
public class ClientQuotaAlteration {

    public static class Op {

        /**
         * @param key the quota type to alter
         * @param value if set then the existing value is updated,
         *              otherwise if null, the existing value is cleared
         */
        public Op(String key, Double value);

        /**
         * @return the quota type to alter
         */
        public String key();

        /**
         * @return if set then the existing value is updated,
         *         otherwise if null, the existing value is cleared
         */
        public Double value();
    }

    private final ClientQuotaEntity entity;
    private final Collection<Op> ops;

    /**
     * @param entity the entity whose config will be modified
     * @param ops the alteration to perform
     */
    public ClientQuotaAlteration(ClientQuotaEntity entity, Collection<Op> ops);

    /**
     * @return the entity whose config will be modified
     */
    public ClientQuotaEntity entity();

    /**
     * @return the alteration to perform
     */
    public Collection<Op> ops();
}

public class DescribeClientQuotasOptions extends AbstractOptions<DescribeClientQuotasOptions> {
    // Empty.
}

/**
 * The result of the {@link Admin#describeClientQuotas(Collection, DescribeClientQuotasOptions)} call.
 */
public class DescribeClientQuotasResult {

    /**
     * Maps an entity to its configured quota value(s). Note if no value is defined for a quota
     * type for that entity's config, then it is not included in the resulting value map.
     *
     * @param entities future for the collection of entities that matched the filter
     */
    public DescribeClientQuotasResult(KafkaFuture<Map<ClientQuotaEntity, Map<String, Double>>> entities);

    /**
     * Returns a map from quota entity to a future which can be used to check the status of the operation.
     */
    public KafkaFuture<Map<ClientQuotaEntity, Map<String, Double>>> entities();
}

public interface Admin extends AutoCloseable {
    ...

    /**
     * Describes all entities matching the provided filter that have at least one client quota configuration
     * value defined.
     * <p>
     * The following exceptions can be anticipated when calling {@code get()} on the future from the
     * returned {@link DescribeClientQuotasResult}:
     * <ul>
     *   <li>{@link org.apache.kafka.common.errors.ClusterAuthorizationException}
     *   If the authenticated user didn't have describe access to the cluster.</li>
     *   <li>{@link org.apache.kafka.common.errors.InvalidRequestException}
     *   If the request details are invalid. e.g., an invalid entity type was specified.</li>
     *   <li>{@link org.apache.kafka.common.errors.TimeoutException}
     *   If the request timed out before the describe could finish.</li>
     * </ul>
     * <p>
     * This operation is supported by brokers with version 2.6.0 or higher.
     *
     * @param filter the filter to apply to match entities
     * @param options the options to use
     * @return the DescribeClientQuotasResult containing the result
     */
    DescribeClientQuotasResult describeClientQuotas(ClientQuotaFilter filter, DescribeClientQuotasOptions options);
}

public class ResolveClientQuotasOptions extends AbstractOptions<ResolveClientQuotasOptions> {
    // Empty.
}

/**
 * The result of the {@link Admin#resolveClientQuotas(Collection, ResolveClientQuotasOptions)} call.
 */
public class ResolveClientQuotasResult {
    /**
     * Information about a specific quota configuration entry.
     */
    public class Entry {
        /**
         * @param source the entity source for the value
         * @param value the non-null value
         */
        public Entry(QuotaEntity source, Double value);
    }

    /**
     * Information about the value for a quota type.
     *
     * NOTE: We maintain a `Value` class because additional information may be added, e.g.,
     *       a list of overridden entries.
     */
    public class Value {
        /**
         * @param entry the quota entry
         */
        public Value(Entry entry);
    }

    /**
     * Maps a collection of entities to their resolved quota values.
     *
     * @param config the quota configuration for the requested entities
     */
    public ResolveClientQuotasResult(Map<QuotaEntity, KafkaFuture<Map<String, Value>>> config);

    /**
     * Returns a map from quota entity to a future which can be used to check the status of the operation.
     */
    public Map<QuotaEntity, KafkaFuture<Map<String, Value>>> config();

    /**
     * Returns a future which succeeds only if all quota descriptions succeed.
     */
    public KafkaFuture<Void> all();
}

public interface Admin extends AutoCloseable {
    ...

    /**
     * Resolves the effective quota values for the provided entities.
     *
     * @param entities the entities to describe the resolved quotas for
     * @param options the options to use
     * @return the resolved quotas for the entities
     */
    ResolveClientQuotasResult resolveClientQuotas(Collection<QuotaEntity> entities, ResolveClientQuotasOptions options);
}

/**
 * Options for {@link Admin#alterClientQuotas(Collection, AlterClientQuotasOptions)}.
 *
 * The API of this class is evolving, see {@link Admin} for details.
 */
public class AlterClientQuotasOptions extends AbstractOptions<AlterClientQuotasOptions> {

/**
 * Describes a fully-qualified entity.
 */
public class QuotaEntity {
    /**
     * Type of an entity entry.
     */
    public enum Type {
        USER,
        CLIENT_ID;
    }

    /**
     * RepresentsReturns whether the request defaultshould be namevalidated forwithout analtering entity,the iconfigs.e.
  the entity that's matched*/
    public boolean validateOnly();

    /**
 when an exact match isn't found.
     */
    public final static String QUOTA_ENTITY_NAME_DEFAULT = // implementation defined

    * Sets whether the request should be validated without altering the configs.
     */
    public AlterClientQuotasOptions validateOnly(boolean validateOnly);
}

/**
 * The result of * `entries` describes the fully-qualified entity. The key is a {@code Type} string, however
     * there may also exist keys that are not enumerated by {@code Type} that still apply, e.gthe {@link Admin#alterClientQuotas(Collection, AlterClientQuotasOptions)} call.
 *
 * The API of this class is evolving, see {@link Admin} for details.
 */
@InterfaceStability.Evolving
public class AlterClientQuotasResult {

    /**
     * Maps an entity to its alteration result.
     *
 the server may internally associate* another@param type. It's necessaryfutures maps entity to returnits allalteration quota typesresult
     */
 because quota values for these types may influence the effective quota value. However,public AlterClientQuotasResult(Map<ClientQuotaEntity, KafkaFuture<Void>> futures);

    /**
     * alteringReturns a map from quota, anyentity typesto thata aren'tfuture specifiedwhich shouldcan be able to be inferred by the used to check the status of the operation.
     */
    public *Map<ClientQuotaEntity, server, otherwise an error is returned.KafkaFuture<Void>> values();

    /**
     *
 Returns a future which succeeds *only Forif example, {("CLIENT_ID" -> "test-client"),all quota alterations succeed.
     */
    public KafkaFuture<Void> all();
}

public interface Admin extends AutoCloseable {
    ("USER" -> "test-user"),...

     /**
     * Alters client quota configurations with the    ("GROUP" -> "internal-group")}specified alterations.
     */ <p>
    public QuotaEntity(Map<String, String> entries);
}

/**
 * Describes a quota key.
 */
public class QuotaKey {
    /*** Alterations for a single entity are atomic, but across entities is not guaranteed. The resulting
     * Theper-entity quotaerror types.
code should be evaluated to */
resolve the success or publicfailure enumof Typeall {updates.
        CONSUMER_BYTE_RATE,* <p>
     * The  PRODUCER_BYTE_RATE,
        REQUEST_PERCENTAGE;
    }

following exceptions can be anticipated when calling {@code get()} on the futures obtained from
     /**
 the returned {@link AlterClientQuotasResult}:
 * The units for a quota value. Note there may be multiple units for a given quota type* <ul>
     *   <li>{@link org.apache.kafka.common.errors.ClusterAuthorizationException}
     * that influences quotaIf behavior.
the authenticated user didn't have */
alter access to  public enum Units {the cluster.</li>
     *   RATE_BPS;
    }

<li>{@link org.apache.kafka.common.errors.InvalidRequestException}
     /**
   If the request *details @paramare type the quota type
     * @param units the units for the quota type
     */invalid. e.g., a configuration key was specified more than once for an entity.</li>
     *   <li>{@link org.apache.kafka.common.errors.TimeoutException}
    public QuotaKey(Type* type, Units units);
}

/**
 * Describes a quota entity filter.
 */
public class QuotaFilter {
    public enum Rule {
        EXACT,    // exact name match If the request timed out before the alterations could finish. It cannot be guaranteed whether the update
     *   succeed or not.</li>
     * </ul>
     * <p>
  PREFIX;   //* matchesThis alloperation namesis withsupported theby givenbrokers prefix
with version 2.6.0 or }higher.

     /**
     * A@param entries filteringthe rulealterations to be applied.perform
     *
 @return the AlterClientQuotasResult containing * @param entityType the entityresult
 type the rule applies to*/
     * @param rule the rule to apply
     * @param match the non-null string that's applied by the rule
     */
    public QuotaFilter(QuotaEntity.Type entityType, Rule rule, String match);
}

$./bin/kafka-client-quotas.sh --bootstrap-server localhost:9092 --describe \

public class DescribeEffectiveQuotasOptions extends AbstractOptions<DescribeEffectiveQuotasOptions> {

    /**
     * Whether to exclude the list of overridden values for every quota type in the result.
     */
    public DescribeEffectiveQuotasOptions setOmitOverriddenValues(boolean omitOverriddenValues);
}

/**
 * The result of the {@link Admin#describeEffectiveQuotas(Collection<QuotaEntity>, DescribeEffectiveQuotasOptions)} call.
 */
public class DescribeEffectiveQuotasResult {
    /**
     * Information about a specific quota configuration entry.
     */
    public class Entry {
        /**
         * @param source the entity source for the value
         * @param value the non-null value
         */
        public Entry(QuotaEntity source, Long value);
    }

    /**
     * Information about the value for a quota type.
     */
    public class Value { --names=client-id=my-client

{user=user-one, client-id=my-client}
consumer_byte_rate=4000000
producer_byte_rate=1000000

{user=user-two, client-id=my-client}
producer_byte_rate=2000000

{user=<default>, client-id=my-client}
consumer_byte_rate=1000000
producer_byte_rate=500000

$./bin/kafka-client-quotas.sh --bootstrap-server localhost:9092 --resolve \
        /**
         * @param entry the quota entry
        --names=user=user-two,client-id=my-client

consumer_byte_rate=2000000 {user=user-two, client-id=my-client}
producer_byte_rate=500000 {user=<default>, client-id=my-client}

$./bin/kafka-client-quotas.sh --bootstrap-server localhost:9092 --alter   \
  * @param overriddenEntries all values that are overridden due to being lower in
         *                          specificity, or null if not requested
         */
 --names=client-id=my-client --defaults=user \
          public Value(Entry entry, List<Entry> overriddenEntries);
    }

    /**
     * Maps a collection of entities to their effective quota values.
 --add=consumer_byte_rate=2000000            *\
     *    @param config the quota configuration for the requested entities
     */
    public DescribeEffectiveQuotasResult(Map<QuotaEntity, KafkaFuture<Map<QuotaKey, Value>>> config); --delete=producer_byte_rate

<no output   /**
     * Returns a map from quota entity to a future which can be used to check the status of the operation.
on success>

$./bin/kafka-client-quotas.sh --bootstrap-server localhost:9092 --describe \
                          */
    --names=client-id=my-client --defaults=user

{user=<default>, client-id=my-client}
consumer_byte_rate=2000000

{
  "apiKey": 48,
  "type": "request",
  "name": "DescribeClientQuotasRequest",
  "validVersions": "0",
  "flexibleVersions": "none",
  "fields": [
    { "name": "Components", "type": "[]ComponentData", "versions": "0+",public Map<QuotaEntity, KafkaFuture<Map<QuotaKey, Value>>> config();

    /**
     * Returns a future which succeeds only if all quota descriptions succeed.
     */
    public KafkaFuture<Void> all();
}

public interface Admin extends AutoCloseable {
    ...

    /**
     * Describes the effective quotas for the provided entities."about": "Filter components to apply to quota entities.", "fields": [
     *
 { "name": "EntityType",  * @param entities the entities to describe the effective quotas for
     * @param options the options to use"type": "string", "versions": "0+",
        "about": "The entity type that the filter component applies to." },
     * @return the effective quotas for the entities{ "name": "MatchType", "type": "int8", "versions": "0+",
     */
    DescribeEffectiveQuotasResult describeEffectiveQuotas(Collection<QuotaEntity> entities, DescribeEffectiveQuotasOptions options);
}

{
  "apiKey": 50,
  "type": "request",
  "name": "ResolveClientQuotasRequest",
  "validVersions": "0",
  "flexibleVersions": "none",
  

{
  "apiKey": 49,
  "type": "responserequest",
  "name": "DescribeEffectiveQuotasResponseAlterClientQuotasRequest",
  "validVersions": "0",
  "flexibleVersions": "none",
  "fields": [
    { "name": "ThrottleTimeMsEntries", "type": "int32[]EntryData", "versions": "0+",
      "about": "The duration in milliseconds for which the request was throttled due to a quota violation, or zero if the request did not violate any quota." },
    quota configuration entries to alter.", "fields": [
      { "name": "Entity", "type": "[]EntityData", "versions": "0+",
        "about": "The quota entity to alter.", "fields": [
        { "name": "EntryEntityType", "type": "[]QuotaEntryDatastring", "versions": "0+",
          "about": "EffectiveThe quotaentity entriestype." },
 "fields": [
      { "name": "ErrorCodeEntityName", "type": "int16string", "versions": "0+", "nullableVersions": "0+",
          "about": "The name errorof the codeentity, or `0`null if the effective quota description succeeded."  default." }
      ]},
      { "name": "ErrorMessageOps", "type": "string[]OpData", "versions": "0+", "nullableVersions": "0+",
        "about": "TheAn errorindividual message,quota orconfiguration `null`entry if the effective quota description succeeded." },
 to alter.", "fields": [
        { "name": "QuotaEntityKey", "type": "[]QuotaEntitystring", "versions": "0+",
          "about": "EffectiveThe quota configuration entrieskey.", "fields": [ },
        { "name": "EntityTypeValue", "type": "stringfloat64", "versions": "0+",
          "about": "The entity type value to set, otherwise ignored if the value is to be removed." },
        { "name": "EntityNameRemove", "type": "stringbool", "versions": "0+",
          "about": "The entity nameWhether the quota configuration value should be removed, otherwise set." }
      ]},
    ]},
    { "name": "QuotaValuesValidateOnly", "type": "[]QuotaValueDatabool", "versions": "0+",
        "about": "Quota configuration values.", "fields": [
        { "nameWhether the alteration should be validated, but not performed." }
  ]
}

{
  "apiKey": 49,
  "type": "Typeresponse",
  "typename": "stringAlterClientQuotasResponse",
  "versionsvalidVersions": "0+",
          "about"flexibleVersions": "The quota type." }none",
    "fields": [
    { "name": "UnitsThrottleTimeMs", "type": "stringint32", "versions": "0+",
          "about": "The duration unitsin milliseconds for which the request was throttled due to a quota typeviolation, or zero if the request did not violate any quota." },
        { "name": "EntryEntries", "type": "[]ValueEntryDataEntryData", "versions": "0+",
          "about": "QuotaThe quota valueconfiguration entries to alter.", "fields": [
          { "name": "QuotaEntityErrorCode", "type": "[]ValueQuotaEntityint16", "versions": "0+",
            "about": "EffectiveThe quotaerror entries."code, "fields": [
      or `0` if the quota alteration succeeded." },
      { "name": "EntityTypeErrorMessage", "type": "string", "versions": "0+",
      "nullableVersions": "0+",
        "about": "The error entity type." },
      message, or `null` if the quota alteration succeeded." },
      { "name": "EntityNameEntity", "type": "string[]EntityData", "versions": "0+",
              "about": "The quota entity to namealter." }
          ]},
 , "fields": [
         { "name": "ValueEntityType", "type": "int64string", "versions": "0+",
            "about": "The quotaentity configuration valuetype." },
        ]}
      ]}
    ]}
  ]
}

    /**
     * Read  "about": "The quota entity to alter.", "fields": [a double-precision 64-bit format IEEE 754 value.
     *
   { "name": "EntityType", "type": "string", "versions": "0+",
    * @param buffer The buffer to read from
     * @return "about": "The entitylong type." },value read
        { "name": "EntityName", "type": "string", "versions": "0+",*/
    public static double readDouble(ByteBuffer buffer) {
        return Double.longBitsToDouble(buffer.getLong());
  "about": "The name}

 of the entity." }
 /**
     * Write ]},
the given double following the  { "name": "Op", "type": "[]OpData", "versions": "0+",double-precision 64-bit format IEEE 754 value into the buffer.
     *
   "about": "An individual quota configuration entry to alter.", "fields": [  * @param value The value to write
     * @param buffer { "name": "Type", "type": "string", "versions": "0+",
   The buffer to write to
     */
    public static  "about": "The quota type." },void writeDouble(double value, ByteBuffer buffer) {
        buffer.putLong(Double.doubleToRawLongBits(value));
    }

    public static final DocumentedType DOUBLE = new DocumentedType() {
        @Override
 { "name": "Units", "type": "string", "versions": "0+",
          "about": "The units for the quota type." },
       public { "name": "Value", "type": "int64", "versions": "0+",void write(ByteBuffer buffer, Object o) {
          "about": "The value to set, otherwise ignored if the value is to be removed." },
   ByteUtils.writeDouble((Double) o, buffer);
        }

        @Override
      { "name": "Remove", "type": "bool", "versions": "0+", public Object read(ByteBuffer buffer) {
          "about": "Whether the quota configuration value should be removed, otherwise set." }
return ByteUtils.readDouble(buffer);
        }

        ]}@Override
    ]},
    public { "name": "ValidateOnly", "type": "bool", "versions": "0+",
int sizeOf(Object o) {
         "about": "Whether the alterationreturn should8;
 be validated, but not performed." }
  ]
}

{
  "apiKey": 50,
  "type": "response",
  "name": "AlterQuotasResponse",@Override
  "validVersions": "0",
  "flexibleVersions": "none",
  "fields": [
    { "name": "ThrottleTimeMs", "type": "int32", "versions": "0+",
public String typeName() {
            return "aboutDOUBLE":;
 "The duration in milliseconds for which the request was throttled}

 due to a quota violation, or zero if@Override
 the request did not violate any quota." },
    { "name": "Entry", "type": "[]EntryData", "versions": "0+",
 public Double validate(Object item) {
            "about": "The quota configuration entries to alter.", "fields": [
if (item instanceof Double)
           { "name": "ErrorCode", "type": "int16", "versions": "0+",   return (Double) item;
        "about": "The error code, orelse
 `0` if the quota alteration succeeded." },
      { "name": "ErrorMessage", "type": "string", "versions": "0+", "nullableVersions": "0+",
    throw new SchemaException(item + " is not a Double.");
     "about": "The error message,}

 or `null` if the quota alteration succeeded." },@Override
      { "name": "QuotaEntity", "type": "[]QuotaEntity", "versions": "0+", public String documentation() {
        "about": "The quota entity toreturn alter.", "fields": [
        { "name": "EntityType", "type": "string", "versions": "0+",
"Represents a double-precision 64-bit format IEEE 754 value. " +
                   "about": "The entity type." },
values are encoded using eight bytes in network byte order (big-endian).";
        }
   { "name": "EntityName", "type": "string", "versions": "0+",
          "about": "The name of the entity." }
      ]}
    ]}
  ]
}

Hash code: Double.hashCode(value)

Empty value: (double) 0

Parsing a default value string: Double.parseDouble(defaultValue)