@kaspernj/api-maker 1.0.2138 → 1.0.2141

package/build/model-recipes-model-loader.d.ts

@@ -9,13 +9,7 @@ export default class ApiMakerModelRecipesModelLoader {
     modelRecipe: any;
     /** createClass. */
     createClass(): {
-        new (args?: {
-            isNewRecord?: boolean;
-            data?: object;
-            a?: Record<string, any>;
-            b?: Record<string, any>;
-            collection?: Collection<typeof import("./base-model.js").default>;
-        }): {
+        new (...args: Array<any>): {
             changes: {};
             newRecord: boolean;
             relationshipsCache: {};
@@ -25,12 +19,234 @@ export default class ApiMakerModelRecipesModelLoader {
             assignAttributes(newAttributes: Record<string, any>): void;
             attributes(): Record<string, any>;
             can(givenAbilityName: string): boolean;
-            clone<Self extends BaseModel>(this: Self): Self;
+            clone(): {
+                changes: {};
+                newRecord: boolean;
+                relationshipsCache: {};
+                relationships: {};
+                abilities: Record<string, any>;
+                modelData: {};
+                assignAttributes(newAttributes: Record<string, any>): void;
+                attributes(): Record<string, any>;
+                can(givenAbilityName: string): boolean;
+                clone(): /*elided*/ any;
+                cacheKey(): number | string;
+                localCacheKey(): string;
+                fullCacheKey(): string;
+                create(attributes?: Record<string, any>, options?: object): Promise<{
+                    model: /*elided*/ any;
+                    response: object;
+                }>;
+                createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+                    model: /*elided*/ any;
+                    response: any;
+                }>;
+                destroy(): Promise<{
+                    model: /*elided*/ any;
+                    response: object;
+                }>;
+                ensureAbilities(listOfAbilities: string[]): Promise<void>;
+                getAttributes(): Record<string, any>;
+                handleResponseError(response: object): never;
+                identifierKey(): number | string;
+                _identifierKey: string | number;
+                isAssociationLoaded(associationName: string): boolean;
+                isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+                isAssociationPresent(associationName: string): boolean;
+                ensureAssociationLoaded(associationName: string): Promise<any>;
+                ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+                isAttributeChanged(attributeName: string): boolean;
+                isChanged(): boolean;
+                isNewRecord(): boolean;
+                isPersisted(): boolean;
+                savedChangeToAttribute(attributeName: string): boolean;
+                setNewModel(model: /*elided*/ any): void;
+                setNewModelData(model: /*elided*/ any): void;
+                previousModelData: any;
+                _isDateChanged(oldValue: any, newValue: any): boolean | void;
+                _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
+                _isStringChanged(oldValue: any, newValue: any): boolean | void;
+                modelClassData(): ModelClassDataType;
+                reload(): Promise<void>;
+                save(): Promise<{
+                    model: /*elided*/ any;
+                    response?: object;
+                }>;
+                saveRaw(rawData: any, options?: {}): Promise<{
+                    model: /*elided*/ any;
+                    response: object;
+                }>;
+                update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+                    model: /*elided*/ any;
+                    response?: object;
+                }>;
+                _refreshModelFromResponse(response: object): void;
+                _refreshModelDataFromResponse(response: object): void;
+                updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+                    simpleModelErrors?: boolean;
+                }): Promise<{
+                    response: object;
+                    model: /*elided*/ any;
+                }>;
+                isValid(): never;
+                isValidOnServer(): Promise<{
+                    valid: boolean;
+                    errors: Record<string, any>;
+                }>;
+                modelClass(): Record<string, any>;
+                preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+                markForDestruction(): void;
+                _markedForDestruction: boolean;
+                markedForDestruction(): boolean;
+                uniqueKey(): number;
+                uniqueKeyValue: number;
+                _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
+                readAttribute(attributeName: string): any;
+                readAttributeUnderscore(attributeName: string): any;
+                isAttributeLoaded(attributeName: any): boolean;
+                _isPresent(value: any): boolean;
+                _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+                _readBelongsToReflection({ reflectionName }: {
+                    modelClass: any;
+                    reflectionName: string;
+                }): any | null;
+                _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
+                _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
+                _readHasOneReflection({ reflectionName }: {
+                    modelClass: any;
+                    reflectionName: string;
+                }): any | null;
+                _readModelDataFromArgs(args?: {
+                    data?: {
+                        b?: Record<string, any>;
+                        a?: Record<string, any>;
+                        r?: any;
+                    };
+                    collection?: Collection<any>;
+                }): void;
+                collection: Collection<any>;
+                preloadedRelationships: any;
+                _readPreloadedRelationships(preloaded: {
+                    getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+                }): void;
+                primaryKey(): number | string;
+            };
             cacheKey(): number | string;
             localCacheKey(): string;
             fullCacheKey(): string;
             create(attributes?: Record<string, any>, options?: object): Promise<{
-                model: BaseModel;
+                model: {
+                    changes: {};
+                    newRecord: boolean;
+                    relationshipsCache: {};
+                    relationships: {};
+                    abilities: Record<string, any>;
+                    modelData: {};
+                    assignAttributes(newAttributes: Record<string, any>): void;
+                    attributes(): Record<string, any>;
+                    can(givenAbilityName: string): boolean;
+                    clone(): /*elided*/ any;
+                    cacheKey(): number | string;
+                    localCacheKey(): string;
+                    fullCacheKey(): string;
+                    create(attributes?: Record<string, any>, options?: object): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+                        model: /*elided*/ any;
+                        response: any;
+                    }>;
+                    destroy(): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    ensureAbilities(listOfAbilities: string[]): Promise<void>;
+                    getAttributes(): Record<string, any>;
+                    handleResponseError(response: object): never;
+                    identifierKey(): number | string;
+                    _identifierKey: string | number;
+                    isAssociationLoaded(associationName: string): boolean;
+                    isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+                    isAssociationPresent(associationName: string): boolean;
+                    ensureAssociationLoaded(associationName: string): Promise<any>;
+                    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+                    isAttributeChanged(attributeName: string): boolean;
+                    isChanged(): boolean;
+                    isNewRecord(): boolean;
+                    isPersisted(): boolean;
+                    savedChangeToAttribute(attributeName: string): boolean;
+                    setNewModel(model: /*elided*/ any): void;
+                    setNewModelData(model: /*elided*/ any): void;
+                    previousModelData: any;
+                    _isDateChanged(oldValue: any, newValue: any): boolean | void;
+                    _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
+                    _isStringChanged(oldValue: any, newValue: any): boolean | void;
+                    modelClassData(): ModelClassDataType;
+                    reload(): Promise<void>;
+                    save(): Promise<{
+                        model: /*elided*/ any;
+                        response?: object;
+                    }>;
+                    saveRaw(rawData: any, options?: {}): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+                        model: /*elided*/ any;
+                        response?: object;
+                    }>;
+                    _refreshModelFromResponse(response: object): void;
+                    _refreshModelDataFromResponse(response: object): void;
+                    updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+                        simpleModelErrors?: boolean;
+                    }): Promise<{
+                        response: object;
+                        model: /*elided*/ any;
+                    }>;
+                    isValid(): never;
+                    isValidOnServer(): Promise<{
+                        valid: boolean;
+                        errors: Record<string, any>;
+                    }>;
+                    modelClass(): Record<string, any>;
+                    preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+                    markForDestruction(): void;
+                    _markedForDestruction: boolean;
+                    markedForDestruction(): boolean;
+                    uniqueKey(): number;
+                    uniqueKeyValue: number;
+                    _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
+                    readAttribute(attributeName: string): any;
+                    readAttributeUnderscore(attributeName: string): any;
+                    isAttributeLoaded(attributeName: any): boolean;
+                    _isPresent(value: any): boolean;
+                    _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+                    _readBelongsToReflection({ reflectionName }: {
+                        modelClass: any;
+                        reflectionName: string;
+                    }): any | null;
+                    _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
+                    _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
+                    _readHasOneReflection({ reflectionName }: {
+                        modelClass: any;
+                        reflectionName: string;
+                    }): any | null;
+                    _readModelDataFromArgs(args?: {
+                        data?: {
+                            b?: Record<string, any>;
+                            a?: Record<string, any>;
+                            r?: any;
+                        };
+                        collection?: Collection<any>;
+                    }): void;
+                    collection: Collection<any>;
+                    preloadedRelationships: any;
+                    _readPreloadedRelationships(preloaded: {
+                        getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+                    }): void;
+                    primaryKey(): number | string;
+                };
                 response: object;
             }>;
             createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
@@ -38,7 +254,118 @@ export default class ApiMakerModelRecipesModelLoader {
                 response: any;
             }>;
             destroy(): Promise<{
-                model: BaseModel;
+                model: {
+                    changes: {};
+                    newRecord: boolean;
+                    relationshipsCache: {};
+                    relationships: {};
+                    abilities: Record<string, any>;
+                    modelData: {};
+                    assignAttributes(newAttributes: Record<string, any>): void;
+                    attributes(): Record<string, any>;
+                    can(givenAbilityName: string): boolean;
+                    clone(): /*elided*/ any;
+                    cacheKey(): number | string;
+                    localCacheKey(): string;
+                    fullCacheKey(): string;
+                    create(attributes?: Record<string, any>, options?: object): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+                        model: /*elided*/ any;
+                        response: any;
+                    }>;
+                    destroy(): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    ensureAbilities(listOfAbilities: string[]): Promise<void>;
+                    getAttributes(): Record<string, any>;
+                    handleResponseError(response: object): never;
+                    identifierKey(): number | string;
+                    _identifierKey: string | number;
+                    isAssociationLoaded(associationName: string): boolean;
+                    isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+                    isAssociationPresent(associationName: string): boolean;
+                    ensureAssociationLoaded(associationName: string): Promise<any>;
+                    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+                    isAttributeChanged(attributeName: string): boolean;
+                    isChanged(): boolean;
+                    isNewRecord(): boolean;
+                    isPersisted(): boolean;
+                    savedChangeToAttribute(attributeName: string): boolean;
+                    setNewModel(model: /*elided*/ any): void;
+                    setNewModelData(model: /*elided*/ any): void;
+                    previousModelData: any;
+                    _isDateChanged(oldValue: any, newValue: any): boolean | void;
+                    _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
+                    _isStringChanged(oldValue: any, newValue: any): boolean | void;
+                    modelClassData(): ModelClassDataType;
+                    reload(): Promise<void>;
+                    save(): Promise<{
+                        model: /*elided*/ any;
+                        response?: object;
+                    }>;
+                    saveRaw(rawData: any, options?: {}): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+                        model: /*elided*/ any;
+                        response?: object;
+                    }>;
+                    _refreshModelFromResponse(response: object): void;
+                    _refreshModelDataFromResponse(response: object): void;
+                    updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+                        simpleModelErrors?: boolean;
+                    }): Promise<{
+                        response: object;
+                        model: /*elided*/ any;
+                    }>;
+                    isValid(): never;
+                    isValidOnServer(): Promise<{
+                        valid: boolean;
+                        errors: Record<string, any>;
+                    }>;
+                    modelClass(): Record<string, any>;
+                    preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+                    markForDestruction(): void;
+                    _markedForDestruction: boolean;
+                    markedForDestruction(): boolean;
+                    uniqueKey(): number;
+                    uniqueKeyValue: number;
+                    _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
+                    readAttribute(attributeName: string): any;
+                    readAttributeUnderscore(attributeName: string): any;
+                    isAttributeLoaded(attributeName: any): boolean;
+                    _isPresent(value: any): boolean;
+                    _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+                    _readBelongsToReflection({ reflectionName }: {
+                        modelClass: any;
+                        reflectionName: string;
+                    }): any | null;
+                    _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
+                    _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
+                    _readHasOneReflection({ reflectionName }: {
+                        modelClass: any;
+                        reflectionName: string;
+                    }): any | null;
+                    _readModelDataFromArgs(args?: {
+                        data?: {
+                            b?: Record<string, any>;
+                            a?: Record<string, any>;
+                            r?: any;
+                        };
+                        collection?: Collection<any>;
+                    }): void;
+                    collection: Collection<any>;
+                    preloadedRelationships: any;
+                    _readPreloadedRelationships(preloaded: {
+                        getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+                    }): void;
+                    primaryKey(): number | string;
+                };
                 response: object;
             }>;
             ensureAbilities(listOfAbilities: string[]): Promise<void>;
@@ -56,8 +383,230 @@ export default class ApiMakerModelRecipesModelLoader {
             isNewRecord(): boolean;
             isPersisted(): boolean;
             savedChangeToAttribute(attributeName: string): boolean;
-            setNewModel(model: BaseModel): void;
-            setNewModelData(model: BaseModel): void;
+            setNewModel(model: {
+                changes: {};
+                newRecord: boolean;
+                relationshipsCache: {};
+                relationships: {};
+                abilities: Record<string, any>;
+                modelData: {};
+                assignAttributes(newAttributes: Record<string, any>): void;
+                attributes(): Record<string, any>;
+                can(givenAbilityName: string): boolean;
+                clone(): /*elided*/ any;
+                cacheKey(): number | string;
+                localCacheKey(): string;
+                fullCacheKey(): string;
+                create(attributes?: Record<string, any>, options?: object): Promise<{
+                    model: /*elided*/ any;
+                    response: object;
+                }>;
+                createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+                    model: /*elided*/ any;
+                    response: any;
+                }>;
+                destroy(): Promise<{
+                    model: /*elided*/ any;
+                    response: object;
+                }>;
+                ensureAbilities(listOfAbilities: string[]): Promise<void>;
+                getAttributes(): Record<string, any>;
+                handleResponseError(response: object): never;
+                identifierKey(): number | string;
+                _identifierKey: string | number;
+                isAssociationLoaded(associationName: string): boolean;
+                isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+                isAssociationPresent(associationName: string): boolean;
+                ensureAssociationLoaded(associationName: string): Promise<any>;
+                ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+                isAttributeChanged(attributeName: string): boolean;
+                isChanged(): boolean;
+                isNewRecord(): boolean;
+                isPersisted(): boolean;
+                savedChangeToAttribute(attributeName: string): boolean;
+                setNewModel(model: /*elided*/ any): void;
+                setNewModelData(model: /*elided*/ any): void;
+                previousModelData: any;
+                _isDateChanged(oldValue: any, newValue: any): boolean | void;
+                _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
+                _isStringChanged(oldValue: any, newValue: any): boolean | void;
+                modelClassData(): ModelClassDataType;
+                reload(): Promise<void>;
+                save(): Promise<{
+                    model: /*elided*/ any;
+                    response?: object;
+                }>;
+                saveRaw(rawData: any, options?: {}): Promise<{
+                    model: /*elided*/ any;
+                    response: object;
+                }>;
+                update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+                    model: /*elided*/ any;
+                    response?: object;
+                }>;
+                _refreshModelFromResponse(response: object): void;
+                _refreshModelDataFromResponse(response: object): void;
+                updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+                    simpleModelErrors?: boolean;
+                }): Promise<{
+                    response: object;
+                    model: /*elided*/ any;
+                }>;
+                isValid(): never;
+                isValidOnServer(): Promise<{
+                    valid: boolean;
+                    errors: Record<string, any>;
+                }>;
+                modelClass(): Record<string, any>;
+                preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+                markForDestruction(): void;
+                _markedForDestruction: boolean;
+                markedForDestruction(): boolean;
+                uniqueKey(): number;
+                uniqueKeyValue: number;
+                _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
+                readAttribute(attributeName: string): any;
+                readAttributeUnderscore(attributeName: string): any;
+                isAttributeLoaded(attributeName: any): boolean;
+                _isPresent(value: any): boolean;
+                _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+                _readBelongsToReflection({ reflectionName }: {
+                    modelClass: any;
+                    reflectionName: string;
+                }): any | null;
+                _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
+                _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
+                _readHasOneReflection({ reflectionName }: {
+                    modelClass: any;
+                    reflectionName: string;
+                }): any | null;
+                _readModelDataFromArgs(args?: {
+                    data?: {
+                        b?: Record<string, any>;
+                        a?: Record<string, any>;
+                        r?: any;
+                    };
+                    collection?: Collection<any>;
+                }): void;
+                collection: Collection<any>;
+                preloadedRelationships: any;
+                _readPreloadedRelationships(preloaded: {
+                    getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+                }): void;
+                primaryKey(): number | string;
+            }): void;
+            setNewModelData(model: {
+                changes: {};
+                newRecord: boolean;
+                relationshipsCache: {};
+                relationships: {};
+                abilities: Record<string, any>;
+                modelData: {};
+                assignAttributes(newAttributes: Record<string, any>): void;
+                attributes(): Record<string, any>;
+                can(givenAbilityName: string): boolean;
+                clone(): /*elided*/ any;
+                cacheKey(): number | string;
+                localCacheKey(): string;
+                fullCacheKey(): string;
+                create(attributes?: Record<string, any>, options?: object): Promise<{
+                    model: /*elided*/ any;
+                    response: object;
+                }>;
+                createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+                    model: /*elided*/ any;
+                    response: any;
+                }>;
+                destroy(): Promise<{
+                    model: /*elided*/ any;
+                    response: object;
+                }>;
+                ensureAbilities(listOfAbilities: string[]): Promise<void>;
+                getAttributes(): Record<string, any>;
+                handleResponseError(response: object): never;
+                identifierKey(): number | string;
+                _identifierKey: string | number;
+                isAssociationLoaded(associationName: string): boolean;
+                isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+                isAssociationPresent(associationName: string): boolean;
+                ensureAssociationLoaded(associationName: string): Promise<any>;
+                ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+                isAttributeChanged(attributeName: string): boolean;
+                isChanged(): boolean;
+                isNewRecord(): boolean;
+                isPersisted(): boolean;
+                savedChangeToAttribute(attributeName: string): boolean;
+                setNewModel(model: /*elided*/ any): void;
+                setNewModelData(model: /*elided*/ any): void;
+                previousModelData: any;
+                _isDateChanged(oldValue: any, newValue: any): boolean | void;
+                _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
+                _isStringChanged(oldValue: any, newValue: any): boolean | void;
+                modelClassData(): ModelClassDataType;
+                reload(): Promise<void>;
+                save(): Promise<{
+                    model: /*elided*/ any;
+                    response?: object;
+                }>;
+                saveRaw(rawData: any, options?: {}): Promise<{
+                    model: /*elided*/ any;
+                    response: object;
+                }>;
+                update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+                    model: /*elided*/ any;
+                    response?: object;
+                }>;
+                _refreshModelFromResponse(response: object): void;
+                _refreshModelDataFromResponse(response: object): void;
+                updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+                    simpleModelErrors?: boolean;
+                }): Promise<{
+                    response: object;
+                    model: /*elided*/ any;
+                }>;
+                isValid(): never;
+                isValidOnServer(): Promise<{
+                    valid: boolean;
+                    errors: Record<string, any>;
+                }>;
+                modelClass(): Record<string, any>;
+                preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+                markForDestruction(): void;
+                _markedForDestruction: boolean;
+                markedForDestruction(): boolean;
+                uniqueKey(): number;
+                uniqueKeyValue: number;
+                _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
+                readAttribute(attributeName: string): any;
+                readAttributeUnderscore(attributeName: string): any;
+                isAttributeLoaded(attributeName: any): boolean;
+                _isPresent(value: any): boolean;
+                _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+                _readBelongsToReflection({ reflectionName }: {
+                    modelClass: any;
+                    reflectionName: string;
+                }): any | null;
+                _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
+                _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
+                _readHasOneReflection({ reflectionName }: {
+                    modelClass: any;
+                    reflectionName: string;
+                }): any | null;
+                _readModelDataFromArgs(args?: {
+                    data?: {
+                        b?: Record<string, any>;
+                        a?: Record<string, any>;
+                        r?: any;
+                    };
+                    collection?: Collection<any>;
+                }): void;
+                collection: Collection<any>;
+                preloadedRelationships: any;
+                _readPreloadedRelationships(preloaded: {
+                    getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+                }): void;
+                primaryKey(): number | string;
+            }): void;
             previousModelData: any;
             _isDateChanged(oldValue: any, newValue: any): boolean | void;
             _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
@@ -65,15 +614,348 @@ export default class ApiMakerModelRecipesModelLoader {
             modelClassData(): ModelClassDataType;
             reload(): Promise<void>;
             save(): Promise<{
-                model: BaseModel;
+                model: {
+                    changes: {};
+                    newRecord: boolean;
+                    relationshipsCache: {};
+                    relationships: {};
+                    abilities: Record<string, any>;
+                    modelData: {};
+                    assignAttributes(newAttributes: Record<string, any>): void;
+                    attributes(): Record<string, any>;
+                    can(givenAbilityName: string): boolean;
+                    clone(): /*elided*/ any;
+                    cacheKey(): number | string;
+                    localCacheKey(): string;
+                    fullCacheKey(): string;
+                    create(attributes?: Record<string, any>, options?: object): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+                        model: /*elided*/ any;
+                        response: any;
+                    }>;
+                    destroy(): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    ensureAbilities(listOfAbilities: string[]): Promise<void>;
+                    getAttributes(): Record<string, any>;
+                    handleResponseError(response: object): never;
+                    identifierKey(): number | string;
+                    _identifierKey: string | number;
+                    isAssociationLoaded(associationName: string): boolean;
+                    isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+                    isAssociationPresent(associationName: string): boolean;
+                    ensureAssociationLoaded(associationName: string): Promise<any>;
+                    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+                    isAttributeChanged(attributeName: string): boolean;
+                    isChanged(): boolean;
+                    isNewRecord(): boolean;
+                    isPersisted(): boolean;
+                    savedChangeToAttribute(attributeName: string): boolean;
+                    setNewModel(model: /*elided*/ any): void;
+                    setNewModelData(model: /*elided*/ any): void;
+                    previousModelData: any;
+                    _isDateChanged(oldValue: any, newValue: any): boolean | void;
+                    _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
+                    _isStringChanged(oldValue: any, newValue: any): boolean | void;
+                    modelClassData(): ModelClassDataType;
+                    reload(): Promise<void>;
+                    save(): Promise<{
+                        model: /*elided*/ any;
+                        response?: object;
+                    }>;
+                    saveRaw(rawData: any, options?: {}): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+                        model: /*elided*/ any;
+                        response?: object;
+                    }>;
+                    _refreshModelFromResponse(response: object): void;
+                    _refreshModelDataFromResponse(response: object): void;
+                    updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+                        simpleModelErrors?: boolean;
+                    }): Promise<{
+                        response: object;
+                        model: /*elided*/ any;
+                    }>;
+                    isValid(): never;
+                    isValidOnServer(): Promise<{
+                        valid: boolean;
+                        errors: Record<string, any>;
+                    }>;
+                    modelClass(): Record<string, any>;
+                    preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+                    markForDestruction(): void;
+                    _markedForDestruction: boolean;
+                    markedForDestruction(): boolean;
+                    uniqueKey(): number;
+                    uniqueKeyValue: number;
+                    _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
+                    readAttribute(attributeName: string): any;
+                    readAttributeUnderscore(attributeName: string): any;
+                    isAttributeLoaded(attributeName: any): boolean;
+                    _isPresent(value: any): boolean;
+                    _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+                    _readBelongsToReflection({ reflectionName }: {
+                        modelClass: any;
+                        reflectionName: string;
+                    }): any | null;
+                    _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
+                    _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
+                    _readHasOneReflection({ reflectionName }: {
+                        modelClass: any;
+                        reflectionName: string;
+                    }): any | null;
+                    _readModelDataFromArgs(args?: {
+                        data?: {
+                            b?: Record<string, any>;
+                            a?: Record<string, any>;
+                            r?: any;
+                        };
+                        collection?: Collection<any>;
+                    }): void;
+                    collection: Collection<any>;
+                    preloadedRelationships: any;
+                    _readPreloadedRelationships(preloaded: {
+                        getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+                    }): void;
+                    primaryKey(): number | string;
+                };
                 response?: object;
             }>;
             saveRaw(rawData: any, options?: {}): Promise<{
-                model: BaseModel;
+                model: {
+                    changes: {};
+                    newRecord: boolean;
+                    relationshipsCache: {};
+                    relationships: {};
+                    abilities: Record<string, any>;
+                    modelData: {};
+                    assignAttributes(newAttributes: Record<string, any>): void;
+                    attributes(): Record<string, any>;
+                    can(givenAbilityName: string): boolean;
+                    clone(): /*elided*/ any;
+                    cacheKey(): number | string;
+                    localCacheKey(): string;
+                    fullCacheKey(): string;
+                    create(attributes?: Record<string, any>, options?: object): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+                        model: /*elided*/ any;
+                        response: any;
+                    }>;
+                    destroy(): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    ensureAbilities(listOfAbilities: string[]): Promise<void>;
+                    getAttributes(): Record<string, any>;
+                    handleResponseError(response: object): never;
+                    identifierKey(): number | string;
+                    _identifierKey: string | number;
+                    isAssociationLoaded(associationName: string): boolean;
+                    isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+                    isAssociationPresent(associationName: string): boolean;
+                    ensureAssociationLoaded(associationName: string): Promise<any>;
+                    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+                    isAttributeChanged(attributeName: string): boolean;
+                    isChanged(): boolean;
+                    isNewRecord(): boolean;
+                    isPersisted(): boolean;
+                    savedChangeToAttribute(attributeName: string): boolean;
+                    setNewModel(model: /*elided*/ any): void;
+                    setNewModelData(model: /*elided*/ any): void;
+                    previousModelData: any;
+                    _isDateChanged(oldValue: any, newValue: any): boolean | void;
+                    _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
+                    _isStringChanged(oldValue: any, newValue: any): boolean | void;
+                    modelClassData(): ModelClassDataType;
+                    reload(): Promise<void>;
+                    save(): Promise<{
+                        model: /*elided*/ any;
+                        response?: object;
+                    }>;
+                    saveRaw(rawData: any, options?: {}): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+                        model: /*elided*/ any;
+                        response?: object;
+                    }>;
+                    _refreshModelFromResponse(response: object): void;
+                    _refreshModelDataFromResponse(response: object): void;
+                    updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+                        simpleModelErrors?: boolean;
+                    }): Promise<{
+                        response: object;
+                        model: /*elided*/ any;
+                    }>;
+                    isValid(): never;
+                    isValidOnServer(): Promise<{
+                        valid: boolean;
+                        errors: Record<string, any>;
+                    }>;
+                    modelClass(): Record<string, any>;
+                    preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+                    markForDestruction(): void;
+                    _markedForDestruction: boolean;
+                    markedForDestruction(): boolean;
+                    uniqueKey(): number;
+                    uniqueKeyValue: number;
+                    _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
+                    readAttribute(attributeName: string): any;
+                    readAttributeUnderscore(attributeName: string): any;
+                    isAttributeLoaded(attributeName: any): boolean;
+                    _isPresent(value: any): boolean;
+                    _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+                    _readBelongsToReflection({ reflectionName }: {
+                        modelClass: any;
+                        reflectionName: string;
+                    }): any | null;
+                    _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
+                    _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
+                    _readHasOneReflection({ reflectionName }: {
+                        modelClass: any;
+                        reflectionName: string;
+                    }): any | null;
+                    _readModelDataFromArgs(args?: {
+                        data?: {
+                            b?: Record<string, any>;
+                            a?: Record<string, any>;
+                            r?: any;
+                        };
+                        collection?: Collection<any>;
+                    }): void;
+                    collection: Collection<any>;
+                    preloadedRelationships: any;
+                    _readPreloadedRelationships(preloaded: {
+                        getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+                    }): void;
+                    primaryKey(): number | string;
+                };
                 response: object;
             }>;
             update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
-                model: BaseModel;
+                model: {
+                    changes: {};
+                    newRecord: boolean;
+                    relationshipsCache: {};
+                    relationships: {};
+                    abilities: Record<string, any>;
+                    modelData: {};
+                    assignAttributes(newAttributes: Record<string, any>): void;
+                    attributes(): Record<string, any>;
+                    can(givenAbilityName: string): boolean;
+                    clone(): /*elided*/ any;
+                    cacheKey(): number | string;
+                    localCacheKey(): string;
+                    fullCacheKey(): string;
+                    create(attributes?: Record<string, any>, options?: object): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+                        model: /*elided*/ any;
+                        response: any;
+                    }>;
+                    destroy(): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    ensureAbilities(listOfAbilities: string[]): Promise<void>;
+                    getAttributes(): Record<string, any>;
+                    handleResponseError(response: object): never;
+                    identifierKey(): number | string;
+                    _identifierKey: string | number;
+                    isAssociationLoaded(associationName: string): boolean;
+                    isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+                    isAssociationPresent(associationName: string): boolean;
+                    ensureAssociationLoaded(associationName: string): Promise<any>;
+                    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+                    isAttributeChanged(attributeName: string): boolean;
+                    isChanged(): boolean;
+                    isNewRecord(): boolean;
+                    isPersisted(): boolean;
+                    savedChangeToAttribute(attributeName: string): boolean;
+                    setNewModel(model: /*elided*/ any): void;
+                    setNewModelData(model: /*elided*/ any): void;
+                    previousModelData: any;
+                    _isDateChanged(oldValue: any, newValue: any): boolean | void;
+                    _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
+                    _isStringChanged(oldValue: any, newValue: any): boolean | void;
+                    modelClassData(): ModelClassDataType;
+                    reload(): Promise<void>;
+                    save(): Promise<{
+                        model: /*elided*/ any;
+                        response?: object;
+                    }>;
+                    saveRaw(rawData: any, options?: {}): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+                        model: /*elided*/ any;
+                        response?: object;
+                    }>;
+                    _refreshModelFromResponse(response: object): void;
+                    _refreshModelDataFromResponse(response: object): void;
+                    updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+                        simpleModelErrors?: boolean;
+                    }): Promise<{
+                        response: object;
+                        model: /*elided*/ any;
+                    }>;
+                    isValid(): never;
+                    isValidOnServer(): Promise<{
+                        valid: boolean;
+                        errors: Record<string, any>;
+                    }>;
+                    modelClass(): Record<string, any>;
+                    preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+                    markForDestruction(): void;
+                    _markedForDestruction: boolean;
+                    markedForDestruction(): boolean;
+                    uniqueKey(): number;
+                    uniqueKeyValue: number;
+                    _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
+                    readAttribute(attributeName: string): any;
+                    readAttributeUnderscore(attributeName: string): any;
+                    isAttributeLoaded(attributeName: any): boolean;
+                    _isPresent(value: any): boolean;
+                    _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+                    _readBelongsToReflection({ reflectionName }: {
+                        modelClass: any;
+                        reflectionName: string;
+                    }): any | null;
+                    _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
+                    _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
+                    _readHasOneReflection({ reflectionName }: {
+                        modelClass: any;
+                        reflectionName: string;
+                    }): any | null;
+                    _readModelDataFromArgs(args?: {
+                        data?: {
+                            b?: Record<string, any>;
+                            a?: Record<string, any>;
+                            r?: any;
+                        };
+                        collection?: Collection<any>;
+                    }): void;
+                    collection: Collection<any>;
+                    preloadedRelationships: any;
+                    _readPreloadedRelationships(preloaded: {
+                        getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+                    }): void;
+                    primaryKey(): number | string;
+                };
                 response?: object;
             }>;
             _refreshModelFromResponse(response: object): void;
@@ -82,88 +964,497 @@ export default class ApiMakerModelRecipesModelLoader {
                 simpleModelErrors?: boolean;
             }): Promise<{
                 response: object;
-                model: BaseModel;
+                model: {
+                    changes: {};
+                    newRecord: boolean;
+                    relationshipsCache: {};
+                    relationships: {};
+                    abilities: Record<string, any>;
+                    modelData: {};
+                    assignAttributes(newAttributes: Record<string, any>): void;
+                    attributes(): Record<string, any>;
+                    can(givenAbilityName: string): boolean;
+                    clone(): /*elided*/ any;
+                    cacheKey(): number | string;
+                    localCacheKey(): string;
+                    fullCacheKey(): string;
+                    create(attributes?: Record<string, any>, options?: object): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+                        model: /*elided*/ any;
+                        response: any;
+                    }>;
+                    destroy(): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    ensureAbilities(listOfAbilities: string[]): Promise<void>;
+                    getAttributes(): Record<string, any>;
+                    handleResponseError(response: object): never;
+                    identifierKey(): number | string;
+                    _identifierKey: string | number;
+                    isAssociationLoaded(associationName: string): boolean;
+                    isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+                    isAssociationPresent(associationName: string): boolean;
+                    ensureAssociationLoaded(associationName: string): Promise<any>;
+                    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+                    isAttributeChanged(attributeName: string): boolean;
+                    isChanged(): boolean;
+                    isNewRecord(): boolean;
+                    isPersisted(): boolean;
+                    savedChangeToAttribute(attributeName: string): boolean;
+                    setNewModel(model: /*elided*/ any): void;
+                    setNewModelData(model: /*elided*/ any): void;
+                    previousModelData: any;
+                    _isDateChanged(oldValue: any, newValue: any): boolean | void;
+                    _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
+                    _isStringChanged(oldValue: any, newValue: any): boolean | void;
+                    modelClassData(): ModelClassDataType;
+                    reload(): Promise<void>;
+                    save(): Promise<{
+                        model: /*elided*/ any;
+                        response?: object;
+                    }>;
+                    saveRaw(rawData: any, options?: {}): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+                        model: /*elided*/ any;
+                        response?: object;
+                    }>;
+                    _refreshModelFromResponse(response: object): void;
+                    _refreshModelDataFromResponse(response: object): void;
+                    updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+                        simpleModelErrors?: boolean;
+                    }): Promise<{
+                        response: object;
+                        model: /*elided*/ any;
+                    }>;
+                    isValid(): never;
+                    isValidOnServer(): Promise<{
+                        valid: boolean;
+                        errors: Record<string, any>;
+                    }>;
+                    modelClass(): Record<string, any>;
+                    preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+                    markForDestruction(): void;
+                    _markedForDestruction: boolean;
+                    markedForDestruction(): boolean;
+                    uniqueKey(): number;
+                    uniqueKeyValue: number;
+                    _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
+                    readAttribute(attributeName: string): any;
+                    readAttributeUnderscore(attributeName: string): any;
+                    isAttributeLoaded(attributeName: any): boolean;
+                    _isPresent(value: any): boolean;
+                    _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+                    _readBelongsToReflection({ reflectionName }: {
+                        modelClass: any;
+                        reflectionName: string;
+                    }): any | null;
+                    _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
+                    _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
+                    _readHasOneReflection({ reflectionName }: {
+                        modelClass: any;
+                        reflectionName: string;
+                    }): any | null;
+                    _readModelDataFromArgs(args?: {
+                        data?: {
+                            b?: Record<string, any>;
+                            a?: Record<string, any>;
+                            r?: any;
+                        };
+                        collection?: Collection<any>;
+                    }): void;
+                    collection: Collection<any>;
+                    preloadedRelationships: any;
+                    _readPreloadedRelationships(preloaded: {
+                        getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+                    }): void;
+                    primaryKey(): number | string;
+                };
             }>;
             isValid(): never;
             isValidOnServer(): Promise<{
                 valid: boolean;
                 errors: Record<string, any>;
             }>;
-            modelClass<Self extends BaseModel>(this: Self): typeof BaseModel & (new (...args: any[]) => Self);
-            preloadRelationship(relationshipName: string, model: BaseModel | BaseModel[] | null): void;
+            modelClass(): Record<string, any>;
+            preloadRelationship(relationshipName: string, model: {
+                changes: {};
+                newRecord: boolean;
+                relationshipsCache: {};
+                relationships: {};
+                abilities: Record<string, any>;
+                modelData: {};
+                assignAttributes(newAttributes: Record<string, any>): void;
+                attributes(): Record<string, any>;
+                can(givenAbilityName: string): boolean;
+                clone(): /*elided*/ any;
+                cacheKey(): number | string;
+                localCacheKey(): string;
+                fullCacheKey(): string;
+                create(attributes?: Record<string, any>, options?: object): Promise<{
+                    model: /*elided*/ any;
+                    response: object;
+                }>;
+                createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+                    model: /*elided*/ any;
+                    response: any;
+                }>;
+                destroy(): Promise<{
+                    model: /*elided*/ any;
+                    response: object;
+                }>;
+                ensureAbilities(listOfAbilities: string[]): Promise<void>;
+                getAttributes(): Record<string, any>;
+                handleResponseError(response: object): never;
+                identifierKey(): number | string;
+                _identifierKey: string | number;
+                isAssociationLoaded(associationName: string): boolean;
+                isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+                isAssociationPresent(associationName: string): boolean;
+                ensureAssociationLoaded(associationName: string): Promise<any>;
+                ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+                isAttributeChanged(attributeName: string): boolean;
+                isChanged(): boolean;
+                isNewRecord(): boolean;
+                isPersisted(): boolean;
+                savedChangeToAttribute(attributeName: string): boolean;
+                setNewModel(model: /*elided*/ any): void;
+                setNewModelData(model: /*elided*/ any): void;
+                previousModelData: any;
+                _isDateChanged(oldValue: any, newValue: any): boolean | void;
+                _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
+                _isStringChanged(oldValue: any, newValue: any): boolean | void;
+                modelClassData(): ModelClassDataType;
+                reload(): Promise<void>;
+                save(): Promise<{
+                    model: /*elided*/ any;
+                    response?: object;
+                }>;
+                saveRaw(rawData: any, options?: {}): Promise<{
+                    model: /*elided*/ any;
+                    response: object;
+                }>;
+                update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+                    model: /*elided*/ any;
+                    response?: object;
+                }>;
+                _refreshModelFromResponse(response: object): void;
+                _refreshModelDataFromResponse(response: object): void;
+                updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+                    simpleModelErrors?: boolean;
+                }): Promise<{
+                    response: object;
+                    model: /*elided*/ any;
+                }>;
+                isValid(): never;
+                isValidOnServer(): Promise<{
+                    valid: boolean;
+                    errors: Record<string, any>;
+                }>;
+                modelClass(): Record<string, any>;
+                preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+                markForDestruction(): void;
+                _markedForDestruction: boolean;
+                markedForDestruction(): boolean;
+                uniqueKey(): number;
+                uniqueKeyValue: number;
+                _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
+                readAttribute(attributeName: string): any;
+                readAttributeUnderscore(attributeName: string): any;
+                isAttributeLoaded(attributeName: any): boolean;
+                _isPresent(value: any): boolean;
+                _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+                _readBelongsToReflection({ reflectionName }: {
+                    modelClass: any;
+                    reflectionName: string;
+                }): any | null;
+                _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
+                _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
+                _readHasOneReflection({ reflectionName }: {
+                    modelClass: any;
+                    reflectionName: string;
+                }): any | null;
+                _readModelDataFromArgs(args?: {
+                    data?: {
+                        b?: Record<string, any>;
+                        a?: Record<string, any>;
+                        r?: any;
+                    };
+                    collection?: Collection<any>;
+                }): void;
+                collection: Collection<any>;
+                preloadedRelationships: any;
+                _readPreloadedRelationships(preloaded: {
+                    getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+                }): void;
+                primaryKey(): number | string;
+            } | {
+                changes: {};
+                newRecord: boolean;
+                relationshipsCache: {};
+                relationships: {};
+                abilities: Record<string, any>;
+                modelData: {};
+                assignAttributes(newAttributes: Record<string, any>): void;
+                attributes(): Record<string, any>;
+                can(givenAbilityName: string): boolean;
+                clone(): /*elided*/ any;
+                cacheKey(): number | string;
+                localCacheKey(): string;
+                fullCacheKey(): string;
+                create(attributes?: Record<string, any>, options?: object): Promise<{
+                    model: /*elided*/ any;
+                    response: object;
+                }>;
+                createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+                    model: /*elided*/ any;
+                    response: any;
+                }>;
+                destroy(): Promise<{
+                    model: /*elided*/ any;
+                    response: object;
+                }>;
+                ensureAbilities(listOfAbilities: string[]): Promise<void>;
+                getAttributes(): Record<string, any>;
+                handleResponseError(response: object): never;
+                identifierKey(): number | string;
+                _identifierKey: string | number;
+                isAssociationLoaded(associationName: string): boolean;
+                isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+                isAssociationPresent(associationName: string): boolean;
+                ensureAssociationLoaded(associationName: string): Promise<any>;
+                ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+                isAttributeChanged(attributeName: string): boolean;
+                isChanged(): boolean;
+                isNewRecord(): boolean;
+                isPersisted(): boolean;
+                savedChangeToAttribute(attributeName: string): boolean;
+                setNewModel(model: /*elided*/ any): void;
+                setNewModelData(model: /*elided*/ any): void;
+                previousModelData: any;
+                _isDateChanged(oldValue: any, newValue: any): boolean | void;
+                _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
+                _isStringChanged(oldValue: any, newValue: any): boolean | void;
+                modelClassData(): ModelClassDataType;
+                reload(): Promise<void>;
+                save(): Promise<{
+                    model: /*elided*/ any;
+                    response?: object;
+                }>;
+                saveRaw(rawData: any, options?: {}): Promise<{
+                    model: /*elided*/ any;
+                    response: object;
+                }>;
+                update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+                    model: /*elided*/ any;
+                    response?: object;
+                }>;
+                _refreshModelFromResponse(response: object): void;
+                _refreshModelDataFromResponse(response: object): void;
+                updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+                    simpleModelErrors?: boolean;
+                }): Promise<{
+                    response: object;
+                    model: /*elided*/ any;
+                }>;
+                isValid(): never;
+                isValidOnServer(): Promise<{
+                    valid: boolean;
+                    errors: Record<string, any>;
+                }>;
+                modelClass(): Record<string, any>;
+                preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+                markForDestruction(): void;
+                _markedForDestruction: boolean;
+                markedForDestruction(): boolean;
+                uniqueKey(): number;
+                uniqueKeyValue: number;
+                _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
+                readAttribute(attributeName: string): any;
+                readAttributeUnderscore(attributeName: string): any;
+                isAttributeLoaded(attributeName: any): boolean;
+                _isPresent(value: any): boolean;
+                _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+                _readBelongsToReflection({ reflectionName }: {
+                    modelClass: any;
+                    reflectionName: string;
+                }): any | null;
+                _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
+                _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
+                _readHasOneReflection({ reflectionName }: {
+                    modelClass: any;
+                    reflectionName: string;
+                }): any | null;
+                _readModelDataFromArgs(args?: {
+                    data?: {
+                        b?: Record<string, any>;
+                        a?: Record<string, any>;
+                        r?: any;
+                    };
+                    collection?: Collection<any>;
+                }): void;
+                collection: Collection<any>;
+                preloadedRelationships: any;
+                _readPreloadedRelationships(preloaded: {
+                    getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+                }): void;
+                primaryKey(): number | string;
+            }[] | null): void;
             markForDestruction(): void;
             _markedForDestruction: boolean;
             markedForDestruction(): boolean;
             uniqueKey(): number;
             uniqueKeyValue: number;
-            _callMemberCommand: (args: Record<string, any>, commandArgs: Record<string, any>) => Promise<object>;
+            _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<AssocMC extends typeof import("./base-model.js").default>(args: import("./collection.js").CollectionArgsType<AssocMC>, queryArgs?: import("./collection.js").QueryArgsType): Promise<InstanceType<AssocMC>>;
-            _readBelongsToReflection<AssocMC extends typeof import("./base-model.js").default>({ reflectionName }: {
-                modelClass: AssocMC;
+            _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+            _readBelongsToReflection({ reflectionName }: {
+                modelClass: any;
                 reflectionName: string;
-            }): InstanceType<AssocMC>;
-            _loadHasManyReflection<AssocMC extends typeof import("./base-model.js").default>(args: import("./collection.js").CollectionArgsType<AssocMC>, queryArgs?: import("./collection.js").QueryArgsType): Promise<InstanceType<AssocMC>[]>;
-            _loadHasOneReflection<AssocMC extends typeof import("./base-model.js").default>(args: import("./collection.js").CollectionArgsType<AssocMC>, queryArgs?: import("./collection.js").QueryArgsType): Promise<InstanceType<AssocMC>>;
-            _readHasOneReflection<AssocMC extends typeof import("./base-model.js").default>({ reflectionName }: {
-                modelClass: AssocMC;
+            }): 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;
-            }): InstanceType<AssocMC>;
+            }): any | null;
             _readModelDataFromArgs(args?: {
                 data?: {
                     b?: Record<string, any>;
                     a?: Record<string, any>;
                     r?: any;
                 };
-                collection?: Collection<typeof import("./base-model.js").default>;
+                collection?: Collection<any>;
             }): void;
-            collection: Collection<typeof BaseModel>;
+            collection: Collection<any>;
             preloadedRelationships: any;
             _readPreloadedRelationships(preloaded: {
-                getModel: (relationshipType: string, relationshipId: number | string) => BaseModel;
+                getModel: (relationshipType: string, relationshipId: number | string) => {
+                    changes: {};
+                    newRecord: boolean;
+                    relationshipsCache: {};
+                    relationships: {};
+                    abilities: Record<string, any>;
+                    modelData: {};
+                    assignAttributes(newAttributes: Record<string, any>): void;
+                    attributes(): Record<string, any>;
+                    can(givenAbilityName: string): boolean;
+                    clone(): /*elided*/ any;
+                    cacheKey(): number | string;
+                    localCacheKey(): string;
+                    fullCacheKey(): string;
+                    create(attributes?: Record<string, any>, options?: object): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+                        model: /*elided*/ any;
+                        response: any;
+                    }>;
+                    destroy(): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    ensureAbilities(listOfAbilities: string[]): Promise<void>;
+                    getAttributes(): Record<string, any>;
+                    handleResponseError(response: object): never;
+                    identifierKey(): number | string;
+                    _identifierKey: string | number;
+                    isAssociationLoaded(associationName: string): boolean;
+                    isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+                    isAssociationPresent(associationName: string): boolean;
+                    ensureAssociationLoaded(associationName: string): Promise<any>;
+                    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+                    isAttributeChanged(attributeName: string): boolean;
+                    isChanged(): boolean;
+                    isNewRecord(): boolean;
+                    isPersisted(): boolean;
+                    savedChangeToAttribute(attributeName: string): boolean;
+                    setNewModel(model: /*elided*/ any): void;
+                    setNewModelData(model: /*elided*/ any): void;
+                    previousModelData: any;
+                    _isDateChanged(oldValue: any, newValue: any): boolean | void;
+                    _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
+                    _isStringChanged(oldValue: any, newValue: any): boolean | void;
+                    modelClassData(): ModelClassDataType;
+                    reload(): Promise<void>;
+                    save(): Promise<{
+                        model: /*elided*/ any;
+                        response?: object;
+                    }>;
+                    saveRaw(rawData: any, options?: {}): Promise<{
+                        model: /*elided*/ any;
+                        response: object;
+                    }>;
+                    update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+                        model: /*elided*/ any;
+                        response?: object;
+                    }>;
+                    _refreshModelFromResponse(response: object): void;
+                    _refreshModelDataFromResponse(response: object): void;
+                    updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+                        simpleModelErrors?: boolean;
+                    }): Promise<{
+                        response: object;
+                        model: /*elided*/ any;
+                    }>;
+                    isValid(): never;
+                    isValidOnServer(): Promise<{
+                        valid: boolean;
+                        errors: Record<string, any>;
+                    }>;
+                    modelClass(): Record<string, any>;
+                    preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+                    markForDestruction(): void;
+                    _markedForDestruction: boolean;
+                    markedForDestruction(): boolean;
+                    uniqueKey(): number;
+                    uniqueKeyValue: number;
+                    _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
+                    readAttribute(attributeName: string): any;
+                    readAttributeUnderscore(attributeName: string): any;
+                    isAttributeLoaded(attributeName: any): boolean;
+                    _isPresent(value: any): boolean;
+                    _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+                    _readBelongsToReflection({ reflectionName }: {
+                        modelClass: any;
+                        reflectionName: string;
+                    }): any | null;
+                    _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
+                    _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
+                    _readHasOneReflection({ reflectionName }: {
+                        modelClass: any;
+                        reflectionName: string;
+                    }): any | null;
+                    _readModelDataFromArgs(args?: {
+                        data?: {
+                            b?: Record<string, any>;
+                            a?: Record<string, any>;
+                            r?: any;
+                        };
+                        collection?: Collection<any>;
+                    }): void;
+                    collection: Collection<any>;
+                    preloadedRelationships: any;
+                    _readPreloadedRelationships(preloaded: {
+                        getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+                    }): void;
+                    primaryKey(): number | string;
+                };
             }): void;
             primaryKey(): number | string;
         };
         readonly name: any;
         apiMakerType: string;
-        attributes(): import("./base-model/attribute.js").default[];
-        hasAttribute(attributeName: any): 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<T extends typeof import("./base-model.js").default>(this: T, id: number | string): Promise<InstanceType<T>>;
-        findOrCreateBy<T extends typeof import("./base-model.js").default>(this: T, findOrCreateByArgs: Record<string, any>, args?: {
-            additionalData?: Record<string, any>;
-        }): Promise<InstanceType<T>>;
-        modelName(): import("./model-name.js").default;
-        primaryKey(): string;
-        ransack<MC extends typeof import("./base-model.js").default>(this: MC, query?: Record<string, any>): import("./collection.js").default<MC>;
-        select<MC extends typeof import("./base-model.js").default>(this: MC, select?: Record<string, any>): import("./collection.js").default<MC>;
-        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: any): import("./base-model/reflection.js").default;
-        _token(): string;
-        all<MC extends typeof import("./base-model.js").default>(this: MC): Collection<MC>;
-        parseValidationErrors({ error, model, options }: {
-            error: any;
-            model?: BaseModel;
-            options: ParseValidationErrorsOptions;
-        }): void;
-        humanAttributeName(attributeName: string): string;
-        snakeCase(string: string): string;
-        _objectDataFromGivenRawData(rawData: FormData | Record<string, any>, options: object): Record<string, any>;
-        _callCollectionCommand(args: {
-            args: any;
-        }, commandArgs: Record<string, any>): Promise<object>;
-        _postDataFromArgs(args?: FormData | Record<string, any>): FormData;
     };
     /** addAttributeMethodsToModelClass. */
     addAttributeMethodsToModelClass(ModelClass: any, attributes: any): void;
@@ -239,5 +1530,4 @@ export default class ApiMakerModelRecipesModelLoader {
     }): void;
 }
 import Collection from "./collection.js";
-import BaseModel from "./base-model.js";
 //# sourceMappingURL=model-recipes-model-loader.d.ts.map