@kaspernj/api-maker 1.0.2160 → 1.0.2161

package/build/use-styles.js

@@ -1,14 +1,21 @@
+// @ts-check
 /* eslint-disable sort-imports */
 import config from "./config.js";
 import { digg } from "diggerize";
 import * as inflection from "inflection";
 import { useBreakpoint } from "responsive-breakpoints";
 import { useMemo } from "react";
+/** @typedef {boolean | string | ((args: object) => object)} BreakpointValue */
+/** @typedef {Record<string, BreakpointValue>} BreakpointState */
+/** @typedef {import("react-native").ImageStyle | import("react-native").TextStyle | import("react-native").ViewStyle} NamedStyle */
+/** @typedef {Record<string, NamedStyle>} StyleDictionary */
+/** @typedef {Record<string, boolean>} StyleFlags */
+/** @typedef {Array<[string, BreakpointValue]>} ReverseBreakpoints */
 /**
- * @param {Record<string, any>} styles
- * @param {Array<Record<string, any>>} listOfStyles
- * @param {Record<string, any>} breakpoint
- * @param {Array<[string, any]>} breakpointsReverse
+ * @param {StyleDictionary} styles
+ * @param {Array<NamedStyle>} listOfStyles
+ * @param {BreakpointState} breakpoint
+ * @param {ReverseBreakpoints} breakpointsReverse
  * @param {string} arg
  * @returns {void}
  */
@@ -32,10 +39,10 @@ function handleStringStyle(styles, listOfStyles, breakpoint, breakpointsReverse,
     }
 }
 /**
- * @param {Record<string, any>} styles
- * @param {string | Array<string | Record<string, any>> | Record<string, any>} args
- * @param {Array<any>} [dependencies]
- * @returns {Array<Record<string, any>>}
+ * @param {StyleDictionary} styles
+ * @param {string | Array<string | StyleFlags> | StyleFlags} args
+ * @param {Array<boolean | number | string | null | undefined>} [dependencies]
+ * @returns {Array<NamedStyle>}
  */
 export default function useStyles(styles, args, dependencies = []) {
     const breakpoint = useBreakpoint();
@@ -66,4 +73,4 @@ export default function useStyles(styles, args, dependencies = []) {
     }, actualDependencies);
     return listOfStyles;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlLXN0eWxlcy5qcyIsInNvdXJjZVJvb3QiOiIvc3JjLyIsInNvdXJjZXMiOlsidXNlLXN0eWxlcy5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBQ1osaUNBQWlDO0FBQ2pDLE9BQU8sTUFBTSxNQUFNLGFBQWEsQ0FBQTtBQUNoQyxPQUFPLEVBQUMsSUFBSSxFQUFDLE1BQU0sV0FBVyxDQUFBO0FBQzlCLE9BQU8sS0FBSyxVQUFVLE1BQU0sWUFBWSxDQUFBO0FBQ3hDLE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSx3QkFBd0IsQ0FBQTtBQUNwRCxPQUFPLEVBQUMsT0FBTyxFQUFDLE1BQU0sT0FBTyxDQUFBO0FBRTdCLCtFQUErRTtBQUMvRSxpRUFBaUU7QUFDakUsb0lBQW9JO0FBQ3BJLDREQUE0RDtBQUM1RCxvREFBb0Q7QUFDcEQscUVBQXFFO0FBRXJFOzs7Ozs7O0dBT0c7QUFDSCxTQUFTLGlCQUFpQixDQUFDLE1BQU0sRUFBRSxZQUFZLEVBQUUsVUFBVSxFQUFFLGtCQUFrQixFQUFFLEdBQUc7SUFDbEYsSUFBSSxDQUFDLENBQUMsR0FBRyxJQUFJLE1BQU0sQ0FBQyxFQUFFLENBQUM7UUFDckIsTUFBTSxJQUFJLEtBQUssQ0FBQyxvQkFBb0IsR0FBRyxzQkFBc0IsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFBO0lBQ2hHLENBQUM7SUFFRCxZQUFZLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFBO0lBRTlCLEtBQUssTUFBTSxjQUFjLElBQUksa0JBQWtCLEVBQUUsQ0FBQztRQUNoRCxNQUFNLGNBQWMsR0FBRyxjQUFjLENBQUMsQ0FBQyxDQUFDLENBQUE7UUFDeEMsTUFBTSxxQkFBcUIsR0FBRyxHQUFHLEdBQUcsR0FBRyxVQUFVLENBQUMsUUFBUSxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUE7UUFDOUUsTUFBTSx1QkFBdUIsR0FBRyxHQUFHLEdBQUcsR0FBRyxVQUFVLENBQUMsUUFBUSxDQUFDLGNBQWMsQ0FBQyxNQUFNLENBQUE7UUFDbEYsTUFBTSxjQUFjLEdBQUcsSUFBSSxDQUFDLFVBQVUsRUFBRSxHQUFHLGNBQWMsSUFBSSxDQUFDLENBQUE7UUFDOUQsTUFBTSxnQkFBZ0IsR0FBRyxJQUFJLENBQUMsVUFBVSxFQUFFLEdBQUcsY0FBYyxNQUFNLENBQUMsQ0FBQTtRQUVsRSxJQUFJLHFCQUFxQixJQUFJLE1BQU0sSUFBSSxjQUFjLEVBQUUsQ0FBQztZQUN0RCxZQUFZLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDLENBQUE7UUFDbEQsQ0FBQztRQUVELElBQUksdUJBQXVCLElBQUksTUFBTSxJQUFJLGdCQUFnQixFQUFFLENBQUM7WUFDMUQsWUFBWSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsdUJBQXVCLENBQUMsQ0FBQyxDQUFBO1FBQ3BELENBQUM7SUFDSCxDQUFDO0FBQ0gsQ0FBQztBQUVEOzs7OztHQUtHO0FBQ0gsTUFBTSxDQUFDLE9BQU8sVUFBVSxTQUFTLENBQUMsTUFBTSxFQUFFLElBQUksRUFBRSxZQUFZLEdBQUcsRUFBRTtJQUMvRCxNQUFNLFVBQVUsR0FBRyxhQUFhLEVBQUUsQ0FBQTtJQUNsQyxNQUFNLGNBQWMsR0FBRyxJQUFJLENBQUMsVUFBVSxFQUFFLE1BQU0sQ0FBQyxDQUFBO0lBQy9DLE1BQU0sa0JBQWtCLEdBQUcsQ0FBQyxHQUFHLFlBQVksRUFBRSxjQUFjLENBQUMsQ0FBQTtJQUU1RCxNQUFNLFlBQVksR0FBRyxPQUFPLENBQUMsR0FBRyxFQUFFO1FBQ2hDLE1BQU0sWUFBWSxHQUFHLEVBQUUsQ0FBQTtRQUN2QixNQUFNLFNBQVMsR0FBRyxLQUFLLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUE7UUFDckQsbUJBQW1CO1FBQ25CLE1BQU0sa0JBQWtCLEdBQUcsQ0FBQyxHQUFHLE1BQU0sQ0FBQyxjQUFjLEVBQUUsQ0FBQyxDQUFDLE9BQU8sRUFBRSxDQUFBO1FBRWpFLEtBQUssTUFBTSxHQUFHLElBQUksU0FBUyxFQUFFLENBQUM7WUFDNUIsSUFBSSxPQUFPLEdBQUcsSUFBSSxRQUFRLEVBQUUsQ0FBQztnQkFDM0IsaUJBQWlCLENBQUMsTUFBTSxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQUUsa0JBQWtCLEVBQUUsR0FBRyxDQUFDLENBQUE7WUFDOUUsQ0FBQztpQkFBTSxJQUFJLE9BQU8sR0FBRyxJQUFJLFFBQVEsRUFBRSxDQUFDO2dCQUNsQyxLQUFLLE1BQU0sR0FBRyxJQUFJLEdBQUcsRUFBRSxDQUFDO29CQUN0QixNQUFNLEtBQUssR0FBRyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUE7b0JBRXRCLElBQUksS0FBSyxFQUFFLENBQUM7d0JBQ1YsaUJBQWlCLENBQUMsTUFBTSxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQUUsa0JBQWtCLEVBQUUsR0FBRyxDQUFDLENBQUE7b0JBQzlFLENBQUM7Z0JBQ0gsQ0FBQztZQUNILENBQUM7aUJBQU0sQ0FBQztnQkFDTixNQUFNLElBQUksS0FBSyxDQUFDLG1CQUFtQixPQUFPLEdBQUcsRUFBRSxDQUFDLENBQUE7WUFDbEQsQ0FBQztRQUNILENBQUM7UUFFRCxPQUFPLFlBQVksQ0FBQTtJQUNyQixDQUFDLEVBQUUsa0JBQWtCLENBQUMsQ0FBQTtJQUV0QixPQUFPLFlBQVksQ0FBQTtBQUNyQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG4vKiBlc2xpbnQtZGlzYWJsZSBzb3J0LWltcG9ydHMgKi9cbmltcG9ydCBjb25maWcgZnJvbSBcIi4vY29uZmlnLmpzXCJcbmltcG9ydCB7ZGlnZ30gZnJvbSBcImRpZ2dlcml6ZVwiXG5pbXBvcnQgKiBhcyBpbmZsZWN0aW9uIGZyb20gXCJpbmZsZWN0aW9uXCJcbmltcG9ydCB7dXNlQnJlYWtwb2ludH0gZnJvbSBcInJlc3BvbnNpdmUtYnJlYWtwb2ludHNcIlxuaW1wb3J0IHt1c2VNZW1vfSBmcm9tIFwicmVhY3RcIlxuXG4vKiogQHR5cGVkZWYge2Jvb2xlYW4gfCBzdHJpbmcgfCAoKGFyZ3M6IG9iamVjdCkgPT4gb2JqZWN0KX0gQnJlYWtwb2ludFZhbHVlICovXG4vKiogQHR5cGVkZWYge1JlY29yZDxzdHJpbmcsIEJyZWFrcG9pbnRWYWx1ZT59IEJyZWFrcG9pbnRTdGF0ZSAqL1xuLyoqIEB0eXBlZGVmIHtpbXBvcnQoXCJyZWFjdC1uYXRpdmVcIikuSW1hZ2VTdHlsZSB8IGltcG9ydChcInJlYWN0LW5hdGl2ZVwiKS5UZXh0U3R5bGUgfCBpbXBvcnQoXCJyZWFjdC1uYXRpdmVcIikuVmlld1N0eWxlfSBOYW1lZFN0eWxlICovXG4vKiogQHR5cGVkZWYge1JlY29yZDxzdHJpbmcsIE5hbWVkU3R5bGU+fSBTdHlsZURpY3Rpb25hcnkgKi9cbi8qKiBAdHlwZWRlZiB7UmVjb3JkPHN0cmluZywgYm9vbGVhbj59IFN0eWxlRmxhZ3MgKi9cbi8qKiBAdHlwZWRlZiB7QXJyYXk8W3N0cmluZywgQnJlYWtwb2ludFZhbHVlXT59IFJldmVyc2VCcmVha3BvaW50cyAqL1xuXG4vKipcbiAqIEBwYXJhbSB7U3R5bGVEaWN0aW9uYXJ5fSBzdHlsZXNcbiAqIEBwYXJhbSB7QXJyYXk8TmFtZWRTdHlsZT59IGxpc3RPZlN0eWxlc1xuICogQHBhcmFtIHtCcmVha3BvaW50U3RhdGV9IGJyZWFrcG9pbnRcbiAqIEBwYXJhbSB7UmV2ZXJzZUJyZWFrcG9pbnRzfSBicmVha3BvaW50c1JldmVyc2VcbiAqIEBwYXJhbSB7c3RyaW5nfSBhcmdcbiAqIEByZXR1cm5zIHt2b2lkfVxuICovXG5mdW5jdGlvbiBoYW5kbGVTdHJpbmdTdHlsZShzdHlsZXMsIGxpc3RPZlN0eWxlcywgYnJlYWtwb2ludCwgYnJlYWtwb2ludHNSZXZlcnNlLCBhcmcpIHsgLy8gZXNsaW50LWRpc2FibGUtbGluZSBmdW5jLXN0eWxlLCBtYXgtcGFyYW1zXG4gIGlmICghKGFyZyBpbiBzdHlsZXMpKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKGBObyBzdWNoIHN0eWxpbmcgJyR7YXJnfScgaW4gZ2l2ZW4gc3R5bGVzOiAke09iamVjdC5rZXlzKHN0eWxlcykuam9pbihcIiwgXCIpfWApXG4gIH1cblxuICBsaXN0T2ZTdHlsZXMucHVzaChzdHlsZXNbYXJnXSlcblxuICBmb3IgKGNvbnN0IGJyZWFrcG9pbnREYXRhIG9mIGJyZWFrcG9pbnRzUmV2ZXJzZSkge1xuICAgIGNvbnN0IGJyZWFrcG9pbnROYW1lID0gYnJlYWtwb2ludERhdGFbMF1cbiAgICBjb25zdCBicmVha3BvaW50U3R5bGVOYW1lVXAgPSBgJHthcmd9JHtpbmZsZWN0aW9uLmNhbWVsaXplKGJyZWFrcG9pbnROYW1lKX1VcGBcbiAgICBjb25zdCBicmVha3BvaW50U3R5bGVOYW1lRG93biA9IGAke2FyZ30ke2luZmxlY3Rpb24uY2FtZWxpemUoYnJlYWtwb2ludE5hbWUpfURvd25gXG4gICAgY29uc3QgYnJlYWtwb2ludElzVXAgPSBkaWdnKGJyZWFrcG9pbnQsIGAke2JyZWFrcG9pbnROYW1lfVVwYClcbiAgICBjb25zdCBicmVha3BvaW50SXNEb3duID0gZGlnZyhicmVha3BvaW50LCBgJHticmVha3BvaW50TmFtZX1Eb3duYClcblxuICAgIGlmIChicmVha3BvaW50U3R5bGVOYW1lVXAgaW4gc3R5bGVzICYmIGJyZWFrcG9pbnRJc1VwKSB7XG4gICAgICBsaXN0T2ZTdHlsZXMucHVzaChzdHlsZXNbYnJlYWtwb2ludFN0eWxlTmFtZVVwXSlcbiAgICB9XG5cbiAgICBpZiAoYnJlYWtwb2ludFN0eWxlTmFtZURvd24gaW4gc3R5bGVzICYmIGJyZWFrcG9pbnRJc0Rvd24pIHtcbiAgICAgIGxpc3RPZlN0eWxlcy5wdXNoKHN0eWxlc1ticmVha3BvaW50U3R5bGVOYW1lRG93bl0pXG4gICAgfVxuICB9XG59XG5cbi8qKlxuICogQHBhcmFtIHtTdHlsZURpY3Rpb25hcnl9IHN0eWxlc1xuICogQHBhcmFtIHtzdHJpbmcgfCBBcnJheTxzdHJpbmcgfCBTdHlsZUZsYWdzPiB8IFN0eWxlRmxhZ3N9IGFyZ3NcbiAqIEBwYXJhbSB7QXJyYXk8Ym9vbGVhbiB8IG51bWJlciB8IHN0cmluZyB8IG51bGwgfCB1bmRlZmluZWQ+fSBbZGVwZW5kZW5jaWVzXVxuICogQHJldHVybnMge0FycmF5PE5hbWVkU3R5bGU+fVxuICovXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiB1c2VTdHlsZXMoc3R5bGVzLCBhcmdzLCBkZXBlbmRlbmNpZXMgPSBbXSkge1xuICBjb25zdCBicmVha3BvaW50ID0gdXNlQnJlYWtwb2ludCgpXG4gIGNvbnN0IGJyZWFrcG9pbnROYW1lID0gZGlnZyhicmVha3BvaW50LCBcIm5hbWVcIilcbiAgY29uc3QgYWN0dWFsRGVwZW5kZW5jaWVzID0gWy4uLmRlcGVuZGVuY2llcywgYnJlYWtwb2ludE5hbWVdXG5cbiAgY29uc3QgbGlzdE9mU3R5bGVzID0gdXNlTWVtbygoKSA9PiB7XG4gICAgY29uc3QgbGlzdE9mU3R5bGVzID0gW11cbiAgICBjb25zdCBhcmdzQXJyYXkgPSBBcnJheS5pc0FycmF5KGFyZ3MpID8gYXJncyA6IFthcmdzXVxuICAgIC8vIEB0cy1leHBlY3QtZXJyb3JcbiAgICBjb25zdCBicmVha3BvaW50c1JldmVyc2UgPSBbLi4uY29uZmlnLmdldEJyZWFrcG9pbnRzKCldLnJldmVyc2UoKVxuXG4gICAgZm9yIChjb25zdCBhcmcgb2YgYXJnc0FycmF5KSB7XG4gICAgICBpZiAodHlwZW9mIGFyZyA9PSBcInN0cmluZ1wiKSB7XG4gICAgICAgIGhhbmRsZVN0cmluZ1N0eWxlKHN0eWxlcywgbGlzdE9mU3R5bGVzLCBicmVha3BvaW50LCBicmVha3BvaW50c1JldmVyc2UsIGFyZylcbiAgICAgIH0gZWxzZSBpZiAodHlwZW9mIGFyZyA9PSBcIm9iamVjdFwiKSB7XG4gICAgICAgIGZvciAoY29uc3Qga2V5IGluIGFyZykge1xuICAgICAgICAgIGNvbnN0IHZhbHVlID0gYXJnW2tleV1cblxuICAgICAgICAgIGlmICh2YWx1ZSkge1xuICAgICAgICAgICAgaGFuZGxlU3RyaW5nU3R5bGUoc3R5bGVzLCBsaXN0T2ZTdHlsZXMsIGJyZWFrcG9pbnQsIGJyZWFrcG9pbnRzUmV2ZXJzZSwga2V5KVxuICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgICAgfSBlbHNlIHtcbiAgICAgICAgdGhyb3cgbmV3IEVycm9yKGBVbmhhbmRsZWQgdHlwZTogJHt0eXBlb2YgYXJnfWApXG4gICAgICB9XG4gICAgfVxuXG4gICAgcmV0dXJuIGxpc3RPZlN0eWxlc1xuICB9LCBhY3R1YWxEZXBlbmRlbmNpZXMpXG5cbiAgcmV0dXJuIGxpc3RPZlN0eWxlc1xufVxuIl19

package/build/use-updated-event.d.ts

@@ -1,160 +1,50 @@
 export default apiMakerUseUpdatedEvent;
-/**
- * @param {import("./base-model.js").default|import("./base-model.js").default[]} model
- * @param {Function} onUpdated
- * @param {object} [props]
- * @param {boolean} [props.active]
- * @param {number} [props.debounce]
- * @param {(...args: any[]) => void} [props.onConnected]
- * @returns {void}
- */
-declare function apiMakerUseUpdatedEvent(model: {
-    changes: {};
-    newRecord: boolean;
-    relationshipsCache: {};
-    relationships: {};
-    abilities: Record<string, any>;
-    modelData: {};
-    assignAttributes(newAttributes: Record<string, any>): void;
-    attributes(): Record<string, any>;
-    can(givenAbilityName: string): boolean;
-    clone(): /*elided*/ any;
-    cacheKey(): number | string;
-    localCacheKey(): string;
-    fullCacheKey(): string;
-    create(attributes?: Record<string, any>, options?: object): Promise<{
-        model: /*elided*/ any;
-        response: object;
-    }>;
-    createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
-        model: /*elided*/ any;
-        response: any;
-    }>;
-    destroy(): Promise<{
-        model: /*elided*/ any;
-        response: object;
-    }>;
-    ensureAbilities(listOfAbilities: string[]): Promise<void>;
-    getAttributes(): Record<string, any>;
-    handleResponseError(response: object): never;
-    identifierKey(): number | string;
+export type UseUpdatedEventProps = {
+    active?: boolean;
+    debounce?: number;
+    onConnected?: () => void;
+};
+export type EventModel = {
+    abilities: import("./base-model.js").ModelAbilityMap;
+    changes: import("./base-model.js").ModelDataMap;
+    collection: import("./collection.js").default<any>;
     _identifierKey: string | number;
-    isAssociationLoaded(associationName: string): boolean;
-    isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
-    isAssociationPresent(associationName: string): boolean;
-    ensureAssociationLoaded(associationName: string): Promise<any>;
-    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
-    isAttributeChanged(attributeName: string): boolean;
-    isChanged(): boolean;
-    isNewRecord(): boolean;
-    isPersisted(): boolean;
-    savedChangeToAttribute(attributeName: string): boolean;
-    setNewModel(model: /*elided*/ any): void;
-    setNewModelData(model: /*elided*/ any): void;
-    previousModelData: any;
-    _isDateChanged(oldValue: any, newValue: any): boolean | void;
-    _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
-    _isStringChanged(oldValue: any, newValue: any): boolean | void;
-    modelClassData(): ModelClassDataType;
-    reload(): Promise<void>;
-    save(): Promise<{
-        model: /*elided*/ any;
-        response?: object;
-    }>;
-    saveRaw(rawData: any, options?: {}): Promise<{
-        model: /*elided*/ any;
-        response: object;
-    }>;
-    update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
-        model: /*elided*/ any;
-        response?: object;
-    }>;
-    _refreshModelFromResponse(response: object): void;
-    _refreshModelDataFromResponse(response: object): void;
-    updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
-        simpleModelErrors?: boolean;
-    }): Promise<{
-        response: object;
-        model: /*elided*/ any;
-    }>;
-    isValid(): never;
-    isValidOnServer(): Promise<{
-        valid: boolean;
-        errors: Record<string, any>;
-    }>;
-    modelClass(): Record<string, any>;
-    preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
-    markForDestruction(): void;
     _markedForDestruction: boolean;
-    markedForDestruction(): boolean;
-    uniqueKey(): number;
-    uniqueKeyValue: number;
-    _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
-    readAttribute(attributeName: string): any;
-    readAttributeUnderscore(attributeName: string): any;
-    isAttributeLoaded(attributeName: any): boolean;
-    _isPresent(value: any): boolean;
-    _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
-    _readBelongsToReflection({ reflectionName }: {
-        modelClass: any;
-        reflectionName: string;
-    }): any | null;
-    _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
-    _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
-    _readHasOneReflection({ reflectionName }: {
-        modelClass: any;
-        reflectionName: string;
-    }): any | null;
-    _readModelDataFromArgs(args?: {
-        data?: {
-            b?: Record<string, any>;
-            a?: Record<string, any>;
-            r?: any;
-        };
-        collection?: import("./collection.js").default<any>;
-    }): void;
-    collection: import("./collection.js").default<any>;
-    preloadedRelationships: any;
-    _readPreloadedRelationships(preloaded: {
-        getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
-    }): void;
-    primaryKey(): number | string;
-} | {
-    changes: {};
+    modelData: import("./base-model.js").ModelDataMap;
     newRecord: boolean;
-    relationshipsCache: {};
-    relationships: {};
-    abilities: Record<string, any>;
-    modelData: {};
-    assignAttributes(newAttributes: Record<string, any>): void;
-    attributes(): Record<string, any>;
+    previousModelData: any;
+    preloadedRelationships: import("./base-model.js").PreloadedRelationshipMap;
+    relationshipsCache: import("./base-model.js").LoadedRelationshipMap;
+    relationships: import("./base-model.js").LoadedRelationshipMap;
+    uniqueKeyValue: number;
+    assignAttributes(newAttributes: ModelDataMap): void;
+    attributes(): ModelDataMap;
     can(givenAbilityName: string): boolean;
     clone(): /*elided*/ any;
     cacheKey(): number | string;
     localCacheKey(): string;
     fullCacheKey(): string;
-    create(attributes?: Record<string, any>, options?: object): Promise<{
+    create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
         model: /*elided*/ any;
-        response: object;
+        response: ModelCommandResponse;
     }>;
-    createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+    createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
         model: /*elided*/ any;
-        response: any;
+        response: ModelCommandResponse;
     }>;
     destroy(): Promise<{
         model: /*elided*/ any;
-        response: object;
+        response: ModelCommandResponse;
     }>;
     ensureAbilities(listOfAbilities: string[]): Promise<void>;
-    getAttributes(): Record<string, any>;
-    handleResponseError(response: object): never;
+    getAttributes(): ModelDataMap;
+    handleResponseError(response: ModelCommandResponse): never;
     identifierKey(): number | string;
-    _identifierKey: string | number;
     isAssociationLoaded(associationName: string): boolean;
     isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
     isAssociationPresent(associationName: string): boolean;
-    ensureAssociationLoaded(associationName: string): Promise<any>;
-    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+    ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
     isAttributeChanged(attributeName: string): boolean;
     isChanged(): boolean;
     isNewRecord(): boolean;
@@ -162,77 +52,71 @@ declare function apiMakerUseUpdatedEvent(model: {
     savedChangeToAttribute(attributeName: string): boolean;
     setNewModel(model: /*elided*/ any): void;
     setNewModelData(model: /*elided*/ any): void;
-    previousModelData: any;
-    _isDateChanged(oldValue: any, newValue: any): boolean | void;
-    _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
-    _isStringChanged(oldValue: any, newValue: any): boolean | void;
+    _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
     modelClassData(): ModelClassDataType;
     reload(): Promise<void>;
     save(): Promise<{
         model: /*elided*/ any;
         response?: object;
     }>;
-    saveRaw(rawData: any, options?: {}): Promise<{
+    saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
         model: /*elided*/ any;
-        response: object;
+        response: ModelCommandResponse;
     }>;
-    update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+    update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
         model: /*elided*/ any;
         response?: object;
     }>;
-    _refreshModelFromResponse(response: object): void;
-    _refreshModelDataFromResponse(response: object): void;
-    updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+    _refreshModelFromResponse(response: ModelCommandResponse): void;
+    _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+    updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
         simpleModelErrors?: boolean;
     }): Promise<{
-        response: object;
+        response: ModelCommandResponse;
         model: /*elided*/ any;
     }>;
     isValid(): never;
     isValidOnServer(): Promise<{
         valid: boolean;
-        errors: Record<string, any>;
+        errors: ValidationResponseErrors;
     }>;
-    modelClass(): Record<string, any>;
+    modelClass(): BaseModelClassType;
     preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
     markForDestruction(): void;
-    _markedForDestruction: boolean;
     markedForDestruction(): boolean;
     uniqueKey(): number;
-    uniqueKeyValue: number;
-    _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
-    readAttribute(attributeName: string): any;
-    readAttributeUnderscore(attributeName: string): any;
-    isAttributeLoaded(attributeName: any): boolean;
-    _isPresent(value: any): boolean;
-    _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
-    _readBelongsToReflection({ reflectionName }: {
-        modelClass: any;
-        reflectionName: string;
-    }): any | null;
-    _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
-    _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
-    _readHasOneReflection({ reflectionName }: {
-        modelClass: any;
-        reflectionName: string;
-    }): any | null;
-    _readModelDataFromArgs(args?: {
-        data?: {
-            b?: Record<string, any>;
-            a?: Record<string, any>;
-            r?: any;
-        };
-        collection?: import("./collection.js").default<any>;
-    }): void;
-    collection: import("./collection.js").default<any>;
-    preloadedRelationships: any;
+    _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
+    readAttribute(attributeName: string): ModelValue | null | undefined;
+    readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+    isAttributeLoaded(attributeName: string): boolean;
+    _isPresent(value: ModelValue | null | undefined): boolean;
+    _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+    _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    _readModelDataFromArgs(args?: BaseModelArgsObject): void;
     _readPreloadedRelationships(preloaded: {
         getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
     }): void;
     primaryKey(): number | string;
-}[], onUpdated: Function, props?: {
-    active?: boolean;
-    debounce?: number;
-    onConnected?: (...args: any[]) => void;
-}): void;
+};
+export type EventModelWithId = EventModel & {
+    id: () => number | string;
+};
+export type UpdatedEventPayload = {
+    model: EventModel;
+};
+export type EventCallback = (payload: UpdatedEventPayload) => void;
+/**
+ * @param {EventModel | EventModel[]} model
+ * @param {EventCallback} onUpdated
+ * @param {UseUpdatedEventProps} [props]
+ * @returns {void}
+ */
+declare function apiMakerUseUpdatedEvent(model: EventModel | EventModel[], onUpdated: EventCallback, props?: UseUpdatedEventProps): void;
 //# sourceMappingURL=use-updated-event.d.ts.map

package/build/use-updated-event.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-updated-event.d.ts","sourceRoot":"/src/","sources":["use-updated-event.js"],"names":[],"mappings":";AA0CA;;;;;;;;GAQG;AACH,gDARW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAmFm4nB,CAAC;;;;;;;;gBAA2iB,CAAC;;;;;yBAAypE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAnFzitB,GAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAmFi2nB,CAAC;;;;;;;;gBAA2iB,CAAC;;;;;yBAAypE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAnFvgtB,EAAE,+BAG7E;IAAwB,MAAM,GAAtB,OAAO;IACQ,QAAQ,GAAvB,MAAM;IAC2B,WAAW,GAA5C,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI;CAChC,GAAU,IAAI,CA0EhB"}
+{"version":3,"file":"use-updated-event.d.ts","sourceRoot":"/src/","sources":["use-updated-event.js"],"names":[],"mappings":";mCAOc;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,IAAI,CAAA;CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA6HqpyB,CAAC;;;yBAA6O,CAAC;;;;;;;gBAAoc,CAAC;;;;;yBAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BA3H5z4B,UAAU,GAAG;IAAC,EAAE,EAAE,MAAM,MAAM,GAAC,MAAM,CAAA;CAAC;kCACtC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAC;4BACnB,CAAC,OAAO,EAAE,mBAAmB,KAAK,IAAI;AAwCpD;;;;;GAKG;AACH,gDALW,UAAU,GAAG,UAAU,EAAE,aACzB,aAAa,UACb,oBAAoB,GAClB,IAAI,CA0EhB"}

package/build/use-updated-event.js

@@ -1,11 +1,17 @@
+// @ts-check
 /* eslint-disable sort-imports */
 import { useCallback, useLayoutEffect, useMemo, useRef } from "react";
 import debounceFunction from "debounce";
 import ModelEvents from "./model-events.js";
 import useShape from "./use-shape.js";
+/** @typedef {{active?: boolean, debounce?: number, onConnected?: () => void}} UseUpdatedEventProps */
+/** @typedef {import("./base-model.js").default} EventModel */
+/** @typedef {EventModel & {id: () => number|string}} EventModelWithId */
+/** @typedef {{model: EventModel}} UpdatedEventPayload */
+/** @typedef {(payload: UpdatedEventPayload) => void} EventCallback */
 /**
- * @param {object|object[]|undefined|null} modelOrModels
- * @returns {object[]}
+ * @param {EventModel | EventModel[] | undefined | null} modelOrModels
+ * @returns {EventModel[]}
  */
 const modelsFromInput = (modelOrModels) => {
     if (!modelOrModels) {
@@ -19,28 +25,26 @@ const modelsFromInput = (modelOrModels) => {
     }
 };
 /**
- * @param {object|object[]|undefined|null} modelOrModels
+ * @param {EventModel | EventModel[] | undefined | null} modelOrModels
  * @returns {string}
  */
-const modelsDependencyKey = (modelOrModels) => JSON.stringify(modelsFromInput(modelOrModels).map((model) => model.id()));
+const modelsDependencyKey = (modelOrModels) => JSON.stringify(modelsFromInput(modelOrModels).map((model) => /** @type {EventModelWithId} */ (model).id()));
 /**
- * @param {object|object[]|undefined|null} modelOrModels
- * @returns {Record<string, object>}
+ * @param {EventModel | EventModel[] | undefined | null} modelOrModels
+ * @returns {Record<string, EventModelWithId>}
  */
 const modelsByIdFromInput = (modelOrModels) => {
-    const modelsById = {};
+    const modelsById = /** @type {Record<string, EventModelWithId>} */ ({});
     modelsFromInput(modelOrModels).forEach((model) => {
-        modelsById[model.id()] = model;
+        const modelWithId = /** @type {EventModelWithId} */ (model);
+        modelsById[modelWithId.id()] = modelWithId;
     });
     return modelsById;
 };
 /**
- * @param {import("./base-model.js").default|import("./base-model.js").default[]} model
- * @param {Function} onUpdated
- * @param {object} [props]
- * @param {boolean} [props.active]
- * @param {number} [props.debounce]
- * @param {(...args: any[]) => void} [props.onConnected]
+ * @param {EventModel | EventModel[]} model
+ * @param {EventCallback} onUpdated
+ * @param {UseUpdatedEventProps} [props]
  * @returns {void}
  */
 const apiMakerUseUpdatedEvent = (model, onUpdated, props = {}) => {
@@ -59,15 +63,15 @@ const apiMakerUseUpdatedEvent = (model, onUpdated, props = {}) => {
         }
     }, [debounce]);
     s.updateMeta({ debounceCallback });
-    const onUpdatedCallback = useCallback((...args) => {
+    const onUpdatedCallback = useCallback((payload) => {
         if (!s.p.active) {
             return;
         }
         if (s.p.debounce) {
-            s.m.debounceCallback(...args);
+            s.m.debounceCallback(payload);
         }
         else {
-            s.p.onUpdated(...args);
+            s.p.onUpdated(payload);
         }
     }, []);
     useLayoutEffect(() => {
@@ -104,4 +108,4 @@ const apiMakerUseUpdatedEvent = (model, onUpdated, props = {}) => {
     }, []);
 };
 export default apiMakerUseUpdatedEvent;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"use-updated-event.js","sourceRoot":"/src/","sources":["use-updated-event.js"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable sort-imports */\nimport {useCallback, useLayoutEffect, useMemo, useRef} from \"react\"\nimport debounceFunction from \"debounce\"\nimport ModelEvents from \"./model-events.js\"\nimport useShape from \"./use-shape.js\"\n\n/**\n * @param {object|object[]|undefined|null} modelOrModels\n * @returns {object[]}\n */\nconst modelsFromInput = (modelOrModels) => {\n  if (!modelOrModels) {\n    return []\n  } else if (Array.isArray(modelOrModels)) {\n    return modelOrModels.filter(Boolean)\n  } else {\n    return [modelOrModels]\n  }\n}\n\n/**\n * @param {object|object[]|undefined|null} modelOrModels\n * @returns {string}\n */\nconst modelsDependencyKey = (modelOrModels) => JSON.stringify(\n  modelsFromInput(modelOrModels).map((model) => model.id())\n)\n\n/**\n * @param {object|object[]|undefined|null} modelOrModels\n * @returns {Record<string, object>}\n */\nconst modelsByIdFromInput = (modelOrModels) => {\n  const modelsById = {}\n\n  modelsFromInput(modelOrModels).forEach((model) => {\n    modelsById[model.id()] = model\n  })\n\n  return modelsById\n}\n\n/**\n * @param {import(\"./base-model.js\").default|import(\"./base-model.js\").default[]} model\n * @param {Function} onUpdated\n * @param {object} [props]\n * @param {boolean} [props.active]\n * @param {number} [props.debounce]\n * @param {(...args: any[]) => void} [props.onConnected]\n * @returns {void}\n */\nconst apiMakerUseUpdatedEvent = (model, onUpdated, props = {}) => {\n  const {active = true, debounce, onConnected, ...restProps} = props\n  const connectionsRef = useRef({})\n\n  if (Object.keys(restProps).length > 0) {\n    throw new Error(`Unknown props given to useUpdatedEvent: ${Object.keys(restProps).join(\", \")}`)\n  }\n\n  const s = useShape({active, debounce, model, onUpdated})\n\n  const debounceCallback = useMemo(() => {\n    if (typeof debounce == \"number\") {\n      return debounceFunction(s.p.onUpdated, debounce)\n    } else {\n      return debounceFunction(s.p.onUpdated)\n    }\n  }, [debounce])\n\n  s.updateMeta({debounceCallback})\n\n  const onUpdatedCallback = useCallback((...args) => {\n    if (!s.p.active) {\n      return\n    }\n\n    if (s.p.debounce) {\n      s.m.debounceCallback(...args)\n    } else {\n      s.p.onUpdated(...args)\n    }\n  }, [])\n\n  useLayoutEffect(() => {\n    const currentConnections = connectionsRef.current\n    const nextModelsById = modelsByIdFromInput(model)\n\n    Object.keys(currentConnections).forEach((modelId) => {\n      if (!(modelId in nextModelsById)) {\n        if (onConnected) {\n          currentConnections[modelId].events.removeListener(\"connected\", onConnected)\n        }\n\n        currentConnections[modelId].unsubscribe()\n        delete currentConnections[modelId]\n      }\n    })\n\n    Object.keys(nextModelsById).forEach((modelId) => {\n      if (modelId in currentConnections) {\n        return\n      }\n\n      const updatedConnection = ModelEvents.connectUpdated(nextModelsById[modelId], onUpdatedCallback)\n      currentConnections[modelId] = updatedConnection\n\n      if (onConnected) {\n        updatedConnection.events.addListener(\"connected\", onConnected)\n      }\n    })\n  }, [modelsDependencyKey(model)])\n\n  useLayoutEffect(() => () => {\n    Object.values(connectionsRef.current).forEach((updatedConnection) => {\n      if (onConnected) {\n        updatedConnection.events.removeListener(\"connected\", onConnected)\n      }\n\n      updatedConnection.unsubscribe()\n    })\n\n    connectionsRef.current = {}\n  }, [])\n}\n\nexport default apiMakerUseUpdatedEvent\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"use-updated-event.js","sourceRoot":"/src/","sources":["use-updated-event.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n/* eslint-disable sort-imports */\nimport {useCallback, useLayoutEffect, useMemo, useRef} from \"react\"\nimport debounceFunction from \"debounce\"\nimport ModelEvents from \"./model-events.js\"\nimport useShape from \"./use-shape.js\"\n\n/** @typedef {{active?: boolean, debounce?: number, onConnected?: () => void}} UseUpdatedEventProps */\n/** @typedef {import(\"./base-model.js\").default} EventModel */\n/** @typedef {EventModel & {id: () => number|string}} EventModelWithId */\n/** @typedef {{model: EventModel}} UpdatedEventPayload */\n/** @typedef {(payload: UpdatedEventPayload) => void} EventCallback */\n\n/**\n * @param {EventModel | EventModel[] | undefined | null} modelOrModels\n * @returns {EventModel[]}\n */\nconst modelsFromInput = (modelOrModels) => {\n  if (!modelOrModels) {\n    return []\n  } else if (Array.isArray(modelOrModels)) {\n    return modelOrModels.filter(Boolean)\n  } else {\n    return [modelOrModels]\n  }\n}\n\n/**\n * @param {EventModel | EventModel[] | undefined | null} modelOrModels\n * @returns {string}\n */\nconst modelsDependencyKey = (modelOrModels) => JSON.stringify(\n  modelsFromInput(modelOrModels).map((model) => /** @type {EventModelWithId} */ (model).id())\n)\n\n/**\n * @param {EventModel | EventModel[] | undefined | null} modelOrModels\n * @returns {Record<string, EventModelWithId>}\n */\nconst modelsByIdFromInput = (modelOrModels) => {\n  const modelsById = /** @type {Record<string, EventModelWithId>} */ ({})\n\n  modelsFromInput(modelOrModels).forEach((model) => {\n    const modelWithId = /** @type {EventModelWithId} */ (model)\n\n    modelsById[modelWithId.id()] = modelWithId\n  })\n\n  return modelsById\n}\n\n/**\n * @param {EventModel | EventModel[]} model\n * @param {EventCallback} onUpdated\n * @param {UseUpdatedEventProps} [props]\n * @returns {void}\n */\nconst apiMakerUseUpdatedEvent = (model, onUpdated, props = {}) => {\n  const {active = true, debounce, onConnected, ...restProps} = props\n  const connectionsRef = useRef({})\n\n  if (Object.keys(restProps).length > 0) {\n    throw new Error(`Unknown props given to useUpdatedEvent: ${Object.keys(restProps).join(\", \")}`)\n  }\n\n  const s = useShape({active, debounce, model, onUpdated})\n\n  const debounceCallback = useMemo(() => {\n    if (typeof debounce == \"number\") {\n      return debounceFunction(s.p.onUpdated, debounce)\n    } else {\n      return debounceFunction(s.p.onUpdated)\n    }\n  }, [debounce])\n\n  s.updateMeta({debounceCallback})\n\n  const onUpdatedCallback = useCallback((payload) => {\n    if (!s.p.active) {\n      return\n    }\n\n    if (s.p.debounce) {\n      s.m.debounceCallback(payload)\n    } else {\n      s.p.onUpdated(payload)\n    }\n  }, [])\n\n  useLayoutEffect(() => {\n    const currentConnections = connectionsRef.current\n    const nextModelsById = modelsByIdFromInput(model)\n\n    Object.keys(currentConnections).forEach((modelId) => {\n      if (!(modelId in nextModelsById)) {\n        if (onConnected) {\n          currentConnections[modelId].events.removeListener(\"connected\", onConnected)\n        }\n\n        currentConnections[modelId].unsubscribe()\n        delete currentConnections[modelId]\n      }\n    })\n\n    Object.keys(nextModelsById).forEach((modelId) => {\n      if (modelId in currentConnections) {\n        return\n      }\n\n      const updatedConnection = ModelEvents.connectUpdated(nextModelsById[modelId], onUpdatedCallback)\n      currentConnections[modelId] = updatedConnection\n\n      if (onConnected) {\n        updatedConnection.events.addListener(\"connected\", onConnected)\n      }\n    })\n  }, [modelsDependencyKey(model)])\n\n  useLayoutEffect(() => () => {\n    Object.values(connectionsRef.current).forEach((updatedConnection) => {\n      if (onConnected) {\n        updatedConnection.events.removeListener(\"connected\", onConnected)\n      }\n\n      updatedConnection.unsubscribe()\n    })\n\n    connectionsRef.current = {}\n  }, [])\n}\n\nexport default apiMakerUseUpdatedEvent\n"]}

package/build/use-validation-errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-validation-errors.d.ts","sourceRoot":"/src/","sources":["use-validation-errors.js"],"names":[],"mappings":";AAKA;;;GAGG;AACH,0DAFa,MAAM,CA2BlB"}
+{"version":3,"file":"use-validation-errors.d.ts","sourceRoot":"/src/","sources":["use-validation-errors.js"],"names":[],"mappings":";AAMA;;;GAGG;AACH,0DAFa,MAAM,CA2BlB"}

package/build/use-validation-errors.js

@@ -1,3 +1,4 @@
+// @ts-check
 import events from "./events.js";
 import { useCallback } from "react";
 import useEventEmitter from "ya-use-event-emitter";
@@ -27,4 +28,4 @@ const useValidationErrors = (callback) => {
     };
 };
 export default useValidationErrors;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/utils/button.d.ts

@@ -1,4 +1,18 @@
 declare const _default: React.NamedExoticComponent<Record<string, any>>;
 export default _default;
+export type Props = {
+    children?: React.ReactNode;
+    danger?: boolean;
+    disabled?: boolean;
+    icon?: string;
+    label?: string;
+    onPress?: Function;
+    pressableProps?: object;
+    submit?: boolean;
+    textProps?: object;
+};
+export type State = {
+    hover: boolean;
+};
 import React from "react";
 //# sourceMappingURL=button.d.ts.map

package/build/utils/button.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"button.d.ts","sourceRoot":"/src/","sources":["utils/button.jsx"],"names":[],"mappings":";;kBAOkB,OAAO"}
+{"version":3,"file":"button.d.ts","sourceRoot":"/src/","sources":["utils/button.jsx"],"names":[],"mappings":";;;eAcc,KAAK,CAAC,SAAS;aACf,OAAO;eACP,OAAO;WACP,MAAM;YACL,MAAM;;qBAEP,MAAM;aACN,OAAO;gBACP,MAAM;;;WAIN,OAAO;;kBAlBH,OAAO"}