@kaspernj/api-maker 1.0.2159 → 1.0.2161

package/build/model-name.js

@@ -1,8 +1,18 @@
+// @ts-check
 import * as inflection from "inflection";
 import Config from "./config.js";
+/**
+ * @typedef {object} ModelClassDataLike
+ * @property {string} camelizedLower
+ * @property {string} i18nKey
+ * @property {string} name
+ * @property {string} paramKey
+ * @typedef {object} ModelNameData
+ * @property {ModelClassDataLike} modelClassData
+ */
 /** Model name helper for i18n lookups and metadata. */
 export default class ModelName {
-    /** @param {{modelClassData: Record<string, any>}} data */
+    /** @param {ModelNameData} data */
     constructor(data) {
         this.data = data;
     }
@@ -33,4 +43,4 @@ export default class ModelName {
     /** @returns {string} */
     paramKey = () => this.data.modelClassData.paramKey;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/model-prop-type.d.ts

@@ -1,32 +1,539 @@
+/** @typedef {typeof import("./base-model.js").default} ApiMakerModelClass */
+/**
+ * @typedef {object} ApiMakerModelInstance
+ * @property {Record<string, boolean>} abilities
+ * @property {{name: string}} constructor
+ * @property {() => boolean} isPersisted
+ * @property {Record<string, object|object[]|null|undefined>} modelData
+ * @property {Record<string, object|object[]|null|undefined>} relationshipsCache
+ */
+/** @typedef {{[propName: string]: ApiMakerModelInstance|undefined}} ModelPropValidatorProps */
+/** @typedef {string} ModelPropName */
+/** @typedef {Error|undefined} ModelPropValidationResult */
 /** PropType helpers for API Maker models. */
 export default class ApiMakerModelPropType {
-    /** ofModel. */
-    static ofModel(modelClass: any): ApiMakerModelPropType;
-    /** isNotRequired. */
-    isNotRequired(props: any, propName: any, _componentName: any): any;
-    /** isRequired. */
-    isRequired(props: any, propName: any, _componentName: any): any;
+    /**
+     * Build a model prop validator that requires a specific model class.
+     * @param {ApiMakerModelClass} modelClass
+     * @returns {ApiMakerModelPropType}
+     */
+    static ofModel(modelClass: ApiMakerModelClass): ApiMakerModelPropType;
+    /**
+     * Validate an optional model prop.
+     * @param {ModelPropValidatorProps} props
+     * @param {ModelPropName} propName
+     * @param {string} _componentName
+     * @returns {ModelPropValidationResult}
+     */
+    isNotRequired(props: ModelPropValidatorProps, propName: ModelPropName, _componentName: string): ModelPropValidationResult;
+    /**
+     * Validate a required model prop.
+     * @param {ModelPropValidatorProps} props
+     * @param {ModelPropName} propName
+     * @param {string} _componentName
+     * @returns {ModelPropValidationResult}
+     */
+    isRequired(props: ModelPropValidatorProps, propName: ModelPropName, _componentName: string): ModelPropValidationResult;
     _withLoadedAssociations: {};
-    /** previous. */
-    previous(): any;
-    /** setPreviousModelPropType. */
-    setPreviousModelPropType(previousModelPropType: any): void;
-    _previousModelPropType: any;
-    /** withModelType. */
-    withModelType(modelClass: any): void;
-    _withModelType: any;
-    /** validate. */
+    /**
+     * Return the previous chained model prop type validator.
+     * @returns {ApiMakerModelPropType}
+     */
+    previous(): ApiMakerModelPropType;
+    /**
+     * Store the previous validator so chained association requirements can return to it.
+     * @param {ApiMakerModelPropType} previousModelPropType
+     */
+    setPreviousModelPropType(previousModelPropType: ApiMakerModelPropType): void;
+    _previousModelPropType: ApiMakerModelPropType;
+    /**
+     * Require validated props to contain a specific model class.
+     * @param {ApiMakerModelClass} modelClass
+     */
+    withModelType(modelClass: ApiMakerModelClass): void;
+    _withModelType: {
+        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;
+    };
+    /**
+     * Validate one model instance against all configured model, ability, association, and attribute requirements.
+     * @param {object} root0
+     * @param {ApiMakerModelInstance} root0.model
+     * @param {ModelPropName} root0.propName
+     * @returns {ModelPropValidationResult}
+     */
     validate({ model, propName }: {
-        model: any;
-        propName: any;
-    }): any;
-    /** withLoadedAbilities. */
-    withLoadedAbilities(arrayOfAbilities: any): this;
-    _withLoadedAbilities: any;
-    /** withLoadedAssociation. */
-    withLoadedAssociation(associationName: any): ApiMakerModelPropType;
-    /** withLoadedAttributes. */
-    withLoadedAttributes(arrayOfAttributes: any): this;
-    _withLoadedAttributes: any;
+        model: ApiMakerModelInstance;
+        propName: ModelPropName;
+    }): ModelPropValidationResult;
+    /**
+     * Require the listed abilities to be preloaded on the model.
+     * @param {string[]} arrayOfAbilities
+     * @returns {ApiMakerModelPropType}
+     */
+    withLoadedAbilities(arrayOfAbilities: string[]): ApiMakerModelPropType;
+    _withLoadedAbilities: string[];
+    /**
+     * Require a named association to be loaded and return a validator for that association.
+     * @param {string} associationName
+     * @returns {ApiMakerModelPropType}
+     */
+    withLoadedAssociation(associationName: string): ApiMakerModelPropType;
+    /**
+     * Require the listed attributes to be loaded on persisted models.
+     * @param {string[]} arrayOfAttributes
+     * @returns {ApiMakerModelPropType}
+     */
+    withLoadedAttributes(arrayOfAttributes: string[]): ApiMakerModelPropType;
+    _withLoadedAttributes: string[];
 }
+export type ApiMakerModelClass = typeof import("./base-model.js").default;
+export type ApiMakerModelInstance = {
+    abilities: Record<string, boolean>;
+    constructor: {
+        name: string;
+    };
+    isPersisted: () => boolean;
+    modelData: Record<string, object | object[] | null | undefined>;
+    relationshipsCache: Record<string, object | object[] | null | undefined>;
+};
+export type ModelPropValidatorProps = {
+    [propName: string]: ApiMakerModelInstance | undefined;
+};
+export type ModelPropName = string;
+export type ModelPropValidationResult = Error | undefined;
 //# sourceMappingURL=model-prop-type.d.ts.map

package/build/model-prop-type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model-prop-type.d.ts","sourceRoot":"/src/","sources":["model-prop-type.js"],"names":[],"mappings":"AAIA,6CAA6C;AAC7C;IACE,eAAe;IACf,uDAMC;IASD,qBAAqB;IACrB,mEAMC;IAED,kBAAkB;IAClB,gEAMC;IAnBC,4BAAiC;IAqBnC,gBAAgB;IAChB,gBAIC;IAED,gCAAgC;IAChC,2DAEC;IADC,4BAAmD;IAGrD,qBAAqB;IACrB,qCAEC;IADC,oBAAgC;IAGlC,gBAAgB;IAChB;;;YAqDC;IAED,2BAA2B;IAC3B,iDAIC;IAHC,0BAA4C;IAK9C,6BAA6B;IAC7B,mEAOC;IAED,4BAA4B;IAC5B,mDAIC;IAHC,2BAA8C;CAIjD"}
+{"version":3,"file":"model-prop-type.d.ts","sourceRoot":"/src/","sources":["model-prop-type.js"],"names":[],"mappings":"AAKA,6EAA6E;AAC7E;;;;;;;GAOG;AACH,+FAA+F;AAC/F,sCAAsC;AACtC,2DAA2D;AAE3D,6CAA6C;AAC7C;IACE;;;;OAIG;IACH,2BAHW,kBAAkB,GAChB,qBAAqB,CAQjC;IASD;;;;;;OAMG;IACH,qBALW,uBAAuB,YACvB,aAAa,kBACb,MAAM,GACJ,yBAAyB,CAUrC;IAED;;;;;;OAMG;IACH,kBALW,uBAAuB,YACvB,aAAa,kBACb,MAAM,GACJ,yBAAyB,CAQrC;IAjCC,4BAAiC;IAmCnC;;;OAGG;IACH,YAFa,qBAAqB,CAMjC;IAED;;;OAGG;IACH,gDAFW,qBAAqB,QAI/B;IADC,8CAAmD;IAGrD;;;OAGG;IACH,0BAFW,kBAAkB,QAI5B;IADC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAuG6htB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAvGrmzB;IAGlC;;;;;;OAMG;IACH,8BAJG;QAAqC,KAAK,EAAlC,qBAAqB;QACA,QAAQ,EAA7B,aAAa;KACrB,GAAU,yBAAyB,CAyDrC;IAED;;;;OAIG;IACH,sCAHW,MAAM,EAAE,GACN,qBAAqB,CAMjC;IAHC,+BAA4C;IAK9C;;;;OAIG;IACH,uCAHW,MAAM,GACJ,qBAAqB,CASjC;IAED;;;;OAIG;IACH,wCAHW,MAAM,EAAE,GACN,qBAAqB,CAMjC;IAHC,gCAA8C;CAIjD;iCAhMa,cAAc,iBAAiB,EAAE,OAAO;;eAGxC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;iBACvB;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;iBACd,MAAM,OAAO;eACb,MAAM,CAAC,MAAM,EAAE,MAAM,GAAC,MAAM,EAAE,GAAC,IAAI,GAAC,SAAS,CAAC;wBAC9C,MAAM,CAAC,MAAM,EAAE,MAAM,GAAC,MAAM,EAAE,GAAC,IAAI,GAAC,SAAS,CAAC;;sCAE9C;IAAC,CAAC,QAAQ,EAAE,MAAM,GAAG,qBAAqB,GAAC,SAAS,CAAA;CAAC;4BACrD,MAAM;wCACN,KAAK,GAAC,SAAS"}