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

/**
 *Constructs Theand resultreturns ofa thefilter {@link Admin#describeClientQuotas(Collection, DescribeClientQuotasOptions)} call.
 */
public class DescribeClientQuotasResult {

component that matches the built-in default entity name
     /**
     * Maps anfor the entity totype.
 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 entityType the entity type the filter component applies to
     */
    public static ClientQuotaFilterComponent ofDefaultEntity(String entityType);

     /**
     * @paramConstructs entitiesand thereturns collectiona offilter entitiescomponent that matchedmatches theany filter
specified name for the
  */
   * public DescribeClientQuotasResult(KafkaFuture<Map<QuotaEntity, Map<String, Double>>> entities);

    /**entity type.
     *
     * Returns@param aentityType map fromthe quota entity totype athe futurefilter whichcomponent can beapplies used to check the status of the operation.
     */
    public KafkaFuture<Map<QuotaEntity,static Map<String, Double>>> entities(ClientQuotaFilterComponent ofEntityType(String entityType);
}

public  interface Admin extends/**
 AutoCloseable {
   * ...

@return the component's entity /**type
     */
 Describes all entities matchingpublic all provided filters (logical AND) that have at least oneString entityType();

    /**
     * quota value defined. @return the optional match string, where:
     *
       * @param filtersif filterspresent, tothe applyname tothat's matchingmatched entitiesexactly
     * @param options         if empty, matches the optionsdefault to usename
     * @return result containing all matching entities         if null, matches any specified name
     */
    DescribeClientQuotasResultpublic describeClientQuotas(Collection<QuotaFilter> filters, DescribeClientQuotasOptions options);
}

public class ResolveClientQuotasOptions extends AbstractOptions<ResolveClientQuotasOptions> {
    // Empty.
Optional<String> match();
}

/**
 * TheDescribes resulta ofclient thequota {@link Admin#resolveClientQuotas(Collection, ResolveClientQuotasOptions)} callentity filter.
 */
public class ResolveClientQuotasResultClientQuotaFilter {

    /**
     * A Informationfilter to aboutbe aapplied specificto quotamatching configurationclient entryquotas.
     */
    public class* Entry@param {
components the components to filter on
   /**
         * * @param sourcestrict the entity source for whether the value
filter only includes       * @param value the non-null value
 specified components
        */
        public Entry(QuotaEntity source, Double value);
    }

private ClientQuotaFilter(Collection<ClientQuotaFilterComponent> components, boolean strict);

    /**
     * InformationConstructs aboutand thereturns valuea forquota afilter quotathat type.
matches all provided components. Matching *entities
     * NOTE:with Weentity maintaintypes athat `Value`are class because additional information may be added, e.g.,not specified by a component will also be included in the result.
     *
     * @param components athe listcomponents offor overriddenthe entries.filter
     */
    public class Value {static ClientQuotaFilter contains(Collection<ClientQuotaFilterComponent> components);

        /**
     * Constructs and returns *a @paramquota entryfilter thethat quotamatches entry
all provided components. Matching entities
     */
 with entity types that are not specified publicby Value(Entry entry);
    }

    /**
     * Maps a collection of entities to their resolved quota valuesa component will *not* be included in the result.
     *
     * @param configcomponents the quotacomponents configuration for the requested entitiesfilter
     */
    public ResolveClientQuotasResult(Map<QuotaEntity, KafkaFuture<Map<String, Value>>> configstatic ClientQuotaFilter containsOnly(Collection<ClientQuotaFilterComponent> components);

    /**
     * ReturnsConstructs aand mapreturns froma quota entityfilter tothat amatches futureall which can be used to check the status of the operationconfigured entities.
     */
    public Map<QuotaEntity,static KafkaFuture<Map<String, Value>>> config(ClientQuotaFilter all();

    /**
     * Returns@return athe future which succeeds only if all quota descriptions succeed.filter's components
     */
    public KafkaFuture<Void>Collection<ClientQuotaFilterComponent> allcomponents();
}

public interface Admin extends AutoCloseable {
    ...

    /**
     * @return Resolveswhether the filter effectiveis quota values for the provided entities.strict, i.e. only includes specified components
     */
    public boolean strict();
}

/**
 * @paramDescribes entitiesa theconfiguration entitiesalteration 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);
}

public class AlterClientQuotasEntry {
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);

    }

    /**
     * @param entity the entity* whose@return configthe will be modified
quota type to alter
         */
        public String key();

        /**
 @param  ops the alteration to perform - if* value@return isif set, then the existing value is updated,
     *    *         otherwise if null, the existing value is cleared
         */
     public  AlterClientQuotasEntry(QuotaEntity entity,public Collection<Op>Double opsvalue();
    }

public   class AlterClientQuotasOptionsprivate extendsfinal AbstractOptions<AlterClientQuotasOptions>ClientQuotaEntity {entity;
    /**
private final Collection<Op> ops;

  * Sets whether the request should be validated without altering the configs. /**
     * @param entity the entity whose config will be modified
     * @param ops the alteration to perform
     */
    public AlterClientQuotasOptions validateOnly(boolean validateOnlyClientQuotaAlteration(ClientQuotaEntity entity, Collection<Op> ops);
}

    /**
   * The result* of@return the entity {@link Admin#alterClientQuotas(Collection, AlterClientQuotasOptions)} call.
 *
 * The API of this class is evolving, see {@link Admin} for details.
 */
public class AlterClientQuotasResult {
    public AlterClientQuotasResult(Map<QuotaEntity, KafkaFuture<Void>> futureswhose config will be modified
     */
    public ClientQuotaEntity entity();

    /**
     * Returns@return athe map from quota entity to a future which can be used to check the status of the operation.alteration to perform
     */
    public Map<QuotaEntity, KafkaFuture<Void>> valuesCollection<Op> ops();
}

{
  "apiKey": 48,
  "type": "request",
  "name": "DescribeClientQuotasRequest",
  "validVersionscomponents to apply to quota entities.", "fields": [
      { "name": "EntityType", "type": "string", "versions": "0+",
        "flexibleVersionsabout": "none"The entity type that the filter component applies to." },
  "fields": [
    { "name": "FilterMatchType", "type": "[]QuotaFilterDataint8", "versions": "0+",
       "about": "Filters to apply to quota entities.", "fields": [ "about": "How to match the entity {0 = exact name, 1 = default name, 2 = any specified name}." },
      { "name": "EntityTypeMatch", "type": "string", "versions": "0+", "nullableVersions": "0+",
        "about": "The entity type thatstring to match against, or null if unused for the filtermatch applies totype." },
    ]},
    { "name": "MatchStrict", "type": "stringbool", "versions": "0+", "nullableVersions": "0+",
        "about": "TheWhether stringthe tomatch matchis against, or null if the typestrict, i.e. should beexclude omitted." }
    ]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": "EntryErrorCode", "type": "[]EntryDataint16", "versions": "0+",
      "about": "AThe resulterror entry."code, "fields": [
   or `0` if the quota description succeeded." },
    { "name": "ErrorCodeErrorMessage", "type": "int16string", "versions": "0+",
 "nullableVersions": "0+",
      "about": "The error codemessage, or `0``null` if the quota description succeeded." },
      { "name": "ErrorMessageEntries", "type": "string[]EntryData", "versions": "0+", "nullableVersions": "0+",
        "about": "TheA errorresult message, or `null` if the quota description succeeded." },entry.", "fields": [
      { "name": "Entity", "type": "[]QuotaEntityDataEntityData", "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": "TypeKey", "type": "string", "versions": "0+",
          "about": "The quota typeconfiguration key." },
        { "name": "Value", "type": "doublefloat64", "versions": "0+",
          "about": "The quota configuration value." }
      ]}
    ]}
  ]
}