@kaspernj/api-maker 1.0.2160 → 1.0.2161

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

@@ -1,48 +1,57 @@
+/** @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: {
-        data: Record<string, any>;
-        preloaded: Record<string, any>;
-    }): {
-        changes: {};
+    static first(response: ModelsResponse): {
+        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;
-        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;
@@ -50,118 +59,104 @@ export default class ModelsResponseReader {
         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;
     } | undefined;
     /**
-     * @param {{data: Record<string, any>, preloaded: Record<string, any>}} response
+     * @param {ModelsResponse} response
      * @returns {Array<import("./base-model.js").default>}
      */
-    static collection(response: {
-        data: Record<string, any>;
-        preloaded: Record<string, any>;
-    }): Array<{
-        changes: {};
+    static collection(response: ModelsResponse): Array<{
+        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;
-        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;
@@ -169,125 +164,545 @@ export default class ModelsResponseReader {
         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;
     }>;
-    /** @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: {
-        collection?: import("./collection.js").default<any>;
-        response: {
-            data: Record<string, any>;
-            preloaded: Record<string, any>;
-        };
+        collection?: import("./collection.js").default<typeof import("./base-model.js").default>;
+        response: ModelsResponse;
     });
-    collection: import("./collection.js").default<any>;
-    response: {
-        data: Record<string, any>;
-        preloaded: Record<string, any>;
-    };
+    collection: import("./collection.js").default<{
+        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;
+    }>;
+    response: ModelsResponse;
     /** @returns {Array<import("./base-model.js").default>} */
     models(): Array<{
-        changes: {};
+        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;
-        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;
@@ -295,74 +710,64 @@ export default class ModelsResponseReader {
         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;
     }>;
 }
+export type ResponseDataMap = Record<string, string[]>;
+export type ResponsePreloadedMap = Record<string, Record<string, object>>;
+export type ModelsResponse = {
+    data: ResponseDataMap;
+    preloaded: ResponsePreloadedMap;
+};
 //# sourceMappingURL=models-response-reader.d.ts.map