@ramathibodi/nuxt-commons 0.1.22 → 0.1.23

package/dist/runtime/composables/graphqlModelItem.d.ts

@@ -1,20 +1,20 @@
-import type { FormDialogCallback } from '../types/formDialog';
-import { type GraphqlModelConfigProps } from './graphqlModelOperation';
+import type { FormDialogCallback } from '../types/formDialog.js';
+import { type GraphqlModelConfigProps } from './graphqlModelOperation.js';
 export type GraphqlModelItemProps = Omit<GraphqlModelConfigProps, 'operationSearch' | 'operationReadPageable'>;
 export declare function useGraphqlModelItem<T extends GraphqlModelItemProps>(props: T): {
-    modelBy: import("vue").Ref<object | undefined>;
-    item: import("vue").Ref<Record<string, any> | undefined>;
-    operationCreate: import("vue").ComputedRef<any>;
-    operationUpdate: import("vue").ComputedRef<any>;
-    operationDelete: import("vue").ComputedRef<any>;
-    operationRead: import("vue").ComputedRef<any>;
-    fields: import("vue").ComputedRef<any[]>;
+    modelBy: import("vue").Ref<object | undefined, object | undefined>;
+    item: import("vue").Ref<Record<string, any> | undefined, Record<string, any> | undefined>;
+    operationCreate: import("vue").ComputedRef<import("../../../playground/composables/graphqlObject").graphqlOperationObject<any, any>>;
+    operationUpdate: import("vue").ComputedRef<import("../../../playground/composables/graphqlObject").graphqlOperationObject<any, any>>;
+    operationDelete: import("vue").ComputedRef<import("../../../playground/composables/graphqlObject").graphqlOperationObject<any, any>>;
+    operationRead: import("vue").ComputedRef<import("../../../playground/composables/graphqlObject").graphqlOperationObject<any, any>>;
+    fields: import("vue").ComputedRef<(string | object)[]>;
     canCreate: import("vue").ComputedRef<boolean>;
     canUpdate: import("vue").ComputedRef<boolean>;
     canDelete: import("vue").ComputedRef<boolean>;
-    createItem: (createItem: Record<string, any>, callback?: FormDialogCallback) => any;
-    updateItem: (updateItem: Record<string, any>, callback?: FormDialogCallback) => any;
-    deleteItem: (item: Record<string, any>, callback?: FormDialogCallback) => any;
+    createItem: (createItem: Record<string, any>, callback?: FormDialogCallback) => Promise<void>;
+    updateItem: (updateItem: Record<string, any>, callback?: FormDialogCallback) => Promise<void>;
+    deleteItem: (item: Record<string, any>, callback?: FormDialogCallback) => Promise<any>;
     reload: () => void;
-    isLoading: import("vue").Ref<boolean>;
+    isLoading: import("vue").Ref<boolean, boolean>;
 };

package/dist/runtime/composables/{graphqlModelItem.mjs → graphqlModelItem.js}

@@ -1,7 +1,7 @@
 import { computed, ref, watch } from "vue";
-import { useAlert } from "./alert.mjs";
-import { buildRequiredInputFields } from "./graphqlOperation.mjs";
-import { useGraphqlModelOperation } from "./graphqlModelOperation.mjs";
+import { useAlert } from "./alert.js";
+import { buildRequiredInputFields } from "./graphqlOperation.js";
+import { useGraphqlModelOperation } from "./graphqlModelOperation.js";
 export function useGraphqlModelItem(props) {
   const alert = useAlert();
   const modelBy = ref();
@@ -34,8 +34,7 @@ export function useGraphqlModelItem(props) {
       reload();
     }).finally(() => {
       isLoading.value = false;
-      if (callback)
-        callback.done();
+      if (callback) callback.done();
     });
   }
   function updateItem(updateItem2, callback) {
@@ -47,8 +46,7 @@ export function useGraphqlModelItem(props) {
       reload();
     }).finally(() => {
       isLoading.value = false;
-      if (callback)
-        callback.done();
+      if (callback) callback.done();
     });
   }
   function deleteItem(item2, callback) {
@@ -58,8 +56,7 @@ export function useGraphqlModelItem(props) {
     }).finally(() => {
       isLoading.value = false;
       reload();
-      if (callback)
-        callback.done();
+      if (callback) callback.done();
     });
   }
   function reload() {

package/dist/runtime/composables/graphqlModelOperation.d.ts

@@ -1,4 +1,4 @@
-import type { graphqlOperationObject } from '../types/graphqlOperation';
+import type { graphqlOperationObject } from '../types/graphqlOperation.js';
 export interface GraphqlModelConfigProps {
     modelName: string;
     modelKey?: string;
@@ -12,10 +12,10 @@ export interface GraphqlModelConfigProps {
     fields?: Array<string | object>;
 }
 export declare function useGraphqlModelOperation<T extends GraphqlModelConfigProps>(props: T): {
-    operationCreate: import("vue").ComputedRef<any>;
-    operationUpdate: import("vue").ComputedRef<any>;
-    operationDelete: import("vue").ComputedRef<any>;
-    operationRead: import("vue").ComputedRef<any>;
-    operationReadPageable: import("vue").ComputedRef<any>;
-    operationSearch: import("vue").ComputedRef<any>;
+    operationCreate: import("vue").ComputedRef<import("#imports").graphqlOperationObject<any, any>>;
+    operationUpdate: import("vue").ComputedRef<import("#imports").graphqlOperationObject<any, any>>;
+    operationDelete: import("vue").ComputedRef<import("#imports").graphqlOperationObject<any, any>>;
+    operationRead: import("vue").ComputedRef<import("#imports").graphqlOperationObject<any, any>>;
+    operationReadPageable: import("vue").ComputedRef<import("#imports").graphqlOperationObject<any, any>>;
+    operationSearch: import("vue").ComputedRef<import("#imports").graphqlOperationObject<any, any>>;
 };

package/dist/runtime/composables/{graphqlModelOperation.mjs → graphqlModelOperation.js}

@@ -13,8 +13,7 @@ export function useGraphqlModelOperation(props) {
   const operationCreate = computed(() => {
     if (props.operationCreate) {
       if (typeof props.operationCreate === "string") {
-        if (graphqlOperation[props.operationCreate])
-          return graphqlOperation[props.operationCreate];
+        if (graphqlOperation[props.operationCreate]) return graphqlOperation[props.operationCreate];
       } else {
         return props.operationCreate;
       }
@@ -24,8 +23,7 @@ export function useGraphqlModelOperation(props) {
   const operationUpdate = computed(() => {
     if (props.operationUpdate) {
       if (typeof props.operationUpdate === "string") {
-        if (graphqlOperation[props.operationUpdate])
-          return graphqlOperation[props.operationUpdate];
+        if (graphqlOperation[props.operationUpdate]) return graphqlOperation[props.operationUpdate];
       } else {
         return props.operationUpdate;
       }
@@ -35,8 +33,7 @@ export function useGraphqlModelOperation(props) {
   const operationDelete = computed(() => {
     if (props.operationDelete) {
       if (typeof props.operationDelete === "string") {
-        if (graphqlOperation[props.operationDelete])
-          return graphqlOperation[props.operationDelete];
+        if (graphqlOperation[props.operationDelete]) return graphqlOperation[props.operationDelete];
       } else {
         return props.operationDelete;
       }
@@ -46,8 +43,7 @@ export function useGraphqlModelOperation(props) {
   const operationRead = computed(() => {
     if (props.operationRead) {
       if (typeof props.operationRead === "string") {
-        if (graphqlOperation[props.operationRead])
-          return graphqlOperation[props.operationRead];
+        if (graphqlOperation[props.operationRead]) return graphqlOperation[props.operationRead];
       } else {
         return props.operationRead;
       }
@@ -57,8 +53,7 @@ export function useGraphqlModelOperation(props) {
   const operationReadPageable = computed(() => {
     if (props.operationReadPageable) {
       if (typeof props.operationReadPageable === "string") {
-        if (graphqlOperation[props.operationReadPageable])
-          return graphqlOperation[props.operationReadPageable];
+        if (graphqlOperation[props.operationReadPageable]) return graphqlOperation[props.operationReadPageable];
       } else {
         return props.operationReadPageable;
       }
@@ -68,8 +63,7 @@ export function useGraphqlModelOperation(props) {
   const operationSearch = computed(() => {
     if (props.operationSearch) {
       if (typeof props.operationSearch === "string") {
-        if (graphqlOperation[props.operationSearch])
-          return graphqlOperation[props.operationSearch];
+        if (graphqlOperation[props.operationSearch]) return graphqlOperation[props.operationSearch];
       } else {
         return props.operationSearch;
       }

package/dist/runtime/composables/graphqlOperation.d.ts

@@ -1,5 +1,5 @@
-import { type ClassConstructor } from '../utils/object';
-import type { graphqlTypeObject, graphqlVariable } from '../types/graphqlOperation';
+import { type ClassConstructor } from '../utils/object.js';
+import type { graphqlTypeObject, graphqlVariable } from '../types/graphqlOperation.js';
 export declare function buildFields(operationFields: graphqlTypeObject, fields?: Array<string | Object> | ClassConstructor<any>, depth?: number): Array<string | Object>;
 export declare function buildVariables(outputVariables?: graphqlVariable[], inputVariables?: {
     [p: string]: any;

package/dist/runtime/composables/{graphqlOperation.mjs → graphqlOperation.js}

@@ -1,26 +1,19 @@
-import { classAttributes, isClassConstructor } from "../utils/object.mjs";
-import { useGraphQl } from "./graphql.mjs";
+import { classAttributes, isClassConstructor } from "../utils/object.js";
+import { useGraphQl } from "./graphql.js";
 import { graphqlInputType, graphqlOperation, graphqlType, scalarType } from "#imports";
 export function buildFields(operationFields, fields, depth = 0) {
-  if (!operationFields)
-    return [];
-  if (isClassConstructor(fields))
-    fields = classAttributes(fields);
-  if (!fields || fields.length == 0)
-    fields = [...operationFields.fields];
+  if (!operationFields) return [];
+  if (isClassConstructor(fields)) fields = classAttributes(fields);
+  if (!fields || fields.length == 0) fields = [...operationFields.fields];
   if (fields.includes("*")) {
     operationFields.fields.forEach((field) => {
-      if (!fields.includes(field))
-        fields.push(field);
+      if (!fields.includes(field)) fields.push(field);
     });
     fields.splice(fields.indexOf("*"), 1);
   }
-  if (depth > 0)
-    operationFields.relations.forEach((relation) => fields.push(relation.name));
-  if (!fields.includes("timestampField") && operationFields.relations.find((relation) => relation.name == "timestampField"))
-    fields.push("timestampField");
-  if (!fields.includes("userstampField") && operationFields.relations.find((relation) => relation.name == "userstampField"))
-    fields.push("userstampField");
+  if (depth > 0) operationFields.relations.forEach((relation) => fields.push(relation.name));
+  if (!fields.includes("timestampField") && operationFields.relations.find((relation) => relation.name == "timestampField")) fields.push("timestampField");
+  if (!fields.includes("userstampField") && operationFields.relations.find((relation) => relation.name == "userstampField")) fields.push("userstampField");
   return fields.map((field) => {
     if (typeof field == "string" && !operationFields?.fields?.includes(field)) {
       const relationField = operationFields?.relations?.find((relation) => relation.name == field);
@@ -42,8 +35,7 @@ export function buildFields(operationFields, fields, depth = 0) {
   }).filter((field) => !!field);
 }
 export function buildVariables(outputVariables, inputVariables, reject, isRoot = true) {
-  if (!outputVariables)
-    return void 0;
+  if (!outputVariables) return void 0;
   if (inputVariables) {
     outputVariables.map((variable) => {
       if (variable.type && !scalarType.includes(variable.type)) {
@@ -77,8 +69,7 @@ export function buildVariables(outputVariables, inputVariables, reject, isRoot =
   });
   const usedVariables = outputVariables.map((variable) => variable.name);
   const droppedVariable = Object.keys(inputVariables || {}).filter((key) => !usedVariables.includes(key));
-  if (droppedVariable.length > 0)
-    console.debug("There is data not appeared in schema and dropped before operation.", droppedVariable);
+  if (droppedVariable.length > 0) console.debug("There is data not appeared in schema and dropped before operation.", droppedVariable);
   return outputVariables.reduce((acc, item) => {
     acc[item.name] = isRoot ? item : item.value;
     return acc;
@@ -89,8 +80,7 @@ export function buildRequiredInputFields(variables, inputField = "input") {
   if (inputVariable) {
     const returnFields = [];
     graphqlInputType[inputVariable.type]?.variables?.forEach((variable) => {
-      if (variable.required)
-        returnFields.push(variable.name);
+      if (variable.required) returnFields.push(variable.name);
     });
     return returnFields;
   } else {
@@ -110,12 +100,9 @@ export function useGraphQlOperation(operationType, operation, fields, variables,
     }
     if (graphqlOperation[operation]?.fields) {
       fields = buildFields(graphqlOperation[operation]?.fields, fields, 0);
-      if (operationType == "Query")
-        useGraphQl().queryPromise(operation, fields, variables, cache).then((result) => resolve(result)).catch((error) => reject(error));
-      else if (operationType == "Mutation")
-        useGraphQl().mutationPromise(operation, fields, variables).then((result) => resolve(result)).catch((error) => reject(error));
-      else
-        reject("Invalid Operation Type");
+      if (operationType == "Query") useGraphQl().queryPromise(operation, fields, variables, cache).then((result) => resolve(result)).catch((error) => reject(error));
+      else if (operationType == "Mutation") useGraphQl().mutationPromise(operation, fields, variables).then((result) => resolve(result)).catch((error) => reject(error));
+      else reject("Invalid Operation Type");
     } else {
       reject("No schema of return data available");
     }

package/dist/runtime/composables/menu.d.ts

@@ -1,6 +1,6 @@
 import { type ComputedRef, type InjectionKey, type Ref } from 'vue';
 import { type RouteRecordNormalized, type RouteRecordRaw } from 'vue-router';
-import { type MenuItem } from '../types/menu';
+import { type MenuItem } from '../types/menu.js';
 export interface MenuProvide {
     menuAll: Ref<MenuItem[]>;
     menuByRoute: ComputedRef<MenuItem[]>;

package/dist/runtime/composables/{menu.mjs → menu.js}

@@ -22,8 +22,7 @@ export function routeToMenuItem(route) {
       const menuItems = new Array();
       for (const children of route.children) {
         const childMenuItem = routeToMenuItem(children);
-        if (childMenuItem)
-          menuItems.push(childMenuItem);
+        if (childMenuItem) menuItems.push(childMenuItem);
         menuItem.menuItems = menuItems;
       }
     }
@@ -38,8 +37,7 @@ export function createMenu() {
     if (paths.length == 2) {
       if (route.path != "/login" && route.path != "/") {
         const menuItem = routeToMenuItem(route);
-        if (menuItem)
-          menuAll.value.push(menuItem);
+        if (menuItem) menuAll.value.push(menuItem);
       }
     }
   }

package/dist/runtime/composables/utils/fuzzy.d.ts

@@ -1,2 +1,2 @@
 import type { MaybeRefOrGetter } from 'vue';
-export declare function useFuzzy(searchTerm: MaybeRefOrGetter<string>, items: MaybeRefOrGetter<any[]>, fieldName: MaybeRefOrGetter<string[]>, options?: MaybeRefOrGetter<Record<string, any>>): import("vue").ComputedRef<Fuse.FuseResult<DataItem>[]>;
+export declare function useFuzzy(searchTerm: MaybeRefOrGetter<string>, items: MaybeRefOrGetter<any[]>, fieldName: MaybeRefOrGetter<string[]>, options?: MaybeRefOrGetter<Record<string, any>>): import("vue").ComputedRef<import("fuse.js").FuseResult<any>[]>;

package/dist/runtime/composables/utils/validation.d.ts

@@ -30,5 +30,37 @@ export declare function useRules(): {
         email: (customError?: string) => (value: any) => string | true;
         regex: (regex: RegExp | string, customError?: string) => (value: any) => string | true;
         idcard: (customError?: string) => (value: any) => string | true;
+    }, {
+        require: (customError?: string) => (value: any) => string | true;
+        requireIf: (conditionIf: boolean, customError?: string) => (value: any) => string | true;
+        requireTrue: (customError?: string) => (value: any) => string | true;
+        requireTrueIf: (conditionIf: boolean, customError?: string) => (value: any) => string | true;
+        numeric: (customError?: string) => (value: any) => string | true;
+        range: (minValue: number, maxValue: number, customError?: string) => (value: any) => string | true;
+        integer: (customError?: string) => (value: any) => string | true;
+        unique: (data: Array<any> | object, fieldName: string, customError?: string) => (value: any) => string | true;
+        length: (length: number, customError?: string) => (value: any) => string | true;
+        lengthGreater: (length: number, customError?: string) => (value: any) => string | true;
+        lengthLess: (length: number, customError?: string) => (value: any) => string | true;
+        telephone: (customError?: string) => (value: any) => string | true;
+        email: (customError?: string) => (value: any) => string | true;
+        regex: (regex: RegExp | string, customError?: string) => (value: any) => string | true;
+        idcard: (customError?: string) => (value: any) => string | true;
+    } | {
+        require: (customError?: string) => (value: any) => string | true;
+        requireIf: (conditionIf: boolean, customError?: string) => (value: any) => string | true;
+        requireTrue: (customError?: string) => (value: any) => string | true;
+        requireTrueIf: (conditionIf: boolean, customError?: string) => (value: any) => string | true;
+        numeric: (customError?: string) => (value: any) => string | true;
+        range: (minValue: number, maxValue: number, customError?: string) => (value: any) => string | true;
+        integer: (customError?: string) => (value: any) => string | true;
+        unique: (data: Array<any> | object, fieldName: string, customError?: string) => (value: any) => string | true;
+        length: (length: number, customError?: string) => (value: any) => string | true;
+        lengthGreater: (length: number, customError?: string) => (value: any) => string | true;
+        lengthLess: (length: number, customError?: string) => (value: any) => string | true;
+        telephone: (customError?: string) => (value: any) => string | true;
+        email: (customError?: string) => (value: any) => string | true;
+        regex: (regex: RegExp | string, customError?: string) => (value: any) => string | true;
+        idcard: (customError?: string) => (value: any) => string | true;
     }>;
 };

package/dist/runtime/plugins/permission.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/plugins/{permission.mjs → permission.js}

@@ -2,8 +2,7 @@ import { defineNuxtPlugin } from "nuxt/app";
 import { useAuthentication } from "#imports";
 export default defineNuxtPlugin(async (nuxtApp) => {
   function permission(permissionId) {
-    if (!permissionId || useAuthentication()?.hasPermission(permissionId) === void 0)
-      return true;
+    if (!permissionId || useAuthentication()?.hasPermission(permissionId) === void 0) return true;
     return useAuthentication()?.hasPermission(permissionId);
   }
   nuxtApp.vueApp.config.globalProperties.$permission = permission;
@@ -15,8 +14,7 @@ export default defineNuxtPlugin(async (nuxtApp) => {
             um();
           });
         }
-        if (el.parentElement)
-          el.parentElement.removeChild(el);
+        if (el.parentElement) el.parentElement.removeChild(el);
       }
     }
   });

package/dist/runtime/utils/datetime.d.ts

@@ -4,22 +4,220 @@ export type dateFormat = 'tinyDate' | 'monthShortDate' | 'shortDate' | 'longDate
 export type dateTimeFormat = 'tinyDateTime' | 'shortDateTime' | 'longDateTime';
 export declare const Datetime: () => {
     luxonDateTime: DateTime<false>;
-    fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
-    fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
-    fromISO: (dateTime: string, locale?: supportedLocale) => any;
-    fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
-    setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
-    toFormat: (format: string, locale?: supportedLocale) => any;
-    toISO: () => any;
-    toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => any;
-    toTinyDate: (locale?: supportedLocale) => any;
-    toMonthShortDate: (locale?: supportedLocale) => any;
-    toShortDate: (locale?: supportedLocale) => any;
-    toLongDate: (locale?: supportedLocale) => any;
-    toTinyDateTime: (locale?: supportedLocale) => any;
-    toShortDateTime: (locale?: supportedLocale) => any;
-    toLongDateTime: (locale?: supportedLocale) => any;
-    now: () => any;
+    fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => {
+        luxonDateTime: DateTime<false>;
+        fromString: any;
+        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
+        fromISO: (dateTime: string, locale?: supportedLocale) => any;
+        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
+        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+        toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+        toISO: () => null;
+        toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+        toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        now: () => any;
+    };
+    fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => {
+        luxonDateTime: DateTime<false>;
+        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
+        fromStringTime: any;
+        fromISO: (dateTime: string, locale?: supportedLocale) => any;
+        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
+        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+        toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+        toISO: () => null;
+        toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+        toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        now: () => any;
+    };
+    fromISO: (dateTime: string, locale?: supportedLocale) => {
+        luxonDateTime: DateTime<false>;
+        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
+        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
+        fromISO: any;
+        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
+        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+        toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+        toISO: () => null;
+        toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+        toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        now: () => any;
+    };
+    fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => {
+        luxonDateTime: DateTime<false>;
+        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
+        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
+        fromISO: (dateTime: string, locale?: supportedLocale) => any;
+        fromObject: any;
+        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+        toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+        toISO: () => null;
+        toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+        toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        now: () => any;
+    };
+    setDateTime: (inputDate: DateTime, locale?: supportedLocale) => {
+        luxonDateTime: DateTime<false>;
+        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
+        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
+        fromISO: (dateTime: string, locale?: supportedLocale) => any;
+        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
+        setDateTime: any;
+        toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+        toISO: () => null;
+        toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+        toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        now: () => any;
+    };
+    toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+    toISO: () => null;
+    toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+    toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+    toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+    toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+    toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+    toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+    toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+    toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+    now: () => {
+        luxonDateTime: DateTime<false>;
+        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => {
+            luxonDateTime: DateTime<false>;
+            fromString: any;
+            fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
+            fromISO: (dateTime: string, locale?: supportedLocale) => any;
+            fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
+            setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+            toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+            toISO: () => null;
+            toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+            toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            now: () => any;
+        };
+        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => {
+            luxonDateTime: DateTime<false>;
+            fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
+            fromStringTime: any;
+            fromISO: (dateTime: string, locale?: supportedLocale) => any;
+            fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
+            setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+            toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+            toISO: () => null;
+            toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+            toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            now: () => any;
+        };
+        fromISO: (dateTime: string, locale?: supportedLocale) => {
+            luxonDateTime: DateTime<false>;
+            fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
+            fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
+            fromISO: any;
+            fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
+            setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+            toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+            toISO: () => null;
+            toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+            toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            now: () => any;
+        };
+        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => {
+            luxonDateTime: DateTime<false>;
+            fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
+            fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
+            fromISO: (dateTime: string, locale?: supportedLocale) => any;
+            fromObject: any;
+            setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+            toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+            toISO: () => null;
+            toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+            toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            now: () => any;
+        };
+        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => {
+            luxonDateTime: DateTime<false>;
+            fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
+            fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
+            fromISO: (dateTime: string, locale?: supportedLocale) => any;
+            fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
+            setDateTime: any;
+            toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+            toISO: () => null;
+            toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+            toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+            toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+            now: () => any;
+        };
+        toFormat: (format: string, locale?: supportedLocale) => "Invalid DateTime";
+        toISO: () => null;
+        toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => "Invalid DateTime";
+        toTinyDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toMonthShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDate: (locale?: supportedLocale) => "Invalid DateTime";
+        toTinyDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toShortDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        toLongDateTime: (locale?: supportedLocale) => "Invalid DateTime";
+        now: any;
+    };
 };
 export declare function verifyDateFormat(date: string): string | null;
 export declare function returnVerifyDate(date: string): string | null;