@kaspernj/api-maker 1.0.2138 → 1.0.2141

package/build/api.js

@@ -112,7 +112,7 @@ export default class Api {
      * @returns {Promise<any>}
      */
     static async requestLocal(args) {
-        let headers = {};
+        let headers = /** @type {Record<string, string>} */ ({});
         if (args.headers) {
             headers = { ...args.headers };
         }
@@ -157,4 +157,4 @@ export default class Api {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"/src/","sources":["api.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport config from \"./config.js\"\nimport CustomError from \"./custom-error.js\" // eslint-disable-line sort-imports\nimport FormDataObjectizer from \"form-data-objectizer\"\nimport Logger from \"./logger.js\"\nimport qs from \"qs\"\nimport SessionStatusUpdater from \"./session-status-updater.js\" // eslint-disable-line sort-imports\nimport urlEncode from \"./url-encode.js\"\n\nconst logger = new Logger({name: \"ApiMaker / Api\"})\n\n// logger.setDebug(true)\n\n/**\n * Thin XMLHttpRequest wrapper used across the client to talk to the API.\n * Provides helper verbs, CSRF token handling and consistent error formatting.\n */\nexport default class Api { // eslint-disable-line padded-blocks\n\n  /**\n   * @param {string} path\n   * @param {Record<string, any>|null} [pathParams]\n   * @returns {Promise<any>}\n   */\n  static get = (path, pathParams = null) => Api.requestLocal({path, pathParams, method: \"GET\"})\n\n  /**\n   * @param {string} path\n   * @param {Record<string, any>|null} [pathParams]\n   * @returns {Promise<any>}\n   */\n  static delete = (path, pathParams = null) => Api.requestLocal({path, pathParams, method: \"DELETE\"})\n\n  /**\n   * @param {string} path\n   * @param {Record<string, any>} [data]\n   * @returns {Promise<any>}\n   */\n  static patch = (path, data = {}) => Api.requestLocal({path, data, method: \"PATCH\"})\n\n  /**\n   * @param {string} path\n   * @param {Record<string, any>} [data]\n   * @returns {Promise<any>}\n   */\n  static post = (path, data = {}) => Api.requestLocal({path, data, method: \"POST\"})\n\n  /**\n   * Performs a network request against the configured host.\n   *\n   * @param {object} args\n   * @param {any} [args.data]\n   * @param {Record<string, string>} [args.headers]\n   * @param {\"GET\"|\"POST\"|\"PATCH\"|\"PUT\"|\"DELETE\"} args.method\n   * @param {string} args.path\n   * @param {Record<string, any>|null} [args.pathParams]\n   * @returns {Promise<any>}\n   */\n  static async request({data, headers, method, path, pathParams}) {\n    let requestPath = \"\"\n    if (config.getHost()) requestPath += config.getHost()\n    requestPath += path\n\n    if (pathParams) {\n      const pathParamsString = qs.stringify(pathParams, {arrayFormat: \"brackets\", encoder: urlEncode})\n      requestPath += `?${pathParamsString}`\n    }\n\n    const xhr = new XMLHttpRequest()\n\n    xhr.open(method, requestPath, true)\n    xhr.withCredentials = true\n\n    if (headers) {\n      for (const headerName in headers) {\n        xhr.setRequestHeader(headerName, headers[headerName])\n      }\n    }\n\n    const response = await Api.executeXhr(xhr, data)\n\n    return response\n  }\n\n  /**\n   * Executes a prepared XMLHttpRequest and resolves/rejects based on status.\n   *\n   * @param {XMLHttpRequest} xhr\n   * @param {any} data\n   * @returns {Promise<any>}\n   */\n  static executeXhr(xhr, data) {\n    return new Promise((resolve, reject) => {\n      xhr.onload = () => {\n        const response = this._parseResponse(xhr)\n\n        if (xhr.status == 200) {\n          resolve(response)\n        } else {\n          // @ts-ignore Allow extra xhr on error args\n          const customError = new CustomError(`Request failed with code: ${xhr.status}`, {response, xhr})\n\n          if (data instanceof FormData) {\n            // @ts-ignore Add custom debug payload\n            customError.peakflowParameters = FormDataObjectizer.toObject(data)\n          } else {\n            // @ts-ignore Add custom debug payload\n            customError.peakflowParameters = data\n          }\n\n          reject(customError)\n        }\n      }\n\n      xhr.send(data)\n    })\n  }\n\n  /**\n   * Adds default headers (CSRF + JSON) and forwards to `request`.\n   *\n   * @param {object} args\n   * @param {Record<string, any>} [args.data]\n   * @param {Record<string, string>} [args.headers]\n   * @param {\"GET\"|\"POST\"|\"PATCH\"|\"PUT\"|\"DELETE\"} args.method\n   * @param {string} args.path\n   * @param {Record<string, any>|null} [args.pathParams]\n   * @param {any} [args.rawData]\n   * @returns {Promise<any>}\n   */\n  static async requestLocal(args) {\n    let headers = {}\n\n    if (args.headers) {\n      headers = {...args.headers}\n    }\n\n    const token = await this._token()\n\n    logger.debug(() => `Got token: ${token}`)\n\n    if (token) {\n      headers[\"X-CSRF-Token\"] = token\n    }\n\n    if (args.data) {\n      headers[\"Content-Type\"] = \"application/json\"\n      // @ts-ignore Allow string body despite data being typed as record\n      args.data = JSON.stringify(args.data)\n    }\n\n    if (args.rawData) {\n      args.data = args.rawData\n    }\n\n    return this.request({...args, headers})\n  }\n\n  /**\n   * @param {string} path\n   * @param {Record<string, any>} [data]\n   * @returns {Promise<any>}\n   */\n  static async put(path, data = {}) {\n    return this.requestLocal({path, data, method: \"PUT\"})\n  }\n\n  /** @returns {Promise<string>} */\n  static _token = async() => SessionStatusUpdater.current().getCsrfToken()\n\n  /**\n   * Parses the response body according to the response content-type.\n   *\n   * @param {XMLHttpRequest} xhr\n   * @returns {any}\n   */\n  static _parseResponse(xhr) {\n    const responseType = xhr.getResponseHeader(\"content-type\")\n\n    if (responseType && responseType.startsWith(\"application/json\")) {\n      return JSON.parse(xhr.responseText)\n    } else {\n      return xhr.responseText\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"/src/","sources":["api.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport config from \"./config.js\"\nimport CustomError from \"./custom-error.js\" // eslint-disable-line sort-imports\nimport FormDataObjectizer from \"form-data-objectizer\"\nimport Logger from \"./logger.js\"\nimport qs from \"qs\"\nimport SessionStatusUpdater from \"./session-status-updater.js\" // eslint-disable-line sort-imports\nimport urlEncode from \"./url-encode.js\"\n\nconst logger = new Logger({name: \"ApiMaker / Api\"})\n\n// logger.setDebug(true)\n\n/**\n * Thin XMLHttpRequest wrapper used across the client to talk to the API.\n * Provides helper verbs, CSRF token handling and consistent error formatting.\n */\nexport default class Api { // eslint-disable-line padded-blocks\n\n  /**\n   * @param {string} path\n   * @param {Record<string, any>|null} [pathParams]\n   * @returns {Promise<any>}\n   */\n  static get = (path, pathParams = null) => Api.requestLocal({path, pathParams, method: \"GET\"})\n\n  /**\n   * @param {string} path\n   * @param {Record<string, any>|null} [pathParams]\n   * @returns {Promise<any>}\n   */\n  static delete = (path, pathParams = null) => Api.requestLocal({path, pathParams, method: \"DELETE\"})\n\n  /**\n   * @param {string} path\n   * @param {Record<string, any>} [data]\n   * @returns {Promise<any>}\n   */\n  static patch = (path, data = {}) => Api.requestLocal({path, data, method: \"PATCH\"})\n\n  /**\n   * @param {string} path\n   * @param {Record<string, any>} [data]\n   * @returns {Promise<any>}\n   */\n  static post = (path, data = {}) => Api.requestLocal({path, data, method: \"POST\"})\n\n  /**\n   * Performs a network request against the configured host.\n   *\n   * @param {object} args\n   * @param {any} [args.data]\n   * @param {Record<string, string>} [args.headers]\n   * @param {\"GET\"|\"POST\"|\"PATCH\"|\"PUT\"|\"DELETE\"} args.method\n   * @param {string} args.path\n   * @param {Record<string, any>|null} [args.pathParams]\n   * @returns {Promise<any>}\n   */\n  static async request({data, headers, method, path, pathParams}) {\n    let requestPath = \"\"\n    if (config.getHost()) requestPath += config.getHost()\n    requestPath += path\n\n    if (pathParams) {\n      const pathParamsString = qs.stringify(pathParams, {arrayFormat: \"brackets\", encoder: urlEncode})\n      requestPath += `?${pathParamsString}`\n    }\n\n    const xhr = new XMLHttpRequest()\n\n    xhr.open(method, requestPath, true)\n    xhr.withCredentials = true\n\n    if (headers) {\n      for (const headerName in headers) {\n        xhr.setRequestHeader(headerName, headers[headerName])\n      }\n    }\n\n    const response = await Api.executeXhr(xhr, data)\n\n    return response\n  }\n\n  /**\n   * Executes a prepared XMLHttpRequest and resolves/rejects based on status.\n   *\n   * @param {XMLHttpRequest} xhr\n   * @param {any} data\n   * @returns {Promise<any>}\n   */\n  static executeXhr(xhr, data) {\n    return new Promise((resolve, reject) => {\n      xhr.onload = () => {\n        const response = this._parseResponse(xhr)\n\n        if (xhr.status == 200) {\n          resolve(response)\n        } else {\n          // @ts-ignore Allow extra xhr on error args\n          const customError = new CustomError(`Request failed with code: ${xhr.status}`, {response, xhr})\n\n          if (data instanceof FormData) {\n            // @ts-ignore Add custom debug payload\n            customError.peakflowParameters = FormDataObjectizer.toObject(data)\n          } else {\n            // @ts-ignore Add custom debug payload\n            customError.peakflowParameters = data\n          }\n\n          reject(customError)\n        }\n      }\n\n      xhr.send(data)\n    })\n  }\n\n  /**\n   * Adds default headers (CSRF + JSON) and forwards to `request`.\n   *\n   * @param {object} args\n   * @param {Record<string, any>} [args.data]\n   * @param {Record<string, string>} [args.headers]\n   * @param {\"GET\"|\"POST\"|\"PATCH\"|\"PUT\"|\"DELETE\"} args.method\n   * @param {string} args.path\n   * @param {Record<string, any>|null} [args.pathParams]\n   * @param {any} [args.rawData]\n   * @returns {Promise<any>}\n   */\n  static async requestLocal(args) {\n    let headers = /** @type {Record<string, string>} */ ({})\n\n    if (args.headers) {\n      headers = {...args.headers}\n    }\n\n    const token = await this._token()\n\n    logger.debug(() => `Got token: ${token}`)\n\n    if (token) {\n      headers[\"X-CSRF-Token\"] = token\n    }\n\n    if (args.data) {\n      headers[\"Content-Type\"] = \"application/json\"\n      // @ts-ignore Allow string body despite data being typed as record\n      args.data = JSON.stringify(args.data)\n    }\n\n    if (args.rawData) {\n      args.data = args.rawData\n    }\n\n    return this.request({...args, headers})\n  }\n\n  /**\n   * @param {string} path\n   * @param {Record<string, any>} [data]\n   * @returns {Promise<any>}\n   */\n  static async put(path, data = {}) {\n    return this.requestLocal({path, data, method: \"PUT\"})\n  }\n\n  /** @returns {Promise<string>} */\n  static _token = async() => SessionStatusUpdater.current().getCsrfToken()\n\n  /**\n   * Parses the response body according to the response content-type.\n   *\n   * @param {XMLHttpRequest} xhr\n   * @returns {any}\n   */\n  static _parseResponse(xhr) {\n    const responseType = xhr.getResponseHeader(\"content-type\")\n\n    if (responseType && responseType.startsWith(\"application/json\")) {\n      return JSON.parse(xhr.responseText)\n    } else {\n      return xhr.responseText\n    }\n  }\n}\n"]}

package/build/base-error.d.ts

@@ -22,7 +22,118 @@ export default class BaseError extends Error {
 }
 export type BaseErrorArgsType = {
     addResponseErrorsToErrorMessage?: boolean;
-    model?: import("./base-model.js").default;
+    model?: {
+        changes: {};
+        newRecord: boolean;
+        relationshipsCache: {};
+        relationships: {};
+        abilities: Record<string, any>;
+        modelData: {};
+        assignAttributes(newAttributes: Record<string, any>): void;
+        attributes(): Record<string, any>;
+        can(givenAbilityName: string): boolean;
+        clone(): /*elided*/ any;
+        cacheKey(): number | string;
+        localCacheKey(): string;
+        fullCacheKey(): string;
+        create(attributes?: Record<string, any>, options?: object): Promise<{
+            model: /*elided*/ any;
+            response: object;
+        }>;
+        createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+            model: /*elided*/ any;
+            response: any;
+        }>;
+        destroy(): Promise<{
+            model: /*elided*/ any;
+            response: object;
+        }>;
+        ensureAbilities(listOfAbilities: string[]): Promise<void>;
+        getAttributes(): Record<string, any>;
+        handleResponseError(response: object): never;
+        identifierKey(): number | string;
+        _identifierKey: string | number;
+        isAssociationLoaded(associationName: string): boolean;
+        isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+        isAssociationPresent(associationName: string): boolean;
+        ensureAssociationLoaded(associationName: string): Promise<any>;
+        ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+        isAttributeChanged(attributeName: string): boolean;
+        isChanged(): boolean;
+        isNewRecord(): boolean;
+        isPersisted(): boolean;
+        savedChangeToAttribute(attributeName: string): boolean;
+        setNewModel(model: /*elided*/ any): void;
+        setNewModelData(model: /*elided*/ any): void;
+        previousModelData: any;
+        _isDateChanged(oldValue: any, newValue: any): boolean | void;
+        _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
+        _isStringChanged(oldValue: any, newValue: any): boolean | void;
+        modelClassData(): ModelClassDataType;
+        reload(): Promise<void>;
+        save(): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        saveRaw(rawData: any, options?: {}): Promise<{
+            model: /*elided*/ any;
+            response: object;
+        }>;
+        update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        _refreshModelFromResponse(response: object): void;
+        _refreshModelDataFromResponse(response: object): void;
+        updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            response: object;
+            model: /*elided*/ any;
+        }>;
+        isValid(): never;
+        isValidOnServer(): Promise<{
+            valid: boolean;
+            errors: Record<string, any>;
+        }>;
+        modelClass(): Record<string, any>;
+        preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+        markForDestruction(): void;
+        _markedForDestruction: boolean;
+        markedForDestruction(): boolean;
+        uniqueKey(): number;
+        uniqueKeyValue: number;
+        _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
+        readAttribute(attributeName: string): any;
+        readAttributeUnderscore(attributeName: string): any;
+        isAttributeLoaded(attributeName: any): boolean;
+        _isPresent(value: any): boolean;
+        _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+        _readBelongsToReflection({ reflectionName }: {
+            modelClass: any;
+            reflectionName: string;
+        }): any | null;
+        _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
+        _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
+        _readHasOneReflection({ reflectionName }: {
+            modelClass: any;
+            reflectionName: string;
+        }): any | null;
+        _readModelDataFromArgs(args?: {
+            data?: {
+                b?: Record<string, any>;
+                a?: Record<string, any>;
+                r?: any;
+            };
+            collection?: import("./collection.js").default<any>;
+        }): void;
+        collection: import("./collection.js").default<any>;
+        preloadedRelationships: any;
+        _readPreloadedRelationships(preloaded: {
+            getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+        }): void;
+        primaryKey(): number | string;
+    };
     response: {
         validation_errors?: string[];
         errors?: import("./error-messages.js").ErrorMessagesArgsType;

package/build/base-error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base-error.d.ts","sourceRoot":"/src/","sources":["base-error.js"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AAEH;IACE,4BAAiC;IAGjC;;;OAGG;IACH,qBAHW,MAAM,SACN,iBAAiB,EAsB3B;IA1BD,qBAA0B;IAsBxB,wBAAgB;IAMlB,0BAA0B;IAC1B,iBADc,MAAM,EAAE,CAGrB;IAED,0BAA0B;IAC1B,cADc,MAAM,EAAE,CAKrB;CACF;;sCAhDa,OAAO;YACP,OAAO,iBAAiB,EAAE,OAAO;cAE5C;QAA+B,iBAAiB,GAArC,MAAM,EAAE;QACuD,MAAM,GAArE,OAAO,qBAAqB,EAAE,qBAAqB;KAAmB"}
+{"version":3,"file":"base-error.d.ts","sourceRoot":"/src/","sources":["base-error.js"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AAEH;IACE,4BAAiC;IAGjC;;;OAGG;IACH,qBAHW,MAAM,SACN,iBAAiB,EAsB3B;IA1BD,qBAA0B;IAsBxB,wBAAgB;IAMlB,0BAA0B;IAC1B,iBADc,MAAM,EAAE,CAGrB;IAED,0BAA0B;IAC1B,cADc,MAAM,EAAE,CAKrB;CACF;;sCAhDa,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAiDgprB,CAAC;;;;;;;;oBAA2iB,CAAC;;;;;6BAAypE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA9Cz2wB;QAA+B,iBAAiB,GAArC,MAAM,EAAE;QACuD,MAAM,GAArE,OAAO,qBAAqB,EAAE,qBAAqB;KAAmB"}

package/build/base-model.d.ts

@@ -0,0 +1,328 @@
+export default BaseModel;
+export type ModelClassDataType = {
+    attributes: Record<string, import("./base-model/attribute.js").AttributeArgType>;
+    camelizedLower: string;
+    className: string;
+    collectionKey: string;
+    collectionName: string;
+    i18nKey: string;
+    name: string;
+    nameDasherized: string;
+    paramKey: string;
+    pluralName: string;
+    primaryKey: string;
+    ransackable_associations: Array<Record<string, any>>;
+    ransackable_attributes: import("./base-model/attribute.js").AttributeArgType[];
+    ransackable_scopes: Array<Record<string, any>>;
+    relationships: Array<Record<string, any>>;
+};
+export type ParseValidationErrorsOptions = {
+    form?: object;
+    throwValidationError?: boolean;
+};
+export type BaseModelClassType = {
+    new (...args: Array<any>): {
+        changes: {};
+        newRecord: boolean;
+        relationshipsCache: {};
+        relationships: {};
+        abilities: Record<string, any>;
+        modelData: {};
+        /**
+         * @param {Record<string, any>} newAttributes
+         * @returns {void}
+         */
+        assignAttributes(newAttributes: Record<string, any>): void;
+        /** @returns {Record<string, any>} */
+        attributes(): Record<string, any>;
+        /**
+         * @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 {Record<string, any>} [attributes]
+         * @param {object} [options]
+         * @returns {Promise<{
+         *   model: BaseModel,
+         *   response: object
+         * }>}
+         */
+        create(attributes?: Record<string, any>, options?: object): Promise<{
+            model: /*elided*/ any;
+            response: object;
+        }>;
+        /**
+         * @param {FormData | Record<string, any>} rawData
+         * @param {object} [options]
+         */
+        createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+            model: /*elided*/ any;
+            response: any;
+        }>;
+        /** @returns {Promise<{model: BaseModel, response: object}>} */
+        destroy(): Promise<{
+            model: /*elided*/ any;
+            response: object;
+        }>;
+        /**
+         * @param {string[]} listOfAbilities
+         * @returns {Promise<void>}
+         */
+        ensureAbilities(listOfAbilities: string[]): Promise<void>;
+        /** @returns {Record<string, any>} */
+        getAttributes(): Record<string, any>;
+        /**
+         * @param {object} response
+         * @returns {never}
+         */
+        handleResponseError(response: object): never;
+        /** @returns {number | string} */
+        identifierKey(): number | string;
+        _identifierKey: string | number;
+        /**
+         * @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<any>}
+         */
+        ensureAssociationLoaded(associationName: string): Promise<any>;
+        /**
+         * @param {string} associationNameUnderscore
+         * @returns {Promise<any>}
+         */
+        ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+        /**
+         * @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;
+        previousModelData: any;
+        /**
+         * @param {any} oldValue
+         * @param {any} newValue
+         * @returns {boolean | void}
+         */
+        _isDateChanged(oldValue: any, newValue: any): boolean | void;
+        /**
+         * @param {any} oldValue
+         * @param {any} newValue
+         * @returns {boolean | void}
+         */
+        _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
+        /**
+         * @param {any} oldValue
+         * @param {any} newValue
+         * @returns {boolean | void}
+         */
+        _isStringChanged(oldValue: any, newValue: any): 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;
+        }>;
+        /** @returns {Promise<{model: BaseModel, response: object}>} */
+        saveRaw(rawData: any, options?: {}): Promise<{
+            model: /*elided*/ any;
+            response: object;
+        }>;
+        /**
+         * @param {Record<string, any>} [newAttributes]
+         * @param {ParseValidationErrorsOptions} [options]
+         * @returns {Promise<{
+         *   model: BaseModel,
+         *   response?: object
+         * }>}
+         */
+        update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        /**
+         * @param {object} response
+         * @returns {void}
+         */
+        _refreshModelFromResponse(response: object): void;
+        /**
+         * @param {object} response
+         * @returns {void}
+         */
+        _refreshModelDataFromResponse(response: object): void;
+        /**
+         * @param {FormData | Record<string, any>} rawData
+         * @param {ParseValidationErrorsOptions & {simpleModelErrors?: boolean}} [options]
+         * @returns {Promise<{response: object, model: BaseModel}>}
+         */
+        updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            response: object;
+            model: /*elided*/ any;
+        }>;
+        /** @returns {never} */
+        isValid(): never;
+        /** @returns {Promise<{valid: boolean, errors: Record<string, any>}>} */
+        isValidOnServer(): Promise<{
+            valid: boolean;
+            errors: Record<string, any>;
+        }>;
+        /** @returns {Record<string, any>} */
+        modelClass(): Record<string, any>;
+        /**
+         * @param {string} relationshipName
+         * @param {BaseModel | BaseModel[] | null} model
+         * @returns {void}
+         */
+        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>}
+         */
+        _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
+        /**
+         * @param {string} attributeName
+         * @returns {any}
+         */
+        readAttribute(attributeName: string): any;
+        /**
+         * @param {string} attributeName
+         * @returns {any}
+         */
+        readAttributeUnderscore(attributeName: string): any;
+        /** @returns {boolean} */
+        isAttributeLoaded(attributeName: any): boolean;
+        /**
+         * @param {any} value
+         * @returns {boolean}
+         */
+        _isPresent(value: any): boolean;
+        /**
+         *
+         * @param {import("./collection.js").CollectionArgsType<any>} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<any | null>}
+         */
+        _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+        /**
+         *
+         * @param {{modelClass: any, reflectionName: string}} args
+         * @returns {any | null}
+         */
+        _readBelongsToReflection({ reflectionName }: {
+            modelClass: any;
+            reflectionName: string;
+        }): any | null;
+        /**
+         *
+         * @param {import("./collection.js").CollectionArgsType<any>} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<Array<any>>}
+         */
+        _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
+        /**
+         *
+         * @param {import("./collection.js").CollectionArgsType<any>} args
+         * @param {import("./collection.js").QueryArgsType} queryArgs
+         * @returns {Promise<any>}
+         */
+        _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
+        /**
+         *
+         * @param {{modelClass: any, reflectionName: string}} args
+         * @returns {any | null}
+         */
+        _readHasOneReflection({ reflectionName }: {
+            modelClass: any;
+            reflectionName: string;
+        }): any | null;
+        /**
+         * @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]
+         * @returns {void}
+         */
+        _readModelDataFromArgs(args?: {
+            data?: {
+                b?: Record<string, any>;
+                a?: Record<string, any>;
+                r?: any;
+            };
+            collection?: Collection<any>;
+        }): void;
+        collection: Collection<any>;
+        preloadedRelationships: any;
+        /**
+         * @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;
+} & Record<string, any>;
+/** BaseModel. */
+/** @type {BaseModelClassType} */
+declare const BaseModel: BaseModelClassType;
+import Collection from "./collection.js";
+//# sourceMappingURL=base-model.d.ts.map

package/build/base-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-model.d.ts","sourceRoot":"/src/","sources":["base-model.js"],"names":[],"mappings":"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"}