@kaspernj/api-maker 1.0.2160 → 1.0.2161

package/build/base-model.d.ts

@@ -1,4 +1,609 @@
 export default BaseModel;
+export type ModelIdentifier = string | number;
+export type ModelScalarValue = string | number | boolean | null | undefined | Date | File | Blob;
+export type ModelValueMap = {
+    [key: string]: ModelValue;
+};
+export type ModelValueArray = Array<ModelValue>;
+export type ModelValue = ModelScalarValue | ModelValueMap | ModelValueArray;
+export type ModelDataMap = Record<string, ModelValue>;
+export type ModelAbilityMap = Record<string, boolean>;
+export type PreloadedRelationshipValue = ModelIdentifier | ModelIdentifier[] | null;
+export type PreloadedRelationshipMap = Record<string, PreloadedRelationshipValue>;
+export type LoadedRelationshipValue = {
+    abilities: ModelAbilityMap;
+    changes: ModelDataMap;
+    collection: Collection<any>;
+    _identifierKey: string | number;
+    _markedForDestruction: boolean;
+    modelData: ModelDataMap;
+    newRecord: boolean;
+    previousModelData: any;
+    preloadedRelationships: PreloadedRelationshipMap;
+    relationshipsCache: LoadedRelationshipMap;
+    relationships: LoadedRelationshipMap;
+    uniqueKeyValue: number;
+    /**
+     * @param {ModelDataMap} newAttributes
+     * @returns {void}
+     */
+    assignAttributes(newAttributes: ModelDataMap): void;
+    /** @returns {ModelDataMap} */
+    attributes(): ModelDataMap;
+    /**
+     * @param {string} givenAbilityName
+     * @returns {boolean}
+     */
+    can(givenAbilityName: string): boolean;
+    /** @returns {BaseModel} */
+    clone(): /*elided*/ any;
+    /** @returns {number | string} */
+    cacheKey(): number | string;
+    /** @returns {string} */
+    localCacheKey(): string;
+    /** @returns {string} */
+    fullCacheKey(): string;
+    /**
+     * @param {ModelDataMap} [attributes]
+     * @param {ParseValidationErrorsOptions} [options]
+     * @returns {Promise<{
+     *   model: BaseModel,
+     *   response: ModelCommandResponse
+     * }>}
+     */
+    create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    /**
+     * @param {RawDataInput} rawData
+     * @param {ParseValidationErrorsOptions} [options]
+     * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+     */
+    createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    /** @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>} */
+    destroy(): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    /**
+     * @param {string[]} listOfAbilities
+     * @returns {Promise<void>}
+     */
+    ensureAbilities(listOfAbilities: string[]): Promise<void>;
+    /** @returns {ModelDataMap} */
+    getAttributes(): ModelDataMap;
+    /**
+     * @param {ModelCommandResponse} response
+     * @returns {never}
+     */
+    handleResponseError(response: ModelCommandResponse): never;
+    /** @returns {number | string} */
+    identifierKey(): number | string;
+    /**
+     * @param {string} associationName
+     * @returns {boolean}
+     */
+    isAssociationLoaded(associationName: string): boolean;
+    /**
+     * @param {string} associationNameUnderscore
+     * @returns {boolean}
+     */
+    isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+    /**
+     * @param {string} associationName
+     * @returns {boolean}
+     */
+    isAssociationPresent(associationName: string): boolean;
+    /**
+     * @param {string} associationName
+     * @returns {Promise<LoadedRelationshipValue>}
+     */
+    ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+    /**
+     * @param {string} associationNameUnderscore
+     * @returns {Promise<LoadedRelationshipValue>}
+     */
+    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+    /**
+     * @param {string} attributeName
+     * @returns {boolean}
+     */
+    isAttributeChanged(attributeName: string): boolean;
+    /** @returns {boolean} */
+    isChanged(): boolean;
+    /** @returns {boolean} */
+    isNewRecord(): boolean;
+    /** @returns {boolean} */
+    isPersisted(): boolean;
+    /**
+     * @param {string} attributeName
+     * @returns {boolean}
+     */
+    savedChangeToAttribute(attributeName: string): boolean;
+    /**
+     * @param {BaseModel} model
+     * @returns {void}
+     */
+    setNewModel(model: /*elided*/ any): void;
+    /**
+     * @param {BaseModel} model
+     * @returns {void}
+     */
+    setNewModelData(model: /*elided*/ any): void;
+    /**
+     * @param {ModelValue | null | undefined} oldValue
+     * @param {ModelValue | null | undefined} newValue
+     * @returns {boolean | void}
+     */
+    _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    /**
+     * @param {ModelValue | null | undefined} oldValue
+     * @param {ModelValue | null | undefined} newValue
+     * @returns {boolean | void}
+     */
+    _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    /**
+     * @param {ModelValue | null | undefined} oldValue
+     * @param {ModelValue | null | undefined} newValue
+     * @returns {boolean | void}
+     */
+    _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    /** @returns {ModelClassDataType} */
+    modelClassData(): ModelClassDataType;
+    /** @returns {Promise<void>} */
+    reload(): Promise<void>;
+    /** @returns {Promise<{model: BaseModel, response?: object}>} */
+    save(): Promise<{
+        model: /*elided*/ any;
+        response?: object;
+    }>;
+    /**
+     * @param {RawDataInput} rawData
+     * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+     * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+     */
+    saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    /**
+     * @param {ModelDataMap} [newAttributes]
+     * @param {ParseValidationErrorsOptions} [options]
+     * @returns {Promise<{
+     *   model: BaseModel,
+     *   response?: object
+     * }>}
+     */
+    update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response?: object;
+    }>;
+    /**
+     * @param {ModelCommandResponse} response
+     * @returns {void}
+     */
+    _refreshModelFromResponse(response: ModelCommandResponse): void;
+    /**
+     * @param {ModelCommandResponse} response
+     * @returns {void}
+     */
+    _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+    /**
+     * @param {RawDataInput} rawData
+     * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+     * @returns {Promise<{response: ModelCommandResponse, model: BaseModel}>}
+     */
+    updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
+        response: ModelCommandResponse;
+        model: /*elided*/ any;
+    }>;
+    /** @returns {never} */
+    isValid(): never;
+    /** @returns {Promise<{valid: boolean, errors: ValidationResponseErrors}>} */
+    isValidOnServer(): Promise<{
+        valid: boolean;
+        errors: ValidationResponseErrors;
+    }>;
+    /** @returns {BaseModelClassType} */
+    modelClass(): BaseModelClassType;
+    /**
+     * @param {string} relationshipName
+     * @param {BaseModel | BaseModel[] | null} model
+     * @returns {void}
+     */
+    preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+    /** @returns {void} */
+    markForDestruction(): void;
+    /** @returns {boolean} */
+    markedForDestruction(): boolean;
+    /** @returns {number} */
+    uniqueKey(): number;
+    /**
+     * @param {ModelCommandDescriptor} args
+     * @param {ModelCommandOptions} commandArgs
+     * @returns {import("./command-execution.js").default}
+     */
+    _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
+    /**
+     * @param {string} attributeName
+     * @returns {ModelValue | null | undefined}
+     */
+    readAttribute(attributeName: string): ModelValue | null | undefined;
+    /**
+     * @param {string} attributeName
+     * @returns {ModelValue | null | undefined}
+     */
+    readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+    /**
+     * @param {string} attributeName
+     * @returns {boolean}
+     */
+    isAttributeLoaded(attributeName: string): boolean;
+    /**
+     * @param {ModelValue | null | undefined} value
+     * @returns {boolean}
+     */
+    _isPresent(value: ModelValue | null | undefined): boolean;
+    /**
+     *
+     * @param {RelationshipLoadArgs} args
+     * @param {import("./collection.js").QueryArgsType} queryArgs
+     * @returns {Promise<BaseModel | null>}
+     */
+    _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    /**
+     *
+     * @param {RelationshipLoadArgs} args
+     * @returns {BaseModel | null}
+     */
+    _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    /**
+     *
+     * @param {RelationshipLoadArgs} args
+     * @param {import("./collection.js").QueryArgsType} queryArgs
+     * @returns {Promise<BaseModel[]>}
+     */
+    _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+    /**
+     *
+     * @param {RelationshipLoadArgs} args
+     * @param {import("./collection.js").QueryArgsType} queryArgs
+     * @returns {Promise<BaseModel | null>}
+     */
+    _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    /**
+     *
+     * @param {RelationshipLoadArgs} args
+     * @returns {BaseModel | null}
+     */
+    _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    /**
+     * @param {BaseModelArgsObject} [args]
+     * @returns {void}
+     */
+    _readModelDataFromArgs(args?: BaseModelArgsObject): void;
+    /**
+     * @param {{getModel: (relationshipType: string, relationshipId: number | string) => BaseModel}} preloaded
+     * @returns {void}
+     */
+    _readPreloadedRelationships(preloaded: {
+        getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+    }): void;
+    /** @returns {number | string} */
+    primaryKey(): number | string;
+} | {
+    abilities: ModelAbilityMap;
+    changes: ModelDataMap;
+    collection: Collection<any>;
+    _identifierKey: string | number;
+    _markedForDestruction: boolean;
+    modelData: ModelDataMap;
+    newRecord: boolean;
+    previousModelData: any;
+    preloadedRelationships: PreloadedRelationshipMap;
+    relationshipsCache: LoadedRelationshipMap;
+    relationships: LoadedRelationshipMap;
+    uniqueKeyValue: number;
+    /**
+     * @param {ModelDataMap} newAttributes
+     * @returns {void}
+     */
+    assignAttributes(newAttributes: ModelDataMap): void;
+    /** @returns {ModelDataMap} */
+    attributes(): ModelDataMap;
+    /**
+     * @param {string} givenAbilityName
+     * @returns {boolean}
+     */
+    can(givenAbilityName: string): boolean;
+    /** @returns {BaseModel} */
+    clone(): /*elided*/ any;
+    /** @returns {number | string} */
+    cacheKey(): number | string;
+    /** @returns {string} */
+    localCacheKey(): string;
+    /** @returns {string} */
+    fullCacheKey(): string;
+    /**
+     * @param {ModelDataMap} [attributes]
+     * @param {ParseValidationErrorsOptions} [options]
+     * @returns {Promise<{
+     *   model: BaseModel,
+     *   response: ModelCommandResponse
+     * }>}
+     */
+    create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    /**
+     * @param {RawDataInput} rawData
+     * @param {ParseValidationErrorsOptions} [options]
+     * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+     */
+    createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    /** @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>} */
+    destroy(): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    /**
+     * @param {string[]} listOfAbilities
+     * @returns {Promise<void>}
+     */
+    ensureAbilities(listOfAbilities: string[]): Promise<void>;
+    /** @returns {ModelDataMap} */
+    getAttributes(): ModelDataMap;
+    /**
+     * @param {ModelCommandResponse} response
+     * @returns {never}
+     */
+    handleResponseError(response: ModelCommandResponse): never;
+    /** @returns {number | string} */
+    identifierKey(): number | string;
+    /**
+     * @param {string} associationName
+     * @returns {boolean}
+     */
+    isAssociationLoaded(associationName: string): boolean;
+    /**
+     * @param {string} associationNameUnderscore
+     * @returns {boolean}
+     */
+    isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+    /**
+     * @param {string} associationName
+     * @returns {boolean}
+     */
+    isAssociationPresent(associationName: string): boolean;
+    /**
+     * @param {string} associationName
+     * @returns {Promise<LoadedRelationshipValue>}
+     */
+    ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+    /**
+     * @param {string} associationNameUnderscore
+     * @returns {Promise<LoadedRelationshipValue>}
+     */
+    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+    /**
+     * @param {string} attributeName
+     * @returns {boolean}
+     */
+    isAttributeChanged(attributeName: string): boolean;
+    /** @returns {boolean} */
+    isChanged(): boolean;
+    /** @returns {boolean} */
+    isNewRecord(): boolean;
+    /** @returns {boolean} */
+    isPersisted(): boolean;
+    /**
+     * @param {string} attributeName
+     * @returns {boolean}
+     */
+    savedChangeToAttribute(attributeName: string): boolean;
+    /**
+     * @param {BaseModel} model
+     * @returns {void}
+     */
+    setNewModel(model: /*elided*/ any): void;
+    /**
+     * @param {BaseModel} model
+     * @returns {void}
+     */
+    setNewModelData(model: /*elided*/ any): void;
+    /**
+     * @param {ModelValue | null | undefined} oldValue
+     * @param {ModelValue | null | undefined} newValue
+     * @returns {boolean | void}
+     */
+    _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    /**
+     * @param {ModelValue | null | undefined} oldValue
+     * @param {ModelValue | null | undefined} newValue
+     * @returns {boolean | void}
+     */
+    _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    /**
+     * @param {ModelValue | null | undefined} oldValue
+     * @param {ModelValue | null | undefined} newValue
+     * @returns {boolean | void}
+     */
+    _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    /** @returns {ModelClassDataType} */
+    modelClassData(): ModelClassDataType;
+    /** @returns {Promise<void>} */
+    reload(): Promise<void>;
+    /** @returns {Promise<{model: BaseModel, response?: object}>} */
+    save(): Promise<{
+        model: /*elided*/ any;
+        response?: object;
+    }>;
+    /**
+     * @param {RawDataInput} rawData
+     * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+     * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+     */
+    saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    /**
+     * @param {ModelDataMap} [newAttributes]
+     * @param {ParseValidationErrorsOptions} [options]
+     * @returns {Promise<{
+     *   model: BaseModel,
+     *   response?: object
+     * }>}
+     */
+    update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response?: object;
+    }>;
+    /**
+     * @param {ModelCommandResponse} response
+     * @returns {void}
+     */
+    _refreshModelFromResponse(response: ModelCommandResponse): void;
+    /**
+     * @param {ModelCommandResponse} response
+     * @returns {void}
+     */
+    _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+    /**
+     * @param {RawDataInput} rawData
+     * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+     * @returns {Promise<{response: ModelCommandResponse, model: BaseModel}>}
+     */
+    updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
+        response: ModelCommandResponse;
+        model: /*elided*/ any;
+    }>;
+    /** @returns {never} */
+    isValid(): never;
+    /** @returns {Promise<{valid: boolean, errors: ValidationResponseErrors}>} */
+    isValidOnServer(): Promise<{
+        valid: boolean;
+        errors: ValidationResponseErrors;
+    }>;
+    /** @returns {BaseModelClassType} */
+    modelClass(): BaseModelClassType;
+    /**
+     * @param {string} relationshipName
+     * @param {BaseModel | BaseModel[] | null} model
+     * @returns {void}
+     */
+    preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+    /** @returns {void} */
+    markForDestruction(): void;
+    /** @returns {boolean} */
+    markedForDestruction(): boolean;
+    /** @returns {number} */
+    uniqueKey(): number;
+    /**
+     * @param {ModelCommandDescriptor} args
+     * @param {ModelCommandOptions} commandArgs
+     * @returns {import("./command-execution.js").default}
+     */
+    _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
+    /**
+     * @param {string} attributeName
+     * @returns {ModelValue | null | undefined}
+     */
+    readAttribute(attributeName: string): ModelValue | null | undefined;
+    /**
+     * @param {string} attributeName
+     * @returns {ModelValue | null | undefined}
+     */
+    readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+    /**
+     * @param {string} attributeName
+     * @returns {boolean}
+     */
+    isAttributeLoaded(attributeName: string): boolean;
+    /**
+     * @param {ModelValue | null | undefined} value
+     * @returns {boolean}
+     */
+    _isPresent(value: ModelValue | null | undefined): boolean;
+    /**
+     *
+     * @param {RelationshipLoadArgs} args
+     * @param {import("./collection.js").QueryArgsType} queryArgs
+     * @returns {Promise<BaseModel | null>}
+     */
+    _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    /**
+     *
+     * @param {RelationshipLoadArgs} args
+     * @returns {BaseModel | null}
+     */
+    _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    /**
+     *
+     * @param {RelationshipLoadArgs} args
+     * @param {import("./collection.js").QueryArgsType} queryArgs
+     * @returns {Promise<BaseModel[]>}
+     */
+    _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+    /**
+     *
+     * @param {RelationshipLoadArgs} args
+     * @param {import("./collection.js").QueryArgsType} queryArgs
+     * @returns {Promise<BaseModel | null>}
+     */
+    _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    /**
+     *
+     * @param {RelationshipLoadArgs} args
+     * @returns {BaseModel | null}
+     */
+    _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    /**
+     * @param {BaseModelArgsObject} [args]
+     * @returns {void}
+     */
+    _readModelDataFromArgs(args?: BaseModelArgsObject): void;
+    /**
+     * @param {{getModel: (relationshipType: string, relationshipId: number | string) => BaseModel}} preloaded
+     * @returns {void}
+     */
+    _readPreloadedRelationships(preloaded: {
+        getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+    }): void;
+    /** @returns {number | string} */
+    primaryKey(): number | string;
+}[] | null;
+export type LoadedRelationshipMap = Record<string, LoadedRelationshipValue>;
+export type ReflectionMacro = import("./base-model/reflection.js").ReflectionMacro;
+export type RawDataInput = FormData | HTMLFormElement | ModelDataMap;
+export type ValidationResponseErrors = Record<string, string | string[] | undefined>;
+export type RelationshipDataType = {
+    collectionName: string;
+    foreignKey?: string;
+    macro: ReflectionMacro;
+    name: string;
+    resource_name: string;
+    through?: string;
+};
+export type ScopeDataType = {
+    name: string;
+};
 export type ModelClassDataType = {
     attributes: Record<string, import("./base-model/attribute.js").AttributeArgType>;
     camelizedLower: string;
@@ -11,30 +616,52 @@ export type ModelClassDataType = {
     paramKey: string;
     pluralName: string;
     primaryKey: string;
-    ransackable_associations: Array<Record<string, any>>;
+    ransackable_associations: RelationshipDataType[];
     ransackable_attributes: import("./base-model/attribute.js").AttributeArgType[];
-    ransackable_scopes: Array<Record<string, any>>;
-    relationships: Array<Record<string, any>>;
+    ransackable_scopes: ScopeDataType[];
+    relationships: RelationshipDataType[];
 };
 export type ParseValidationErrorsOptions = {
-    form?: object;
+    form?: HTMLFormElement;
     throwValidationError?: boolean;
 };
-export type BaseModelClassType = {
-    new (...args: Array<any>): {
-        changes: {};
+export type LoadedModelDataType = {
+    a?: ModelDataMap;
+    b?: ModelAbilityMap;
+    r?: PreloadedRelationshipMap;
+};
+export type BaseModelArgsObject = {
+    a?: ModelDataMap;
+    b?: ModelAbilityMap;
+    collection?: Collection<any>;
+    data?: LoadedModelDataType;
+    isNewRecord?: boolean;
+};
+export type BaseModelArgs = BaseModelArgsObject | ModelDataMap;
+export type BaseModelStaticMethods = {
+    apiMakerType: string;
+    all: () => Collection<any>;
+    attributes: () => Attribute[];
+    find: (id: ModelIdentifier) => Promise<{
+        abilities: ModelAbilityMap;
+        changes: ModelDataMap;
+        collection: Collection<any>;
+        _identifierKey: string | number;
+        _markedForDestruction: boolean;
+        modelData: ModelDataMap;
         newRecord: boolean;
-        relationshipsCache: {};
-        relationships: {};
-        abilities: Record<string, any>;
-        modelData: {};
+        previousModelData: any;
+        preloadedRelationships: PreloadedRelationshipMap;
+        relationshipsCache: LoadedRelationshipMap;
+        relationships: LoadedRelationshipMap;
+        uniqueKeyValue: number;
         /**
-         * @param {Record<string, any>} newAttributes
+         * @param {ModelDataMap} newAttributes
          * @returns {void}
          */
-        assignAttributes(newAttributes: Record<string, any>): void;
-        /** @returns {Record<string, any>} */
-        attributes(): Record<string, any>;
+        assignAttributes(newAttributes: ModelDataMap): void;
+        /** @returns {ModelDataMap} */
+        attributes(): ModelDataMap;
         /**
          * @param {string} givenAbilityName
          * @returns {boolean}
@@ -49,45 +676,45 @@ export type BaseModelClassType = {
         /** @returns {string} */
         fullCacheKey(): string;
         /**
-         * @param {Record<string, any>} [attributes]
-         * @param {object} [options]
+         * @param {ModelDataMap} [attributes]
+         * @param {ParseValidationErrorsOptions} [options]
          * @returns {Promise<{
          *   model: BaseModel,
-         *   response: object
+         *   response: ModelCommandResponse
          * }>}
          */
-        create(attributes?: Record<string, any>, options?: object): Promise<{
+        create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
             model: /*elided*/ any;
-            response: object;
+            response: ModelCommandResponse;
         }>;
         /**
-         * @param {FormData | Record<string, any>} rawData
-         * @param {object} [options]
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
          */
-        createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+        createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
             model: /*elided*/ any;
-            response: any;
+            response: ModelCommandResponse;
         }>;
-        /** @returns {Promise<{model: BaseModel, response: object}>} */
+        /** @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>} */
         destroy(): Promise<{
             model: /*elided*/ any;
-            response: object;
+            response: ModelCommandResponse;
         }>;
         /**
          * @param {string[]} listOfAbilities
          * @returns {Promise<void>}
          */
         ensureAbilities(listOfAbilities: string[]): Promise<void>;
-        /** @returns {Record<string, any>} */
-        getAttributes(): Record<string, any>;
+        /** @returns {ModelDataMap} */
+        getAttributes(): ModelDataMap;
         /**
-         * @param {object} response
+         * @param {ModelCommandResponse} response
          * @returns {never}
          */
-        handleResponseError(response: object): never;
+        handleResponseError(response: ModelCommandResponse): never;
         /** @returns {number | string} */
         identifierKey(): number | string;
-        _identifierKey: string | number;
         /**
          * @param {string} associationName
          * @returns {boolean}
@@ -105,14 +732,14 @@ export type BaseModelClassType = {
         isAssociationPresent(associationName: string): boolean;
         /**
          * @param {string} associationName
-         * @returns {Promise<any>}
+         * @returns {Promise<LoadedRelationshipValue>}
          */
-        ensureAssociationLoaded(associationName: string): Promise<any>;
+        ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
         /**
          * @param {string} associationNameUnderscore
-         * @returns {Promise<any>}
+         * @returns {Promise<LoadedRelationshipValue>}
          */
-        ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+        ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
         /**
          * @param {string} attributeName
          * @returns {boolean}
@@ -139,25 +766,24 @@ export type BaseModelClassType = {
          * @returns {void}
          */
         setNewModelData(model: /*elided*/ any): void;
-        previousModelData: any;
         /**
-         * @param {any} oldValue
-         * @param {any} newValue
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
          * @returns {boolean | void}
          */
-        _isDateChanged(oldValue: any, newValue: any): boolean | void;
+        _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
         /**
-         * @param {any} oldValue
-         * @param {any} newValue
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
          * @returns {boolean | void}
          */
-        _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
+        _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
         /**
-         * @param {any} oldValue
-         * @param {any} newValue
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
          * @returns {boolean | void}
          */
-        _isStringChanged(oldValue: any, newValue: any): boolean | void;
+        _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
         /** @returns {ModelClassDataType} */
         modelClassData(): ModelClassDataType;
         /** @returns {Promise<void>} */
@@ -167,53 +793,59 @@ export type BaseModelClassType = {
             model: /*elided*/ any;
             response?: object;
         }>;
-        /** @returns {Promise<{model: BaseModel, response: object}>} */
-        saveRaw(rawData: any, options?: {}): Promise<{
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+         * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+         */
+        saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
             model: /*elided*/ any;
-            response: object;
+            response: ModelCommandResponse;
         }>;
         /**
-         * @param {Record<string, any>} [newAttributes]
+         * @param {ModelDataMap} [newAttributes]
          * @param {ParseValidationErrorsOptions} [options]
          * @returns {Promise<{
          *   model: BaseModel,
          *   response?: object
          * }>}
          */
-        update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+        update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
             model: /*elided*/ any;
             response?: object;
         }>;
         /**
-         * @param {object} response
+         * @param {ModelCommandResponse} response
          * @returns {void}
          */
-        _refreshModelFromResponse(response: object): void;
+        _refreshModelFromResponse(response: ModelCommandResponse): void;
         /**
-         * @param {object} response
+         * @param {ModelCommandResponse} response
          * @returns {void}
          */
-        _refreshModelDataFromResponse(response: object): void;
+        _refreshModelDataFromResponse(response: ModelCommandResponse): void;
         /**
-         * @param {FormData | Record<string, any>} rawData
+         * @param {RawDataInput} rawData
          * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
-         * @returns {Promise<{response: object, model: BaseModel}>}
+         * @returns {Promise<{response: ModelCommandResponse, model: BaseModel}>}
          */
-        updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+        updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
             simpleModelErrors?: boolean;
         }): Promise<{
-            response: object;
+            response: ModelCommandResponse;
             model: /*elided*/ any;
         }>;
         /** @returns {never} */
         isValid(): never;
-        /** @returns {Promise<{valid: boolean, errors: Record<string, any>}>} */
+        /** @returns {Promise<{valid: boolean, errors: ValidationResponseErrors}>} */
         isValidOnServer(): Promise<{
             valid: boolean;
-            errors: Record<string, any>;
+            errors: ValidationResponseErrors;
         }>;
-        /** @returns {Record<string, any>} */
-        modelClass(): Record<string, any>;
+        /** @returns {BaseModelClassType} */
+        modelClass(): BaseModelClassType;
         /**
          * @param {string} relationshipName
          * @param {BaseModel | BaseModel[] | null} model
@@ -222,93 +854,366 @@ export type BaseModelClassType = {
         preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
         /** @returns {void} */
         markForDestruction(): void;
-        _markedForDestruction: boolean;
         /** @returns {boolean} */
         markedForDestruction(): boolean;
         /** @returns {number} */
         uniqueKey(): number;
-        uniqueKeyValue: number;
         /**
-         * @param {Record<string, any>} args
-         * @param {Record<string, any>} commandArgs
-         * @returns {Promise<object>}
+         * @param {ModelCommandDescriptor} args
+         * @param {ModelCommandOptions} commandArgs
+         * @returns {import("./command-execution.js").default}
          */
-        _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
+        _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
         /**
          * @param {string} attributeName
-         * @returns {any}
+         * @returns {ModelValue | null | undefined}
          */
-        readAttribute(attributeName: string): any;
+        readAttribute(attributeName: string): ModelValue | null | undefined;
         /**
          * @param {string} attributeName
-         * @returns {any}
+         * @returns {ModelValue | null | undefined}
          */
-        readAttributeUnderscore(attributeName: string): any;
-        /** @returns {boolean} */
-        isAttributeLoaded(attributeName: any): boolean;
+        readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        isAttributeLoaded(attributeName: string): boolean;
         /**
-         * @param {any} value
+         * @param {ModelValue | null | undefined} value
          * @returns {boolean}
          */
-        _isPresent(value: any): boolean;
+        _isPresent(value: ModelValue | null | undefined): boolean;
         /**
          *
-         * @param {import("./collection.js").CollectionArgsType<any>} args
+         * @param {RelationshipLoadArgs} args
          * @param {import("./collection.js").QueryArgsType} queryArgs
-         * @returns {Promise<any | null>}
+         * @returns {Promise<BaseModel | null>}
          */
-        _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+        _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
         /**
          *
-         * @param {{modelClass: any, reflectionName: string}} args
-         * @returns {any | null}
+         * @param {RelationshipLoadArgs} args
+         * @returns {BaseModel | null}
          */
-        _readBelongsToReflection({ reflectionName }: {
-            modelClass: any;
-            reflectionName: string;
-        }): any | null;
+        _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
         /**
          *
-         * @param {import("./collection.js").CollectionArgsType<any>} args
+         * @param {RelationshipLoadArgs} args
          * @param {import("./collection.js").QueryArgsType} queryArgs
-         * @returns {Promise<Array<any>>}
+         * @returns {Promise<BaseModel[]>}
          */
-        _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
+        _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
         /**
          *
-         * @param {import("./collection.js").CollectionArgsType<any>} args
+         * @param {RelationshipLoadArgs} args
          * @param {import("./collection.js").QueryArgsType} queryArgs
-         * @returns {Promise<any>}
+         * @returns {Promise<BaseModel | null>}
          */
-        _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
+        _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
         /**
          *
-         * @param {{modelClass: any, reflectionName: string}} args
-         * @returns {any | null}
+         * @param {RelationshipLoadArgs} args
+         * @returns {BaseModel | null}
+         */
+        _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+        /**
+         * @param {BaseModelArgsObject} [args]
+         * @returns {void}
          */
-        _readHasOneReflection({ reflectionName }: {
-            modelClass: any;
-            reflectionName: string;
-        }): any | null;
+        _readModelDataFromArgs(args?: BaseModelArgsObject): void;
         /**
-         * @param {object} [args]
-         * @param {object} [args.data]
-         * @param {Record<string, any>} [args.data.b]
-         * @param {Record<string, any>} [args.data.a]
-         * @param {any} [args.data.r]
-         * @param {Collection<any>} [args.collection]
+         * @param {{getModel: (relationshipType: string, relationshipId: number | string) => BaseModel}} preloaded
          * @returns {void}
          */
-        _readModelDataFromArgs(args?: {
-            data?: {
-                b?: Record<string, any>;
-                a?: Record<string, any>;
-                r?: any;
-            };
-            collection?: Collection<any>;
+        _readPreloadedRelationships(preloaded: {
+            getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
         }): void;
+        /** @returns {number | string} */
+        primaryKey(): number | string;
+    }>;
+    findOrCreateBy: (findOrCreateByArgs: ModelDataMap, args?: {
+        additionalData?: ModelDataMap;
+    }) => Promise<{
+        abilities: ModelAbilityMap;
+        changes: ModelDataMap;
         collection: Collection<any>;
-        preloadedRelationships: any;
+        _identifierKey: string | number;
+        _markedForDestruction: boolean;
+        modelData: ModelDataMap;
+        newRecord: boolean;
+        previousModelData: any;
+        preloadedRelationships: PreloadedRelationshipMap;
+        relationshipsCache: LoadedRelationshipMap;
+        relationships: LoadedRelationshipMap;
+        uniqueKeyValue: number;
+        /**
+         * @param {ModelDataMap} newAttributes
+         * @returns {void}
+         */
+        assignAttributes(newAttributes: ModelDataMap): void;
+        /** @returns {ModelDataMap} */
+        attributes(): ModelDataMap;
+        /**
+         * @param {string} givenAbilityName
+         * @returns {boolean}
+         */
+        can(givenAbilityName: string): boolean;
+        /** @returns {BaseModel} */
+        clone(): /*elided*/ any;
+        /** @returns {number | string} */
+        cacheKey(): number | string;
+        /** @returns {string} */
+        localCacheKey(): string;
+        /** @returns {string} */
+        fullCacheKey(): string;
+        /**
+         * @param {ModelDataMap} [attributes]
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{
+         *   model: BaseModel,
+         *   response: ModelCommandResponse
+         * }>}
+         */
+        create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+         */
+        createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /** @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>} */
+        destroy(): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {string[]} listOfAbilities
+         * @returns {Promise<void>}
+         */
+        ensureAbilities(listOfAbilities: string[]): Promise<void>;
+        /** @returns {ModelDataMap} */
+        getAttributes(): ModelDataMap;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {never}
+         */
+        handleResponseError(response: ModelCommandResponse): never;
+        /** @returns {number | string} */
+        identifierKey(): number | string;
+        /**
+         * @param {string} associationName
+         * @returns {boolean}
+         */
+        isAssociationLoaded(associationName: string): boolean;
+        /**
+         * @param {string} associationNameUnderscore
+         * @returns {boolean}
+         */
+        isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+        /**
+         * @param {string} associationName
+         * @returns {boolean}
+         */
+        isAssociationPresent(associationName: string): boolean;
+        /**
+         * @param {string} associationName
+         * @returns {Promise<LoadedRelationshipValue>}
+         */
+        ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+        /**
+         * @param {string} associationNameUnderscore
+         * @returns {Promise<LoadedRelationshipValue>}
+         */
+        ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        isAttributeChanged(attributeName: string): boolean;
+        /** @returns {boolean} */
+        isChanged(): boolean;
+        /** @returns {boolean} */
+        isNewRecord(): boolean;
+        /** @returns {boolean} */
+        isPersisted(): boolean;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        savedChangeToAttribute(attributeName: string): boolean;
+        /**
+         * @param {BaseModel} model
+         * @returns {void}
+         */
+        setNewModel(model: /*elided*/ any): void;
+        /**
+         * @param {BaseModel} model
+         * @returns {void}
+         */
+        setNewModelData(model: /*elided*/ any): void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /** @returns {ModelClassDataType} */
+        modelClassData(): ModelClassDataType;
+        /** @returns {Promise<void>} */
+        reload(): Promise<void>;
+        /** @returns {Promise<{model: BaseModel, response?: object}>} */
+        save(): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+         * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+         */
+        saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {ModelDataMap} [newAttributes]
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{
+         *   model: BaseModel,
+         *   response?: object
+         * }>}
+         */
+        update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {void}
+         */
+        _refreshModelFromResponse(response: ModelCommandResponse): void;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {void}
+         */
+        _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+         * @returns {Promise<{response: ModelCommandResponse, model: BaseModel}>}
+         */
+        updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            response: ModelCommandResponse;
+            model: /*elided*/ any;
+        }>;
+        /** @returns {never} */
+        isValid(): never;
+        /** @returns {Promise<{valid: boolean, errors: ValidationResponseErrors}>} */
+        isValidOnServer(): Promise<{
+            valid: boolean;
+            errors: ValidationResponseErrors;
+        }>;
+        /** @returns {BaseModelClassType} */
+        modelClass(): BaseModelClassType;
+        /**
+         * @param {string} relationshipName
+         * @param {BaseModel | BaseModel[] | null} model
+         * @returns {void}
+         */
+        preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+        /** @returns {void} */
+        markForDestruction(): void;
+        /** @returns {boolean} */
+        markedForDestruction(): boolean;
+        /** @returns {number} */
+        uniqueKey(): number;
+        /**
+         * @param {ModelCommandDescriptor} args
+         * @param {ModelCommandOptions} commandArgs
+         * @returns {import("./command-execution.js").default}
+         */
+        _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
+        /**
+         * @param {string} attributeName
+         * @returns {ModelValue | null | undefined}
+         */
+        readAttribute(attributeName: string): ModelValue | null | undefined;
+        /**
+         * @param {string} attributeName
+         * @returns {ModelValue | null | undefined}
+         */
+        readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        isAttributeLoaded(attributeName: string): boolean;
+        /**
+         * @param {ModelValue | null | undefined} value
+         * @returns {boolean}
+         */
+        _isPresent(value: ModelValue | null | undefined): boolean;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel | null>}
+         */
+        _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @returns {BaseModel | null}
+         */
+        _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel[]>}
+         */
+        _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel | null>}
+         */
+        _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @returns {BaseModel | null}
+         */
+        _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+        /**
+         * @param {BaseModelArgsObject} [args]
+         * @returns {void}
+         */
+        _readModelDataFromArgs(args?: BaseModelArgsObject): void;
         /**
          * @param {{getModel: (relationshipType: string, relationshipId: number | string) => BaseModel}} preloaded
          * @returns {void}
@@ -316,13 +1221,2792 @@ export type BaseModelClassType = {
         _readPreloadedRelationships(preloaded: {
             getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
         }): void;
-        /** @returns {number|string} */
+        /** @returns {number | string} */
         primaryKey(): number | string;
+    }>;
+    createLink?: (args: ModelDataMap) => import("./command-execution.js").default;
+    destroyLinks?: (args: ModelDataMap) => import("./command-execution.js").default;
+    hasAttribute: (attributeName: string) => boolean;
+    humanAttributeName: (attributeName: string) => string;
+    linkFor?: (args: ModelDataMap) => Promise<{
+        link?: {
+            abilities: ModelAbilityMap;
+            changes: ModelDataMap;
+            collection: Collection<any>;
+            _identifierKey: string | number;
+            _markedForDestruction: boolean;
+            modelData: ModelDataMap;
+            newRecord: boolean;
+            previousModelData: any;
+            preloadedRelationships: PreloadedRelationshipMap;
+            relationshipsCache: LoadedRelationshipMap;
+            relationships: LoadedRelationshipMap;
+            uniqueKeyValue: number;
+            /**
+             * @param {ModelDataMap} newAttributes
+             * @returns {void}
+             */
+            assignAttributes(newAttributes: ModelDataMap): void;
+            /** @returns {ModelDataMap} */
+            attributes(): ModelDataMap;
+            /**
+             * @param {string} givenAbilityName
+             * @returns {boolean}
+             */
+            can(givenAbilityName: string): boolean;
+            /** @returns {BaseModel} */
+            clone(): /*elided*/ any;
+            /** @returns {number | string} */
+            cacheKey(): number | string;
+            /** @returns {string} */
+            localCacheKey(): string;
+            /** @returns {string} */
+            fullCacheKey(): string;
+            /**
+             * @param {ModelDataMap} [attributes]
+             * @param {ParseValidationErrorsOptions} [options]
+             * @returns {Promise<{
+             *   model: BaseModel,
+             *   response: ModelCommandResponse
+             * }>}
+             */
+            create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+                model: /*elided*/ any;
+                response: ModelCommandResponse;
+            }>;
+            /**
+             * @param {RawDataInput} rawData
+             * @param {ParseValidationErrorsOptions} [options]
+             * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+             */
+            createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+                model: /*elided*/ any;
+                response: ModelCommandResponse;
+            }>;
+            /** @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>} */
+            destroy(): Promise<{
+                model: /*elided*/ any;
+                response: ModelCommandResponse;
+            }>;
+            /**
+             * @param {string[]} listOfAbilities
+             * @returns {Promise<void>}
+             */
+            ensureAbilities(listOfAbilities: string[]): Promise<void>;
+            /** @returns {ModelDataMap} */
+            getAttributes(): ModelDataMap;
+            /**
+             * @param {ModelCommandResponse} response
+             * @returns {never}
+             */
+            handleResponseError(response: ModelCommandResponse): never;
+            /** @returns {number | string} */
+            identifierKey(): number | string;
+            /**
+             * @param {string} associationName
+             * @returns {boolean}
+             */
+            isAssociationLoaded(associationName: string): boolean;
+            /**
+             * @param {string} associationNameUnderscore
+             * @returns {boolean}
+             */
+            isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+            /**
+             * @param {string} associationName
+             * @returns {boolean}
+             */
+            isAssociationPresent(associationName: string): boolean;
+            /**
+             * @param {string} associationName
+             * @returns {Promise<LoadedRelationshipValue>}
+             */
+            ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+            /**
+             * @param {string} associationNameUnderscore
+             * @returns {Promise<LoadedRelationshipValue>}
+             */
+            ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+            /**
+             * @param {string} attributeName
+             * @returns {boolean}
+             */
+            isAttributeChanged(attributeName: string): boolean;
+            /** @returns {boolean} */
+            isChanged(): boolean;
+            /** @returns {boolean} */
+            isNewRecord(): boolean;
+            /** @returns {boolean} */
+            isPersisted(): boolean;
+            /**
+             * @param {string} attributeName
+             * @returns {boolean}
+             */
+            savedChangeToAttribute(attributeName: string): boolean;
+            /**
+             * @param {BaseModel} model
+             * @returns {void}
+             */
+            setNewModel(model: /*elided*/ any): void;
+            /**
+             * @param {BaseModel} model
+             * @returns {void}
+             */
+            setNewModelData(model: /*elided*/ any): void;
+            /**
+             * @param {ModelValue | null | undefined} oldValue
+             * @param {ModelValue | null | undefined} newValue
+             * @returns {boolean | void}
+             */
+            _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+            /**
+             * @param {ModelValue | null | undefined} oldValue
+             * @param {ModelValue | null | undefined} newValue
+             * @returns {boolean | void}
+             */
+            _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+            /**
+             * @param {ModelValue | null | undefined} oldValue
+             * @param {ModelValue | null | undefined} newValue
+             * @returns {boolean | void}
+             */
+            _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+            /** @returns {ModelClassDataType} */
+            modelClassData(): ModelClassDataType;
+            /** @returns {Promise<void>} */
+            reload(): Promise<void>;
+            /** @returns {Promise<{model: BaseModel, response?: object}>} */
+            save(): Promise<{
+                model: /*elided*/ any;
+                response?: object;
+            }>;
+            /**
+             * @param {RawDataInput} rawData
+             * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+             * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+             */
+            saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+                simpleModelErrors?: boolean;
+            }): Promise<{
+                model: /*elided*/ any;
+                response: ModelCommandResponse;
+            }>;
+            /**
+             * @param {ModelDataMap} [newAttributes]
+             * @param {ParseValidationErrorsOptions} [options]
+             * @returns {Promise<{
+             *   model: BaseModel,
+             *   response?: object
+             * }>}
+             */
+            update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+                model: /*elided*/ any;
+                response?: object;
+            }>;
+            /**
+             * @param {ModelCommandResponse} response
+             * @returns {void}
+             */
+            _refreshModelFromResponse(response: ModelCommandResponse): void;
+            /**
+             * @param {ModelCommandResponse} response
+             * @returns {void}
+             */
+            _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+            /**
+             * @param {RawDataInput} rawData
+             * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+             * @returns {Promise<{response: ModelCommandResponse, model: BaseModel}>}
+             */
+            updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+                simpleModelErrors?: boolean;
+            }): Promise<{
+                response: ModelCommandResponse;
+                model: /*elided*/ any;
+            }>;
+            /** @returns {never} */
+            isValid(): never;
+            /** @returns {Promise<{valid: boolean, errors: ValidationResponseErrors}>} */
+            isValidOnServer(): Promise<{
+                valid: boolean;
+                errors: ValidationResponseErrors;
+            }>;
+            /** @returns {BaseModelClassType} */
+            modelClass(): BaseModelClassType;
+            /**
+             * @param {string} relationshipName
+             * @param {BaseModel | BaseModel[] | null} model
+             * @returns {void}
+             */
+            preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+            /** @returns {void} */
+            markForDestruction(): void;
+            /** @returns {boolean} */
+            markedForDestruction(): boolean;
+            /** @returns {number} */
+            uniqueKey(): number;
+            /**
+             * @param {ModelCommandDescriptor} args
+             * @param {ModelCommandOptions} commandArgs
+             * @returns {import("./command-execution.js").default}
+             */
+            _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
+            /**
+             * @param {string} attributeName
+             * @returns {ModelValue | null | undefined}
+             */
+            readAttribute(attributeName: string): ModelValue | null | undefined;
+            /**
+             * @param {string} attributeName
+             * @returns {ModelValue | null | undefined}
+             */
+            readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+            /**
+             * @param {string} attributeName
+             * @returns {boolean}
+             */
+            isAttributeLoaded(attributeName: string): boolean;
+            /**
+             * @param {ModelValue | null | undefined} value
+             * @returns {boolean}
+             */
+            _isPresent(value: ModelValue | null | undefined): boolean;
+            /**
+             *
+             * @param {RelationshipLoadArgs} args
+             * @param {import("./collection.js").QueryArgsType} queryArgs
+             * @returns {Promise<BaseModel | null>}
+             */
+            _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+            /**
+             *
+             * @param {RelationshipLoadArgs} args
+             * @returns {BaseModel | null}
+             */
+            _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+            /**
+             *
+             * @param {RelationshipLoadArgs} args
+             * @param {import("./collection.js").QueryArgsType} queryArgs
+             * @returns {Promise<BaseModel[]>}
+             */
+            _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+            /**
+             *
+             * @param {RelationshipLoadArgs} args
+             * @param {import("./collection.js").QueryArgsType} queryArgs
+             * @returns {Promise<BaseModel | null>}
+             */
+            _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+            /**
+             *
+             * @param {RelationshipLoadArgs} args
+             * @returns {BaseModel | null}
+             */
+            _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+            /**
+             * @param {BaseModelArgsObject} [args]
+             * @returns {void}
+             */
+            _readModelDataFromArgs(args?: BaseModelArgsObject): void;
+            /**
+             * @param {{getModel: (relationshipType: string, relationshipId: number | string) => BaseModel}} preloaded
+             * @returns {void}
+             */
+            _readPreloadedRelationships(preloaded: {
+                getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+            }): void;
+            /** @returns {number | string} */
+            primaryKey(): number | string;
+        } | null;
+    }>;
+    modelClassData: () => ModelClassDataType;
+    modelName: () => ModelName;
+    primaryKey: () => string;
+    current?: () => Promise<{
+        current?: {
+            abilities: ModelAbilityMap;
+            changes: ModelDataMap;
+            collection: Collection<any>;
+            _identifierKey: string | number;
+            _markedForDestruction: boolean;
+            modelData: ModelDataMap;
+            newRecord: boolean;
+            previousModelData: any;
+            preloadedRelationships: PreloadedRelationshipMap;
+            relationshipsCache: LoadedRelationshipMap;
+            relationships: LoadedRelationshipMap;
+            uniqueKeyValue: number;
+            /**
+             * @param {ModelDataMap} newAttributes
+             * @returns {void}
+             */
+            assignAttributes(newAttributes: ModelDataMap): void;
+            /** @returns {ModelDataMap} */
+            attributes(): ModelDataMap;
+            /**
+             * @param {string} givenAbilityName
+             * @returns {boolean}
+             */
+            can(givenAbilityName: string): boolean;
+            /** @returns {BaseModel} */
+            clone(): /*elided*/ any;
+            /** @returns {number | string} */
+            cacheKey(): number | string;
+            /** @returns {string} */
+            localCacheKey(): string;
+            /** @returns {string} */
+            fullCacheKey(): string;
+            /**
+             * @param {ModelDataMap} [attributes]
+             * @param {ParseValidationErrorsOptions} [options]
+             * @returns {Promise<{
+             *   model: BaseModel,
+             *   response: ModelCommandResponse
+             * }>}
+             */
+            create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+                model: /*elided*/ any;
+                response: ModelCommandResponse;
+            }>;
+            /**
+             * @param {RawDataInput} rawData
+             * @param {ParseValidationErrorsOptions} [options]
+             * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+             */
+            createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+                model: /*elided*/ any;
+                response: ModelCommandResponse;
+            }>;
+            /** @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>} */
+            destroy(): Promise<{
+                model: /*elided*/ any;
+                response: ModelCommandResponse;
+            }>;
+            /**
+             * @param {string[]} listOfAbilities
+             * @returns {Promise<void>}
+             */
+            ensureAbilities(listOfAbilities: string[]): Promise<void>;
+            /** @returns {ModelDataMap} */
+            getAttributes(): ModelDataMap;
+            /**
+             * @param {ModelCommandResponse} response
+             * @returns {never}
+             */
+            handleResponseError(response: ModelCommandResponse): never;
+            /** @returns {number | string} */
+            identifierKey(): number | string;
+            /**
+             * @param {string} associationName
+             * @returns {boolean}
+             */
+            isAssociationLoaded(associationName: string): boolean;
+            /**
+             * @param {string} associationNameUnderscore
+             * @returns {boolean}
+             */
+            isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+            /**
+             * @param {string} associationName
+             * @returns {boolean}
+             */
+            isAssociationPresent(associationName: string): boolean;
+            /**
+             * @param {string} associationName
+             * @returns {Promise<LoadedRelationshipValue>}
+             */
+            ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+            /**
+             * @param {string} associationNameUnderscore
+             * @returns {Promise<LoadedRelationshipValue>}
+             */
+            ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+            /**
+             * @param {string} attributeName
+             * @returns {boolean}
+             */
+            isAttributeChanged(attributeName: string): boolean;
+            /** @returns {boolean} */
+            isChanged(): boolean;
+            /** @returns {boolean} */
+            isNewRecord(): boolean;
+            /** @returns {boolean} */
+            isPersisted(): boolean;
+            /**
+             * @param {string} attributeName
+             * @returns {boolean}
+             */
+            savedChangeToAttribute(attributeName: string): boolean;
+            /**
+             * @param {BaseModel} model
+             * @returns {void}
+             */
+            setNewModel(model: /*elided*/ any): void;
+            /**
+             * @param {BaseModel} model
+             * @returns {void}
+             */
+            setNewModelData(model: /*elided*/ any): void;
+            /**
+             * @param {ModelValue | null | undefined} oldValue
+             * @param {ModelValue | null | undefined} newValue
+             * @returns {boolean | void}
+             */
+            _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+            /**
+             * @param {ModelValue | null | undefined} oldValue
+             * @param {ModelValue | null | undefined} newValue
+             * @returns {boolean | void}
+             */
+            _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+            /**
+             * @param {ModelValue | null | undefined} oldValue
+             * @param {ModelValue | null | undefined} newValue
+             * @returns {boolean | void}
+             */
+            _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+            /** @returns {ModelClassDataType} */
+            modelClassData(): ModelClassDataType;
+            /** @returns {Promise<void>} */
+            reload(): Promise<void>;
+            /** @returns {Promise<{model: BaseModel, response?: object}>} */
+            save(): Promise<{
+                model: /*elided*/ any;
+                response?: object;
+            }>;
+            /**
+             * @param {RawDataInput} rawData
+             * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+             * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+             */
+            saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+                simpleModelErrors?: boolean;
+            }): Promise<{
+                model: /*elided*/ any;
+                response: ModelCommandResponse;
+            }>;
+            /**
+             * @param {ModelDataMap} [newAttributes]
+             * @param {ParseValidationErrorsOptions} [options]
+             * @returns {Promise<{
+             *   model: BaseModel,
+             *   response?: object
+             * }>}
+             */
+            update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+                model: /*elided*/ any;
+                response?: object;
+            }>;
+            /**
+             * @param {ModelCommandResponse} response
+             * @returns {void}
+             */
+            _refreshModelFromResponse(response: ModelCommandResponse): void;
+            /**
+             * @param {ModelCommandResponse} response
+             * @returns {void}
+             */
+            _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+            /**
+             * @param {RawDataInput} rawData
+             * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+             * @returns {Promise<{response: ModelCommandResponse, model: BaseModel}>}
+             */
+            updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+                simpleModelErrors?: boolean;
+            }): Promise<{
+                response: ModelCommandResponse;
+                model: /*elided*/ any;
+            }>;
+            /** @returns {never} */
+            isValid(): never;
+            /** @returns {Promise<{valid: boolean, errors: ValidationResponseErrors}>} */
+            isValidOnServer(): Promise<{
+                valid: boolean;
+                errors: ValidationResponseErrors;
+            }>;
+            /** @returns {BaseModelClassType} */
+            modelClass(): BaseModelClassType;
+            /**
+             * @param {string} relationshipName
+             * @param {BaseModel | BaseModel[] | null} model
+             * @returns {void}
+             */
+            preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+            /** @returns {void} */
+            markForDestruction(): void;
+            /** @returns {boolean} */
+            markedForDestruction(): boolean;
+            /** @returns {number} */
+            uniqueKey(): number;
+            /**
+             * @param {ModelCommandDescriptor} args
+             * @param {ModelCommandOptions} commandArgs
+             * @returns {import("./command-execution.js").default}
+             */
+            _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
+            /**
+             * @param {string} attributeName
+             * @returns {ModelValue | null | undefined}
+             */
+            readAttribute(attributeName: string): ModelValue | null | undefined;
+            /**
+             * @param {string} attributeName
+             * @returns {ModelValue | null | undefined}
+             */
+            readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+            /**
+             * @param {string} attributeName
+             * @returns {boolean}
+             */
+            isAttributeLoaded(attributeName: string): boolean;
+            /**
+             * @param {ModelValue | null | undefined} value
+             * @returns {boolean}
+             */
+            _isPresent(value: ModelValue | null | undefined): boolean;
+            /**
+             *
+             * @param {RelationshipLoadArgs} args
+             * @param {import("./collection.js").QueryArgsType} queryArgs
+             * @returns {Promise<BaseModel | null>}
+             */
+            _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+            /**
+             *
+             * @param {RelationshipLoadArgs} args
+             * @returns {BaseModel | null}
+             */
+            _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+            /**
+             *
+             * @param {RelationshipLoadArgs} args
+             * @param {import("./collection.js").QueryArgsType} queryArgs
+             * @returns {Promise<BaseModel[]>}
+             */
+            _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+            /**
+             *
+             * @param {RelationshipLoadArgs} args
+             * @param {import("./collection.js").QueryArgsType} queryArgs
+             * @returns {Promise<BaseModel | null>}
+             */
+            _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+            /**
+             *
+             * @param {RelationshipLoadArgs} args
+             * @returns {BaseModel | null}
+             */
+            _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+            /**
+             * @param {BaseModelArgsObject} [args]
+             * @returns {void}
+             */
+            _readModelDataFromArgs(args?: BaseModelArgsObject): void;
+            /**
+             * @param {{getModel: (relationshipType: string, relationshipId: number | string) => BaseModel}} preloaded
+             * @returns {void}
+             */
+            _readPreloadedRelationships(preloaded: {
+                getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+            }): void;
+            /** @returns {number | string} */
+            primaryKey(): number | string;
+        }[];
+    }>;
+    ransack: (query?: import("./collection.js").CollectionRansackParams) => Collection<any>;
+    resourceData?: () => {
+        name?: string;
     };
-    apiMakerType: string;
-} & Record<string, any>;
-/** BaseModel. */
-/** @type {BaseModelClassType} */
-declare const BaseModel: BaseModelClassType;
+    reflections: () => Reflection[];
+    reflection: (name: string) => Reflection;
+    ransackableAssociations: () => Reflection[];
+    ransackableAttributes: () => Attribute[];
+    ransackableScopes: () => Scope[];
+    select: (select?: Record<string, string[]>) => Collection<any>;
+    snakeCase: (attributeName: string) => string;
+};
+export type BaseModelClassType = typeof import("./base-model.js").default & BaseModelStaticMethods;
+export type ModelCommandDescriptor = {
+    args?: ModelDataMap | FormData | HTMLFormElement;
+    collectionName: string;
+    command: string;
+    primaryKey?: ModelIdentifier;
+    type: string;
+};
+export type ModelCommandOptions = {
+    cacheResponse?: boolean;
+    forceHttp?: boolean;
+    form?: HTMLFormElement;
+    instant?: boolean;
+};
+export type ModelCommandResponse = {
+    errors?: ValidationResponseErrors;
+    model?: {
+        abilities: ModelAbilityMap;
+        changes: ModelDataMap;
+        collection: Collection<any>;
+        _identifierKey: string | number;
+        _markedForDestruction: boolean;
+        modelData: ModelDataMap;
+        newRecord: boolean;
+        previousModelData: any;
+        preloadedRelationships: PreloadedRelationshipMap;
+        relationshipsCache: LoadedRelationshipMap;
+        relationships: LoadedRelationshipMap;
+        uniqueKeyValue: number;
+        /**
+         * @param {ModelDataMap} newAttributes
+         * @returns {void}
+         */
+        assignAttributes(newAttributes: ModelDataMap): void;
+        /** @returns {ModelDataMap} */
+        attributes(): ModelDataMap;
+        /**
+         * @param {string} givenAbilityName
+         * @returns {boolean}
+         */
+        can(givenAbilityName: string): boolean;
+        /** @returns {BaseModel} */
+        clone(): /*elided*/ any;
+        /** @returns {number | string} */
+        cacheKey(): number | string;
+        /** @returns {string} */
+        localCacheKey(): string;
+        /** @returns {string} */
+        fullCacheKey(): string;
+        /**
+         * @param {ModelDataMap} [attributes]
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{
+         *   model: BaseModel,
+         *   response: ModelCommandResponse
+         * }>}
+         */
+        create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+         */
+        createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /** @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>} */
+        destroy(): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {string[]} listOfAbilities
+         * @returns {Promise<void>}
+         */
+        ensureAbilities(listOfAbilities: string[]): Promise<void>;
+        /** @returns {ModelDataMap} */
+        getAttributes(): ModelDataMap;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {never}
+         */
+        handleResponseError(response: ModelCommandResponse): never;
+        /** @returns {number | string} */
+        identifierKey(): number | string;
+        /**
+         * @param {string} associationName
+         * @returns {boolean}
+         */
+        isAssociationLoaded(associationName: string): boolean;
+        /**
+         * @param {string} associationNameUnderscore
+         * @returns {boolean}
+         */
+        isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+        /**
+         * @param {string} associationName
+         * @returns {boolean}
+         */
+        isAssociationPresent(associationName: string): boolean;
+        /**
+         * @param {string} associationName
+         * @returns {Promise<LoadedRelationshipValue>}
+         */
+        ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+        /**
+         * @param {string} associationNameUnderscore
+         * @returns {Promise<LoadedRelationshipValue>}
+         */
+        ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        isAttributeChanged(attributeName: string): boolean;
+        /** @returns {boolean} */
+        isChanged(): boolean;
+        /** @returns {boolean} */
+        isNewRecord(): boolean;
+        /** @returns {boolean} */
+        isPersisted(): boolean;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        savedChangeToAttribute(attributeName: string): boolean;
+        /**
+         * @param {BaseModel} model
+         * @returns {void}
+         */
+        setNewModel(model: /*elided*/ any): void;
+        /**
+         * @param {BaseModel} model
+         * @returns {void}
+         */
+        setNewModelData(model: /*elided*/ any): void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /** @returns {ModelClassDataType} */
+        modelClassData(): ModelClassDataType;
+        /** @returns {Promise<void>} */
+        reload(): Promise<void>;
+        /** @returns {Promise<{model: BaseModel, response?: object}>} */
+        save(): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+         * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+         */
+        saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {ModelDataMap} [newAttributes]
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{
+         *   model: BaseModel,
+         *   response?: object
+         * }>}
+         */
+        update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {void}
+         */
+        _refreshModelFromResponse(response: ModelCommandResponse): void;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {void}
+         */
+        _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+         * @returns {Promise<{response: ModelCommandResponse, model: BaseModel}>}
+         */
+        updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            response: ModelCommandResponse;
+            model: /*elided*/ any;
+        }>;
+        /** @returns {never} */
+        isValid(): never;
+        /** @returns {Promise<{valid: boolean, errors: ValidationResponseErrors}>} */
+        isValidOnServer(): Promise<{
+            valid: boolean;
+            errors: ValidationResponseErrors;
+        }>;
+        /** @returns {BaseModelClassType} */
+        modelClass(): BaseModelClassType;
+        /**
+         * @param {string} relationshipName
+         * @param {BaseModel | BaseModel[] | null} model
+         * @returns {void}
+         */
+        preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+        /** @returns {void} */
+        markForDestruction(): void;
+        /** @returns {boolean} */
+        markedForDestruction(): boolean;
+        /** @returns {number} */
+        uniqueKey(): number;
+        /**
+         * @param {ModelCommandDescriptor} args
+         * @param {ModelCommandOptions} commandArgs
+         * @returns {import("./command-execution.js").default}
+         */
+        _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
+        /**
+         * @param {string} attributeName
+         * @returns {ModelValue | null | undefined}
+         */
+        readAttribute(attributeName: string): ModelValue | null | undefined;
+        /**
+         * @param {string} attributeName
+         * @returns {ModelValue | null | undefined}
+         */
+        readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        isAttributeLoaded(attributeName: string): boolean;
+        /**
+         * @param {ModelValue | null | undefined} value
+         * @returns {boolean}
+         */
+        _isPresent(value: ModelValue | null | undefined): boolean;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel | null>}
+         */
+        _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @returns {BaseModel | null}
+         */
+        _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel[]>}
+         */
+        _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel | null>}
+         */
+        _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @returns {BaseModel | null}
+         */
+        _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+        /**
+         * @param {BaseModelArgsObject} [args]
+         * @returns {void}
+         */
+        _readModelDataFromArgs(args?: BaseModelArgsObject): void;
+        /**
+         * @param {{getModel: (relationshipType: string, relationshipId: number | string) => BaseModel}} preloaded
+         * @returns {void}
+         */
+        _readPreloadedRelationships(preloaded: {
+            getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+        }): void;
+        /** @returns {number | string} */
+        primaryKey(): number | string;
+    } | {
+        abilities: ModelAbilityMap;
+        changes: ModelDataMap;
+        collection: Collection<any>;
+        _identifierKey: string | number;
+        _markedForDestruction: boolean;
+        modelData: ModelDataMap;
+        newRecord: boolean;
+        previousModelData: any;
+        preloadedRelationships: PreloadedRelationshipMap;
+        relationshipsCache: LoadedRelationshipMap;
+        relationships: LoadedRelationshipMap;
+        uniqueKeyValue: number;
+        /**
+         * @param {ModelDataMap} newAttributes
+         * @returns {void}
+         */
+        assignAttributes(newAttributes: ModelDataMap): void;
+        /** @returns {ModelDataMap} */
+        attributes(): ModelDataMap;
+        /**
+         * @param {string} givenAbilityName
+         * @returns {boolean}
+         */
+        can(givenAbilityName: string): boolean;
+        /** @returns {BaseModel} */
+        clone(): /*elided*/ any;
+        /** @returns {number | string} */
+        cacheKey(): number | string;
+        /** @returns {string} */
+        localCacheKey(): string;
+        /** @returns {string} */
+        fullCacheKey(): string;
+        /**
+         * @param {ModelDataMap} [attributes]
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{
+         *   model: BaseModel,
+         *   response: ModelCommandResponse
+         * }>}
+         */
+        create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+         */
+        createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /** @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>} */
+        destroy(): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {string[]} listOfAbilities
+         * @returns {Promise<void>}
+         */
+        ensureAbilities(listOfAbilities: string[]): Promise<void>;
+        /** @returns {ModelDataMap} */
+        getAttributes(): ModelDataMap;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {never}
+         */
+        handleResponseError(response: ModelCommandResponse): never;
+        /** @returns {number | string} */
+        identifierKey(): number | string;
+        /**
+         * @param {string} associationName
+         * @returns {boolean}
+         */
+        isAssociationLoaded(associationName: string): boolean;
+        /**
+         * @param {string} associationNameUnderscore
+         * @returns {boolean}
+         */
+        isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+        /**
+         * @param {string} associationName
+         * @returns {boolean}
+         */
+        isAssociationPresent(associationName: string): boolean;
+        /**
+         * @param {string} associationName
+         * @returns {Promise<LoadedRelationshipValue>}
+         */
+        ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+        /**
+         * @param {string} associationNameUnderscore
+         * @returns {Promise<LoadedRelationshipValue>}
+         */
+        ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        isAttributeChanged(attributeName: string): boolean;
+        /** @returns {boolean} */
+        isChanged(): boolean;
+        /** @returns {boolean} */
+        isNewRecord(): boolean;
+        /** @returns {boolean} */
+        isPersisted(): boolean;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        savedChangeToAttribute(attributeName: string): boolean;
+        /**
+         * @param {BaseModel} model
+         * @returns {void}
+         */
+        setNewModel(model: /*elided*/ any): void;
+        /**
+         * @param {BaseModel} model
+         * @returns {void}
+         */
+        setNewModelData(model: /*elided*/ any): void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /** @returns {ModelClassDataType} */
+        modelClassData(): ModelClassDataType;
+        /** @returns {Promise<void>} */
+        reload(): Promise<void>;
+        /** @returns {Promise<{model: BaseModel, response?: object}>} */
+        save(): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+         * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+         */
+        saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {ModelDataMap} [newAttributes]
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{
+         *   model: BaseModel,
+         *   response?: object
+         * }>}
+         */
+        update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {void}
+         */
+        _refreshModelFromResponse(response: ModelCommandResponse): void;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {void}
+         */
+        _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+         * @returns {Promise<{response: ModelCommandResponse, model: BaseModel}>}
+         */
+        updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            response: ModelCommandResponse;
+            model: /*elided*/ any;
+        }>;
+        /** @returns {never} */
+        isValid(): never;
+        /** @returns {Promise<{valid: boolean, errors: ValidationResponseErrors}>} */
+        isValidOnServer(): Promise<{
+            valid: boolean;
+            errors: ValidationResponseErrors;
+        }>;
+        /** @returns {BaseModelClassType} */
+        modelClass(): BaseModelClassType;
+        /**
+         * @param {string} relationshipName
+         * @param {BaseModel | BaseModel[] | null} model
+         * @returns {void}
+         */
+        preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+        /** @returns {void} */
+        markForDestruction(): void;
+        /** @returns {boolean} */
+        markedForDestruction(): boolean;
+        /** @returns {number} */
+        uniqueKey(): number;
+        /**
+         * @param {ModelCommandDescriptor} args
+         * @param {ModelCommandOptions} commandArgs
+         * @returns {import("./command-execution.js").default}
+         */
+        _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
+        /**
+         * @param {string} attributeName
+         * @returns {ModelValue | null | undefined}
+         */
+        readAttribute(attributeName: string): ModelValue | null | undefined;
+        /**
+         * @param {string} attributeName
+         * @returns {ModelValue | null | undefined}
+         */
+        readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        isAttributeLoaded(attributeName: string): boolean;
+        /**
+         * @param {ModelValue | null | undefined} value
+         * @returns {boolean}
+         */
+        _isPresent(value: ModelValue | null | undefined): boolean;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel | null>}
+         */
+        _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @returns {BaseModel | null}
+         */
+        _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel[]>}
+         */
+        _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel | null>}
+         */
+        _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @returns {BaseModel | null}
+         */
+        _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+        /**
+         * @param {BaseModelArgsObject} [args]
+         * @returns {void}
+         */
+        _readModelDataFromArgs(args?: BaseModelArgsObject): void;
+        /**
+         * @param {{getModel: (relationshipType: string, relationshipId: number | string) => BaseModel}} preloaded
+         * @returns {void}
+         */
+        _readPreloadedRelationships(preloaded: {
+            getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+        }): void;
+        /** @returns {number | string} */
+        primaryKey(): number | string;
+    }[];
+    success?: boolean;
+    valid?: boolean;
+};
+export type ValidationErrorWithResponse = {
+    args?: {
+        response?: {
+            validation_errors?: import("./validation-errors.js").ValidationErrorEntryArgs[];
+        };
+    };
+};
+export type RelationshipLoadArgs = {
+    model?: {
+        abilities: ModelAbilityMap;
+        changes: ModelDataMap;
+        collection: Collection<any>;
+        _identifierKey: string | number;
+        _markedForDestruction: boolean;
+        modelData: ModelDataMap;
+        newRecord: boolean;
+        previousModelData: any;
+        preloadedRelationships: PreloadedRelationshipMap;
+        relationshipsCache: LoadedRelationshipMap;
+        relationships: LoadedRelationshipMap;
+        uniqueKeyValue: number;
+        /**
+         * @param {ModelDataMap} newAttributes
+         * @returns {void}
+         */
+        assignAttributes(newAttributes: ModelDataMap): void;
+        /** @returns {ModelDataMap} */
+        attributes(): ModelDataMap;
+        /**
+         * @param {string} givenAbilityName
+         * @returns {boolean}
+         */
+        can(givenAbilityName: string): boolean;
+        /** @returns {BaseModel} */
+        clone(): /*elided*/ any;
+        /** @returns {number | string} */
+        cacheKey(): number | string;
+        /** @returns {string} */
+        localCacheKey(): string;
+        /** @returns {string} */
+        fullCacheKey(): string;
+        /**
+         * @param {ModelDataMap} [attributes]
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{
+         *   model: BaseModel,
+         *   response: ModelCommandResponse
+         * }>}
+         */
+        create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+         */
+        createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /** @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>} */
+        destroy(): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {string[]} listOfAbilities
+         * @returns {Promise<void>}
+         */
+        ensureAbilities(listOfAbilities: string[]): Promise<void>;
+        /** @returns {ModelDataMap} */
+        getAttributes(): ModelDataMap;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {never}
+         */
+        handleResponseError(response: ModelCommandResponse): never;
+        /** @returns {number | string} */
+        identifierKey(): number | string;
+        /**
+         * @param {string} associationName
+         * @returns {boolean}
+         */
+        isAssociationLoaded(associationName: string): boolean;
+        /**
+         * @param {string} associationNameUnderscore
+         * @returns {boolean}
+         */
+        isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+        /**
+         * @param {string} associationName
+         * @returns {boolean}
+         */
+        isAssociationPresent(associationName: string): boolean;
+        /**
+         * @param {string} associationName
+         * @returns {Promise<LoadedRelationshipValue>}
+         */
+        ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+        /**
+         * @param {string} associationNameUnderscore
+         * @returns {Promise<LoadedRelationshipValue>}
+         */
+        ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        isAttributeChanged(attributeName: string): boolean;
+        /** @returns {boolean} */
+        isChanged(): boolean;
+        /** @returns {boolean} */
+        isNewRecord(): boolean;
+        /** @returns {boolean} */
+        isPersisted(): boolean;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        savedChangeToAttribute(attributeName: string): boolean;
+        /**
+         * @param {BaseModel} model
+         * @returns {void}
+         */
+        setNewModel(model: /*elided*/ any): void;
+        /**
+         * @param {BaseModel} model
+         * @returns {void}
+         */
+        setNewModelData(model: /*elided*/ any): void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /** @returns {ModelClassDataType} */
+        modelClassData(): ModelClassDataType;
+        /** @returns {Promise<void>} */
+        reload(): Promise<void>;
+        /** @returns {Promise<{model: BaseModel, response?: object}>} */
+        save(): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+         * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+         */
+        saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {ModelDataMap} [newAttributes]
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{
+         *   model: BaseModel,
+         *   response?: object
+         * }>}
+         */
+        update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {void}
+         */
+        _refreshModelFromResponse(response: ModelCommandResponse): void;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {void}
+         */
+        _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+         * @returns {Promise<{response: ModelCommandResponse, model: BaseModel}>}
+         */
+        updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            response: ModelCommandResponse;
+            model: /*elided*/ any;
+        }>;
+        /** @returns {never} */
+        isValid(): never;
+        /** @returns {Promise<{valid: boolean, errors: ValidationResponseErrors}>} */
+        isValidOnServer(): Promise<{
+            valid: boolean;
+            errors: ValidationResponseErrors;
+        }>;
+        /** @returns {BaseModelClassType} */
+        modelClass(): BaseModelClassType;
+        /**
+         * @param {string} relationshipName
+         * @param {BaseModel | BaseModel[] | null} model
+         * @returns {void}
+         */
+        preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+        /** @returns {void} */
+        markForDestruction(): void;
+        /** @returns {boolean} */
+        markedForDestruction(): boolean;
+        /** @returns {number} */
+        uniqueKey(): number;
+        /**
+         * @param {ModelCommandDescriptor} args
+         * @param {ModelCommandOptions} commandArgs
+         * @returns {import("./command-execution.js").default}
+         */
+        _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
+        /**
+         * @param {string} attributeName
+         * @returns {ModelValue | null | undefined}
+         */
+        readAttribute(attributeName: string): ModelValue | null | undefined;
+        /**
+         * @param {string} attributeName
+         * @returns {ModelValue | null | undefined}
+         */
+        readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        isAttributeLoaded(attributeName: string): boolean;
+        /**
+         * @param {ModelValue | null | undefined} value
+         * @returns {boolean}
+         */
+        _isPresent(value: ModelValue | null | undefined): boolean;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel | null>}
+         */
+        _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @returns {BaseModel | null}
+         */
+        _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel[]>}
+         */
+        _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel | null>}
+         */
+        _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @returns {BaseModel | null}
+         */
+        _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+        /**
+         * @param {BaseModelArgsObject} [args]
+         * @returns {void}
+         */
+        _readModelDataFromArgs(args?: BaseModelArgsObject): void;
+        /**
+         * @param {{getModel: (relationshipType: string, relationshipId: number | string) => BaseModel}} preloaded
+         * @returns {void}
+         */
+        _readPreloadedRelationships(preloaded: {
+            getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+        }): void;
+        /** @returns {number | string} */
+        primaryKey(): number | string;
+    };
+    modelClass?: typeof import("./base-model.js").default;
+    reflectionName: string;
+};
+/** BaseModel. */
+declare const BaseModel: {
+    new (args?: BaseModelArgs): {
+        abilities: ModelAbilityMap;
+        changes: ModelDataMap;
+        collection: Collection<any>;
+        _identifierKey: string | number;
+        _markedForDestruction: boolean;
+        modelData: ModelDataMap;
+        newRecord: boolean;
+        previousModelData: any;
+        preloadedRelationships: PreloadedRelationshipMap;
+        relationshipsCache: LoadedRelationshipMap;
+        relationships: LoadedRelationshipMap;
+        uniqueKeyValue: number;
+        /**
+         * @param {ModelDataMap} newAttributes
+         * @returns {void}
+         */
+        assignAttributes(newAttributes: ModelDataMap): void;
+        /** @returns {ModelDataMap} */
+        attributes(): ModelDataMap;
+        /**
+         * @param {string} givenAbilityName
+         * @returns {boolean}
+         */
+        can(givenAbilityName: string): boolean;
+        /** @returns {BaseModel} */
+        clone(): /*elided*/ any;
+        /** @returns {number | string} */
+        cacheKey(): number | string;
+        /** @returns {string} */
+        localCacheKey(): string;
+        /** @returns {string} */
+        fullCacheKey(): string;
+        /**
+         * @param {ModelDataMap} [attributes]
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{
+         *   model: BaseModel,
+         *   response: ModelCommandResponse
+         * }>}
+         */
+        create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+         */
+        createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /** @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>} */
+        destroy(): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {string[]} listOfAbilities
+         * @returns {Promise<void>}
+         */
+        ensureAbilities(listOfAbilities: string[]): Promise<void>;
+        /** @returns {ModelDataMap} */
+        getAttributes(): ModelDataMap;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {never}
+         */
+        handleResponseError(response: ModelCommandResponse): never;
+        /** @returns {number | string} */
+        identifierKey(): number | string;
+        /**
+         * @param {string} associationName
+         * @returns {boolean}
+         */
+        isAssociationLoaded(associationName: string): boolean;
+        /**
+         * @param {string} associationNameUnderscore
+         * @returns {boolean}
+         */
+        isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+        /**
+         * @param {string} associationName
+         * @returns {boolean}
+         */
+        isAssociationPresent(associationName: string): boolean;
+        /**
+         * @param {string} associationName
+         * @returns {Promise<LoadedRelationshipValue>}
+         */
+        ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+        /**
+         * @param {string} associationNameUnderscore
+         * @returns {Promise<LoadedRelationshipValue>}
+         */
+        ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        isAttributeChanged(attributeName: string): boolean;
+        /** @returns {boolean} */
+        isChanged(): boolean;
+        /** @returns {boolean} */
+        isNewRecord(): boolean;
+        /** @returns {boolean} */
+        isPersisted(): boolean;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        savedChangeToAttribute(attributeName: string): boolean;
+        /**
+         * @param {BaseModel} model
+         * @returns {void}
+         */
+        setNewModel(model: /*elided*/ any): void;
+        /**
+         * @param {BaseModel} model
+         * @returns {void}
+         */
+        setNewModelData(model: /*elided*/ any): void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /** @returns {ModelClassDataType} */
+        modelClassData(): ModelClassDataType;
+        /** @returns {Promise<void>} */
+        reload(): Promise<void>;
+        /** @returns {Promise<{model: BaseModel, response?: object}>} */
+        save(): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+         * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+         */
+        saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {ModelDataMap} [newAttributes]
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{
+         *   model: BaseModel,
+         *   response?: object
+         * }>}
+         */
+        update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {void}
+         */
+        _refreshModelFromResponse(response: ModelCommandResponse): void;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {void}
+         */
+        _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+         * @returns {Promise<{response: ModelCommandResponse, model: BaseModel}>}
+         */
+        updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            response: ModelCommandResponse;
+            model: /*elided*/ any;
+        }>;
+        /** @returns {never} */
+        isValid(): never;
+        /** @returns {Promise<{valid: boolean, errors: ValidationResponseErrors}>} */
+        isValidOnServer(): Promise<{
+            valid: boolean;
+            errors: ValidationResponseErrors;
+        }>;
+        /** @returns {BaseModelClassType} */
+        modelClass(): BaseModelClassType;
+        /**
+         * @param {string} relationshipName
+         * @param {BaseModel | BaseModel[] | null} model
+         * @returns {void}
+         */
+        preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+        /** @returns {void} */
+        markForDestruction(): void;
+        /** @returns {boolean} */
+        markedForDestruction(): boolean;
+        /** @returns {number} */
+        uniqueKey(): number;
+        /**
+         * @param {ModelCommandDescriptor} args
+         * @param {ModelCommandOptions} commandArgs
+         * @returns {import("./command-execution.js").default}
+         */
+        _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
+        /**
+         * @param {string} attributeName
+         * @returns {ModelValue | null | undefined}
+         */
+        readAttribute(attributeName: string): ModelValue | null | undefined;
+        /**
+         * @param {string} attributeName
+         * @returns {ModelValue | null | undefined}
+         */
+        readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        isAttributeLoaded(attributeName: string): boolean;
+        /**
+         * @param {ModelValue | null | undefined} value
+         * @returns {boolean}
+         */
+        _isPresent(value: ModelValue | null | undefined): boolean;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel | null>}
+         */
+        _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @returns {BaseModel | null}
+         */
+        _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel[]>}
+         */
+        _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel | null>}
+         */
+        _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @returns {BaseModel | null}
+         */
+        _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+        /**
+         * @param {BaseModelArgsObject} [args]
+         * @returns {void}
+         */
+        _readModelDataFromArgs(args?: BaseModelArgsObject): void;
+        /**
+         * @param {{getModel: (relationshipType: string, relationshipId: number | string) => BaseModel}} preloaded
+         * @returns {void}
+         */
+        _readPreloadedRelationships(preloaded: {
+            getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+        }): void;
+        /** @returns {number | string} */
+        primaryKey(): number | string;
+    };
+    apiMakerType: string;
+    /** @returns {Attribute[]} */
+    attributes(): Attribute[];
+    /**
+     * @param {string} attributeName
+     * @returns {boolean}
+     */
+    hasAttribute(attributeName: string): boolean;
+    /**
+     * @interface
+     * @returns {ModelClassDataType}
+     */
+    modelClassData(): ModelClassDataType;
+    /**
+     * @param {ValidationErrors} validationErrors
+     * @returns {CustomEvent}
+     */
+    newCustomEvent(validationErrors: ValidationErrors): CustomEvent;
+    /**
+     * @param {ValidationErrors} validationErrors
+     * @param {object} [options]
+     * @param {object} [options.form]
+     * @param {boolean} [options.throwValidationError]
+     */
+    sendValidationErrorsEvent(validationErrors: ValidationErrors, options?: {
+        form?: object;
+        throwValidationError?: boolean;
+    }): void;
+    /**
+     * @param {number | string} id
+     * @returns {Promise<BaseModel>}
+     */
+    find(id: number | string): Promise<{
+        abilities: ModelAbilityMap;
+        changes: ModelDataMap;
+        collection: Collection<any>;
+        _identifierKey: string | number;
+        _markedForDestruction: boolean;
+        modelData: ModelDataMap;
+        newRecord: boolean;
+        previousModelData: any;
+        preloadedRelationships: PreloadedRelationshipMap;
+        relationshipsCache: LoadedRelationshipMap;
+        relationships: LoadedRelationshipMap;
+        uniqueKeyValue: number;
+        /**
+         * @param {ModelDataMap} newAttributes
+         * @returns {void}
+         */
+        assignAttributes(newAttributes: ModelDataMap): void;
+        /** @returns {ModelDataMap} */
+        attributes(): ModelDataMap;
+        /**
+         * @param {string} givenAbilityName
+         * @returns {boolean}
+         */
+        can(givenAbilityName: string): boolean;
+        /** @returns {BaseModel} */
+        clone(): /*elided*/ any;
+        /** @returns {number | string} */
+        cacheKey(): number | string;
+        /** @returns {string} */
+        localCacheKey(): string;
+        /** @returns {string} */
+        fullCacheKey(): string;
+        /**
+         * @param {ModelDataMap} [attributes]
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{
+         *   model: BaseModel,
+         *   response: ModelCommandResponse
+         * }>}
+         */
+        create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+         */
+        createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /** @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>} */
+        destroy(): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {string[]} listOfAbilities
+         * @returns {Promise<void>}
+         */
+        ensureAbilities(listOfAbilities: string[]): Promise<void>;
+        /** @returns {ModelDataMap} */
+        getAttributes(): ModelDataMap;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {never}
+         */
+        handleResponseError(response: ModelCommandResponse): never;
+        /** @returns {number | string} */
+        identifierKey(): number | string;
+        /**
+         * @param {string} associationName
+         * @returns {boolean}
+         */
+        isAssociationLoaded(associationName: string): boolean;
+        /**
+         * @param {string} associationNameUnderscore
+         * @returns {boolean}
+         */
+        isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+        /**
+         * @param {string} associationName
+         * @returns {boolean}
+         */
+        isAssociationPresent(associationName: string): boolean;
+        /**
+         * @param {string} associationName
+         * @returns {Promise<LoadedRelationshipValue>}
+         */
+        ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+        /**
+         * @param {string} associationNameUnderscore
+         * @returns {Promise<LoadedRelationshipValue>}
+         */
+        ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        isAttributeChanged(attributeName: string): boolean;
+        /** @returns {boolean} */
+        isChanged(): boolean;
+        /** @returns {boolean} */
+        isNewRecord(): boolean;
+        /** @returns {boolean} */
+        isPersisted(): boolean;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        savedChangeToAttribute(attributeName: string): boolean;
+        /**
+         * @param {BaseModel} model
+         * @returns {void}
+         */
+        setNewModel(model: /*elided*/ any): void;
+        /**
+         * @param {BaseModel} model
+         * @returns {void}
+         */
+        setNewModelData(model: /*elided*/ any): void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /** @returns {ModelClassDataType} */
+        modelClassData(): ModelClassDataType;
+        /** @returns {Promise<void>} */
+        reload(): Promise<void>;
+        /** @returns {Promise<{model: BaseModel, response?: object}>} */
+        save(): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+         * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+         */
+        saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {ModelDataMap} [newAttributes]
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{
+         *   model: BaseModel,
+         *   response?: object
+         * }>}
+         */
+        update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {void}
+         */
+        _refreshModelFromResponse(response: ModelCommandResponse): void;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {void}
+         */
+        _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+         * @returns {Promise<{response: ModelCommandResponse, model: BaseModel}>}
+         */
+        updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            response: ModelCommandResponse;
+            model: /*elided*/ any;
+        }>;
+        /** @returns {never} */
+        isValid(): never;
+        /** @returns {Promise<{valid: boolean, errors: ValidationResponseErrors}>} */
+        isValidOnServer(): Promise<{
+            valid: boolean;
+            errors: ValidationResponseErrors;
+        }>;
+        /** @returns {BaseModelClassType} */
+        modelClass(): BaseModelClassType;
+        /**
+         * @param {string} relationshipName
+         * @param {BaseModel | BaseModel[] | null} model
+         * @returns {void}
+         */
+        preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+        /** @returns {void} */
+        markForDestruction(): void;
+        /** @returns {boolean} */
+        markedForDestruction(): boolean;
+        /** @returns {number} */
+        uniqueKey(): number;
+        /**
+         * @param {ModelCommandDescriptor} args
+         * @param {ModelCommandOptions} commandArgs
+         * @returns {import("./command-execution.js").default}
+         */
+        _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
+        /**
+         * @param {string} attributeName
+         * @returns {ModelValue | null | undefined}
+         */
+        readAttribute(attributeName: string): ModelValue | null | undefined;
+        /**
+         * @param {string} attributeName
+         * @returns {ModelValue | null | undefined}
+         */
+        readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        isAttributeLoaded(attributeName: string): boolean;
+        /**
+         * @param {ModelValue | null | undefined} value
+         * @returns {boolean}
+         */
+        _isPresent(value: ModelValue | null | undefined): boolean;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel | null>}
+         */
+        _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @returns {BaseModel | null}
+         */
+        _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel[]>}
+         */
+        _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel | null>}
+         */
+        _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @returns {BaseModel | null}
+         */
+        _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+        /**
+         * @param {BaseModelArgsObject} [args]
+         * @returns {void}
+         */
+        _readModelDataFromArgs(args?: BaseModelArgsObject): void;
+        /**
+         * @param {{getModel: (relationshipType: string, relationshipId: number | string) => BaseModel}} preloaded
+         * @returns {void}
+         */
+        _readPreloadedRelationships(preloaded: {
+            getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+        }): void;
+        /** @returns {number | string} */
+        primaryKey(): number | string;
+    }>;
+    /**
+     * @param {ModelDataMap} findOrCreateByArgs
+     * @param {object} [args]
+     * @param {ModelDataMap} [args.additionalData]
+     * @returns {Promise<BaseModel>}
+     */
+    findOrCreateBy(findOrCreateByArgs: ModelDataMap, args?: {
+        additionalData?: ModelDataMap;
+    }): Promise<{
+        abilities: ModelAbilityMap;
+        changes: ModelDataMap;
+        collection: Collection<any>;
+        _identifierKey: string | number;
+        _markedForDestruction: boolean;
+        modelData: ModelDataMap;
+        newRecord: boolean;
+        previousModelData: any;
+        preloadedRelationships: PreloadedRelationshipMap;
+        relationshipsCache: LoadedRelationshipMap;
+        relationships: LoadedRelationshipMap;
+        uniqueKeyValue: number;
+        /**
+         * @param {ModelDataMap} newAttributes
+         * @returns {void}
+         */
+        assignAttributes(newAttributes: ModelDataMap): void;
+        /** @returns {ModelDataMap} */
+        attributes(): ModelDataMap;
+        /**
+         * @param {string} givenAbilityName
+         * @returns {boolean}
+         */
+        can(givenAbilityName: string): boolean;
+        /** @returns {BaseModel} */
+        clone(): /*elided*/ any;
+        /** @returns {number | string} */
+        cacheKey(): number | string;
+        /** @returns {string} */
+        localCacheKey(): string;
+        /** @returns {string} */
+        fullCacheKey(): string;
+        /**
+         * @param {ModelDataMap} [attributes]
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{
+         *   model: BaseModel,
+         *   response: ModelCommandResponse
+         * }>}
+         */
+        create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+         */
+        createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /** @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>} */
+        destroy(): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {string[]} listOfAbilities
+         * @returns {Promise<void>}
+         */
+        ensureAbilities(listOfAbilities: string[]): Promise<void>;
+        /** @returns {ModelDataMap} */
+        getAttributes(): ModelDataMap;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {never}
+         */
+        handleResponseError(response: ModelCommandResponse): never;
+        /** @returns {number | string} */
+        identifierKey(): number | string;
+        /**
+         * @param {string} associationName
+         * @returns {boolean}
+         */
+        isAssociationLoaded(associationName: string): boolean;
+        /**
+         * @param {string} associationNameUnderscore
+         * @returns {boolean}
+         */
+        isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+        /**
+         * @param {string} associationName
+         * @returns {boolean}
+         */
+        isAssociationPresent(associationName: string): boolean;
+        /**
+         * @param {string} associationName
+         * @returns {Promise<LoadedRelationshipValue>}
+         */
+        ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+        /**
+         * @param {string} associationNameUnderscore
+         * @returns {Promise<LoadedRelationshipValue>}
+         */
+        ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        isAttributeChanged(attributeName: string): boolean;
+        /** @returns {boolean} */
+        isChanged(): boolean;
+        /** @returns {boolean} */
+        isNewRecord(): boolean;
+        /** @returns {boolean} */
+        isPersisted(): boolean;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        savedChangeToAttribute(attributeName: string): boolean;
+        /**
+         * @param {BaseModel} model
+         * @returns {void}
+         */
+        setNewModel(model: /*elided*/ any): void;
+        /**
+         * @param {BaseModel} model
+         * @returns {void}
+         */
+        setNewModelData(model: /*elided*/ any): void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /**
+         * @param {ModelValue | null | undefined} oldValue
+         * @param {ModelValue | null | undefined} newValue
+         * @returns {boolean | void}
+         */
+        _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+        /** @returns {ModelClassDataType} */
+        modelClassData(): ModelClassDataType;
+        /** @returns {Promise<void>} */
+        reload(): Promise<void>;
+        /** @returns {Promise<{model: BaseModel, response?: object}>} */
+        save(): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+         * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+         */
+        saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            model: /*elided*/ any;
+            response: ModelCommandResponse;
+        }>;
+        /**
+         * @param {ModelDataMap} [newAttributes]
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{
+         *   model: BaseModel,
+         *   response?: object
+         * }>}
+         */
+        update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {void}
+         */
+        _refreshModelFromResponse(response: ModelCommandResponse): void;
+        /**
+         * @param {ModelCommandResponse} response
+         * @returns {void}
+         */
+        _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+        /**
+         * @param {RawDataInput} rawData
+         * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+         * @returns {Promise<{response: ModelCommandResponse, model: BaseModel}>}
+         */
+        updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            response: ModelCommandResponse;
+            model: /*elided*/ any;
+        }>;
+        /** @returns {never} */
+        isValid(): never;
+        /** @returns {Promise<{valid: boolean, errors: ValidationResponseErrors}>} */
+        isValidOnServer(): Promise<{
+            valid: boolean;
+            errors: ValidationResponseErrors;
+        }>;
+        /** @returns {BaseModelClassType} */
+        modelClass(): BaseModelClassType;
+        /**
+         * @param {string} relationshipName
+         * @param {BaseModel | BaseModel[] | null} model
+         * @returns {void}
+         */
+        preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+        /** @returns {void} */
+        markForDestruction(): void;
+        /** @returns {boolean} */
+        markedForDestruction(): boolean;
+        /** @returns {number} */
+        uniqueKey(): number;
+        /**
+         * @param {ModelCommandDescriptor} args
+         * @param {ModelCommandOptions} commandArgs
+         * @returns {import("./command-execution.js").default}
+         */
+        _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
+        /**
+         * @param {string} attributeName
+         * @returns {ModelValue | null | undefined}
+         */
+        readAttribute(attributeName: string): ModelValue | null | undefined;
+        /**
+         * @param {string} attributeName
+         * @returns {ModelValue | null | undefined}
+         */
+        readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+        /**
+         * @param {string} attributeName
+         * @returns {boolean}
+         */
+        isAttributeLoaded(attributeName: string): boolean;
+        /**
+         * @param {ModelValue | null | undefined} value
+         * @returns {boolean}
+         */
+        _isPresent(value: ModelValue | null | undefined): boolean;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel | null>}
+         */
+        _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @returns {BaseModel | null}
+         */
+        _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel[]>}
+         */
+        _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<BaseModel | null>}
+         */
+        _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+        /**
+         *
+         * @param {RelationshipLoadArgs} args
+         * @returns {BaseModel | null}
+         */
+        _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+        /**
+         * @param {BaseModelArgsObject} [args]
+         * @returns {void}
+         */
+        _readModelDataFromArgs(args?: BaseModelArgsObject): void;
+        /**
+         * @param {{getModel: (relationshipType: string, relationshipId: number | string) => BaseModel}} preloaded
+         * @returns {void}
+         */
+        _readPreloadedRelationships(preloaded: {
+            getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+        }): void;
+        /** @returns {number | string} */
+        primaryKey(): number | string;
+    }>;
+    /** @returns {ModelName} */
+    modelName(): ModelName;
+    /** @returns {string} */
+    primaryKey(): string;
+    /**
+     * @param {import("./collection.js").CollectionRansackParams} [query]
+     * @returns {import("./collection.js").default}
+     */
+    ransack(query?: import("./collection.js").CollectionRansackParams): Collection<any>;
+    /**
+     * @param {Record<string, string[]>} [select]
+     * @returns {import("./collection.js").default}
+     */
+    select(select?: Record<string, string[]>): Collection<any>;
+    /** @returns {Reflection[]} */
+    ransackableAssociations(): Reflection[];
+    /** @returns {Attribute[]} */
+    ransackableAttributes(): Attribute[];
+    /** @returns {Scope[]} */
+    ransackableScopes(): Scope[];
+    /** @returns {Reflection[]} */
+    reflections(): Reflection[];
+    /**
+     * @param {string} name
+     * @returns {Reflection}
+     */
+    reflection(name: string): Reflection;
+    /** @returns {string | undefined} */
+    _token(): string | undefined;
+    /** @returns {import("./collection.js").default} */
+    all(): Collection<any>;
+    /**
+     * @param {object} args
+     * @param {ValidationError | Error | ValidationErrorWithResponse} args.error
+     * @param {BaseModel} [args.model]
+     * @param {ParseValidationErrorsOptions} [args.options]
+     */
+    parseValidationErrors({ error, model, options }: {
+        error: ValidationError | Error | ValidationErrorWithResponse;
+        model?: {
+            abilities: ModelAbilityMap;
+            changes: ModelDataMap;
+            collection: Collection<any>;
+            _identifierKey: string | number;
+            _markedForDestruction: boolean;
+            modelData: ModelDataMap;
+            newRecord: boolean;
+            previousModelData: any;
+            preloadedRelationships: PreloadedRelationshipMap;
+            relationshipsCache: LoadedRelationshipMap;
+            relationships: LoadedRelationshipMap;
+            uniqueKeyValue: number;
+            /**
+             * @param {ModelDataMap} newAttributes
+             * @returns {void}
+             */
+            assignAttributes(newAttributes: ModelDataMap): void;
+            /** @returns {ModelDataMap} */
+            attributes(): ModelDataMap;
+            /**
+             * @param {string} givenAbilityName
+             * @returns {boolean}
+             */
+            can(givenAbilityName: string): boolean;
+            /** @returns {BaseModel} */
+            clone(): /*elided*/ any;
+            /** @returns {number | string} */
+            cacheKey(): number | string;
+            /** @returns {string} */
+            localCacheKey(): string;
+            /** @returns {string} */
+            fullCacheKey(): string;
+            /**
+             * @param {ModelDataMap} [attributes]
+             * @param {ParseValidationErrorsOptions} [options]
+             * @returns {Promise<{
+             *   model: BaseModel,
+             *   response: ModelCommandResponse
+             * }>}
+             */
+            create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+                model: /*elided*/ any;
+                response: ModelCommandResponse;
+            }>;
+            /**
+             * @param {RawDataInput} rawData
+             * @param {ParseValidationErrorsOptions} [options]
+             * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+             */
+            createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+                model: /*elided*/ any;
+                response: ModelCommandResponse;
+            }>;
+            /** @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>} */
+            destroy(): Promise<{
+                model: /*elided*/ any;
+                response: ModelCommandResponse;
+            }>;
+            /**
+             * @param {string[]} listOfAbilities
+             * @returns {Promise<void>}
+             */
+            ensureAbilities(listOfAbilities: string[]): Promise<void>;
+            /** @returns {ModelDataMap} */
+            getAttributes(): ModelDataMap;
+            /**
+             * @param {ModelCommandResponse} response
+             * @returns {never}
+             */
+            handleResponseError(response: ModelCommandResponse): never;
+            /** @returns {number | string} */
+            identifierKey(): number | string;
+            /**
+             * @param {string} associationName
+             * @returns {boolean}
+             */
+            isAssociationLoaded(associationName: string): boolean;
+            /**
+             * @param {string} associationNameUnderscore
+             * @returns {boolean}
+             */
+            isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+            /**
+             * @param {string} associationName
+             * @returns {boolean}
+             */
+            isAssociationPresent(associationName: string): boolean;
+            /**
+             * @param {string} associationName
+             * @returns {Promise<LoadedRelationshipValue>}
+             */
+            ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+            /**
+             * @param {string} associationNameUnderscore
+             * @returns {Promise<LoadedRelationshipValue>}
+             */
+            ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+            /**
+             * @param {string} attributeName
+             * @returns {boolean}
+             */
+            isAttributeChanged(attributeName: string): boolean;
+            /** @returns {boolean} */
+            isChanged(): boolean;
+            /** @returns {boolean} */
+            isNewRecord(): boolean;
+            /** @returns {boolean} */
+            isPersisted(): boolean;
+            /**
+             * @param {string} attributeName
+             * @returns {boolean}
+             */
+            savedChangeToAttribute(attributeName: string): boolean;
+            /**
+             * @param {BaseModel} model
+             * @returns {void}
+             */
+            setNewModel(model: /*elided*/ any): void;
+            /**
+             * @param {BaseModel} model
+             * @returns {void}
+             */
+            setNewModelData(model: /*elided*/ any): void;
+            /**
+             * @param {ModelValue | null | undefined} oldValue
+             * @param {ModelValue | null | undefined} newValue
+             * @returns {boolean | void}
+             */
+            _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+            /**
+             * @param {ModelValue | null | undefined} oldValue
+             * @param {ModelValue | null | undefined} newValue
+             * @returns {boolean | void}
+             */
+            _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+            /**
+             * @param {ModelValue | null | undefined} oldValue
+             * @param {ModelValue | null | undefined} newValue
+             * @returns {boolean | void}
+             */
+            _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+            /** @returns {ModelClassDataType} */
+            modelClassData(): ModelClassDataType;
+            /** @returns {Promise<void>} */
+            reload(): Promise<void>;
+            /** @returns {Promise<{model: BaseModel, response?: object}>} */
+            save(): Promise<{
+                model: /*elided*/ any;
+                response?: object;
+            }>;
+            /**
+             * @param {RawDataInput} rawData
+             * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+             * @returns {Promise<{model: BaseModel, response: ModelCommandResponse}>}
+             */
+            saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+                simpleModelErrors?: boolean;
+            }): Promise<{
+                model: /*elided*/ any;
+                response: ModelCommandResponse;
+            }>;
+            /**
+             * @param {ModelDataMap} [newAttributes]
+             * @param {ParseValidationErrorsOptions} [options]
+             * @returns {Promise<{
+             *   model: BaseModel,
+             *   response?: object
+             * }>}
+             */
+            update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+                model: /*elided*/ any;
+                response?: object;
+            }>;
+            /**
+             * @param {ModelCommandResponse} response
+             * @returns {void}
+             */
+            _refreshModelFromResponse(response: ModelCommandResponse): void;
+            /**
+             * @param {ModelCommandResponse} response
+             * @returns {void}
+             */
+            _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+            /**
+             * @param {RawDataInput} rawData
+             * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+             * @returns {Promise<{response: ModelCommandResponse, model: BaseModel}>}
+             */
+            updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+                simpleModelErrors?: boolean;
+            }): Promise<{
+                response: ModelCommandResponse;
+                model: /*elided*/ any;
+            }>;
+            /** @returns {never} */
+            isValid(): never;
+            /** @returns {Promise<{valid: boolean, errors: ValidationResponseErrors}>} */
+            isValidOnServer(): Promise<{
+                valid: boolean;
+                errors: ValidationResponseErrors;
+            }>;
+            /** @returns {BaseModelClassType} */
+            modelClass(): BaseModelClassType;
+            /**
+             * @param {string} relationshipName
+             * @param {BaseModel | BaseModel[] | null} model
+             * @returns {void}
+             */
+            preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+            /** @returns {void} */
+            markForDestruction(): void;
+            /** @returns {boolean} */
+            markedForDestruction(): boolean;
+            /** @returns {number} */
+            uniqueKey(): number;
+            /**
+             * @param {ModelCommandDescriptor} args
+             * @param {ModelCommandOptions} commandArgs
+             * @returns {import("./command-execution.js").default}
+             */
+            _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
+            /**
+             * @param {string} attributeName
+             * @returns {ModelValue | null | undefined}
+             */
+            readAttribute(attributeName: string): ModelValue | null | undefined;
+            /**
+             * @param {string} attributeName
+             * @returns {ModelValue | null | undefined}
+             */
+            readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+            /**
+             * @param {string} attributeName
+             * @returns {boolean}
+             */
+            isAttributeLoaded(attributeName: string): boolean;
+            /**
+             * @param {ModelValue | null | undefined} value
+             * @returns {boolean}
+             */
+            _isPresent(value: ModelValue | null | undefined): boolean;
+            /**
+             *
+             * @param {RelationshipLoadArgs} args
+             * @param {import("./collection.js").QueryArgsType} queryArgs
+             * @returns {Promise<BaseModel | null>}
+             */
+            _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+            /**
+             *
+             * @param {RelationshipLoadArgs} args
+             * @returns {BaseModel | null}
+             */
+            _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+            /**
+             *
+             * @param {RelationshipLoadArgs} args
+             * @param {import("./collection.js").QueryArgsType} queryArgs
+             * @returns {Promise<BaseModel[]>}
+             */
+            _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+            /**
+             *
+             * @param {RelationshipLoadArgs} args
+             * @param {import("./collection.js").QueryArgsType} queryArgs
+             * @returns {Promise<BaseModel | null>}
+             */
+            _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+            /**
+             *
+             * @param {RelationshipLoadArgs} args
+             * @returns {BaseModel | null}
+             */
+            _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+            /**
+             * @param {BaseModelArgsObject} [args]
+             * @returns {void}
+             */
+            _readModelDataFromArgs(args?: BaseModelArgsObject): void;
+            /**
+             * @param {{getModel: (relationshipType: string, relationshipId: number | string) => BaseModel}} preloaded
+             * @returns {void}
+             */
+            _readPreloadedRelationships(preloaded: {
+                getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+            }): void;
+            /** @returns {number | string} */
+            primaryKey(): number | string;
+        };
+        options?: ParseValidationErrorsOptions;
+    }): void;
+    /**
+     * @param {string} attributeName
+     * @returns {string}
+     */
+    humanAttributeName(attributeName: string): string;
+    /**
+     * @param {string} string
+     * @returns {string}
+     */
+    snakeCase(string: string): string;
+    /**
+     * @param {RawDataInput} rawData
+     * @param {object} options
+     * @returns {ModelDataMap}
+     */
+    _objectDataFromGivenRawData(rawData: RawDataInput, options: object): ModelDataMap;
+    /**
+     * @param {RawDataInput | ModelValue} value
+     * @returns {value is HTMLFormElement}
+     */
+    _isFormElement(value: RawDataInput | ModelValue): value is HTMLFormElement;
+    /**
+     * @param {ModelCommandDescriptor} args
+     * @param {ModelCommandOptions} commandArgs
+     * @returns {Promise<ModelCommandResponse>}
+     */
+    _callCollectionCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): Promise<ModelCommandResponse>;
+    /**
+     * @param {FormData | ModelDataMap} [args]
+     * @returns {FormData}
+     */
+    _postDataFromArgs(args?: FormData | ModelDataMap): FormData;
+};
 import Collection from "./collection.js";
+import Attribute from "./base-model/attribute.js";
+import ModelName from "./model-name.js";
+import Reflection from "./base-model/reflection.js";
+import Scope from "./base-model/scope.js";
+import { ValidationErrors } from "./validation-errors.js";
+import ValidationError from "./validation-error.js";
 //# sourceMappingURL=base-model.d.ts.map