@bottlebooks/valid-values 7.4.2 → 7.4.3

package/dist/validValues/designation.d.ts

@@ -0,0 +1,632 @@
+import type { MessageDescriptor } from '@lingui/core';
+import type { ProductType as ProductTypeKey } from './types/ProductTypeKey.js';
+interface ValidValueDefinition {
+    title: MessageDescriptor;
+    /**
+     * Fields that will never be stored in the database,
+     * because they are not relevant to the frontend rendering.
+     * They are only used for the form, like grouping values for easier entry.
+     */
+    form?: {
+        /**
+         * A helpful description shown only when using the form.
+         */
+        description?: MessageDescriptor;
+    };
+    /**
+     * Fields that are stored in the database together with each lookup value,
+     * because they affect the frontend rendering.
+     * They are also included in the hash values to detect breaking changes.
+     *
+     * We should try to avoid them if possible because if false positives:
+     * Any change in one of those fields would lead to
+     * eLabels that are marked as incompatible,
+     * although there might be no user-visible changes.
+     */
+    frontend?: {};
+}
+interface DesignationInput extends ValidValueDefinition {
+}
+declare const allDesignations: readonly [{
+    key: "brut";
+    title: MessageDescriptor;
+    /**
+     * Fields that will never be stored in the database,
+     * because they are not relevant to the frontend rendering.
+     * They are only used for the form, like grouping values for easier entry.
+     */
+    form?: {
+        /**
+         * A helpful description shown only when using the form.
+         */
+        description?: MessageDescriptor | undefined;
+    } | undefined;
+    /**
+     * Fields that are stored in the database together with each lookup value,
+     * because they affect the frontend rendering.
+     * They are also included in the hash values to detect breaking changes.
+     *
+     * We should try to avoid them if possible because if false positives:
+     * Any change in one of those fields would lead to
+     * eLabels that are marked as incompatible,
+     * although there might be no user-visible changes.
+     */
+    frontend?: {} | undefined;
+}, {
+    key: "brut_nature";
+    title: MessageDescriptor;
+    /**
+     * Fields that will never be stored in the database,
+     * because they are not relevant to the frontend rendering.
+     * They are only used for the form, like grouping values for easier entry.
+     */
+    form?: {
+        /**
+         * A helpful description shown only when using the form.
+         */
+        description?: MessageDescriptor | undefined;
+    } | undefined;
+    /**
+     * Fields that are stored in the database together with each lookup value,
+     * because they affect the frontend rendering.
+     * They are also included in the hash values to detect breaking changes.
+     *
+     * We should try to avoid them if possible because if false positives:
+     * Any change in one of those fields would lead to
+     * eLabels that are marked as incompatible,
+     * although there might be no user-visible changes.
+     */
+    frontend?: {} | undefined;
+}, {
+    key: "demi-sec";
+    title: MessageDescriptor;
+    /**
+     * Fields that will never be stored in the database,
+     * because they are not relevant to the frontend rendering.
+     * They are only used for the form, like grouping values for easier entry.
+     */
+    form?: {
+        /**
+         * A helpful description shown only when using the form.
+         */
+        description?: MessageDescriptor | undefined;
+    } | undefined;
+    /**
+     * Fields that are stored in the database together with each lookup value,
+     * because they affect the frontend rendering.
+     * They are also included in the hash values to detect breaking changes.
+     *
+     * We should try to avoid them if possible because if false positives:
+     * Any change in one of those fields would lead to
+     * eLabels that are marked as incompatible,
+     * although there might be no user-visible changes.
+     */
+    frontend?: {} | undefined;
+}, {
+    key: "dry";
+    title: MessageDescriptor;
+    /**
+     * Fields that will never be stored in the database,
+     * because they are not relevant to the frontend rendering.
+     * They are only used for the form, like grouping values for easier entry.
+     */
+    form?: {
+        /**
+         * A helpful description shown only when using the form.
+         */
+        description?: MessageDescriptor | undefined;
+    } | undefined;
+    /**
+     * Fields that are stored in the database together with each lookup value,
+     * because they affect the frontend rendering.
+     * They are also included in the hash values to detect breaking changes.
+     *
+     * We should try to avoid them if possible because if false positives:
+     * Any change in one of those fields would lead to
+     * eLabels that are marked as incompatible,
+     * although there might be no user-visible changes.
+     */
+    frontend?: {} | undefined;
+}, {
+    key: "extra_brut";
+    title: MessageDescriptor;
+    /**
+     * Fields that will never be stored in the database,
+     * because they are not relevant to the frontend rendering.
+     * They are only used for the form, like grouping values for easier entry.
+     */
+    form?: {
+        /**
+         * A helpful description shown only when using the form.
+         */
+        description?: MessageDescriptor | undefined;
+    } | undefined;
+    /**
+     * Fields that are stored in the database together with each lookup value,
+     * because they affect the frontend rendering.
+     * They are also included in the hash values to detect breaking changes.
+     *
+     * We should try to avoid them if possible because if false positives:
+     * Any change in one of those fields would lead to
+     * eLabels that are marked as incompatible,
+     * although there might be no user-visible changes.
+     */
+    frontend?: {} | undefined;
+}, {
+    key: "extra_dry";
+    title: MessageDescriptor;
+    /**
+     * Fields that will never be stored in the database,
+     * because they are not relevant to the frontend rendering.
+     * They are only used for the form, like grouping values for easier entry.
+     */
+    form?: {
+        /**
+         * A helpful description shown only when using the form.
+         */
+        description?: MessageDescriptor | undefined;
+    } | undefined;
+    /**
+     * Fields that are stored in the database together with each lookup value,
+     * because they affect the frontend rendering.
+     * They are also included in the hash values to detect breaking changes.
+     *
+     * We should try to avoid them if possible because if false positives:
+     * Any change in one of those fields would lead to
+     * eLabels that are marked as incompatible,
+     * although there might be no user-visible changes.
+     */
+    frontend?: {} | undefined;
+}, {
+    key: "feinherb";
+    title: MessageDescriptor;
+    /**
+     * Fields that will never be stored in the database,
+     * because they are not relevant to the frontend rendering.
+     * They are only used for the form, like grouping values for easier entry.
+     */
+    form?: {
+        /**
+         * A helpful description shown only when using the form.
+         */
+        description?: MessageDescriptor | undefined;
+    } | undefined;
+    /**
+     * Fields that are stored in the database together with each lookup value,
+     * because they affect the frontend rendering.
+     * They are also included in the hash values to detect breaking changes.
+     *
+     * We should try to avoid them if possible because if false positives:
+     * Any change in one of those fields would lead to
+     * eLabels that are marked as incompatible,
+     * although there might be no user-visible changes.
+     */
+    frontend?: {} | undefined;
+}, {
+    key: "lieblich";
+    title: MessageDescriptor;
+    /**
+     * Fields that will never be stored in the database,
+     * because they are not relevant to the frontend rendering.
+     * They are only used for the form, like grouping values for easier entry.
+     */
+    form?: {
+        /**
+         * A helpful description shown only when using the form.
+         */
+        description?: MessageDescriptor | undefined;
+    } | undefined;
+    /**
+     * Fields that are stored in the database together with each lookup value,
+     * because they affect the frontend rendering.
+     * They are also included in the hash values to detect breaking changes.
+     *
+     * We should try to avoid them if possible because if false positives:
+     * Any change in one of those fields would lead to
+     * eLabels that are marked as incompatible,
+     * although there might be no user-visible changes.
+     */
+    frontend?: {} | undefined;
+}, {
+    key: "semi";
+    title: MessageDescriptor;
+    /**
+     * Fields that will never be stored in the database,
+     * because they are not relevant to the frontend rendering.
+     * They are only used for the form, like grouping values for easier entry.
+     */
+    form?: {
+        /**
+         * A helpful description shown only when using the form.
+         */
+        description?: MessageDescriptor | undefined;
+    } | undefined;
+    /**
+     * Fields that are stored in the database together with each lookup value,
+     * because they affect the frontend rendering.
+     * They are also included in the hash values to detect breaking changes.
+     *
+     * We should try to avoid them if possible because if false positives:
+     * Any change in one of those fields would lead to
+     * eLabels that are marked as incompatible,
+     * although there might be no user-visible changes.
+     */
+    frontend?: {} | undefined;
+}, {
+    key: "sweet";
+    title: MessageDescriptor;
+    /**
+     * Fields that will never be stored in the database,
+     * because they are not relevant to the frontend rendering.
+     * They are only used for the form, like grouping values for easier entry.
+     */
+    form?: {
+        /**
+         * A helpful description shown only when using the form.
+         */
+        description?: MessageDescriptor | undefined;
+    } | undefined;
+    /**
+     * Fields that are stored in the database together with each lookup value,
+     * because they affect the frontend rendering.
+     * They are also included in the hash values to detect breaking changes.
+     *
+     * We should try to avoid them if possible because if false positives:
+     * Any change in one of those fields would lead to
+     * eLabels that are marked as incompatible,
+     * although there might be no user-visible changes.
+     */
+    frontend?: {} | undefined;
+}, {
+    key: "semi_sweet";
+    title: MessageDescriptor;
+    /**
+     * Fields that will never be stored in the database,
+     * because they are not relevant to the frontend rendering.
+     * They are only used for the form, like grouping values for easier entry.
+     */
+    form?: {
+        /**
+         * A helpful description shown only when using the form.
+         */
+        description?: MessageDescriptor | undefined;
+    } | undefined;
+    /**
+     * Fields that are stored in the database together with each lookup value,
+     * because they affect the frontend rendering.
+     * They are also included in the hash values to detect breaking changes.
+     *
+     * We should try to avoid them if possible because if false positives:
+     * Any change in one of those fields would lead to
+     * eLabels that are marked as incompatible,
+     * although there might be no user-visible changes.
+     */
+    frontend?: {} | undefined;
+}];
+declare type DesignationKey = typeof allDesignations[number]['key'];
+interface DesignationOutput extends DesignationInput {
+    key: DesignationKey;
+}
+declare const _default: {
+    byProductType: {
+        beer: {};
+        spirit_absinthe: {};
+        spirit_anise: {};
+        spirit_aquavit: {};
+        spirit_arak: {};
+        spirit_armagnac: {};
+        spirit_asianspirit: {};
+        spirit_bitter: {};
+        spirit_cachaca: {};
+        spirit_calvados: {};
+        spirit_cocktail: {};
+        spirit_cognac: {};
+        spirit_fruitspirit: {};
+        spirit_genever: {};
+        spirit_gin: {};
+        spirit_grainspirit: {};
+        spirit_grapebrandy: {};
+        spirit_grappa: {};
+        spirit_liqueur: {};
+        spirit_marc: {};
+        spirit_mezcal: {};
+        spirit_miscspririt: {};
+        spirit_ouzo: {};
+        spirit_pastis: {};
+        spirit_pisco: {};
+        spirit_raki: {};
+        spirit_rum: {};
+        spirit_sambuca: {};
+        spirit_shochu: {};
+        spirit_schnaps: {};
+        spirit_tequila: {};
+        spirit_vermouth: {};
+        spirit_vodka: {};
+        spirit_whisky: {};
+        wine_fortified: Record<"dry" | "semi" | "sweet", DesignationOutput>;
+        wine_pearlwine: Record<"dry" | "semi" | "sweet", DesignationOutput>;
+        wine_sparkling: Record<"brut" | "demi-sec" | "dry" | "brut_nature" | "extra_brut" | "extra_dry", DesignationOutput>;
+        wine_stillwine: Record<"dry" | "feinherb" | "lieblich" | "semi" | "sweet", DesignationOutput>;
+        wine_aromatized: Record<"dry" | "extra_dry" | "semi" | "sweet" | "semi_sweet", DesignationOutput>;
+    };
+    listByProductType: Record<ProductTypeKey, DesignationOutput[]>;
+    list: readonly [{
+        key: "brut";
+        title: MessageDescriptor;
+        /**
+         * Fields that will never be stored in the database,
+         * because they are not relevant to the frontend rendering.
+         * They are only used for the form, like grouping values for easier entry.
+         */
+        form?: {
+            /**
+             * A helpful description shown only when using the form.
+             */
+            description?: MessageDescriptor | undefined;
+        } | undefined;
+        /**
+         * Fields that are stored in the database together with each lookup value,
+         * because they affect the frontend rendering.
+         * They are also included in the hash values to detect breaking changes.
+         *
+         * We should try to avoid them if possible because if false positives:
+         * Any change in one of those fields would lead to
+         * eLabels that are marked as incompatible,
+         * although there might be no user-visible changes.
+         */
+        frontend?: {} | undefined;
+    }, {
+        key: "brut_nature";
+        title: MessageDescriptor;
+        /**
+         * Fields that will never be stored in the database,
+         * because they are not relevant to the frontend rendering.
+         * They are only used for the form, like grouping values for easier entry.
+         */
+        form?: {
+            /**
+             * A helpful description shown only when using the form.
+             */
+            description?: MessageDescriptor | undefined;
+        } | undefined;
+        /**
+         * Fields that are stored in the database together with each lookup value,
+         * because they affect the frontend rendering.
+         * They are also included in the hash values to detect breaking changes.
+         *
+         * We should try to avoid them if possible because if false positives:
+         * Any change in one of those fields would lead to
+         * eLabels that are marked as incompatible,
+         * although there might be no user-visible changes.
+         */
+        frontend?: {} | undefined;
+    }, {
+        key: "demi-sec";
+        title: MessageDescriptor;
+        /**
+         * Fields that will never be stored in the database,
+         * because they are not relevant to the frontend rendering.
+         * They are only used for the form, like grouping values for easier entry.
+         */
+        form?: {
+            /**
+             * A helpful description shown only when using the form.
+             */
+            description?: MessageDescriptor | undefined;
+        } | undefined;
+        /**
+         * Fields that are stored in the database together with each lookup value,
+         * because they affect the frontend rendering.
+         * They are also included in the hash values to detect breaking changes.
+         *
+         * We should try to avoid them if possible because if false positives:
+         * Any change in one of those fields would lead to
+         * eLabels that are marked as incompatible,
+         * although there might be no user-visible changes.
+         */
+        frontend?: {} | undefined;
+    }, {
+        key: "dry";
+        title: MessageDescriptor;
+        /**
+         * Fields that will never be stored in the database,
+         * because they are not relevant to the frontend rendering.
+         * They are only used for the form, like grouping values for easier entry.
+         */
+        form?: {
+            /**
+             * A helpful description shown only when using the form.
+             */
+            description?: MessageDescriptor | undefined;
+        } | undefined;
+        /**
+         * Fields that are stored in the database together with each lookup value,
+         * because they affect the frontend rendering.
+         * They are also included in the hash values to detect breaking changes.
+         *
+         * We should try to avoid them if possible because if false positives:
+         * Any change in one of those fields would lead to
+         * eLabels that are marked as incompatible,
+         * although there might be no user-visible changes.
+         */
+        frontend?: {} | undefined;
+    }, {
+        key: "extra_brut";
+        title: MessageDescriptor;
+        /**
+         * Fields that will never be stored in the database,
+         * because they are not relevant to the frontend rendering.
+         * They are only used for the form, like grouping values for easier entry.
+         */
+        form?: {
+            /**
+             * A helpful description shown only when using the form.
+             */
+            description?: MessageDescriptor | undefined;
+        } | undefined;
+        /**
+         * Fields that are stored in the database together with each lookup value,
+         * because they affect the frontend rendering.
+         * They are also included in the hash values to detect breaking changes.
+         *
+         * We should try to avoid them if possible because if false positives:
+         * Any change in one of those fields would lead to
+         * eLabels that are marked as incompatible,
+         * although there might be no user-visible changes.
+         */
+        frontend?: {} | undefined;
+    }, {
+        key: "extra_dry";
+        title: MessageDescriptor;
+        /**
+         * Fields that will never be stored in the database,
+         * because they are not relevant to the frontend rendering.
+         * They are only used for the form, like grouping values for easier entry.
+         */
+        form?: {
+            /**
+             * A helpful description shown only when using the form.
+             */
+            description?: MessageDescriptor | undefined;
+        } | undefined;
+        /**
+         * Fields that are stored in the database together with each lookup value,
+         * because they affect the frontend rendering.
+         * They are also included in the hash values to detect breaking changes.
+         *
+         * We should try to avoid them if possible because if false positives:
+         * Any change in one of those fields would lead to
+         * eLabels that are marked as incompatible,
+         * although there might be no user-visible changes.
+         */
+        frontend?: {} | undefined;
+    }, {
+        key: "feinherb";
+        title: MessageDescriptor;
+        /**
+         * Fields that will never be stored in the database,
+         * because they are not relevant to the frontend rendering.
+         * They are only used for the form, like grouping values for easier entry.
+         */
+        form?: {
+            /**
+             * A helpful description shown only when using the form.
+             */
+            description?: MessageDescriptor | undefined;
+        } | undefined;
+        /**
+         * Fields that are stored in the database together with each lookup value,
+         * because they affect the frontend rendering.
+         * They are also included in the hash values to detect breaking changes.
+         *
+         * We should try to avoid them if possible because if false positives:
+         * Any change in one of those fields would lead to
+         * eLabels that are marked as incompatible,
+         * although there might be no user-visible changes.
+         */
+        frontend?: {} | undefined;
+    }, {
+        key: "lieblich";
+        title: MessageDescriptor;
+        /**
+         * Fields that will never be stored in the database,
+         * because they are not relevant to the frontend rendering.
+         * They are only used for the form, like grouping values for easier entry.
+         */
+        form?: {
+            /**
+             * A helpful description shown only when using the form.
+             */
+            description?: MessageDescriptor | undefined;
+        } | undefined;
+        /**
+         * Fields that are stored in the database together with each lookup value,
+         * because they affect the frontend rendering.
+         * They are also included in the hash values to detect breaking changes.
+         *
+         * We should try to avoid them if possible because if false positives:
+         * Any change in one of those fields would lead to
+         * eLabels that are marked as incompatible,
+         * although there might be no user-visible changes.
+         */
+        frontend?: {} | undefined;
+    }, {
+        key: "semi";
+        title: MessageDescriptor;
+        /**
+         * Fields that will never be stored in the database,
+         * because they are not relevant to the frontend rendering.
+         * They are only used for the form, like grouping values for easier entry.
+         */
+        form?: {
+            /**
+             * A helpful description shown only when using the form.
+             */
+            description?: MessageDescriptor | undefined;
+        } | undefined;
+        /**
+         * Fields that are stored in the database together with each lookup value,
+         * because they affect the frontend rendering.
+         * They are also included in the hash values to detect breaking changes.
+         *
+         * We should try to avoid them if possible because if false positives:
+         * Any change in one of those fields would lead to
+         * eLabels that are marked as incompatible,
+         * although there might be no user-visible changes.
+         */
+        frontend?: {} | undefined;
+    }, {
+        key: "sweet";
+        title: MessageDescriptor;
+        /**
+         * Fields that will never be stored in the database,
+         * because they are not relevant to the frontend rendering.
+         * They are only used for the form, like grouping values for easier entry.
+         */
+        form?: {
+            /**
+             * A helpful description shown only when using the form.
+             */
+            description?: MessageDescriptor | undefined;
+        } | undefined;
+        /**
+         * Fields that are stored in the database together with each lookup value,
+         * because they affect the frontend rendering.
+         * They are also included in the hash values to detect breaking changes.
+         *
+         * We should try to avoid them if possible because if false positives:
+         * Any change in one of those fields would lead to
+         * eLabels that are marked as incompatible,
+         * although there might be no user-visible changes.
+         */
+        frontend?: {} | undefined;
+    }, {
+        key: "semi_sweet";
+        title: MessageDescriptor;
+        /**
+         * Fields that will never be stored in the database,
+         * because they are not relevant to the frontend rendering.
+         * They are only used for the form, like grouping values for easier entry.
+         */
+        form?: {
+            /**
+             * A helpful description shown only when using the form.
+             */
+            description?: MessageDescriptor | undefined;
+        } | undefined;
+        /**
+         * Fields that are stored in the database together with each lookup value,
+         * because they affect the frontend rendering.
+         * They are also included in the hash values to detect breaking changes.
+         *
+         * We should try to avoid them if possible because if false positives:
+         * Any change in one of those fields would lead to
+         * eLabels that are marked as incompatible,
+         * although there might be no user-visible changes.
+         */
+        frontend?: {} | undefined;
+    }];
+    byId: Record<"brut" | "demi-sec" | "dry" | "feinherb" | "lieblich" | "brut_nature" | "extra_brut" | "extra_dry" | "semi" | "sweet" | "semi_sweet", DesignationOutput>;
+};
+export default _default;
+//# sourceMappingURL=designation.d.ts.map

package/dist/validValues/designation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"designation.d.ts","sourceRoot":"","sources":["../../src/validValues/designation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEtD,OAAO,KAAK,EAAE,WAAW,IAAI,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAI/E,UAAU,oBAAoB;IAC5B,KAAK,EAAE,iBAAiB,CAAC;IACzB;;;;OAIG;IACH,IAAI,CAAC,EAAE;QACL;;WAEG;QACH,WAAW,CAAC,EAAE,iBAAiB,CAAC;KACjC,CAAC;IACF;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,EAAE,CAAC;CACf;AAED,UAAU,gBAAiB,SAAQ,oBAAoB;CAAG;AAW1D,QAAA,MAAM,eAAe;;WApCZ,iBAAiB;IACxB;;;;OAIG;;QAED;;WAEG;;;IAGL;;;;;;;;;OASG;;;;WArBI,iBAAiB;IACxB;;;;OAIG;;QAED;;WAEG;;;IAGL;;;;;;;;;OASG;;;;WArBI,iBAAiB;IACxB;;;;OAIG;;QAED;;WAEG;;;IAGL;;;;;;;;;OASG;;;;WArBI,iBAAiB;IACxB;;;;OAIG;;QAED;;WAEG;;;IAGL;;;;;;;;;OASG;;;;WArBI,iBAAiB;IACxB;;;;OAIG;;QAED;;WAEG;;;IAGL;;;;;;;;;OASG;;;;WArBI,iBAAiB;IACxB;;;;OAIG;;QAED;;WAEG;;;IAGL;;;;;;;;;OASG;;;;WArBI,iBAAiB;IACxB;;;;OAIG;;QAED;;WAEG;;;IAGL;;;;;;;;;OASG;;;;WArBI,iBAAiB;IACxB;;;;OAIG;;QAED;;WAEG;;;IAGL;;;;;;;;;OASG;;;;WArBI,iBAAiB;IACxB;;;;OAIG;;QAED;;WAEG;;;IAGL;;;;;;;;;OASG;;;;WArBI,iBAAiB;IACxB;;;;OAIG;;QAED;;WAEG;;;IAGL;;;;;;;;;OASG;;;;WArBI,iBAAiB;IACxB;;;;OAIG;;QAED;;WAEG;;;IAGL;;;;;;;;;OASG;;EAkFK,CAAC;AAEX,aAAK,cAAc,GAAG,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC;AAC5D,UAAU,iBAAkB,SAAQ,gBAAgB;IAClD,GAAG,EAAE,cAAc,CAAC;CACrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA3GC;;;;WAIG;;YAED;;eAEG;;;QAGL;;;;;;;;;WASG;;;;;QApBH;;;;WAIG;;YAED;;eAEG;;;QAGL;;;;;;;;;WASG;;;;;QApBH;;;;WAIG;;YAED;;eAEG;;;QAGL;;;;;;;;;WASG;;;;;QApBH;;;;WAIG;;YAED;;eAEG;;;QAGL;;;;;;;;;WASG;;;;;QApBH;;;;WAIG;;YAED;;eAEG;;;QAGL;;;;;;;;;WASG;;;;;QApBH;;;;WAIG;;YAED;;eAEG;;;QAGL;;;;;;;;;WASG;;;;;QApBH;;;;WAIG;;YAED;;eAEG;;;QAGL;;;;;;;;;WASG;;;;;QApBH;;;;WAIG;;YAED;;eAEG;;;QAGL;;;;;;;;;WASG;;;;;QApBH;;;;WAIG;;YAED;;eAEG;;;QAGL;;;;;;;;;WASG;;;;;QApBH;;;;WAIG;;YAED;;eAEG;;;QAGL;;;;;;;;;WASG;;;;;QApBH;;;;WAIG;;YAED;;eAEG;;;QAGL;;;;;;;;;WASG;;;;;AA8JL,wBAKE"}