@kaspernj/api-maker 1.0.2159 → 1.0.2161

package/build/models-response-reader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"models-response-reader.d.ts","sourceRoot":"/src/","sources":["models-response-reader.js"],"names":[],"mappings":"AAIA,6DAA6D;AAC7D;IACE;;;OAGG;IACH,uBAHW;QAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAAC,GACzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAmDq2qB,CAAC;;;;;;;;oBAA2iB,CAAC;;;;;6BAAypE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAnD3gwB,GAAG,SAAS,CAIzD;IAED;;;OAGG;IACH,4BAHW;QAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAAC,GACzD,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA2C+1qB,CAAC;;;;;;;;oBAA2iB,CAAC;;;;;6BAAypE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA3CrgwB,CAAC,CAKpD;IAED,iJAAiJ;IACjJ,kBADY;QAAC,UAAU,CAAC,EAAE,OAAO,iBAAiB,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;QAAC,QAAQ,EAAE;YAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;YAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;SAAC,CAAA;KAAC,EAIvI;IAFC,mDAAiC;IACjC;cAHiF,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;mBAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;MAGvG;IAG/B,0DAA0D;IAC1D,UADc,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA8B81qB,CAAC;;;;;;;;oBAA2iB,CAAC;;;;;6BAAypE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA9BpgwB,CAAC,CA4BrD;CACF"}
+{"version":3,"file":"models-response-reader.d.ts","sourceRoot":"/src/","sources":["models-response-reader.js"],"names":[],"mappings":"AAKA,0DAA0D;AAC1D,6EAA6E;AAC7E;;;;GAIG;AAEH,6DAA6D;AAC7D;IACE;;;OAGG;IACH,uBAHW,cAAc,GACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAmDq81B,CAAC;;;6BAA6O,CAAC;;;;;;;oBAAoc,CAAC;;;;;6BAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAnD5g8B,GAAG,SAAS,CAIzD;IAED;;;OAGG;IACH,4BAHW,cAAc,GACZ,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA2C+71B,CAAC;;;6BAA6O,CAAC;;;;;;;oBAAoc,CAAC;;;;;6BAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA3Ctg8B,CAAC,CAKpD;IAED,yIAAyI;IACzI,kBADY;QAAC,UAAU,CAAC,EAAE,OAAO,iBAAiB,EAAE,OAAO,CAAC,cAAc,iBAAiB,EAAE,OAAO,CAAC,CAAC;QAAC,QAAQ,EAAE,cAAc,CAAA;KAAC,EAI/H;IAFC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAkCg91B,CAAC;;;iCAA6O,CAAC;;;;;;;wBAAoc,CAAC;;;;;iCAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAAxmG,CAAC;;;iCAA6O,CAAC;;;;;;;wBAAoc,CAAC;;;;;iCAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAAxmG,CAAC;;;iCAA6O,CAAC;;;;;;;wBAAoc,CAAC;;;;;iCAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAxmG,CAAC;;;qCAA6O,CAAC;;;;;;;4BAAoc,CAAC;;;;;qCAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAlCvh8B;IACjC,yBAA6B;IAG/B,0DAA0D;IAC1D,UADc,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA8B871B,CAAC;;;6BAA6O,CAAC;;;;;;;oBAAoc,CAAC;;;;;6BAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA9Brg8B,CAAC,CA4BrD;CACF;8BA9Da,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;mCACxB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;;UAGtC,eAAe;eACf,oBAAoB"}

package/build/models-response-reader.js

@@ -1,24 +1,32 @@
+// @ts-check
 import * as inflection from "inflection";
 import Preloaded from "./preloaded.js";
 import modelClassRequire from "./model-class-require.js";
+/** @typedef {Record<string, string[]>} ResponseDataMap */
+/** @typedef {Record<string, Record<string, object>>} ResponsePreloadedMap */
+/**
+ * @typedef {object} ModelsResponse
+ * @property {ResponseDataMap} data
+ * @property {ResponsePreloadedMap} preloaded
+ */
 /** Builds model instances from backend model collections. */
 export default class ModelsResponseReader {
     /**
-     * @param {{data: Record<string, any>, preloaded: Record<string, any>}} response
+     * @param {ModelsResponse} response
      * @returns {import("./base-model.js").default | undefined}
      */
     static first(response) {
         return ModelsResponseReader.collection(response)[0];
     }
     /**
-     * @param {{data: Record<string, any>, preloaded: Record<string, any>}} response
+     * @param {ModelsResponse} response
      * @returns {Array<import("./base-model.js").default>}
      */
     static collection(response) {
         const reader = new ModelsResponseReader({ response });
         return reader.models();
     }
-    /** @param {{collection?: import("./collection.js").default<any>, response: {data: Record<string, any>, preloaded: Record<string, any>}}} args */
+    /** @param {{collection?: import("./collection.js").default<typeof import("./base-model.js").default>, response: ModelsResponse}} args */
     constructor(args) {
         this.collection = args.collection;
         this.response = args.response;
@@ -47,4 +55,4 @@ export default class ModelsResponseReader {
         return models;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kZWxzLXJlc3BvbnNlLXJlYWRlci5qcyIsInNvdXJjZVJvb3QiOiIvc3JjLyIsInNvdXJjZXMiOlsibW9kZWxzLXJlc3BvbnNlLXJlYWRlci5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBQ1osT0FBTyxLQUFLLFVBQVUsTUFBTSxZQUFZLENBQUE7QUFDeEMsT0FBTyxTQUFTLE1BQU0sZ0JBQWdCLENBQUE7QUFDdEMsT0FBTyxpQkFBaUIsTUFBTSwwQkFBMEIsQ0FBQTtBQUV4RCwwREFBMEQ7QUFDMUQsNkVBQTZFO0FBQzdFOzs7O0dBSUc7QUFFSCw2REFBNkQ7QUFDN0QsTUFBTSxDQUFDLE9BQU8sT0FBTyxvQkFBb0I7SUFDdkM7OztPQUdHO0lBQ0gsTUFBTSxDQUFDLEtBQUssQ0FBRSxRQUFRO1FBQ3BCLE9BQU8sb0JBQW9CLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFBO0lBQ3JELENBQUM7SUFFRDs7O09BR0c7SUFDSCxNQUFNLENBQUMsVUFBVSxDQUFFLFFBQVE7UUFDekIsTUFBTSxNQUFNLEdBQUcsSUFBSSxvQkFBb0IsQ0FBQyxFQUFDLFFBQVEsRUFBQyxDQUFDLENBQUE7UUFDbkQsT0FBTyxNQUFNLENBQUMsTUFBTSxFQUFFLENBQUE7SUFDeEIsQ0FBQztJQUVELHlJQUF5STtJQUN6SSxZQUFhLElBQUk7UUFDZixJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUE7UUFDakMsSUFBSSxDQUFDLFFBQVEsR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFBO0lBQy9CLENBQUM7SUFFRCwwREFBMEQ7SUFDMUQsTUFBTTtRQUNKLE1BQU0sU0FBUyxHQUFHLElBQUksU0FBUyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQTtRQUM5QyxNQUFNLE1BQU0sR0FBRyxFQUFFLENBQUE7UUFFakIsS0FBSyxNQUFNLFNBQVMsSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksRUFBRSxDQUFDO1lBQzNDLE1BQU0sY0FBYyxHQUFHLFVBQVUsQ0FBQyxRQUFRLENBQUMsU0FBUyxDQUFDLENBQUE7WUFDckQsTUFBTSxVQUFVLEdBQUcsaUJBQWlCLENBQUMsY0FBYyxDQUFDLENBQUE7WUFDcEQsTUFBTSxjQUFjLEdBQUcsVUFBVSxDQUFDLGNBQWMsRUFBRSxDQUFDLGNBQWMsQ0FBQTtZQUVqRSxLQUFLLE1BQU0sT0FBTyxJQUFJLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUM7Z0JBQ3BELE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsU0FBUyxDQUFDLGNBQWMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFBO2dCQUVsRSxJQUFJLENBQUMsU0FBUztvQkFDWixNQUFNLElBQUksS0FBSyxDQUFDLGdDQUFnQyxjQUFjLElBQUksT0FBTyxHQUFHLENBQUMsQ0FBQTtnQkFFL0UsTUFBTSxLQUFLLEdBQUcsSUFBSSxVQUFVLENBQUM7b0JBQzNCLFVBQVUsRUFBRSxJQUFJLENBQUMsVUFBVTtvQkFDM0IsSUFBSSxFQUFFLFNBQVM7b0JBQ2YsV0FBVyxFQUFFLEtBQUs7aUJBQ25CLENBQUMsQ0FBQTtnQkFFRixLQUFLLENBQUMsMkJBQTJCLENBQUMsU0FBUyxDQUFDLENBQUE7Z0JBQzVDLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUE7WUFDcEIsQ0FBQztRQUNILENBQUM7UUFFRCxPQUFPLE1BQU0sQ0FBQTtJQUNmLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1jaGVja1xuaW1wb3J0ICogYXMgaW5mbGVjdGlvbiBmcm9tIFwiaW5mbGVjdGlvblwiXG5pbXBvcnQgUHJlbG9hZGVkIGZyb20gXCIuL3ByZWxvYWRlZC5qc1wiXG5pbXBvcnQgbW9kZWxDbGFzc1JlcXVpcmUgZnJvbSBcIi4vbW9kZWwtY2xhc3MtcmVxdWlyZS5qc1wiXG5cbi8qKiBAdHlwZWRlZiB7UmVjb3JkPHN0cmluZywgc3RyaW5nW10+fSBSZXNwb25zZURhdGFNYXAgKi9cbi8qKiBAdHlwZWRlZiB7UmVjb3JkPHN0cmluZywgUmVjb3JkPHN0cmluZywgb2JqZWN0Pj59IFJlc3BvbnNlUHJlbG9hZGVkTWFwICovXG4vKipcbiAqIEB0eXBlZGVmIHtvYmplY3R9IE1vZGVsc1Jlc3BvbnNlXG4gKiBAcHJvcGVydHkge1Jlc3BvbnNlRGF0YU1hcH0gZGF0YVxuICogQHByb3BlcnR5IHtSZXNwb25zZVByZWxvYWRlZE1hcH0gcHJlbG9hZGVkXG4gKi9cblxuLyoqIEJ1aWxkcyBtb2RlbCBpbnN0YW5jZXMgZnJvbSBiYWNrZW5kIG1vZGVsIGNvbGxlY3Rpb25zLiAqL1xuZXhwb3J0IGRlZmF1bHQgY2xhc3MgTW9kZWxzUmVzcG9uc2VSZWFkZXIge1xuICAvKipcbiAgICogQHBhcmFtIHtNb2RlbHNSZXNwb25zZX0gcmVzcG9uc2VcbiAgICogQHJldHVybnMge2ltcG9ydChcIi4vYmFzZS1tb2RlbC5qc1wiKS5kZWZhdWx0IHwgdW5kZWZpbmVkfVxuICAgKi9cbiAgc3RhdGljIGZpcnN0IChyZXNwb25zZSkge1xuICAgIHJldHVybiBNb2RlbHNSZXNwb25zZVJlYWRlci5jb2xsZWN0aW9uKHJlc3BvbnNlKVswXVxuICB9XG5cbiAgLyoqXG4gICAqIEBwYXJhbSB7TW9kZWxzUmVzcG9uc2V9IHJlc3BvbnNlXG4gICAqIEByZXR1cm5zIHtBcnJheTxpbXBvcnQoXCIuL2Jhc2UtbW9kZWwuanNcIikuZGVmYXVsdD59XG4gICAqL1xuICBzdGF0aWMgY29sbGVjdGlvbiAocmVzcG9uc2UpIHtcbiAgICBjb25zdCByZWFkZXIgPSBuZXcgTW9kZWxzUmVzcG9uc2VSZWFkZXIoe3Jlc3BvbnNlfSlcbiAgICByZXR1cm4gcmVhZGVyLm1vZGVscygpXG4gIH1cblxuICAvKiogQHBhcmFtIHt7Y29sbGVjdGlvbj86IGltcG9ydChcIi4vY29sbGVjdGlvbi5qc1wiKS5kZWZhdWx0PHR5cGVvZiBpbXBvcnQoXCIuL2Jhc2UtbW9kZWwuanNcIikuZGVmYXVsdD4sIHJlc3BvbnNlOiBNb2RlbHNSZXNwb25zZX19IGFyZ3MgKi9cbiAgY29uc3RydWN0b3IgKGFyZ3MpIHtcbiAgICB0aGlzLmNvbGxlY3Rpb24gPSBhcmdzLmNvbGxlY3Rpb25cbiAgICB0aGlzLnJlc3BvbnNlID0gYXJncy5yZXNwb25zZVxuICB9XG5cbiAgLyoqIEByZXR1cm5zIHtBcnJheTxpbXBvcnQoXCIuL2Jhc2UtbW9kZWwuanNcIikuZGVmYXVsdD59ICovXG4gIG1vZGVscyAoKSB7XG4gICAgY29uc3QgcHJlbG9hZGVkID0gbmV3IFByZWxvYWRlZCh0aGlzLnJlc3BvbnNlKVxuICAgIGNvbnN0IG1vZGVscyA9IFtdXG5cbiAgICBmb3IgKGNvbnN0IG1vZGVsVHlwZSBpbiB0aGlzLnJlc3BvbnNlLmRhdGEpIHtcbiAgICAgIGNvbnN0IG1vZGVsQ2xhc3NOYW1lID0gaW5mbGVjdGlvbi5jbGFzc2lmeShtb2RlbFR5cGUpXG4gICAgICBjb25zdCBNb2RlbENsYXNzID0gbW9kZWxDbGFzc1JlcXVpcmUobW9kZWxDbGFzc05hbWUpXG4gICAgICBjb25zdCBjb2xsZWN0aW9uTmFtZSA9IE1vZGVsQ2xhc3MubW9kZWxDbGFzc0RhdGEoKS5jb2xsZWN0aW9uTmFtZVxuXG4gICAgICBmb3IgKGNvbnN0IG1vZGVsSWQgb2YgdGhpcy5yZXNwb25zZS5kYXRhW21vZGVsVHlwZV0pIHtcbiAgICAgICAgY29uc3QgbW9kZWxEYXRhID0gdGhpcy5yZXNwb25zZS5wcmVsb2FkZWRbY29sbGVjdGlvbk5hbWVdW21vZGVsSWRdXG5cbiAgICAgICAgaWYgKCFtb2RlbERhdGEpXG4gICAgICAgICAgdGhyb3cgbmV3IEVycm9yKGBDb3VsZG4ndCBmaW5kIG1vZGVsIGRhdGEgZm9yICR7Y29sbGVjdGlvbk5hbWV9KCR7bW9kZWxJZH0pYClcblxuICAgICAgICBjb25zdCBtb2RlbCA9IG5ldyBNb2RlbENsYXNzKHtcbiAgICAgICAgICBjb2xsZWN0aW9uOiB0aGlzLmNvbGxlY3Rpb24sXG4gICAgICAgICAgZGF0YTogbW9kZWxEYXRhLFxuICAgICAgICAgIGlzTmV3UmVjb3JkOiBmYWxzZVxuICAgICAgICB9KVxuXG4gICAgICAgIG1vZGVsLl9yZWFkUHJlbG9hZGVkUmVsYXRpb25zaGlwcyhwcmVsb2FkZWQpXG4gICAgICAgIG1vZGVscy5wdXNoKG1vZGVsKVxuICAgICAgfVxuICAgIH1cblxuICAgIHJldHVybiBtb2RlbHNcbiAgfVxufVxuIl19

package/build/models.d.ts

@@ -1,3 +1,440 @@
 export default result;
-declare const result: Record<string, import("./base-model.js").BaseModelClassType>;
+declare const result: Record<string, {
+    new (args?: import("./base-model.js").BaseModelArgs): {
+        abilities: import("./base-model.js").ModelAbilityMap;
+        changes: import("./base-model.js").ModelDataMap;
+        collection: import("./collection.js").default<any>;
+        _identifierKey: string | number;
+        _markedForDestruction: boolean;
+        modelData: import("./base-model.js").ModelDataMap;
+        newRecord: boolean;
+        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?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        destroy(): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        ensureAbilities(listOfAbilities: string[]): Promise<void>;
+        getAttributes(): ModelDataMap;
+        handleResponseError(response: ModelCommandResponse): never;
+        identifierKey(): number | string;
+        isAssociationLoaded(associationName: string): boolean;
+        isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+        isAssociationPresent(associationName: string): boolean;
+        ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+        ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+        isAttributeChanged(attributeName: string): boolean;
+        isChanged(): boolean;
+        isNewRecord(): boolean;
+        isPersisted(): boolean;
+        savedChangeToAttribute(attributeName: string): boolean;
+        setNewModel(model: /*elided*/ any): void;
+        setNewModelData(model: /*elided*/ any): 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: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        _refreshModelFromResponse(response: ModelCommandResponse): void;
+        _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+        updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            response: ModelCommandResponse;
+            model: /*elided*/ any;
+        }>;
+        isValid(): never;
+        isValidOnServer(): Promise<{
+            valid: boolean;
+            errors: ValidationResponseErrors;
+        }>;
+        modelClass(): BaseModelClassType;
+        preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+        markForDestruction(): void;
+        markedForDestruction(): boolean;
+        uniqueKey(): number;
+        _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;
+    };
+    apiMakerType: string;
+    attributes(): import("./base-model/attribute.js").default[];
+    hasAttribute(attributeName: string): boolean;
+    modelClassData(): ModelClassDataType;
+    newCustomEvent(validationErrors: import("./validation-errors.js").ValidationErrors): CustomEvent;
+    sendValidationErrorsEvent(validationErrors: import("./validation-errors.js").ValidationErrors, options?: {
+        form?: object;
+        throwValidationError?: boolean;
+    }): void;
+    find(id: number | string): Promise<{
+        abilities: import("./base-model.js").ModelAbilityMap;
+        changes: import("./base-model.js").ModelDataMap;
+        collection: import("./collection.js").default<any>;
+        _identifierKey: string | number;
+        _markedForDestruction: boolean;
+        modelData: import("./base-model.js").ModelDataMap;
+        newRecord: boolean;
+        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?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        destroy(): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        ensureAbilities(listOfAbilities: string[]): Promise<void>;
+        getAttributes(): ModelDataMap;
+        handleResponseError(response: ModelCommandResponse): never;
+        identifierKey(): number | string;
+        isAssociationLoaded(associationName: string): boolean;
+        isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+        isAssociationPresent(associationName: string): boolean;
+        ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+        ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+        isAttributeChanged(attributeName: string): boolean;
+        isChanged(): boolean;
+        isNewRecord(): boolean;
+        isPersisted(): boolean;
+        savedChangeToAttribute(attributeName: string): boolean;
+        setNewModel(model: /*elided*/ any): void;
+        setNewModelData(model: /*elided*/ any): 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: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        _refreshModelFromResponse(response: ModelCommandResponse): void;
+        _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+        updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            response: ModelCommandResponse;
+            model: /*elided*/ any;
+        }>;
+        isValid(): never;
+        isValidOnServer(): Promise<{
+            valid: boolean;
+            errors: ValidationResponseErrors;
+        }>;
+        modelClass(): BaseModelClassType;
+        preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+        markForDestruction(): void;
+        markedForDestruction(): boolean;
+        uniqueKey(): number;
+        _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;
+    }>;
+    findOrCreateBy(findOrCreateByArgs: ModelDataMap, args?: {
+        additionalData?: ModelDataMap;
+    }): Promise<{
+        abilities: import("./base-model.js").ModelAbilityMap;
+        changes: import("./base-model.js").ModelDataMap;
+        collection: import("./collection.js").default<any>;
+        _identifierKey: string | number;
+        _markedForDestruction: boolean;
+        modelData: import("./base-model.js").ModelDataMap;
+        newRecord: boolean;
+        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?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        destroy(): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        ensureAbilities(listOfAbilities: string[]): Promise<void>;
+        getAttributes(): ModelDataMap;
+        handleResponseError(response: ModelCommandResponse): never;
+        identifierKey(): number | string;
+        isAssociationLoaded(associationName: string): boolean;
+        isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+        isAssociationPresent(associationName: string): boolean;
+        ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+        ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+        isAttributeChanged(attributeName: string): boolean;
+        isChanged(): boolean;
+        isNewRecord(): boolean;
+        isPersisted(): boolean;
+        savedChangeToAttribute(attributeName: string): boolean;
+        setNewModel(model: /*elided*/ any): void;
+        setNewModelData(model: /*elided*/ any): 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: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        _refreshModelFromResponse(response: ModelCommandResponse): void;
+        _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+        updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            response: ModelCommandResponse;
+            model: /*elided*/ any;
+        }>;
+        isValid(): never;
+        isValidOnServer(): Promise<{
+            valid: boolean;
+            errors: ValidationResponseErrors;
+        }>;
+        modelClass(): BaseModelClassType;
+        preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+        markForDestruction(): void;
+        markedForDestruction(): boolean;
+        uniqueKey(): number;
+        _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;
+    }>;
+    modelName(): import("./model-name.js").default;
+    primaryKey(): string;
+    ransack(query?: import("./collection.js").CollectionRansackParams): import("./collection.js").default<any>;
+    select(select?: Record<string, string[]>): import("./collection.js").default<any>;
+    ransackableAssociations(): import("./base-model/reflection.js").default[];
+    ransackableAttributes(): import("./base-model/attribute.js").default[];
+    ransackableScopes(): import("./base-model/scope.js").default[];
+    reflections(): import("./base-model/reflection.js").default[];
+    reflection(name: string): import("./base-model/reflection.js").default;
+    _token(): string | undefined;
+    all(): import("./collection.js").default<any>;
+    parseValidationErrors({ error, model, options }: {
+        error: import("./validation-error.js").default | Error | ValidationErrorWithResponse;
+        model?: {
+            abilities: import("./base-model.js").ModelAbilityMap;
+            changes: import("./base-model.js").ModelDataMap;
+            collection: import("./collection.js").default<any>;
+            _identifierKey: string | number;
+            _markedForDestruction: boolean;
+            modelData: import("./base-model.js").ModelDataMap;
+            newRecord: boolean;
+            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?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+                model: /*elided*/ any;
+                response: ModelCommandResponse;
+            }>;
+            createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+                model: /*elided*/ any;
+                response: ModelCommandResponse;
+            }>;
+            destroy(): Promise<{
+                model: /*elided*/ any;
+                response: ModelCommandResponse;
+            }>;
+            ensureAbilities(listOfAbilities: string[]): Promise<void>;
+            getAttributes(): ModelDataMap;
+            handleResponseError(response: ModelCommandResponse): never;
+            identifierKey(): number | string;
+            isAssociationLoaded(associationName: string): boolean;
+            isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+            isAssociationPresent(associationName: string): boolean;
+            ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+            ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+            isAttributeChanged(attributeName: string): boolean;
+            isChanged(): boolean;
+            isNewRecord(): boolean;
+            isPersisted(): boolean;
+            savedChangeToAttribute(attributeName: string): boolean;
+            setNewModel(model: /*elided*/ any): void;
+            setNewModelData(model: /*elided*/ any): 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: RawDataInput, options?: ParseValidationErrorsOptions & {
+                simpleModelErrors?: boolean;
+            }): Promise<{
+                model: /*elided*/ any;
+                response: ModelCommandResponse;
+            }>;
+            update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+                model: /*elided*/ any;
+                response?: object;
+            }>;
+            _refreshModelFromResponse(response: ModelCommandResponse): void;
+            _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+            updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+                simpleModelErrors?: boolean;
+            }): Promise<{
+                response: ModelCommandResponse;
+                model: /*elided*/ any;
+            }>;
+            isValid(): never;
+            isValidOnServer(): Promise<{
+                valid: boolean;
+                errors: ValidationResponseErrors;
+            }>;
+            modelClass(): BaseModelClassType;
+            preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+            markForDestruction(): void;
+            markedForDestruction(): boolean;
+            uniqueKey(): number;
+            _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;
+        };
+        options?: ParseValidationErrorsOptions;
+    }): void;
+    humanAttributeName(attributeName: string): string;
+    snakeCase(string: string): string;
+    _objectDataFromGivenRawData(rawData: RawDataInput, options: object): ModelDataMap;
+    _isFormElement(value: RawDataInput | ModelValue): value is HTMLFormElement;
+    _callCollectionCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): Promise<ModelCommandResponse>;
+    _postDataFromArgs(args?: FormData | ModelDataMap): FormData;
+}>;
 //# sourceMappingURL=models.d.ts.map

package/build/models.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"models.d.ts","sourceRoot":"/src/","sources":["models.js"],"names":[],"mappings":";AAMA,mFAA4B"}
+{"version":3,"file":"models.d.ts","sourceRoot":"/src/","sources":["models.js"],"names":[],"mappings":";AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAG6p5B,CAAC;;;6BAA6O,CAAC;;;;;;;oBAAoc,CAAC;;;;;6BAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAxmG,CAAC;;;6BAA6O,CAAC;;;;;;;oBAAoc,CAAC;;;;;6BAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAxmG,CAAC;;;6BAA6O,CAAC;;;;;;;oBAAoc,CAAC;;;;;6BAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAAxmG,CAAC;;;iCAA6O,CAAC;;;;;;;wBAAoc,CAAC;;;;;iCAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAHzu/B"}

package/build/models.js

@@ -1,3 +1,4 @@
+// @ts-check
 import ModelRecipesLoader from "./model-recipes-loader.js";
 // @ts-expect-error Runtime-resolved module
 import modelRecipes from "model-recipes.json"; // eslint-disable-line import/no-unresolved
@@ -5,4 +6,4 @@ import modelRecipes from "model-recipes.json"; // eslint-disable-line import/no-
 const loader = new ModelRecipesLoader({ recipes: modelRecipes });
 const result = loader.load();
 export default result;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kZWxzLmpzIiwic291cmNlUm9vdCI6Ii9zcmMvIiwic291cmNlcyI6WyJtb2RlbHMuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxrQkFBa0IsTUFBTSwyQkFBMkIsQ0FBQTtBQUMxRCwyQ0FBMkM7QUFDM0MsT0FBTyxZQUFZLE1BQU0sb0JBQW9CLENBQUEsQ0FBQywyQ0FBMkM7QUFFekYsb0NBQW9DO0FBQ3BDLE1BQU0sTUFBTSxHQUFHLElBQUksa0JBQWtCLENBQUMsRUFBQyxPQUFPLEVBQUUsWUFBWSxFQUFDLENBQUMsQ0FBQTtBQUM5RCxNQUFNLE1BQU0sR0FBRyxNQUFNLENBQUMsSUFBSSxFQUFFLENBQUE7QUFFNUIsZUFBZSxNQUFNLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgTW9kZWxSZWNpcGVzTG9hZGVyIGZyb20gXCIuL21vZGVsLXJlY2lwZXMtbG9hZGVyLmpzXCJcbi8vIEB0cy1leHBlY3QtZXJyb3IgUnVudGltZS1yZXNvbHZlZCBtb2R1bGVcbmltcG9ydCBtb2RlbFJlY2lwZXMgZnJvbSBcIm1vZGVsLXJlY2lwZXMuanNvblwiIC8vIGVzbGludC1kaXNhYmxlLWxpbmUgaW1wb3J0L25vLXVucmVzb2x2ZWRcblxuLyoqIEdlbmVyYXRlZCBydW50aW1lIG1vZGVscyBtYXAuICovXG5jb25zdCBsb2FkZXIgPSBuZXcgTW9kZWxSZWNpcGVzTG9hZGVyKHtyZWNpcGVzOiBtb2RlbFJlY2lwZXN9KVxuY29uc3QgcmVzdWx0ID0gbG9hZGVyLmxvYWQoKVxuXG5leHBvcnQgZGVmYXVsdCByZXN1bHRcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kZWxzLmpzIiwic291cmNlUm9vdCI6Ii9zcmMvIiwic291cmNlcyI6WyJtb2RlbHMuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUNaLE9BQU8sa0JBQWtCLE1BQU0sMkJBQTJCLENBQUE7QUFDMUQsMkNBQTJDO0FBQzNDLE9BQU8sWUFBWSxNQUFNLG9CQUFvQixDQUFBLENBQUMsMkNBQTJDO0FBRXpGLG9DQUFvQztBQUNwQyxNQUFNLE1BQU0sR0FBRyxJQUFJLGtCQUFrQixDQUFDLEVBQUMsT0FBTyxFQUFFLFlBQVksRUFBQyxDQUFDLENBQUE7QUFDOUQsTUFBTSxNQUFNLEdBQUcsTUFBTSxDQUFDLElBQUksRUFBRSxDQUFBO0FBRTVCLGVBQWUsTUFBTSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5pbXBvcnQgTW9kZWxSZWNpcGVzTG9hZGVyIGZyb20gXCIuL21vZGVsLXJlY2lwZXMtbG9hZGVyLmpzXCJcbi8vIEB0cy1leHBlY3QtZXJyb3IgUnVudGltZS1yZXNvbHZlZCBtb2R1bGVcbmltcG9ydCBtb2RlbFJlY2lwZXMgZnJvbSBcIm1vZGVsLXJlY2lwZXMuanNvblwiIC8vIGVzbGludC1kaXNhYmxlLWxpbmUgaW1wb3J0L25vLXVucmVzb2x2ZWRcblxuLyoqIEdlbmVyYXRlZCBydW50aW1lIG1vZGVscyBtYXAuICovXG5jb25zdCBsb2FkZXIgPSBuZXcgTW9kZWxSZWNpcGVzTG9hZGVyKHtyZWNpcGVzOiBtb2RlbFJlY2lwZXN9KVxuY29uc3QgcmVzdWx0ID0gbG9hZGVyLmxvYWQoKVxuXG5leHBvcnQgZGVmYXVsdCByZXN1bHRcbiJdfQ==

package/build/money-formatter.d.ts

@@ -1,28 +1,22 @@
+/** @typedef {{id?: string, iso_code?: string, code?: string}} MoneyCurrencyLike */
+/** @typedef {{amount?: number | string, fractional?: number | string, currency: string | MoneyCurrencyLike}} MoneyLike */
 /** Money formatter and converter utilities. */
 export default class MoneyFormatter {
     /**
-     * @param {Money | {amount?: number | string, fractional?: number | string, currency: any}} money
+     * @param {Money | MoneyLike} money
      * @param {{decimals?: number | null, excludeCurrency?: boolean}} [args]
      * @returns {MoneyFormatter}
      */
-    static fromMoney(money: Money | {
-        amount?: number | string;
-        fractional?: number | string;
-        currency: any;
-    }, args?: {
+    static fromMoney(money: Money | MoneyLike, args?: {
         decimals?: number | null;
         excludeCurrency?: boolean;
     }): MoneyFormatter;
     /**
-     * @param {Money | {amount?: number | string, fractional?: number | string, currency: any}} money
+     * @param {Money | MoneyLike} money
      * @param {{decimals?: number | null, excludeCurrency?: boolean}} [args]
      * @returns {string}
      */
-    static format(money: Money | {
-        amount?: number | string;
-        fractional?: number | string;
-        currency: any;
-    }, args?: {
+    static format(money: Money | MoneyLike, args?: {
         decimals?: number | null;
         excludeCurrency?: boolean;
     }): string;
@@ -32,35 +26,25 @@ export default class MoneyFormatter {
      */
     static stringToFloat(moneyString: string): number;
     /**
-     * @param {Money | {amount?: number | string, fractional?: number | string, currency: any}} money
+     * @param {Money | MoneyLike} money
      * @returns {number}
      */
-    static amountFromMoney(money: Money | {
-        amount?: number | string;
-        fractional?: number | string;
-        currency: any;
-    }): number;
+    static amountFromMoney(money: Money | MoneyLike): number;
     /**
-     * @param {Money | {currency: any}} money
-     * @returns {any}
+     * @param {Money | Pick<MoneyLike, "currency">} money
+     * @returns {typeof Money.USD}
      */
-    static currencyFromMoney(money: Money | {
-        currency: any;
-    }): any;
+    static currencyFromMoney(money: Money | Pick<MoneyLike, "currency">): typeof Money.USD;
     /**
-     * @param {any} value
+     * @param {unknown} value
      * @returns {boolean}
      */
-    static isMoney(value: any): boolean;
+    static isMoney(value: unknown): boolean;
     /**
-     * @param {Money | {amount?: number | string, fractional?: number | string, currency: any}} money
+     * @param {Money | MoneyLike} money
      * @param {{decimals?: number | null, excludeCurrency?: boolean}} [args]
      */
-    constructor(money: Money | {
-        amount?: number | string;
-        fractional?: number | string;
-        currency: any;
-    }, args?: {
+    constructor(money: Money | MoneyLike, args?: {
         decimals?: number | null;
         excludeCurrency?: boolean;
     });
@@ -78,4 +62,14 @@ export default class MoneyFormatter {
     /** @returns {string} */
     prefix(): string;
 }
+export type MoneyCurrencyLike = {
+    id?: string;
+    iso_code?: string;
+    code?: string;
+};
+export type MoneyLike = {
+    amount?: number | string;
+    fractional?: number | string;
+    currency: string | MoneyCurrencyLike;
+};
 //# sourceMappingURL=money-formatter.d.ts.map

package/build/money-formatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"money-formatter.d.ts","sourceRoot":"/src/","sources":["money-formatter.js"],"names":[],"mappings":"AAKA,+CAA+C;AAC/C;IACE;;;;OAIG;IACH,wBAJW,KAAK,GAAG;QAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,QAAQ,EAAE,GAAG,CAAA;KAAC,SAC/E;QAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,eAAe,CAAC,EAAE,OAAO,CAAA;KAAC,GACnD,cAAc,CAI1B;IAED;;;;OAIG;IACH,qBAJW,KAAK,GAAG;QAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,QAAQ,EAAE,GAAG,CAAA;KAAC,SAC/E;QAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,eAAe,CAAC,EAAE,OAAO,CAAA;KAAC,GACnD,MAAM,CAIlB;IAED;;;OAGG;IACH,kCAHW,MAAM,GACJ,MAAM,CASlB;IAED;;;OAGG;IACH,8BAHW,KAAK,GAAG;QAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,QAAQ,EAAE,GAAG,CAAA;KAAC,GAC7E,MAAM,CAUlB;IAED;;;OAGG;IACH,gCAHW,KAAK,GAAG;QAAC,QAAQ,EAAE,GAAG,CAAA;KAAC,GACrB,GAAG,CAwBf;IAED;;;OAGG;IACH,sBAHW,GAAG,GACD,OAAO,CASnB;IAED;;;OAGG;IACH,mBAHW,KAAK,GAAG;QAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,QAAQ,EAAE,GAAG,CAAA;KAAC,SAC/E;QAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,eAAe,CAAC,EAAE,OAAO,CAAA;KAAC,EAO/D;IAJC;mBAHqB,MAAM,GAAG,IAAI;0BAAoB,OAAO;MAG7C;IAChB,WAAkB;IAClB,eAAmD;IACnD,cAAuD;IAGzD,wBAAwB;IACxB,YADc,MAAM,CAWnB;IAED,wBAAwB;IACxB,iBADc,MAAM,CAOnB;IAED,wBAAwB;IACxB,UADc,MAAM,CAOnB;CACF"}
+{"version":3,"file":"money-formatter.d.ts","sourceRoot":"/src/","sources":["money-formatter.js"],"names":[],"mappings":"AAMA,mFAAmF;AACnF,0HAA0H;AAE1H,+CAA+C;AAC/C;IACE;;;;OAIG;IACH,wBAJW,KAAK,GAAG,SAAS,SACjB;QAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,eAAe,CAAC,EAAE,OAAO,CAAA;KAAC,GACnD,cAAc,CAI1B;IAED;;;;OAIG;IACH,qBAJW,KAAK,GAAG,SAAS,SACjB;QAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,eAAe,CAAC,EAAE,OAAO,CAAA;KAAC,GACnD,MAAM,CAIlB;IAED;;;OAGG;IACH,kCAHW,MAAM,GACJ,MAAM,CASlB;IAED;;;OAGG;IACH,8BAHW,KAAK,GAAG,SAAS,GACf,MAAM,CAUlB;IAED;;;OAGG;IACH,gCAHW,KAAK,GAAG,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC,GACjC,OAAO,KAAK,CAAC,GAAG,CAwB5B;IAED;;;OAGG;IACH,sBAHW,OAAO,GACL,OAAO,CASnB;IAED;;;OAGG;IACH,mBAHW,KAAK,GAAG,SAAS,SACjB;QAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,eAAe,CAAC,EAAE,OAAO,CAAA;KAAC,EAO/D;IAJC;mBAHqB,MAAM,GAAG,IAAI;0BAAoB,OAAO;MAG7C;IAChB,WAAkB;IAClB,eAAmD;IACnD,cAAuD;IAGzD,wBAAwB;IACxB,YADc,MAAM,CAWnB;IAED,wBAAwB;IACxB,iBADc,MAAM,CAOnB;IAED,wBAAwB;IACxB,UADc,MAAM,CAOnB;CACF;gCApIa;IAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAC;wBAC/C;IAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,CAAA;CAAC"}