@dialpad/dialtone-vue 3.103.0 → 3.105.0

package/dist/types/common/mixins/keyboard_list_navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard_list_navigation.d.ts","sourceRoot":"","sources":["../../../../common/mixins/keyboard_list_navigation.js"],"names":[],"mappings":"AA6Be;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuNb"}

package/dist/types/common/mixins/modal.d.ts

@@ -0,0 +1,43 @@
+declare namespace _default {
+    namespace methods {
+        /**
+         * get the first focusable element in your component, includes tabindex="-1".
+         * @param {object} el - optional - ref of dom element to trap focus on.
+         *  will default to the root node of the vue component
+         */
+        function getFirstFocusableElement(el: object): Promise<any>;
+        /**
+         * set focus to the first focusable element in your component, includes tabindex="-1".
+         * @param {object} el - optional - ref of dom element to trap focus on.
+         *  will default to the root node of the vue component
+         */
+        function focusFirstElement(el: object): Promise<void>;
+        /**
+         * internal use only.
+         *
+         * @param focusableElements - list of focusable elements
+         * @returns {*} - first DOM element that is focusable.
+         * @private
+         */
+        function _getFirstFocusElement(focusableElements: any): any;
+        /**
+         * internal use only.
+         *
+         * gets all the focusable elements within the component
+         * and sets the first and last of those elements.
+         *
+         * @param {object} el - the root dom element to find focusable elements in.
+         * @param {bool} includeNegativeTabIndex - will include tabindex="-1" in the list of focusable elements.
+         */
+        function _getFocusableElements(el?: object, includeNegativeTabIndex?: bool): any[];
+        /**
+         * tabs to the next element contained within your component, does not include tabindex="-1".
+         * @param {object} e - keypress event
+         * @param {object} el - optional - ref of dom element to trap focus on.
+         *  will default to the root node of the vue component
+         */
+        function focusTrappedTabPress(e: object, el: object): void;
+    }
+}
+export default _default;
+//# sourceMappingURL=modal.d.ts.map

package/dist/types/common/mixins/modal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modal.d.ts","sourceRoot":"","sources":["../../../../common/mixins/modal.js"],"names":[],"mappings":";;QAqBI;;;;WAIG;QACH,4DAIC;QAED;;;;WAIG;QACH,sDAGC;QAED;;;;;;WAMG;QACH,4DAUC;QAED;;;;;;;;WAQG;QACH,mFASC;QAED;;;;;WAKG;QACH,2DA2BC"}

package/dist/types/common/mixins/skeleton.d.ts

@@ -0,0 +1,11 @@
+declare namespace _default {
+    namespace computed {
+        function skeletonOffset(): any;
+        function skeletonStyle(): {
+            animationDelay: string;
+            animationDuration: any;
+        };
+    }
+}
+export default _default;
+//# sourceMappingURL=skeleton.d.ts.map

package/dist/types/common/mixins/skeleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skeleton.d.ts","sourceRoot":"","sources":["../../../../common/mixins/skeleton.js"],"names":[],"mappings":";;QAOI,+BAKC;QAED;;;UAWC"}

package/dist/types/common/mixins/sr_only_close_button.d.ts

@@ -0,0 +1,30 @@
+declare namespace _default {
+    namespace props {
+        namespace visuallyHiddenClose {
+            export let type: BooleanConstructor;
+            let _default: boolean;
+            export { _default as default };
+        }
+        namespace visuallyHiddenCloseLabel {
+            let type_1: StringConstructor;
+            export { type_1 as type };
+            let _default_1: null;
+            export { _default_1 as default };
+        }
+    }
+    namespace watch {
+        namespace $props {
+            let immediate: boolean;
+            let deep: boolean;
+            function handler(): void;
+        }
+    }
+    namespace computed {
+        function showVisuallyHiddenClose(): any;
+    }
+    namespace methods {
+        function validateVisuallyHiddenCloseProps(): void;
+    }
+}
+export default _default;
+//# sourceMappingURL=sr_only_close_button.d.ts.map

package/dist/types/common/mixins/sr_only_close_button.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sr_only_close_button.d.ts","sourceRoot":"","sources":["../../../../common/mixins/sr_only_close_button.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;YA4BM,yBAEC;;;;QAKH,wCAEC;;;QAID,kDAKC"}

package/dist/types/common/sr_only_close_button.vue.d.ts

@@ -0,0 +1,27 @@
+declare const _default: import("vue").DefineComponent<{
+    /**
+     * Label for the visually hidden close button
+     * Required if visuallyHiddenClose is set to `true`
+     */
+    visuallyHiddenCloseLabel: {
+        type: StringConstructor;
+        default: null;
+    };
+}, any, any, {}, {
+    close(): void;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "close"[], "close", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    /**
+     * Label for the visually hidden close button
+     * Required if visuallyHiddenClose is set to `true`
+     */
+    visuallyHiddenCloseLabel: {
+        type: StringConstructor;
+        default: null;
+    };
+}>> & {
+    onClose?: ((...args: any[]) => any) | undefined;
+}, {
+    visuallyHiddenCloseLabel: string;
+}, {}>;
+export default _default;
+//# sourceMappingURL=sr_only_close_button.vue.d.ts.map

package/dist/types/common/sr_only_close_button.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sr_only_close_button.vue.d.ts","sourceRoot":"","sources":["../../../common/sr_only_close_button.vue.js"],"names":[],"mappings":";IAaI;;;OAGG;;;;;;;;IAHH;;;OAGG"}

package/dist/types/common/storybook_utils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Gets the full list of icon component names from the dialtone package
+ * @returns {string[]} icon component names
+ */
+export function getIconNames(): string[];
+export function createTemplateFromVueFile(args: object, argTypes: any, templateComponent: component): component;
+export function generateTemplate(component: any, { props, excludeProps, customProps, childTemplate }?: {
+    props?: any[] | undefined;
+    excludeProps?: any[] | undefined;
+    customProps?: any[] | undefined;
+    childTemplate: any;
+}): string;
+declare namespace _default {
+    export { generateTemplate };
+    export { createTemplateFromVueFile };
+    export { getIconNames };
+}
+export default _default;
+//# sourceMappingURL=storybook_utils.d.ts.map

package/dist/types/common/storybook_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storybook_utils.d.ts","sourceRoot":"","sources":["../../../common/storybook_utils.js"],"names":[],"mappings":"AAqBA;;;GAGG;AACH,gCAFa,MAAM,EAAE,CAIpB;AAdM,gDANI,MAAM,0DAYf;AAUK;;;;;WAoBN"}

package/dist/types/common/utils.d.ts

@@ -0,0 +1,118 @@
+export function getUniqueString(prefix?: string): string;
+/**
+ * Returns a random element from array
+ * @param array - the array to return a random element from
+ * @param {string} seed - use a string to seed the randomization, so it returns the same element each time
+ * based on that string.
+ * @returns {*} - the random element
+ */
+export function getRandomElement(array: any, seed: string): any;
+/**
+ * Returns a hash code for a string.
+ * (Compatible to Java's String.hashCode())
+ * We use this algo to be in sync with android.
+ *
+ * The hash code for a string object is computed as
+ *     s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
+ * using number arithmetic, where s[i] is the i th character
+ * of the given string, n is the length of the string,
+ * and ^ indicates exponentiation.
+ * (The hash value of the empty string is zero.)
+ *
+ * @param {string} str a string
+ * @return {number} a hash code value for the given string.
+ */
+export function javaHashCode(str: string): number;
+/**
+ * Generate a random integer
+ * @param {number} max - max range of integer to generate
+ * @returns {number} randomly generated integer between 0 and max
+ */
+export function getRandomInt(max: number): number;
+export function formatMessages(messages: any): any;
+export function filterFormattedMessages(formattedMessages: any): any;
+export function getValidationState(formattedMessages: any): string | null;
+export function hasFormattedMessageOfType(formattedMessages: any, messageType: any): any;
+export function findFirstFocusableNode(element: any): any;
+export function hasSlotContent(slot: any, slotProps?: {}): any;
+export function debounce(func: any, timeout?: number): void;
+/**
+ * Checks if the element is out of the viewport
+ * https://gomakethings.com/how-to-check-if-any-part-of-an-element-is-out-of-the-viewport-with-vanilla-js/
+ * @param  {HTMLElement} element The element to check
+ * @return {Object} A set of booleans for each side of the element
+ */
+export function isOutOfViewPort(element: HTMLElement): Object;
+/**
+ * Match phone numbers, e.g. "765-8813", "(778) 765-8813" or "+17787658813".
+ * @param {number} minLength
+ * @param {number} maxLength
+ * @returns {RegExp}
+ */
+export function getPhoneNumberRegex(minLength?: number, maxLength?: number): RegExp;
+/**
+ * Check if a string is a phone number. Validates only exact matches.
+ * @param {string|number} input
+ * @returns {boolean}
+ */
+export function isPhoneNumber(input: string | number): boolean;
+/**
+ * Check if a string is an URL. Validates only exact matches.
+ * @param {string} input
+ * @returns {boolean}
+ */
+export function isURL(input: string): boolean;
+/**
+ * Check if a string is an email address. Validates only exact matches.
+ * @param {string} input
+ * @returns {boolean}
+ */
+export function isEmailAddress(input: string): boolean;
+/**
+ * Concatenate a string removing null or undefined elements
+ * avoiding parsing them as string with template strings
+ * @param {Array} elements
+ * @returns {String}
+ */
+export function safeConcatStrings(elements: any[]): string;
+/**
+ * Locale safe function to capitalize the first letter of a string.
+ * @param {string} str the string to capitalize the first letter of
+ * @param {string} locale a string representing the locale to be used. Defaults to 'en-US'
+ * @returns The passed in string with the first letter capitalized
+ */
+export function capitalizeFirstLetter(str: string, locale?: string): string;
+export function htmlFragment(props: any): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export function flushPromises(): Promise<any>;
+export function kebabCaseToPascalCase(string: any): string;
+export function pascalCaseToKebabCase(string: any): string;
+export function extractVueListeners(attrs: any): {
+    [k: string]: any;
+};
+export const linkRegex: RegExp;
+declare namespace _default {
+    export { getUniqueString };
+    export { getRandomElement };
+    export { getRandomInt };
+    export { formatMessages };
+    export { filterFormattedMessages };
+    export { hasFormattedMessageOfType };
+    export { getValidationState };
+    export { htmlFragment };
+    export { flushPromises };
+    export { kebabCaseToPascalCase };
+    export { extractVueListeners };
+    export { debounce };
+    export { isOutOfViewPort };
+    export { getPhoneNumberRegex };
+    export { linkRegex };
+    export { isEmailAddress };
+    export { isPhoneNumber };
+    export { isURL };
+    export { safeConcatStrings };
+    export { capitalizeFirstLetter };
+}
+export default _default;
+//# sourceMappingURL=utils.d.ts.map

package/dist/types/common/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../common/utils.js"],"names":[],"mappings":"AAyBA,yDAEC;AAED;;;;;;GAMG;AACH,mDAJW,MAAM,OAWhB;AAED;;;;;;;;;;;;;;GAcG;AACH,kCAHW,MAAM,GACL,MAAM,CASjB;AAED;;;;GAIG;AACH,kCAHW,MAAM,GACJ,MAAM,CAIlB;AAED,mDAeC;AAED,qEAQC;AAOD,0EAgBC;AAED,yFAMC;AAED,0DAEC;AAqBD,+DAcC;AAoCD,4DAGC;AAED;;;;;GAKG;AAEH,yCAJY,WAAW,GACX,MAAM,CAejB;AAoED;;;;;GAKG;AACH,gDAJW,MAAM,cACN,MAAM,GACJ,MAAM,CAmBlB;AAeD;;;;GAIG;AACH,qCAHW,MAAM,GAAC,MAAM,GACX,OAAO,CAMnB;AAED;;;;GAIG;AACH,6BAHW,MAAM,GACJ,OAAO,CAMnB;AAED;;;;GAIG;AACH,sCAHW,MAAM,GACJ,OAAO,CAKnB;AAED;;;;;GAKG;AACH,2DAEC;AAED;;;;;GAKG;AACH,2CAJW,MAAM,WACN,MAAM,UAKhB;AArPM;;GAEN;AAEM,8CAIN;AA4BM,oDAFM,MAAM,CAOlB;AAOM,oDAFM,MAAM,CAMlB;AAEM;;EAIN;AA+HD,+BAQE"}

package/dist/types/common/validators.d.ts

@@ -0,0 +1,6 @@
+export function validationMessageValidator(rawMessages: any): any;
+declare namespace _default {
+    export { validationMessageValidator };
+}
+export default _default;
+//# sourceMappingURL=validators.d.ts.map

package/dist/types/common/validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../../common/validators.js"],"names":[],"mappings":"AAIA,kEAgBC"}

package/dist/types/components/avatar/avatar.vue.d.ts

@@ -0,0 +1,369 @@
+declare const _default: import("vue").DefineComponent<{
+    /**
+     * Id of the avatar content wrapper element
+     */
+    id: {
+        type: StringConstructor;
+        default(): string;
+    };
+    /**
+     * Pass in a seed to get the random color generation based on that string. For example if you pass in a
+     * user ID as the string it will return the same randomly generated colors every time for that user.
+     */
+    seed: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /**
+     * Set the avatar background to a specific color. If undefined will randomize the color which can be deterministic
+     * if the seed prop is set.
+     */
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /**
+     * The size of the avatar
+     * @values xs, sm, md, lg, xl
+     */
+    size: {
+        type: StringConstructor;
+        default: string;
+        validator: (size: unknown) => boolean;
+    };
+    /**
+     * Used to customize the avatar container
+     */
+    avatarClass: {
+        type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+        default: string;
+    };
+    /**
+     * Set classes on the avatar canvas. Wrapper around the core avatar image.
+     */
+    canvasClass: {
+        type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+        default: string;
+    };
+    /**
+     * Pass through classes. Used to customize the avatar icon
+     */
+    iconClass: {
+        type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+        default: string;
+    };
+    /**
+     * Determines whether to show the presence indicator for
+     * Avatar - accepts PRESENCE_STATES values: 'busy', 'away', 'offline',
+     * or 'active'. By default, it's null and nothing is shown.
+     * @values null, busy, away, offline, active
+     */
+    presence: {
+        type: StringConstructor;
+        default: string;
+        validator: (state: unknown) => boolean;
+    };
+    /**
+     * A set of props to be passed into the presence component.
+     */
+    presenceProps: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    /**
+     * Determines whether to show a group avatar.
+     * Limit to 2 digits max, more than 99 will be rendered as “99+”.
+     * if the number is 1 or less it would just show the regular avatar as if group had not been set.
+     */
+    group: {
+        type: NumberConstructor;
+        default: undefined;
+        validator: (group: unknown) => boolean;
+    };
+    /**
+     * The icon that overlays the avatar
+     */
+    overlayIcon: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * The text that overlays the avatar
+     */
+    overlayText: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Used to customize the avatar overlay
+     */
+    overlayClass: {
+        type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+        default: string;
+    };
+    /**
+     * Source of the image
+     */
+    imageSrc: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Alt attribute of the image, by default
+     * it'd be the full name
+     */
+    imageAlt: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Icon name to be displayed on the avatar
+     */
+    iconName: {
+        type: StringConstructor;
+        default: undefined;
+        validator: (name: unknown) => boolean;
+    };
+    /**
+     * Icon size to be displayed on the avatar
+     * @values 100, 200, 300, 400, 500, 600, 700, 800
+     */
+    iconSize: {
+        type: StringConstructor;
+        default: string;
+        validator: (size: unknown) => boolean;
+    };
+    /**
+     * Full name used to extract initials and set alt attribute.
+     */
+    fullName: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Makes the avatar focusable and clickable,
+     * emits a click event when clicked.
+     */
+    clickable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, any, {
+    AVATAR_SIZE_MODIFIERS: {
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+    };
+    AVATAR_KIND_MODIFIERS: {
+        default: string;
+        icon: string;
+        initials: string;
+    };
+    AVATAR_PRESENCE_SIZE_MODIFIERS: {
+        md: string;
+        lg: string;
+    };
+    AVATAR_ICON_SIZES: {
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+    };
+    imageLoadedSuccessfully: null;
+    formattedInitials: string;
+    initializing: boolean;
+}, {
+    isNotIconType(): boolean;
+    avatarClasses(): any[];
+    overlayClasses(): (string | Record<string, any> | unknown[])[];
+    showGroup(): boolean;
+    formattedGroup(): number | "99+" | undefined;
+    validatedSize(): string;
+    showImage(): string | false;
+    buttonAriaLabel(): unknown;
+}, {
+    setImageListeners(): Promise<void>;
+    formatInitials(string: any): void;
+    getColor(): any;
+    _loadedImageEventHandler(el: any): void;
+    _erroredImageEventHandler(el: any): void;
+    validateProps(): void;
+    handleClick(e: any): void;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    /**
+     * Id of the avatar content wrapper element
+     */
+    id: {
+        type: StringConstructor;
+        default(): string;
+    };
+    /**
+     * Pass in a seed to get the random color generation based on that string. For example if you pass in a
+     * user ID as the string it will return the same randomly generated colors every time for that user.
+     */
+    seed: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /**
+     * Set the avatar background to a specific color. If undefined will randomize the color which can be deterministic
+     * if the seed prop is set.
+     */
+    color: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /**
+     * The size of the avatar
+     * @values xs, sm, md, lg, xl
+     */
+    size: {
+        type: StringConstructor;
+        default: string;
+        validator: (size: unknown) => boolean;
+    };
+    /**
+     * Used to customize the avatar container
+     */
+    avatarClass: {
+        type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+        default: string;
+    };
+    /**
+     * Set classes on the avatar canvas. Wrapper around the core avatar image.
+     */
+    canvasClass: {
+        type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+        default: string;
+    };
+    /**
+     * Pass through classes. Used to customize the avatar icon
+     */
+    iconClass: {
+        type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+        default: string;
+    };
+    /**
+     * Determines whether to show the presence indicator for
+     * Avatar - accepts PRESENCE_STATES values: 'busy', 'away', 'offline',
+     * or 'active'. By default, it's null and nothing is shown.
+     * @values null, busy, away, offline, active
+     */
+    presence: {
+        type: StringConstructor;
+        default: string;
+        validator: (state: unknown) => boolean;
+    };
+    /**
+     * A set of props to be passed into the presence component.
+     */
+    presenceProps: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    /**
+     * Determines whether to show a group avatar.
+     * Limit to 2 digits max, more than 99 will be rendered as “99+”.
+     * if the number is 1 or less it would just show the regular avatar as if group had not been set.
+     */
+    group: {
+        type: NumberConstructor;
+        default: undefined;
+        validator: (group: unknown) => boolean;
+    };
+    /**
+     * The icon that overlays the avatar
+     */
+    overlayIcon: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * The text that overlays the avatar
+     */
+    overlayText: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Used to customize the avatar overlay
+     */
+    overlayClass: {
+        type: (ObjectConstructor | ArrayConstructor | StringConstructor)[];
+        default: string;
+    };
+    /**
+     * Source of the image
+     */
+    imageSrc: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Alt attribute of the image, by default
+     * it'd be the full name
+     */
+    imageAlt: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Icon name to be displayed on the avatar
+     */
+    iconName: {
+        type: StringConstructor;
+        default: undefined;
+        validator: (name: unknown) => boolean;
+    };
+    /**
+     * Icon size to be displayed on the avatar
+     * @values 100, 200, 300, 400, 500, 600, 700, 800
+     */
+    iconSize: {
+        type: StringConstructor;
+        default: string;
+        validator: (size: unknown) => boolean;
+    };
+    /**
+     * Full name used to extract initials and set alt attribute.
+     */
+    fullName: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Makes the avatar focusable and clickable,
+     * emits a click event when clicked.
+     */
+    clickable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onClick?: ((...args: any[]) => any) | undefined;
+}, {
+    presence: string;
+    id: string;
+    size: string;
+    iconSize: string;
+    fullName: string;
+    imageSrc: string;
+    seed: string;
+    color: string;
+    avatarClass: string | Record<string, any> | unknown[];
+    canvasClass: string | Record<string, any> | unknown[];
+    iconClass: string | Record<string, any> | unknown[];
+    presenceProps: Record<string, any>;
+    group: number;
+    overlayIcon: string;
+    overlayText: string;
+    overlayClass: string | Record<string, any> | unknown[];
+    imageAlt: string;
+    iconName: string;
+    clickable: boolean;
+}, {}>;
+export default _default;
+//# sourceMappingURL=avatar.vue.d.ts.map

package/dist/types/components/avatar/avatar.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avatar.vue.d.ts","sourceRoot":"","sources":["../../../../components/avatar/avatar.vue.js"],"names":[],"mappings":";IA+BI;;OAEG;;;;;IAMH;;;OAGG;;;;;IAMH;;;OAGG;;;;;IAMH;;;OAGG;;;;;;IAOH;;OAEG;;;;;IAMH;;OAEG;;;;;IAMH;;OAEG;;;;;IAMH;;;;;OAKG;;;;;;IASH;;OAEG;;;;;IAMH;;;;OAIG;;;;;;IAOH;;OAEG;;;;;IAMH;;OAEG;;;;;IAMH;;OAEG;;;;;IAMH;;OAEG;;;;;IAMH;;;OAGG;;;;;IAMH;;OAEG;;;;;;IAOH;;;OAGG;;;;;;IAOH;;OAEG;;;;;IAMH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IApKH;;OAEG;;;;;IAMH;;;OAGG;;;;;IAMH;;;OAGG;;;;;IAMH;;;OAGG;;;;;;IAOH;;OAEG;;;;;IAMH;;OAEG;;;;;IAMH;;OAEG;;;;;IAMH;;;;;OAKG;;;;;;IASH;;OAEG;;;;;IAMH;;;;OAIG;;;;;;IAOH;;OAEG;;;;;IAMH;;OAEG;;;;;IAMH;;OAEG;;;;;IAMH;;OAEG;;;;;IAMH;;;OAGG;;;;;IAMH;;OAEG;;;;;;IAOH;;;OAGG;;;;;;IAOH;;OAEG;;;;;IAMH;;;OAGG"}