/**
     * Represents the default name for an entity, i.e. the entity that's matched
     * when an exact match isn't found.
     */
    public final static String QUOTA_ENTITY_DEFAULT = // implementation defined

    /**
     * Describes an entity type.
     */
    public enum QuotaEntity {
        USER,        // The user principal.
        CLIENT_ID,   // The client ID.

        // Note others may be added in the future.
    }

    public class QuotaFilter {
       public enum Rule {
         EXACT,    // exact name match
         NOT,      // matches all non-matching names
         PREFIX,   // matches all names with the given prefix

         // Note others may be added in the future.
       }

       /**
        * A filtering rule to be applied.
        *
        * @param entity the entity 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 entity, Rule rule, String match);

       public QuotaEntity entity();
       public Rule rule();
       public String match();
    }

    public class DescribeQuotasOptions {
        // Default.
    }

    public class DescribeQuotasResult {
        /**
         * @return the collection of entities that matched the filter
         */
        KafkaFuture<Collection<Map<QuotaEntity, String>>> entities();
    }

    public interface Admin extends AutoCloseable {
        /**
         * Describes all entities matching all provided filters (logical AND) that have at least one
         * quota value defined.
         */
        DescribeQuotasResult describeQuotas(Collection<QuotaFilter> filters, DescribeQuotasOptions options);
    }

    /**
     * The quota types.
     */
    public enum QuotaType {
        CONSUMER_BYTE_RATE,
        PRODUCER_BYTE_RATE,
        REQUEST_PERCENTAGE,

        // Note others may be added in the future.
    }

    public class DescribeEffectiveQuotasOptions {
        // Whether to omit any inherited values in the result. If true, then undefined values for
        // the entity's config will be excluded from the results.
        //
        // Default: false.
        DescribeQuotasOptions setOmitInheritedValues(boolean omitInheritedValues);

        // Whether to include the list of overridden values for every quota type in the result.
        //
        // Default: false.
        DescribeQuotasOptions setOmitOverriddenValues(boolean omitOverriddenValues);
    }

    public class DescribeEffectiveQuotasResult {
        /**
         * Information about a specific quota configuration value.
         */
        public class Value {
            /**
             * @param source the entity source for the value
             * @param value the non-null value
             */
            public Value(Map<QuotaEntity, String> source, Double value);

            public Map<QuotaEntity, String> source();
            public Double value();
        }

        /**
         * Information about the value for a quota type.
         */
        public class Entry {
            /**
             * @param value the active quota value
             * @param overriddenValues all values that are overridden due to being lower in specificity
             */
            public Entry(Value value, List<Value> overriddenValues);

            public Value value();
            public List<Value> overriddenValues();
        }

        /**
         * Maps a quota type to its configuration entry.
         *
         * Note that if `options.omitInheritedValues` is true, then this config may not map every
         * quota type to an entry. If a key is not contained in the map, then that quota type's value
         * is not specified.
         */
        public KafkaFuture<Map<QuotaType, Entry>> config();
    }

    public interface Admin extends AutoCloseable {
        /**
         * Describes the effective quotas for the provided entities.
         */
        DescribeEffectiveQuotasResult describeEffectiveQuotas(Collection<QuotaEntity> quotaEntities,
                                                              DescribeEffectiveQuotasOptions options);
    }

    public class AlterQuotasOp {
        /**
         * @param type the quota type to alter
         * @param the new value for the quota, otherwise if null, then the existing value is cleared
         */
        public QuotaAlteration(QuotaType type, Double value);
        public QuotaType type();
        public Double value();
    }

    public class AlterQuotasOptions {
        // Default.
    }

    public class AlterQuotasResult {
        /**
         * @return map of a quota entity update to its future
         */
        public Map<QuotaEntity, KafkaFuture<Void>> futures();
    }

    public interface Admin extends AutoCloseable {
        /**
         * Alters the quotas as specified for the provided quota entities.
         *
         * @param alterations the alterations to perform
         * @return the result of the alterations
         */
        AlterQuotasResult alterQuotas(Map<QuotaEntity, AlterQuotasOp> alterations);
    }