/**
 * 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);

/**
 * Describes a fully-qualified entity.
 */
public class QuotaEntity {
    /**
     * @return Typemap of an entity entry.
type to its name
     */
    public enumMap<String, Type {String> entries();
}

/**
 * Describes a component for applying a USER,
client quota       CLIENT_ID;
    }filter.
 */
public class ClientQuotaFilterComponent {

    /**
     * RepresentsConstructs and thereturns defaulta namefilter forcomponent anthat entity, i.e.exactly matches the provided entity that's matched
     * whenname anfor exactthe match isn't foundentity type.
     */
    public final* static@param String QUOTA_ENTITY_NAME_DEFAULT = // implementation defined

    /**entityType the entity type the filter component applies to
     * `entries`@param describesentityName the fully-qualified entity. Thename keythat's is a {@code Type} string, howevermatched exactly
     */
 there may also existpublic keysstatic thatClientQuotaFilterComponent are not enumerated by {@code Type} that still apply, e.g.ofEntity(String entityType, String entityName);

    /**
     * theConstructs serverand mayreturns internallya associatefilter anothercomponent type. It's necessary to return all quota typesthat matches the built-in default entity name
     * because quota values for these types may influence the effectiveentity quota value. However,type.
     *
 altering a quota, any types* that@param aren'tentityType specifiedthe shouldentity betype ablethe tofilter becomponent inferredapplies by theto
     */
 server,   otherwisepublic anstatic errorClientQuotaFilterComponent is returned.ofDefaultEntity(String entityType);

     /**
     * ForConstructs example, {("CLIENT_ID" -> "test-client"),
     *   and returns a filter component that matches any specified name for the
     * entity type.
     ("USER" -> "test-user"),*
     * @param entityType the entity type the filter component       ("GROUP" -> "internal-group")}.applies to
     */
    public static ClientQuotaFilterComponent QuotaEntityofEntityType(Map<String, String> entriesString entityType);
}

    /**
     * @return Describesthe acomponent's quotaentity key.type
     */
    public class QuotaKey {String entityType();

    /**
     * The quota types. @return the optional match string, where:
     */
    public enum Type {
  if present, the name that's  CONSUMER_BYTE_RATE,matched exactly
     *   PRODUCER_BYTE_RATE,
        REQUEST_PERCENTAGE;
    }

if empty, matches the default name
     /**
     * The units for aif quotanull, value.matches Noteany therespecified mayname
 be multiple units for a*/
 given quota type
 public Optional<String> match();
}

/**
 * *Describes thata influencesclient quota entity behaviorfilter.
     */
public class ClientQuotaFilter {

 public enum Units {/**
     * A  RATE_BPS;
    }

filter to be applied to matching client quotas.
     /**
     * @param typecomponents the quota typecomponents to filter on
     * @param unitsstrict whether the unitsfilter foronly theincludes quotaspecified typecomponents
     */
    publicprivate QuotaKeyClientQuotaFilter(TypeCollection<ClientQuotaFilterComponent> typecomponents, Unitsboolean unitsstrict);
}

    /**
     * Constructs and Describesreturns a quota filter entity filter.
 */
public class QuotaFilter {that matches all provided components. Matching entities
    public enum* Rulewith {
entity types that are not specified by a EXACT,component will also be //included exactin namethe matchresult.
     *
   PREFIX;  * //@param matchescomponents allthe namescomponents withfor the filter
   given  prefix*/
     }public static ClientQuotaFilter contains(Collection<ClientQuotaFilterComponent> components);

    /**
     * Constructs Aand returns filteringa rulequota tofilter bethat applied.
matches all provided components. Matching *entities
     * @paramwith entityType the entity typetypes thethat ruleare appliesnot to
specified by a component will *not* be @paramincluded rulein the rule to applyresult.
     *
     * @param matchcomponents the non-nullcomponents stringfor that's applied by the rulethe filter
     */
    public QuotaFilter(QuotaEntity.Type entityType, Rule rule, String matchstatic ClientQuotaFilter containsOnly(Collection<ClientQuotaFilterComponent> components);
}

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

/**
 * The result of public Value(Entry entry, List<Entry> overriddenEntries);
    }the {@link Admin#describeClientQuotas(Collection, DescribeClientQuotasOptions)} call.
 */
public class DescribeClientQuotasResult {

    /**
     * Maps a collection of entitiesan entity to theirits effectiveconfigured quota values.
     *value(s). Note if no value is defined for a quota
     * @paramtype for that entity's config, then it is not included in the quota configuration resulting value map.
     *
     * @param entities future for the collection requestedof entities that matched the filter
     */
    public DescribeEffectiveQuotasResultDescribeClientQuotasResult(Map<QuotaEntityKafkaFuture<Map<ClientQuotaEntity, KafkaFuture<Map<QuotaKeyMap<String, Value>>>Double>>> configentities);

    /**
     * Returns a 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>>>Double>>> configentities();
}

public interface Admin extends AutoCloseable {
    ...

    /**
     * Returns a future which succeeds only if all quota descriptions succeed.Describes all entities matching the provided filter that have at least one client quota configuration
     */ value defined.
    public KafkaFuture<Void> all();
}

public interface Admin extends AutoCloseable {
    ...

    /**
     * Describes the effective quotas for the provided entities.* <p>
     * The following exceptions can be anticipated when calling {@code get()} on the future from the
     * returned {@link DescribeClientQuotasResult}:
     * <ul>
     * @param entities the entities to describe the effective quotas for
     * @param options the options to use<li>{@link org.apache.kafka.common.errors.ClusterAuthorizationException}
     *   If the authenticated user didn't have describe access to the cluster.</li>
     * @return the effective quotas for the entities
     */
    DescribeEffectiveQuotasResult describeEffectiveQuotas(Collection<QuotaEntity> entities, DescribeEffectiveQuotasOptions options);
}

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

/**
 * The result of the {@link  * @param entity the entity whose config will be modifiedAdmin#resolveClientQuotas(Collection, ResolveClientQuotasOptions)} call.
 */
public class ResolveClientQuotasResult {
    /**
     * Information about @parama opsspecific thequota alterationconfiguration toentry.
 perform - if value is*/
 set, then the existingpublic valueclass isEntry updated,{
     *   /**
         otherwise* if@param null,source the entity existingsource valuefor isthe clearedvalue
     */
    public AlterQuotasEntry* @param value the non-null value
         */
        public Entry(QuotaEntity entitysource, Collection<Op>Double opsvalue);
}

public class AlterQuotasOptions extends AbstractOptions<AlterQuotasOptions> {}

    /**
     * SetsInformation whetherabout the requestvalue shouldfor bea validated without altering the configsquota type.
     */
    public AlterQuotasOptions validateOnly(boolean validateOnly);
}

/**
 *NOTE: TheWe resultmaintain ofa the`Value` {@link Admin#alterQuotas(Collection<AlterQuotasEntry>, AlterQuotasOptions)} call.
 *
 * The API of this class is evolving, see {@link Admin} for details.
 */
public class AlterQuotasResultclass because additional information may be added, e.g.,
     *       a list of overridden entries.
     */
    public class Value {
    public  AlterQuotasResult(Map<QuotaEntity, KafkaFuture<Void>> futures);

 /**
    /**
     * Returns@param aentry mapthe fromquota quotaentry
 entity to a future which can be used to*/
 check the status of the operation.
  public   */Value(Entry entry);
    public Map<QuotaEntity, KafkaFuture<Void>> values();}

    /**
     * ReturnsMaps a futurecollection whichof succeedsentities onlyto iftheir allresolved quota alterations succeedvalues.
     */
    public KafkaFuture<Void> all();
}

public interface Admin extends AutoCloseable {
    ... * @param config the quota configuration for the requested entities
     */
    public ResolveClientQuotasResult(Map<QuotaEntity, KafkaFuture<Map<String, Value>>> config);

    /**
     * AltersReturns thea quotasmap as specified forfrom quota entity to a future which can be used to check the status of the entriesoperation.
     */
    public * @param alterations the alterations to performMap<QuotaEntity, KafkaFuture<Map<String, Value>>> config();

    /**
     * @return the result of the alterations Returns a future which succeeds only if all quota descriptions succeed.
     */
    public AlterQuotasResultKafkaFuture<Void> 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 \

{
  "apiKey": 49,
  "type": "request",
  "name": "DescribeEffectiveQuotasRequest",
  "validVersions": "0",
  "flexibleVersions": "none",
  "fields": [
    { "name": "Entity", "type": "[]QuotaEntityData", "versions": "0+",
      "about": "The quota entity description.", "fields": [
      { "name": "EntityType", "type": "string", "versions": "0+",
        "about": "The entity type." },
      { "name": "EntityName", "type": "string", "versions": "0+",
        "about": "The entity name." }
    ]},
    { "name": "OmitOverriddenValues", "type": "bool", "versions": "0+",
      "about": "Whether to exclude the list of overridden values for every quota type." }
  ]
}

{
  "apiKey": 49,
  "type": "response",
  "name": "DescribeEffectiveQuotasResponse",
  "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": "Entry", "type": "[]QuotaEntryData", "versions": "0+",
      "about": "Effective quota entries.", "fields": [
      { "name": "ErrorCode", "type": "int16", "versions": "0+",
        "about": "The error code, or `0` if the effective quota description succeeded." },
      { "name": "ErrorMessage", "type": "string", "versions": "0+", "nullableVersions": "0+",
        "about": "The error message, or `null` if the effective quota description succeeded." },
      { "name": "QuotaEntity", "type": "[]QuotaEntity", "versions": "0+",
        "about": "Effective quota entries.", "fields": [
        { "name": "EntityType", "type": "string", "versions": "0+",
          "about": "The entity type." },
        { "name": "EntityName", "type": "string", "versions": "0+",
          "about": "The entity name." }
      ]},
      { "name": "QuotaValues", "type": "[]QuotaValueData", "versions": "0+",
        "about": "Quota configuration values.", "fields": [
        { "name": "Type", "type": "string", "versions": "0+", --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 \
          "about": "The quota type." },
        { "name": "Units", "type": "string", "versions":   --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   \"0+",
          "about": "The units for the quota type." },
        { "name": "Entry", "type": "[]ValueEntryData", "versions": "0+",
          "about": "Quota value entries.", "fields": [
          { "name": "QuotaEntity", "type": "[]ValueQuotaEntity", "versions": "0+",  --names=client-id=my-client --defaults=user \
            "about": "Effective quota entries.", "fields": [
                  { "name": "EntityType", "type": "string", "versions": "0+",
--add=consumer_byte_rate=2000000            \
        "about": "The entity type." },
            { "name": "EntityName", "type": "string", "versions": "0+",
        --delete=producer_byte_rate

<no output on success>

$./bin/kafka-client-quotas.sh --bootstrap-server localhost:9092 --describe \
       "about": "The entity name." }
          ]},
         --names=client-id=my-client --defaults=user

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

{
  "apiKey": 48,
  "type"name": "Valuerequest",
  "typename": "int64DescribeClientQuotasRequest",
  "versionsvalidVersions": "0+",
  "flexibleVersions": "none",
  "fields": [
     { "aboutname": "The quota configuration value." }
        ]}
      ]}
    ]}
  ]
}

{
  "apiKey": 50,
  "type": "request",
  "name": "ResolveClientQuotasRequest",
  "validVersions": "0",
  "flexibleVersions": "none",
  "fields": [
    { "name": "Entity", "type": "[]QuotaEntityData", "versions": "0+",
      "about": "The quota entity description.", "fields": [
      { "name": "EntityType", "type": "string", "versions": "0+",
        "about": "The entity type." },
      { "name": "EntityName", "type": "string", "versions": "0+",
        "about": "The entity name." }
    ]}
  ]
}

{
  "apiKey": 50,
  "type": "response",
  "name": "ResolveClientQuotasResponse",
  "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": "Entry", "type": "[]QuotaEntryData", "versions": "0+",
      "about": "Resolved quota entries.", "fields": [
      { "name": "ErrorCode", "type": "int16", "versions": "0+",
        "about": "The error code, or `0` if the resolved quota description succeeded." },
      { "name": "ErrorMessage", "type": "string", "versions": "0+", "nullableVersions": "0+",
        "about": "The error message, or `null` if the resolved quota description succeeded." },
      { "name": "QuotaEntity", "type": "[]QuotaEntity", "versions": "0+",
        "about": "Resolved quota entries.", "fields": [
        { "name": "EntityType", "type": "string", "versions": "0+",
          "about": "The entity type." },
        { "name": "EntityName", "type": "string", "versions": "0+",
          "about": "The entity name." }
      ]},
      { "name": "QuotaValues", "type": "[]QuotaValueData", "versions": "0+",
        "about": "Quota configuration values.", "fields": [
        { "name": "Type", "type": "string", "versions": "0+",
          "about": "The quota type." },
        { "name": "Entry", "type": "[]ValueEntryData", "versions": "0+",
          "about": "Quota value entries.", "fields": [
          { "name": "QuotaEntity", "type": "[]ValueQuotaEntity", "versions": "0+",
            "about": "Resolved quota entries.", "fields": [
            { "name": "EntityType", "type": "string", "versions": "0+",
              "about": "The entity type." },
            { "name": "EntityName", "type": "string", "versions": "0+",
              "about": "The entity name." }
          ]},
          { "name": "Value", "type": "double", "versions": "0+",
            "about": "The quota configuration value." }
        ]}
      ]}
    ]}
  ]
}

{
  "apiKey": 49,
  "type": "request",
  "name": "AlterClientQuotasRequest",
  "validVersions": "0",
  "flexibleVersions": "none",
  "fields": [
    { "name": "Entries", "type": "[]EntryData", "versions": "0+",
      "about": "The quota configuration entries to alter.", "fields": [
      { "name": "Entity", "type": "[]EntityData", "versions": "0+",
        "about": "The quota entity to alter.", "fields": [
        { "name": "EntityType", "type": "string", "versions": "0+",
          "about": "The entity type." },
        { "name": "EntityName", "type": "string", "versions": "0+", "nullableVersions": "0+",
          "about": "The name of the entity, or null if the default." }
      ]},
      { "name": "Ops", "type": "[]OpData", "versions": "0+",
        "about": "An individual quota configuration entry to alter.", "fields": [
        { "name": "Key", "type": "string", "versions": "0+",
          "about": "The quota configuration key." },
        { "name": "Value", "type": "float64", "versions": "0+",
          "about": "The value to set, otherwise ignored if the value is to be removed." },
        { "name": "Remove", "type": "bool", "versions": "0+",
          "about": "Whether the quota configuration value should be removed, otherwise set." }
      ]}
    ]},
    { "name": "ValidateOnly", "type": "bool", "versions": "0+",
      "about": "Whether the alteration should be validated, but not performed." }
  ]
}

{
  "apiKey": 49,
  "type": "response",
  "name": "AlterClientQuotasResponse",
  "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": "Entries", "type": "[]EntryData", "versions": "0+",
      "about": "The quota configuration entries to alter.", "fields": [
      { "name": "ErrorCode", "type": "int16", "versions": "0+",
        "about": "The error code, or `0` if the quota alteration succeeded." },
      { "name": "ErrorMessage", "type": "string", "versions": "0+", "nullableVersions": "0+",
        "about": "The error message, or `null` if the quota alteration succeeded." },
      { "name": "Entity", "type": "[]EntityData", "versions": "0+",
        "about": "The quota entity to alter.", "fields": [
        { "name": "EntityType", "type": "string", "versions": "0+",
          "about": "The entity type." },
        { "name": "EntityName", "type": "string", "versions": "0+", "nullableVersions": "0+",
          "about": "The name of the entity, or null if the default." }
      ]}
    ]}
  ]
}

    /**
     * Read a double-precision 64-bit format IEEE 754 value.
     *
     * @param buffer The buffer to read from
     * @return The long value read
     */
    public static double readDouble(ByteBuffer buffer) {
        return Double.longBitsToDouble(buffer.getLong());
    }

    /**
     * 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 The buffer to write to
     */
    public static void writeDouble(double value, ByteBuffer buffer) {
        buffer.putLong(Double.doubleToRawLongBits(value));
    }

    public static final DocumentedType DOUBLE = new DocumentedType() {
        @Override
        public void write(ByteBuffer buffer, Object o) {
            ByteUtils.writeDouble((Double) o, buffer);
        }

        @Override
        public Object read(ByteBuffer buffer) {
            return ByteUtils.readDouble(buffer);
        }

        @Override
        public int sizeOf(Object o) {
            return 8;
        }

        @Override
        public String typeName() {
            return "DOUBLE";
        }

        @Override
        public Double validate(Object item) {
            if (item instanceof Double)
                return (Double) item;
            else
                throw new SchemaException(item + " is not a Double.");
        }

        @Override
        public String documentation() {
            return "Represents a double-precision 64-bit format IEEE 754 value. " +
                    "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)