@adyen/bento-vue3 0.9.3

package/dist/@types/components/data-grid/composables/useConfigSettings/useConfigSettings.d.ts

@@ -0,0 +1,69 @@
+import { MaybeRef } from '@/types';
+import { BentoColumn } from '../../data-grid.types';
+import type { EmitFn } from 'vue/types/v3-setup-context';
+export declare const useConfigSettings: (columnsRef: MaybeRef<BentoColumn[]>, emit: EmitFn) => {
+    columnSets: import("vue").ComputedRef<({
+        columnSet: (BentoColumn | {
+            field: string;
+            label: string;
+            width?: number;
+            minWidth?: number;
+            flex?: number;
+            sortable?: boolean;
+            numeric?: boolean;
+            infoIconTooltip?: string;
+            padding?: {
+                left?: boolean;
+                right?: boolean;
+            };
+            overflow?: import("../../data-grid.types").BentoColumnOverflow;
+            visible?: boolean;
+            mandatory?: boolean;
+            frozen?: boolean;
+        })[];
+        id: string;
+        isFrozenColumns: boolean;
+    } | {
+        columnSet: (BentoColumn | {
+            field: string;
+            label: string;
+            width?: number;
+            minWidth?: number;
+            flex?: number;
+            sortable?: boolean;
+            numeric?: boolean;
+            infoIconTooltip?: string;
+            padding?: {
+                left?: boolean;
+                right?: boolean;
+            };
+            overflow?: import("../../data-grid.types").BentoColumnOverflow;
+            visible?: boolean;
+            mandatory?: boolean;
+            frozen?: boolean;
+        })[];
+        id: string;
+        isFrozenColumns?: undefined;
+    })[]>;
+    sortedColumns: import("vue").ComputedRef<(BentoColumn | {
+        field: string;
+        label: string;
+        width?: number;
+        minWidth?: number;
+        flex?: number;
+        sortable?: boolean;
+        numeric?: boolean;
+        infoIconTooltip?: string;
+        padding?: {
+            left?: boolean;
+            right?: boolean;
+        };
+        overflow?: import("../../data-grid.types").BentoColumnOverflow;
+        visible?: boolean;
+        mandatory?: boolean;
+        frozen?: boolean;
+    })[]>;
+    onConfigSettingsUpdate: (isCompactView: boolean) => void;
+    onConfigSettingsColumnsUpdate: (newColumns: BentoColumn[]) => void;
+    onConfigSettingsColumnUpdate: (updatedColumn: BentoColumn) => void;
+};

package/dist/@types/components/data-grid/composables/useResizer.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'vue';
+import { BentoColumn, BentoColumnWidthOverridesLookup } from '../data-grid.types';
+import { DatagridColumnsEvent } from '../components/data-grid-columns/data-grid-columns-types';
+export declare const useResizer: (columns: Ref<BentoColumn[]>, emit: (event: DatagridColumnsEvent, ...args: unknown[]) => void) => {
+    resizeData: Ref<BentoColumnWidthOverridesLookup>;
+    allColumnRefs: import("vue").ToRefs<{}>;
+    startResize: (hasResizableColumns: boolean, field: BentoColumn['field'], event: MouseEvent) => void;
+    isResizing: Ref<boolean>;
+};
+export default useResizer;

package/dist/@types/components/data-grid/composables/useSelector.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+import { BentoDatagridData, BentoDatagridDataItemId, BentoDatagridGetDataItemIdFn, BentoDatagridIsDataItemDisabledFn } from '../data-grid.types';
+export declare const useSelector: (selection: Ref<BentoDatagridDataItemId[]>, emit: (event: string, emitedSelectedItems: BentoDatagridDataItemId[]) => void, data: Ref<BentoDatagridData>, getDataItemId: BentoDatagridGetDataItemIdFn, isDataItemDisabled: BentoDatagridIsDataItemDisabledFn) => {
+    onAllRowSelect: (allItemsSelected: boolean) => void;
+    onRowSelect: () => void;
+    allItemsSelectedState: {
+        allItemsSelected: boolean;
+        isIndeterminate: boolean;
+    };
+    selectedItems: Ref<BentoDatagridDataItemId[]>;
+};

package/dist/@types/components/data-grid/composables/useSorter.d.ts

@@ -0,0 +1,9 @@
+import { Ref } from 'vue';
+import { BentoColumn, BentoDatagridSortByColumn, BentoDatagridSortDirection } from '../data-grid.types';
+import { DatagridColumnsEvent } from '../components/data-grid-columns/data-grid-columns-types';
+export declare const useSorter: (sortBy: Ref<BentoDatagridSortByColumn[]>, columns: Ref<BentoColumn[]>, emit: (event: DatagridColumnsEvent, updatedSortBy: BentoDatagridSortByColumn[]) => void) => {
+    conditionalSortDirectionClasses: (field: string, direction: BentoDatagridSortDirection) => {
+        'b-data-grid-columns__column-sort-icon--sorted': boolean;
+    };
+    sortByColumnField: (field: string) => void;
+};

package/dist/@types/components/data-grid/data-grid.types.d.ts

@@ -0,0 +1,68 @@
+import { BentoPagination } from '@/components/pagination';
+export declare enum BentoColumnOverflow {
+    WRAP = "wrap",
+    ELLIPSIS = "ellipsis"
+}
+export interface BentoColumn {
+    field: string;
+    label: string;
+    width?: number;
+    minWidth?: number;
+    flex?: number;
+    sortable?: boolean;
+    numeric?: boolean;
+    infoIconTooltip?: string;
+    padding?: {
+        left?: boolean;
+        right?: boolean;
+    };
+    overflow?: BentoColumnOverflow;
+    visible?: boolean;
+    mandatory?: boolean;
+    frozen?: boolean;
+}
+export declare enum BentoDatagridStyleState {
+    OUTLINE = "outline"
+}
+export declare enum BentoDatagridSortDirection {
+    ASCENDING = "asc",
+    DESCENDING = "desc"
+}
+export interface BentoDatagridSortByColumn {
+    field: BentoColumn['field'];
+    direction: BentoDatagridSortDirection;
+}
+export interface BentoDatagridDataItem {
+    id?: string;
+    [fieldName: string]: unknown;
+}
+export type BentoDatagridData = BentoDatagridDataItem[];
+export type BentoDatagridDataItemId = string | number;
+export type BentoDatagridGetDataItemIdFn = (item: BentoDatagridDataItem) => BentoDatagridDataItemId;
+export type BentoDatagridIsDataItemDisabledFn = (item: BentoDatagridDataItem) => boolean;
+export type BentoDatagridPaginationProps = InstanceType<typeof BentoPagination>['$props'];
+export interface BentoColumnWidthOverridesLookup {
+    [field: string]: {
+        width: BentoColumn['width'];
+        minWidth: BentoColumn['minWidth'];
+    };
+}
+export interface BentoDatagridAllItemsSelectedState {
+    allItemsSelected: boolean;
+    isIndeterminate: boolean;
+}
+export declare enum BentoDatagridEvent {
+    COLUMN_RESIZE = "column-resize",
+    SORT = "sort",
+    SELECT = "select",
+    NAVIGATE = "navigate",
+    UPDATE_FILERS = "update:filters",
+    ITEMS_PAGE = "items-page",
+    UPDATE_FILTER_SEARCH_TERM = "update:filter-search-term",
+    FILTER_SEARCH_INPUT = "filter-search-input",
+    FILTER_SEARCH_CLEAR = "filter-search-clear",
+    COLUMNS = "columns",
+    UPDATE_COLUMNS = "update:columns",
+    ROW_CLICK = "row-click",
+    UPDATE_CONDENSED = "update:condensed"
+}

package/dist/@types/components/data-grid/data-grid.vue.d.ts

@@ -0,0 +1,477 @@
+import { PropType } from 'vue';
+import { BentoColumn, BentoColumnOverflow, BentoDatagridData, BentoDatagridDataItem, BentoDatagridDataItemId, BentoDatagridEvent, BentoDatagridGetDataItemIdFn, BentoDatagridIsDataItemDisabledFn, BentoDatagridSortByColumn, BentoDatagridSortDirection } from './data-grid.types';
+import { BentoTypographyElement, BentoTypographyVariant } from '@/components/typography';
+declare const _default: import("vue").DefineComponent<{
+    allowRowClicks: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowColumnDragAndDrop: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    condensed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    columns: {
+        type: PropType<BentoColumn[]>;
+        required: true;
+    };
+    columnPanel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    data: {
+        type: PropType<BentoDatagridData>;
+        required: true;
+    };
+    filters: {
+        type: PropType<import("@/components/filter-bar").BentoFilterBarModel>;
+        default: any;
+    };
+    filterSearchTerm: {
+        type: StringConstructor;
+        default: any;
+    };
+    getDataItemId: {
+        type: PropType<BentoDatagridGetDataItemIdFn>;
+        default: (item: BentoDatagridDataItem) => string;
+    };
+    hasResizableColumns: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDataItemDisabled: {
+        type: PropType<BentoDatagridIsDataItemDisabledFn>;
+        default: () => false;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    outline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    pagination: {
+        type: PropType<Readonly<Partial<{
+            ariaLabel: string;
+            size: number;
+            totalCount: number;
+            page: number;
+            hasNext: boolean;
+            hidePageSize: boolean;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            ariaLabel: {
+                type: StringConstructor;
+                default: any;
+            };
+            hasNext: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            hidePageSize: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            page: {
+                type: NumberConstructor;
+                default: number;
+                validator: (value: number) => boolean;
+            };
+            size: {
+                type: NumberConstructor;
+                default: number;
+                validator: (itemsPerPageValue: number) => boolean;
+            };
+            totalCount: {
+                type: NumberConstructor;
+                default: any;
+            };
+        }>>, import("vue/types/v3-component-props").DefaultKeys<{
+            ariaLabel: {
+                type: StringConstructor;
+                default: any;
+            };
+            hasNext: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            hidePageSize: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            page: {
+                type: NumberConstructor;
+                default: number;
+                validator: (value: number) => boolean;
+            };
+            size: {
+                type: NumberConstructor;
+                default: number;
+                validator: (itemsPerPageValue: number) => boolean;
+            };
+            totalCount: {
+                type: NumberConstructor;
+                default: any;
+            };
+        }>>>>;
+        default: any;
+    };
+    stickyPagination: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selection: {
+        type: PropType<BentoDatagridDataItemId[]>;
+        default: () => any[];
+    };
+    sortBy: {
+        type: PropType<BentoDatagridSortByColumn[]>;
+        default: () => any[];
+    };
+}, {
+    body: import("vue").Ref<HTMLDivElement>;
+    columnDefs: import("vue").ComputedRef<{
+        width: number;
+        field: string;
+        label: string;
+        minWidth?: number;
+        flex?: number;
+        sortable?: boolean;
+        numeric?: boolean;
+        infoIconTooltip?: string;
+        padding?: {
+            left?: boolean;
+            right?: boolean;
+        };
+        overflow?: BentoColumnOverflow;
+        visible?: boolean;
+        mandatory?: boolean;
+        frozen?: boolean;
+    }[]>;
+    columnSets: import("vue").ComputedRef<({
+        columnSet: (BentoColumn | {
+            field: string;
+            label: string;
+            width?: number;
+            minWidth?: number;
+            flex?: number;
+            sortable?: boolean;
+            numeric?: boolean;
+            infoIconTooltip?: string;
+            padding?: {
+                left?: boolean;
+                right?: boolean;
+            };
+            overflow?: BentoColumnOverflow;
+            visible?: boolean;
+            mandatory?: boolean;
+            frozen?: boolean;
+        })[];
+        id: string;
+        isFrozenColumns: boolean;
+    } | {
+        columnSet: (BentoColumn | {
+            field: string;
+            label: string;
+            width?: number;
+            minWidth?: number;
+            flex?: number;
+            sortable?: boolean;
+            numeric?: boolean;
+            infoIconTooltip?: string;
+            padding?: {
+                left?: boolean;
+                right?: boolean;
+            };
+            overflow?: BentoColumnOverflow;
+            visible?: boolean;
+            mandatory?: boolean;
+            frozen?: boolean;
+        })[];
+        id: string;
+        isFrozenColumns?: undefined;
+    })[]>;
+    ariaGridHeaderText: import("vue").ComputedRef<string>;
+    conditionalTitleAttribute: (column: BentoColumn, content: unknown) => string;
+    getRowData: (rowData: unknown) => unknown;
+    gridColumnWidthStyle: import("vue").ComputedRef<{
+        width: string;
+    }>;
+    conditionalGridClasses: import("vue").ComputedRef<{
+        [x: string]: boolean;
+    }>;
+    conditionalRowClasses: (row: BentoDatagridDataItem) => {
+        'b-data-grid__row--disabled': boolean;
+        'b-data-grid__row--row-clicks-enabled': boolean;
+        'b-data-grid__cell--is-re-ordering': boolean;
+    };
+    conditionalRowSetClasses: (isFrozenRowSet: boolean) => {
+        'b-data-grid__row-cell-set--frozen': boolean;
+        'b-data-grid__row-cell-set--unfrozen': boolean;
+        'b-data-grid__row-cell-set--config-settings-margin': boolean;
+    };
+    conditionalRowCellClasses: (column: BentoColumn) => {
+        [x: string]: boolean;
+        'b-data-grid__cell--padding-left-unset': boolean;
+        'b-data-grid__cell--padding-right-unset': boolean;
+        'b-data-grid__cell--numeric': boolean;
+        'b-data-grid__cell--condensed': boolean;
+        'b-data-grid__cell--frozen': boolean;
+        'b-data-grid__cell--is-column-re-ordering': boolean;
+        'b-data-grid__cell--is-column-re-order-target': boolean;
+    };
+    conditionalPaginationClasses: import("vue").ComputedRef<{
+        'b-data-grid__pagination--padding-left-unset': boolean;
+        'b-data-grid__pagination--padding-right-unset': boolean;
+        'b-data-grid__pagination--sticky': boolean;
+    }>;
+    onColumnWidthOverride: (newColumnWidthOverridesLookup: import("./data-grid.types").BentoColumnWidthOverridesLookup) => void;
+    onColumnResized: (resizeEvent: {
+        field: string;
+        width: number;
+    }) => void;
+    onSort: (updatedSortBy: BentoDatagridSortByColumn[]) => void;
+    allItemsSelectedState: {
+        allItemsSelected: boolean;
+        isIndeterminate: boolean;
+    };
+    selectedItems: import("vue").Ref<BentoDatagridDataItemId[]>;
+    onAllRowSelect: (allItemsSelected: boolean) => void;
+    onRowSelect: () => void;
+    DATAGRID_SELECT_FIELD_NAME: string;
+    onRowClick: (row: BentoDatagridDataItem, event: MouseEvent) => void;
+    onConfigSettingsUpdate: (isCompactView: boolean) => void;
+    onConfigSettingsColumnsUpdate: (newColumns: BentoColumn[]) => void;
+    onConfigSettingsColumnUpdate: (updatedColumn: BentoColumn) => void;
+    columnsRef: import("vue").Ref<HTMLDivElement>;
+    configSettingsButtonStyle: import("vue").ComputedRef<{
+        height: string;
+    }>;
+    BentoDatagridSortDirection: typeof BentoDatagridSortDirection;
+    BentoTypographyElement: typeof BentoTypographyElement;
+    BentoTypographyVariant: typeof BentoTypographyVariant;
+    BentoDatagridEvent: typeof BentoDatagridEvent;
+    onPaginationNavigate: (page: number) => void;
+    onItemsPerPageChange: (itemsPerPage: number) => void;
+    onSearchTermCleared: () => void;
+    onSearchTermInput: (newSearchTerm: any) => void;
+    onMoveColumnByOffset: (movingColumn: BentoColumn, offset?: number) => void;
+    draggingColumns: {
+        dragging?: {
+            field: string;
+            label: string;
+            width?: number;
+            minWidth?: number;
+            flex?: number;
+            sortable?: boolean;
+            numeric?: boolean;
+            infoIconTooltip?: string;
+            padding?: {
+                left?: boolean;
+                right?: boolean;
+            };
+            overflow?: BentoColumnOverflow;
+            visible?: boolean;
+            mandatory?: boolean;
+            frozen?: boolean;
+        };
+        target?: {
+            field: string;
+            label: string;
+            width?: number;
+            minWidth?: number;
+            flex?: number;
+            sortable?: boolean;
+            numeric?: boolean;
+            infoIconTooltip?: string;
+            padding?: {
+                left?: boolean;
+                right?: boolean;
+            };
+            overflow?: BentoColumnOverflow;
+            visible?: boolean;
+            mandatory?: boolean;
+            frozen?: boolean;
+        };
+    };
+    draggingEventsForColumns: import("vue").ComputedRef<{
+        "column-dragstart"?: undefined;
+        "column-dragenter"?: undefined;
+        "column-drop"?: undefined;
+        "column-dragend"?: undefined;
+    } | {
+        "column-dragstart": (column: BentoColumn, e: DragEvent & Event) => void;
+        "column-dragenter": (column: BentoColumn) => void;
+        "column-drop": (column: BentoColumn) => void;
+        "column-dragend": () => void;
+    }>;
+    draggingEventsForRowCell: import("vue").ComputedRef<(column: BentoColumn) => {
+        dragenter?: undefined;
+        drop?: undefined;
+        dragover?: undefined;
+    } | {
+        dragenter: (e: DragEvent) => void;
+        drop: () => void;
+        dragover: (e: DragEvent) => void;
+    }>;
+    computedColumnPanelAlignment: import("vue").ComputedRef<number>;
+}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, (BentoDatagridEvent.COLUMN_RESIZE | BentoDatagridEvent.SORT | BentoDatagridEvent.SELECT | BentoDatagridEvent.NAVIGATE | BentoDatagridEvent.UPDATE_FILERS | BentoDatagridEvent.ITEMS_PAGE | BentoDatagridEvent.UPDATE_FILTER_SEARCH_TERM | BentoDatagridEvent.FILTER_SEARCH_INPUT | BentoDatagridEvent.FILTER_SEARCH_CLEAR | BentoDatagridEvent.COLUMNS | BentoDatagridEvent.UPDATE_COLUMNS | BentoDatagridEvent.ROW_CLICK)[], string, Readonly<import("vue").ExtractPropTypes<{
+    allowRowClicks: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowColumnDragAndDrop: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    condensed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    columns: {
+        type: PropType<BentoColumn[]>;
+        required: true;
+    };
+    columnPanel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    data: {
+        type: PropType<BentoDatagridData>;
+        required: true;
+    };
+    filters: {
+        type: PropType<import("@/components/filter-bar").BentoFilterBarModel>;
+        default: any;
+    };
+    filterSearchTerm: {
+        type: StringConstructor;
+        default: any;
+    };
+    getDataItemId: {
+        type: PropType<BentoDatagridGetDataItemIdFn>;
+        default: (item: BentoDatagridDataItem) => string;
+    };
+    hasResizableColumns: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDataItemDisabled: {
+        type: PropType<BentoDatagridIsDataItemDisabledFn>;
+        default: () => false;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    outline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    pagination: {
+        type: PropType<Readonly<Partial<{
+            ariaLabel: string;
+            size: number;
+            totalCount: number;
+            page: number;
+            hasNext: boolean;
+            hidePageSize: boolean;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            ariaLabel: {
+                type: StringConstructor;
+                default: any;
+            };
+            hasNext: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            hidePageSize: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            page: {
+                type: NumberConstructor;
+                default: number;
+                validator: (value: number) => boolean;
+            };
+            size: {
+                type: NumberConstructor;
+                default: number;
+                validator: (itemsPerPageValue: number) => boolean;
+            };
+            totalCount: {
+                type: NumberConstructor;
+                default: any;
+            };
+        }>>, import("vue/types/v3-component-props").DefaultKeys<{
+            ariaLabel: {
+                type: StringConstructor;
+                default: any;
+            };
+            hasNext: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            hidePageSize: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            page: {
+                type: NumberConstructor;
+                default: number;
+                validator: (value: number) => boolean;
+            };
+            size: {
+                type: NumberConstructor;
+                default: number;
+                validator: (itemsPerPageValue: number) => boolean;
+            };
+            totalCount: {
+                type: NumberConstructor;
+                default: any;
+            };
+        }>>>>;
+        default: any;
+    };
+    stickyPagination: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selection: {
+        type: PropType<BentoDatagridDataItemId[]>;
+        default: () => any[];
+    };
+    sortBy: {
+        type: PropType<BentoDatagridSortByColumn[]>;
+        default: () => any[];
+    };
+}>>, {
+    filters: import("@/components/filter-bar").BentoFilterBarModel;
+    condensed: boolean;
+    outline: boolean;
+    loading: boolean;
+    hasResizableColumns: boolean;
+    sortBy: BentoDatagridSortByColumn[];
+    allowRowClicks: boolean;
+    allowColumnDragAndDrop: boolean;
+    columnPanel: boolean;
+    filterSearchTerm: string;
+    getDataItemId: BentoDatagridGetDataItemIdFn;
+    isDataItemDisabled: BentoDatagridIsDataItemDisabledFn;
+    pagination: any;
+    stickyPagination: boolean;
+    selectable: boolean;
+    selection: BentoDatagridDataItemId[];
+}>;
+export default _default;

package/dist/@types/components/data-grid/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BentoDataGrid } from './data-grid.vue';
+export * from './data-grid.types';

package/dist/@types/components/date/date.types.d.ts

@@ -0,0 +1,18 @@
+export declare enum BentoDateFormat {
+    DAY_OF_MONTH = "d",
+    LONG_WEEKDAY = "EEEE",
+    SHORT_TIME_WITH_PERIOD = "h:mm aa",
+    SHORT_TIME_WITHOUT_PERIOD = "H:mm",
+    EXACT_TIME_WITH_PERIOD = "h:mm:ss aa",
+    EXACT_TIME_WITHOUT_PERIOD = "H:mm:ss",
+    LONG_DATE = "LLLL dd, yyyy",
+    SHORT_DATE = "LLL dd, yyyy",
+    FULL_DATE_EXACT_TIME_WITH_PERIOD = "LLL dd, yyyy, h:mm:ss aa",
+    FULL_DATE_EXACT_TIME_WITHOUT_PERIOD = "LLL dd, yyyy, H:mm:ss",
+    FULL_DATE_EXACT_TIME_WITH_TIMEZONE_AND_PERIOD = "LLL dd, yyyy, h:mm:ss aa O",
+    FULL_DATE_EXACT_TIME_WITH_TIMEZONE_AND_WITHOUT_PERIOD = "LLL dd, yyyy, H:mm:ss O",
+    FULL_DATE_TIME_WITH_PERIOD = "LLL dd, yyyy, h:mm aa",
+    FULL_DATE_TIME_WITH_TIMEZONE_AND_PERIOD = "LLL dd, yyyy, h:mm aa O",
+    FULL_DATE_TIME_WITHOUT_PERIOD = "LLL dd, yyyy, H:mm",
+    FULL_DATE_TIME_WITH_TIMEZONE_AND_WITHOUT_PERIOD = "LLL dd, yyyy, H:mm O"
+}