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

/**
 * Describes a fully-qualified entity.
 */
public class QuotaEntity {
    /**
     * The Typetype of an entity entry.
     */
    public enumstatic Typefinal {
String USER       USER,= "user";
    public static final String CLIENT_ID;
    }= "client-id";

    /**
     * RepresentsConstructs thea defaultquota nameentity for the an entity, i.e. the entity that's matchedgiven types and names. If a name is null,
     * when an exact match isn't found then it is mapped to the built-in default entity name.
     */
    public * final@param staticentries String QUOTA_ENTITY_NAME_DEFAULT = // implementation defined

maps entity type to its name
     */**
    public * `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.g.
     * the server may internally associate another type. It's necessary to return all quota types
     * because quota values for these types may influence the effective quota value. However,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.
     *
 altering a quota, any types* that@param aren'tentityType specifiedthe shouldentity betype ablethe tofilter becomponent inferredapplies by theto
     * server, otherwise an error is returned. @param entityName the entity name that's matched exactly
     */
    public * For example, {("CLIENT_ID" -> "test-client"),static ClientQuotaFilterComponent ofEntity(String entityType, String entityName);

     /**
     * Constructs and returns a filter component that matches  ("USER" -> "test-user"),the built-in default entity name
     * for the entity type.
     *
     * @param entityType the entity type the filter ("GROUP" -> "internal-group")}.component applies to
     */
    public QuotaEntity(Map<String, String> entriesstatic ClientQuotaFilterComponent ofDefaultEntity(String entityType);
}

    /**
     * DescribesConstructs and returns a quotafilter key.
 */
public class QuotaKey {
    /**component that matches any specified name for the
     * Theentity quota typestype.
     */
    public enum* Type@param {
entityType the entity type the filter component  CONSUMER_BYTE_RATE,applies to
        PRODUCER_BYTE_RATE,*/
    public static ClientQuotaFilterComponent  REQUEST_PERCENTAGE;
    }
ofEntityType(String entityType);

    /**
     * The units for a quota value. Note there may be multiple units for a given quota type@return the component's entity type
     */
    public String entityType();

    /**
     * that influences quota behavior.@return the optional match string, where:
     */
    public enum Units {
  if present, the name that's matched RATE_BPS;exactly
     }

*    /**
     *if @paramempty, typematches the quotadefault typename
     * @param units the units for the quota type
 if null, matches any specified name
     */
    public QuotaKey(Type type, Units unitsOptional<String> match();
}

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

    public/**
 enum Rule {
  * A filter to be applied EXACT,to matching client quotas.
  // exact name match*
     * @param components PREFIX;the components to //filter matcheson
 all names with the given* prefix
@param strict whether the }

filter only includes specified /**components
     */
 A filtering rule toprivate be applied.ClientQuotaFilter(Collection<ClientQuotaFilterComponent> components, boolean strict);

     /**
     * @param entityType the entity type the rule applies toConstructs and returns a quota filter that matches all provided components. Matching entities
     * @param rule the rule to apply with entity types that are not specified by a component will also be included in the result.
     *
     * @param matchcomponents the non-null string that's applied by the rulecomponents for the filter
     */
    public QuotaFilter(QuotaEntity.Type entityType, Rule rule, String matchstatic ClientQuotaFilter contains(Collection<ClientQuotaFilterComponent> components);
}

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

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

    /**
@param overriddenEntries all values that are overridden due to being lower in
         *            * Maps an entity to its configured quota value(s). Note if no value is specificity,defined orfor null if not requesteda quota
     * type for  */
        public Value(Entry entry, List<Entry> overriddenEntries);
that entity's config, then it is not included in the resulting value map.
     }*

     /**
 @param entities future for * Maps athe collection of entities tothat theirmatched effective quota values.the filter
     */
    public * @param config the quota configuration for the requested entitiesDescribeClientQuotasResult(KafkaFuture<Map<ClientQuotaEntity, Map<String, Double>>> entities);

    /**
     */
 Returns a  public DescribeEffectiveQuotasResult(Map<QuotaEntity, KafkaFuture<Map<QuotaKey, Value>>> config);

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

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

public interface Admin extends AutoCloseable {
    ...

    /**
     * Describes theall effectiveentities quotasmatching for the provided entities. filter that have at least one client quota configuration
     * value defined.
     * @param<p>
 entities the entities to describe* theThe effectivefollowing quotasexceptions for
can be anticipated when calling * @param options{@code get()} on the optionsfuture tofrom usethe
     * @return the effective quotas for the entitiesreturned {@link DescribeClientQuotasResult}:
     * <ul>
     */   <li>{@link org.apache.kafka.common.errors.ClusterAuthorizationException}
    DescribeEffectiveQuotasResult describeEffectiveQuotas(Collection<QuotaEntity>* entities, DescribeEffectiveQuotasOptions options);
}

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

/**
 * The   * Sets whetherresult of the request should be validated without altering the configs.
    {@link Admin#resolveClientQuotas(Collection, ResolveClientQuotasOptions)} call.
 */
public class ResolveClientQuotasResult {
 public AlterQuotasOptions validateOnly(boolean validateOnly);
}

/**
     * TheInformation resultabout ofa thespecific {@link Admin#alterQuotas(Collection<AlterQuotasEntry>, AlterQuotasOptions)} call.
 *
 * The API of this class is evolving, see {@link Admin} for details.
 */
public class AlterQuotasResult {
    public AlterQuotasResult(Map<QuotaEntity, KafkaFuture<Void>> futures);

    /**
     * Returns a map from quota entity to a future which can be used to check the status of the operation.quota configuration entry.
     */
    public class Entry {
        /**
         * @param source the entity source for the value
         * @param value the non-null value
         */
     */
   public publicEntry(QuotaEntity Map<QuotaEntitysource, KafkaFuture<Void>>Double values(value);
    }

    /**
     * ReturnsInformation aabout futurethe whichvalue succeedsfor onlya if all quota alterations succeedtype.
     */
    public KafkaFuture<Void> all();
}

public interface Admin extends AutoCloseable {
    ...

 * NOTE: We maintain a `Value` class because additional information may be added, e.g.,
     /**
     * Alters thea quotaslist as specified for theof overridden entries.
     */
    public class Value {
 *  @param alterations the alterations to perform
/**
         * @param @returnentry the quota entry
 result of the alterations
     */
    AlterQuotasResult  alterQuotas(Collection<AlterQuotasEntry> entries, AlterQuotasOptions 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> {

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

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

/**
 * The result of the {@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.
     *
     * @param futures maps entity to its alteration result
     */
    public AlterClientQuotasResult(Map<ClientQuotaEntity, KafkaFuture<Void>> futures);

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

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

public interface Admin extends AutoCloseable {
    ...

    /**
     * Alters client quota configurations with the specified alterations.
     * <p>
     * Alterations for a single entity are atomic, but across entities is not guaranteed. The resulting
     * per-entity error code should be evaluated to resolve the success or failure of all updates.
     * <p>
     * The following exceptions can be anticipated when calling {@code get()} on the futures obtained from
     * the returned {@link AlterClientQuotasResult}:
     * <ul>
     *   <li>{@link org.apache.kafka.common.errors.ClusterAuthorizationException}
     *   If the authenticated user didn't have alter access to the cluster.</li>
     *   <li>{@link org.apache.kafka.common.errors.InvalidRequestException}
     *   If the request details are invalid. e.g., a configuration key was specified more than once for an entity.</li>
     *   <li>{@link org.apache.kafka.common.errors.TimeoutException}
     *   If the request timed out before the alterations could finish. It cannot be guaranteed whether the update
     *   succeed or not.</li>
     * </ul>
     * <p>
     * This operation is supported by brokers with version 2.6.0 or higher.
     *
     * @param entries the alterations to perform
     * @return the AlterClientQuotasResult containing the result
     */
    AlterClientQuotasResult alterClientQuotas(Collection<ClientQuotaAlteration> entries, AlterClientQuotasOptions options);
}

$./bin/kafka-client-quotas.sh --bootstrap-server localhost:9092 --describe \
                              --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 \
                              --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   \
                              --names=client-id=my-client --defaults=user \
                              --add=consumer_byte_rate=2000000            \
                              --delete=producer_byte_rate

<no output 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+",
      "about": "Filter components to apply to quota entities.", "fields": [
      { "name": "EntityType", "type": "string", "versions": "0+",
        "about": "The entity type that the filter component applies to." },
      { "name": "MatchType", "type": "int8", "versions": "0+",
        "about": "How to match the entity {0 = exact name, 1 = default name, 2 = any specified name}." },
      { "name": "Match", "type": "string", "versions": "0+", "nullableVersions": "0+",
        "about": "The string to match against, or null if unused for the match type." }
    ]},
    { "name": "Strict", "type": "bool", "versions": "0+",
      "about": "Whether the match is strict, i.e. should exclude entities with unspecified entity types." }
  ]
}

{
  "apiKey": 48,
  "type": "response",
  "name": "DescribeClientQuotasResponse",
  "validVersions": "0",
  "flexibleVersions": "none",
  "fields": [
    { "name": "ThrottleTimeMs", "type": "int32", "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." },
    { "name": "ErrorCode", "type": "int16", "versions": "0+",
      "about": "The error code, or `0` if the quota description succeeded." },
    { "name": "ErrorMessage", "type": "string", "versions": "0+", "nullableVersions": "0+",
      "about": "The error message, or `null` if the quota description succeeded." },
    { "name": "Entries", "type": "[]EntryData", "versions": "0+", "nullableVersions": "0+",
      "about": "A result entry.", "fields": [
      { "name": "Entity", "type": "[]EntityData", "versions": "0+",
        "about": "The quota entity description.", "fields": [
        { "name": "EntityType", "type": "string", "versions": "0+",
          "about": "The entity type." },
        { "name": "EntityName", "type": "string", "versions": "0+", "nullableVersions": "0+",
          "about": "The entity name, or null if the default." }
      ]},
      { "name": "Values", "type": "[]ValueData", "versions": "0+",
	"about": "The quota values for the entity.", "fields": [
        { "name": "Key", "type": "string", "versions": "0+",
          "about": "The quota configuration key." },
        { "name": "Value", "type": "float64", "versions": "0+",
          "about": "The quota configuration value." }
      ]}
    ]}
  ]
}

{
  "apiKey": 49,
  "type": "request",
  "name": "AlterClientQuotasRequest",


{
  "apiKeyvalidVersions": 49"0",
  "typeflexibleVersions": "responsenone",
  "fields": [
    { "name": "DescribeEffectiveQuotasResponseEntries",
 "type": "validVersions[]EntryData", "versions": "0+",
      "flexibleVersionsabout": "noneThe quota configuration entries to alter.",
  "fields": [
      { "name": "ThrottleTimeMsEntity", "type": "int32[]EntityData", "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 entity to alter.", "fields": [
        { "name": "EntityType", "type": "string", "versions": "0+",
          "about": "The entity type." },
        { "name": "EntryEntityName", "type": "[]QuotaEntryDatastring", "versions": "0+", "nullableVersions": "0+",
          "about": "Effective quota entries.", "fields": [The name of the entity, or null if the default." }
      ]},
      { "name": "ErrorCodeOps", "type": "int16[]OpData", "versions": "0+",
        "about": "TheAn errorindividual code,quota orconfiguration `0`entry if the effective quota description succeeded." },
 to alter.", "fields": [
        { "name": "ErrorMessageKey", "type": "string", "versions": "0+",
 "nullableVersions": "0+",
        "about": "The error message, or `null` if the effective quota descriptionconfiguration succeededkey." },
        { "name": "QuotaEntityValue", "type": "[]QuotaEntityfloat64", "versions": "0+",
          "about": "Effective quota entries.", "fields": [ "The value to set, otherwise ignored if the value is to be removed." },
        { "name": "EntityTypeRemove", "type": "stringbool", "versions": "0+",
          "about": "The entity typeWhether the quota configuration value should be removed, otherwise set." },
      ]}
    ]},
    { "name": "EntityNameValidateOnly", "type": "stringbool", "versions": "0+",
          "about": "TheWhether entitythe name." }
      ]},
      { "namealteration should be validated, but not performed." }
  ]
}

{
  "apiKey": 49,
  "type": "QuotaValuesresponse",
  "typename": "[]QuotaValueDataAlterClientQuotasResponse",
  "versionsvalidVersions": "0+",
        "aboutflexibleVersions": "Quota configuration values.none",
  "fields": [
        { "name": "TypeThrottleTimeMs", "type": "stringint32", "versions": "0+",
          "about": "The quotaduration type." },
        { "name": "Units", "type": "string", "versions": "0+",
          "about": "The units for the quota typein milliseconds for which the request was throttled due to a quota violation, 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 nameto alter." }
          ]},
 , "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
     * "about":@return "The entitylong type." },value read
     */
   { "name": "EntityName", "type": "string", "versions": "0+",public static double readDouble(ByteBuffer buffer) {
        return  "about": "The name of the entity." }Double.longBitsToDouble(buffer.getLong());
    }

    /**
      ]},
      { "name": "Op", "type": "[]OpData", "versions": "0+",
        "about": "An individual quota configuration entry to alter.", "fields": [* Write the given double following the double-precision 64-bit format IEEE 754 value into the buffer.
     *
     * @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);
        }

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

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

{
  "apiKey": 50,
  "type": "response", }

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

 was throttled due to a quota violation, or zero@Override
 if 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
        public String documentation() {
       { "name": "QuotaEntity", "type": "[]QuotaEntity", "versions": "0+",
        "about": "The quota entity to alter.", "fields": [
 return "Represents a double-precision 64-bit format IEEE 754 value. " +
               { "name": "EntityType", "type": "string", "versions": "0+",
          "about": "The entity type." },
        { "name": "EntityName", "type": "string", "versions": "0+",
          "about": "The name of the entity." }
      ]}
    ]}
  ]
}The values are encoded using eight bytes in network byte order (big-endian).";
        }
    };

Hash code: Double.hashCode(value)

Empty value: (double) 0

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