@kaspernj/api-maker 1.0.2159 → 1.0.2161

package/build/api.d.ts

@@ -1,3 +1,9 @@
+/** @typedef {string | number | boolean | null | undefined} ApiPrimitive */
+/** @typedef {object | ApiPrimitive | Array<object | ApiPrimitive>} ApiJsonValue */
+/** @typedef {Record<string, ApiPrimitive>} ApiPathParams */
+/** @typedef {Record<string, ApiJsonValue>} ApiJsonData */
+/** @typedef {ApiJsonData | FormData | string | undefined} ApiRequestBody */
+/** @typedef {object | string} ApiResponseBody */
 /**
  * Thin XMLHttpRequest wrapper used across the client to talk to the API.
  * Provides helper verbs, CSRF token handling and consistent error formatting.
@@ -5,88 +11,94 @@
 export default class Api {
     /**
      * @param {string} path
-     * @param {Record<string, any>|null} [pathParams]
-     * @returns {Promise<any>}
+     * @param {ApiPathParams|null} [pathParams]
+     * @returns {Promise<ApiResponseBody>}
      */
-    static get: (path: string, pathParams?: Record<string, any> | null) => Promise<any>;
+    static get: (path: string, pathParams?: ApiPathParams | null) => Promise<ApiResponseBody>;
     /**
      * @param {string} path
-     * @param {Record<string, any>|null} [pathParams]
-     * @returns {Promise<any>}
+     * @param {ApiPathParams|null} [pathParams]
+     * @returns {Promise<ApiResponseBody>}
      */
-    static delete: (path: string, pathParams?: Record<string, any> | null) => Promise<any>;
+    static delete: (path: string, pathParams?: ApiPathParams | null) => Promise<ApiResponseBody>;
     /**
      * @param {string} path
-     * @param {Record<string, any>} [data]
-     * @returns {Promise<any>}
+     * @param {ApiJsonData} [data]
+     * @returns {Promise<ApiResponseBody>}
      */
-    static patch: (path: string, data?: Record<string, any>) => Promise<any>;
+    static patch: (path: string, data?: ApiJsonData) => Promise<ApiResponseBody>;
     /**
      * @param {string} path
-     * @param {Record<string, any>} [data]
-     * @returns {Promise<any>}
+     * @param {ApiJsonData} [data]
+     * @returns {Promise<ApiResponseBody>}
      */
-    static post: (path: string, data?: Record<string, any>) => Promise<any>;
+    static post: (path: string, data?: ApiJsonData) => Promise<ApiResponseBody>;
     /**
      * Performs a network request against the configured host.
      *
      * @param {object} args
-     * @param {any} [args.data]
+     * @param {ApiRequestBody} [args.data]
      * @param {Record<string, string>} [args.headers]
      * @param {"GET"|"POST"|"PATCH"|"PUT"|"DELETE"} args.method
      * @param {string} args.path
-     * @param {Record<string, any>|null} [args.pathParams]
-     * @returns {Promise<any>}
+     * @param {ApiPathParams|null} [args.pathParams]
+     * @returns {Promise<ApiResponseBody>}
      */
     static request({ data, headers, method, path, pathParams }: {
-        data?: any;
+        data?: ApiRequestBody;
         headers?: Record<string, string>;
         method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
         path: string;
-        pathParams?: Record<string, any> | null;
-    }): Promise<any>;
+        pathParams?: ApiPathParams | null;
+    }): Promise<ApiResponseBody>;
     /**
      * Executes a prepared XMLHttpRequest and resolves/rejects based on status.
      *
      * @param {XMLHttpRequest} xhr
-     * @param {any} data
-     * @returns {Promise<any>}
+     * @param {ApiRequestBody} data
+     * @returns {Promise<ApiResponseBody>}
      */
-    static executeXhr(xhr: XMLHttpRequest, data: any): Promise<any>;
+    static executeXhr(xhr: XMLHttpRequest, data: ApiRequestBody): Promise<ApiResponseBody>;
     /**
      * Adds default headers (CSRF + JSON) and forwards to `request`.
      *
      * @param {object} args
-     * @param {Record<string, any>} [args.data]
+     * @param {ApiJsonData} [args.data]
      * @param {Record<string, string>} [args.headers]
      * @param {"GET"|"POST"|"PATCH"|"PUT"|"DELETE"} args.method
      * @param {string} args.path
-     * @param {Record<string, any>|null} [args.pathParams]
-     * @param {any} [args.rawData]
-     * @returns {Promise<any>}
+     * @param {ApiPathParams|null} [args.pathParams]
+     * @param {ApiRequestBody} [args.rawData]
+     * @returns {Promise<ApiResponseBody>}
      */
     static requestLocal(args: {
-        data?: Record<string, any>;
+        data?: ApiJsonData;
         headers?: Record<string, string>;
         method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
         path: string;
-        pathParams?: Record<string, any> | null;
-        rawData?: any;
-    }): Promise<any>;
+        pathParams?: ApiPathParams | null;
+        rawData?: ApiRequestBody;
+    }): Promise<ApiResponseBody>;
     /**
      * @param {string} path
-     * @param {Record<string, any>} [data]
-     * @returns {Promise<any>}
+     * @param {ApiJsonData} [data]
+     * @returns {Promise<ApiResponseBody>}
      */
-    static put(path: string, data?: Record<string, any>): Promise<any>;
+    static put(path: string, data?: ApiJsonData): Promise<ApiResponseBody>;
     /** @returns {Promise<string>} */
     static _token: () => Promise<string>;
     /**
      * Parses the response body according to the response content-type.
      *
      * @param {XMLHttpRequest} xhr
-     * @returns {any}
+     * @returns {ApiResponseBody}
      */
-    static _parseResponse(xhr: XMLHttpRequest): any;
+    static _parseResponse(xhr: XMLHttpRequest): ApiResponseBody;
 }
+export type ApiPrimitive = string | number | boolean | null | undefined;
+export type ApiJsonValue = object | ApiPrimitive | Array<object | ApiPrimitive>;
+export type ApiPathParams = Record<string, ApiPrimitive>;
+export type ApiJsonData = Record<string, ApiJsonValue>;
+export type ApiRequestBody = ApiJsonData | FormData | string | undefined;
+export type ApiResponseBody = object | string;
 //# sourceMappingURL=api.d.ts.map

package/build/api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"/src/","sources":["api.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH;IAEE;;;;OAIG;IACH,aAAc,MAJH,MAIO,EAAE,aAHT,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAC,IAGM,KAFxB,OAAO,CAAC,GAAG,CAAC,CAEoE;IAE7F;;;;OAIG;IACH,gBAAiB,MAJN,MAIU,EAAE,aAHZ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAC,IAGS,KAF3B,OAAO,CAAC,GAAG,CAAC,CAE0E;IAEnG;;;;OAIG;IACH,eAAgB,MAJL,MAIS,EAAE,OAHX,MAAM,CAAC,MAAM,EAAE,GAAG,CAGE,KAFlB,OAAO,CAAC,GAAG,CAAC,CAE0D;IAEnF;;;;OAIG;IACH,cAAe,MAJJ,MAIQ,EAAE,OAHV,MAAM,CAAC,MAAM,EAAE,GAAG,CAGC,KAFjB,OAAO,CAAC,GAAG,CAAC,CAEwD;IAEjF;;;;;;;;;;OAUG;IACH,4DAPG;QAAmB,IAAI,GAAf,GAAG;QAC2B,OAAO,GAArC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;QACoB,MAAM,EAAhD,KAAK,GAAC,MAAM,GAAC,OAAO,GAAC,KAAK,GAAC,QAAQ;QACtB,IAAI,EAAjB,MAAM;QAC0B,UAAU,GAA1C,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAC,IAAI;KAChC,GAAU,OAAO,CAAC,GAAG,CAAC,CA0BxB;IAED;;;;;;OAMG;IACH,uBAJW,cAAc,QACd,GAAG,GACD,OAAO,CAAC,GAAG,CAAC,CA2BxB;IAED;;;;;;;;;;;OAWG;IACH,0BARG;QAAmC,IAAI,GAA/B,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;QACW,OAAO,GAArC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;QACoB,MAAM,EAAhD,KAAK,GAAC,MAAM,GAAC,OAAO,GAAC,KAAK,GAAC,QAAQ;QACtB,IAAI,EAAjB,MAAM;QAC0B,UAAU,GAA1C,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAC,IAAI;QACb,OAAO,GAAlB,GAAG;KACX,GAAU,OAAO,CAAC,GAAG,CAAC,CA4BxB;IAED;;;;OAIG;IACH,iBAJW,MAAM,SACN,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,OAAO,CAAC,GAAG,CAAC,CAIxB;IAED,iCAAiC;IACjC,qBADc,OAAO,CAAC,MAAM,CAAC,CAC2C;IAExE;;;;;OAKG;IACH,2BAHW,cAAc,GACZ,GAAG,CAUf;CACF"}
+{"version":3,"file":"api.d.ts","sourceRoot":"/src/","sources":["api.js"],"names":[],"mappings":"AAcA,2EAA2E;AAC3E,mFAAmF;AACnF,4DAA4D;AAC5D,0DAA0D;AAC1D,4EAA4E;AAC5E,iDAAiD;AAEjD;;;GAGG;AACH;IAEE;;;;OAIG;IACH,aAAc,MAJH,MAIO,EAAE,aAHT,aAAa,GAAC,IAGY,KAFxB,OAAO,CAAC,eAAe,CAAC,CAEwD;IAE7F;;;;OAIG;IACH,gBAAiB,MAJN,MAIU,EAAE,aAHZ,aAAa,GAAC,IAGe,KAF3B,OAAO,CAAC,eAAe,CAAC,CAE8D;IAEnG;;;;OAIG;IACH,eAAgB,MAJL,MAIS,EAAE,OAHX,WAGoB,KAFlB,OAAO,CAAC,eAAe,CAAC,CAE8C;IAEnF;;;;OAIG;IACH,cAAe,MAJJ,MAIQ,EAAE,OAHV,WAGmB,KAFjB,OAAO,CAAC,eAAe,CAAC,CAE4C;IAEjF;;;;;;;;;;OAUG;IACH,4DAPG;QAA8B,IAAI,GAA1B,cAAc;QACgB,OAAO,GAArC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;QACoB,MAAM,EAAhD,KAAK,GAAC,MAAM,GAAC,OAAO,GAAC,KAAK,GAAC,QAAQ;QACtB,IAAI,EAAjB,MAAM;QACoB,UAAU,GAApC,aAAa,GAAC,IAAI;KAC1B,GAAU,OAAO,CAAC,eAAe,CAAC,CA0BpC;IAED;;;;;;OAMG;IACH,uBAJW,cAAc,QACd,cAAc,GACZ,OAAO,CAAC,eAAe,CAAC,CA2BpC;IAED;;;;;;;;;;;OAWG;IACH,0BARG;QAA2B,IAAI,GAAvB,WAAW;QACmB,OAAO,GAArC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;QACoB,MAAM,EAAhD,KAAK,GAAC,MAAM,GAAC,OAAO,GAAC,KAAK,GAAC,QAAQ;QACtB,IAAI,EAAjB,MAAM;QACoB,UAAU,GAApC,aAAa,GAAC,IAAI;QACI,OAAO,GAA7B,cAAc;KACtB,GAAU,OAAO,CAAC,eAAe,CAAC,CA6BpC;IAED;;;;OAIG;IACH,iBAJW,MAAM,SACN,WAAW,GACT,OAAO,CAAC,eAAe,CAAC,CAIpC;IAED,iCAAiC;IACjC,qBADc,OAAO,CAAC,MAAM,CAAC,CAC2C;IAExE;;;;;OAKG;IACH,2BAHW,cAAc,GACZ,eAAe,CAU3B;CACF;2BApLa,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS;2BAC5C,MAAM,GAAG,YAAY,GAAG,KAAK,CAAC,MAAM,GAAG,YAAY,CAAC;4BACpD,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC;0BAC5B,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC;6BAC5B,WAAW,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS;8BAC3C,MAAM,GAAG,MAAM"}

package/build/api.js

@@ -8,6 +8,12 @@ import SessionStatusUpdater from "./session-status-updater.js"; // eslint-disabl
 import urlEncode from "./url-encode.js";
 const logger = new Logger({ name: "ApiMaker / Api" });
 // logger.setDebug(true)
+/** @typedef {string | number | boolean | null | undefined} ApiPrimitive */
+/** @typedef {object | ApiPrimitive | Array<object | ApiPrimitive>} ApiJsonValue */
+/** @typedef {Record<string, ApiPrimitive>} ApiPathParams */
+/** @typedef {Record<string, ApiJsonValue>} ApiJsonData */
+/** @typedef {ApiJsonData | FormData | string | undefined} ApiRequestBody */
+/** @typedef {object | string} ApiResponseBody */
 /**
  * Thin XMLHttpRequest wrapper used across the client to talk to the API.
  * Provides helper verbs, CSRF token handling and consistent error formatting.
@@ -15,38 +21,38 @@ const logger = new Logger({ name: "ApiMaker / Api" });
 export default class Api {
     /**
      * @param {string} path
-     * @param {Record<string, any>|null} [pathParams]
-     * @returns {Promise<any>}
+     * @param {ApiPathParams|null} [pathParams]
+     * @returns {Promise<ApiResponseBody>}
      */
     static get = (path, pathParams = null) => Api.requestLocal({ path, pathParams, method: "GET" });
     /**
      * @param {string} path
-     * @param {Record<string, any>|null} [pathParams]
-     * @returns {Promise<any>}
+     * @param {ApiPathParams|null} [pathParams]
+     * @returns {Promise<ApiResponseBody>}
      */
     static delete = (path, pathParams = null) => Api.requestLocal({ path, pathParams, method: "DELETE" });
     /**
      * @param {string} path
-     * @param {Record<string, any>} [data]
-     * @returns {Promise<any>}
+     * @param {ApiJsonData} [data]
+     * @returns {Promise<ApiResponseBody>}
      */
     static patch = (path, data = {}) => Api.requestLocal({ path, data, method: "PATCH" });
     /**
      * @param {string} path
-     * @param {Record<string, any>} [data]
-     * @returns {Promise<any>}
+     * @param {ApiJsonData} [data]
+     * @returns {Promise<ApiResponseBody>}
      */
     static post = (path, data = {}) => Api.requestLocal({ path, data, method: "POST" });
     /**
      * Performs a network request against the configured host.
      *
      * @param {object} args
-     * @param {any} [args.data]
+     * @param {ApiRequestBody} [args.data]
      * @param {Record<string, string>} [args.headers]
      * @param {"GET"|"POST"|"PATCH"|"PUT"|"DELETE"} args.method
      * @param {string} args.path
-     * @param {Record<string, any>|null} [args.pathParams]
-     * @returns {Promise<any>}
+     * @param {ApiPathParams|null} [args.pathParams]
+     * @returns {Promise<ApiResponseBody>}
      */
     static async request({ data, headers, method, path, pathParams }) {
         let requestPath = "";
@@ -72,8 +78,8 @@ export default class Api {
      * Executes a prepared XMLHttpRequest and resolves/rejects based on status.
      *
      * @param {XMLHttpRequest} xhr
-     * @param {any} data
-     * @returns {Promise<any>}
+     * @param {ApiRequestBody} data
+     * @returns {Promise<ApiResponseBody>}
      */
     static executeXhr(xhr, data) {
         return new Promise((resolve, reject) => {
@@ -103,16 +109,18 @@ export default class Api {
      * Adds default headers (CSRF + JSON) and forwards to `request`.
      *
      * @param {object} args
-     * @param {Record<string, any>} [args.data]
+     * @param {ApiJsonData} [args.data]
      * @param {Record<string, string>} [args.headers]
      * @param {"GET"|"POST"|"PATCH"|"PUT"|"DELETE"} args.method
      * @param {string} args.path
-     * @param {Record<string, any>|null} [args.pathParams]
-     * @param {any} [args.rawData]
-     * @returns {Promise<any>}
+     * @param {ApiPathParams|null} [args.pathParams]
+     * @param {ApiRequestBody} [args.rawData]
+     * @returns {Promise<ApiResponseBody>}
      */
     static async requestLocal(args) {
         let headers = /** @type {Record<string, string>} */ ({});
+        /** @type {ApiRequestBody} */
+        let requestBody = args.data;
         if (args.headers) {
             headers = { ...args.headers };
         }
@@ -123,18 +131,17 @@ export default class Api {
         }
         if (args.data) {
             headers["Content-Type"] = "application/json";
-            // @ts-ignore Allow string body despite data being typed as record
-            args.data = JSON.stringify(args.data);
+            requestBody = JSON.stringify(args.data);
         }
         if (args.rawData) {
-            args.data = args.rawData;
+            requestBody = args.rawData;
         }
-        return this.request({ ...args, headers });
+        return this.request({ ...args, data: requestBody, headers });
     }
     /**
      * @param {string} path
-     * @param {Record<string, any>} [data]
-     * @returns {Promise<any>}
+     * @param {ApiJsonData} [data]
+     * @returns {Promise<ApiResponseBody>}
      */
     static async put(path, data = {}) {
         return this.requestLocal({ path, data, method: "PUT" });
@@ -145,7 +152,7 @@ export default class Api {
      * Parses the response body according to the response content-type.
      *
      * @param {XMLHttpRequest} xhr
-     * @returns {any}
+     * @returns {ApiResponseBody}
      */
     static _parseResponse(xhr) {
         const responseType = xhr.getResponseHeader("content-type");
@@ -157,4 +164,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 = /** @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"]}
+//# 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/** @typedef {string | number | boolean | null | undefined} ApiPrimitive */\n/** @typedef {object | ApiPrimitive | Array<object | ApiPrimitive>} ApiJsonValue */\n/** @typedef {Record<string, ApiPrimitive>} ApiPathParams */\n/** @typedef {Record<string, ApiJsonValue>} ApiJsonData */\n/** @typedef {ApiJsonData | FormData | string | undefined} ApiRequestBody */\n/** @typedef {object | string} ApiResponseBody */\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 {ApiPathParams|null} [pathParams]\n   * @returns {Promise<ApiResponseBody>}\n   */\n  static get = (path, pathParams = null) => Api.requestLocal({path, pathParams, method: \"GET\"})\n\n  /**\n   * @param {string} path\n   * @param {ApiPathParams|null} [pathParams]\n   * @returns {Promise<ApiResponseBody>}\n   */\n  static delete = (path, pathParams = null) => Api.requestLocal({path, pathParams, method: \"DELETE\"})\n\n  /**\n   * @param {string} path\n   * @param {ApiJsonData} [data]\n   * @returns {Promise<ApiResponseBody>}\n   */\n  static patch = (path, data = {}) => Api.requestLocal({path, data, method: \"PATCH\"})\n\n  /**\n   * @param {string} path\n   * @param {ApiJsonData} [data]\n   * @returns {Promise<ApiResponseBody>}\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 {ApiRequestBody} [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 {ApiPathParams|null} [args.pathParams]\n   * @returns {Promise<ApiResponseBody>}\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 {ApiRequestBody} data\n   * @returns {Promise<ApiResponseBody>}\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 {ApiJsonData} [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 {ApiPathParams|null} [args.pathParams]\n   * @param {ApiRequestBody} [args.rawData]\n   * @returns {Promise<ApiResponseBody>}\n   */\n  static async requestLocal(args) {\n    let headers = /** @type {Record<string, string>} */ ({})\n    /** @type {ApiRequestBody} */\n    let requestBody = args.data\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      requestBody = JSON.stringify(args.data)\n    }\n\n    if (args.rawData) {\n      requestBody = args.rawData\n    }\n\n    return this.request({...args, data: requestBody, headers})\n  }\n\n  /**\n   * @param {string} path\n   * @param {ApiJsonData} [data]\n   * @returns {Promise<ApiResponseBody>}\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 {ApiResponseBody}\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/attribute-not-loaded-error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attribute-not-loaded-error.d.ts","sourceRoot":"/src/","sources":["attribute-not-loaded-error.js"],"names":[],"mappings":"AAAA,kCAAkC;AAClC;CAA6D"}
+{"version":3,"file":"attribute-not-loaded-error.d.ts","sourceRoot":"/src/","sources":["attribute-not-loaded-error.js"],"names":[],"mappings":"AACA,kCAAkC;AAClC;CAA6D"}

package/build/attribute-not-loaded-error.js

@@ -1,4 +1,5 @@
+// @ts-check
 /** Attribute-not-loaded error. */
 export default class AttributeNotLoadedError extends Error {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0cmlidXRlLW5vdC1sb2FkZWQtZXJyb3IuanMiLCJzb3VyY2VSb290IjoiL3NyYy8iLCJzb3VyY2VzIjpbImF0dHJpYnV0ZS1ub3QtbG9hZGVkLWVycm9yLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGtDQUFrQztBQUNsQyxNQUFNLENBQUMsT0FBTyxPQUFPLHVCQUF3QixTQUFRLEtBQUs7Q0FBRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKiBBdHRyaWJ1dGUtbm90LWxvYWRlZCBlcnJvci4gKi9cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIEF0dHJpYnV0ZU5vdExvYWRlZEVycm9yIGV4dGVuZHMgRXJyb3Ige31cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0cmlidXRlLW5vdC1sb2FkZWQtZXJyb3IuanMiLCJzb3VyY2VSb290IjoiL3NyYy8iLCJzb3VyY2VzIjpbImF0dHJpYnV0ZS1ub3QtbG9hZGVkLWVycm9yLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVk7QUFDWixrQ0FBa0M7QUFDbEMsTUFBTSxDQUFDLE9BQU8sT0FBTyx1QkFBd0IsU0FBUSxLQUFLO0NBQUciLCJzb3VyY2VzQ29udGVudCI6WyIvLyBAdHMtY2hlY2tcbi8qKiBBdHRyaWJ1dGUtbm90LWxvYWRlZCBlcnJvci4gKi9cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIEF0dHJpYnV0ZU5vdExvYWRlZEVycm9yIGV4dGVuZHMgRXJyb3Ige31cbiJdfQ==

package/build/base-error.d.ts

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

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAiDgprB,CAAC;;;;;;;;oBAA2iB,CAAC;;;;;6BAAypE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA9Cz2wB;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,sCAAsC;IACtC,cADc,MAAM,EAAE,GAAG,SAAS,CAOjC;CACF;;sCAlDa,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAmDi42B,CAAC;;;6BAA6O,CAAC;;;;;;;oBAAoc,CAAC;;;;;6BAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAhD3/8B;QAA+B,iBAAiB,GAArC,MAAM,EAAE;QACuD,MAAM,GAArE,OAAO,qBAAqB,EAAE,qBAAqB;KAAmB"}

package/build/base-error.js

@@ -41,11 +41,12 @@ export default class BaseError extends Error {
     errorMessages() {
         return errorMessages(this.args);
     }
-    /** @returns {string[]} */
+    /** @returns {string[] | undefined} */
     errorTypes() {
         if (typeof this.args.response == "object") {
             return digg(this, "args", "response", "errors").map((error) => digg(error, "type"));
         }
+        return undefined;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1lcnJvci5qcyIsInNvdXJjZVJvb3QiOiIvc3JjLyIsInNvdXJjZXMiOlsiYmFzZS1lcnJvci5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBRVosT0FBTyxFQUFDLEdBQUcsRUFBRSxJQUFJLEVBQUMsTUFBTSxXQUFXLENBQUE7QUFDbkMsT0FBTyxhQUFhLE1BQU0scUJBQXFCLENBQUE7QUFFL0M7Ozs7Ozs7R0FPRztBQUVILE1BQU0sQ0FBQyxPQUFPLE9BQU8sU0FBVSxTQUFRLEtBQUs7SUFDMUMsTUFBTSxDQUFDLFlBQVksR0FBRyxXQUFXLENBQUE7SUFDakMsWUFBWSxHQUFHLFdBQVcsQ0FBQTtJQUUxQjs7O09BR0c7SUFDSCxZQUFZLE9BQU8sRUFBRSxJQUFJO1FBQ3ZCLElBQUksWUFBWSxHQUFHLE9BQU8sQ0FBQTtRQUUxQixJQUFJLElBQUksSUFBSSxpQ0FBaUMsSUFBSSxJQUFJLElBQUksQ0FBQyxJQUFJLENBQUMsK0JBQStCLEVBQUUsQ0FBQztZQUMvRixZQUFZLEdBQUcsT0FBTyxDQUFBO1FBQ3hCLENBQUM7YUFBTSxDQUFDO1lBQ04sSUFBSSxPQUFPLElBQUksQ0FBQyxRQUFRLElBQUksUUFBUSxJQUFJLEdBQUcsQ0FBQyxJQUFJLEVBQUUsVUFBVSxFQUFFLFFBQVEsQ0FBQyxFQUFFLENBQUM7Z0JBQ3hFLElBQUksT0FBTyxFQUFFLENBQUM7b0JBQ1osWUFBWSxHQUFHLEdBQUcsWUFBWSxLQUFLLGFBQWEsQ0FBQyxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQTtnQkFDckUsQ0FBQztxQkFBTSxDQUFDO29CQUNOLFlBQVksR0FBRyxhQUFhLENBQUMsSUFBSSxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFBO2dCQUMvQyxDQUFDO1lBQ0gsQ0FBQztRQUNILENBQUM7UUFFRCxLQUFLLENBQUMsWUFBWSxDQUFDLENBQUE7UUFDbkIsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUE7UUFFaEIscUZBQXFGO1FBQ3JGLElBQUksS0FBSyxDQUFDLGlCQUFpQjtZQUFFLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxJQUFJLEVBQUUsU0FBUyxDQUFDLENBQUE7SUFDdkUsQ0FBQztJQUVELDBCQUEwQjtJQUMxQixhQUFhO1FBQ1gsT0FBTyxhQUFhLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFBO0lBQ2pDLENBQUM7SUFFRCwwQkFBMEI7SUFDMUIsVUFBVTtRQUNSLElBQUksT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsSUFBSSxRQUFRLEVBQUUsQ0FBQztZQUMxQyxPQUFPLElBQUksQ0FBQyxJQUFJLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxRQUFRLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsTUFBTSxDQUFDLENBQUMsQ0FBQTtRQUNyRixDQUFDO0lBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1jaGVja1xuXG5pbXBvcnQge2RpZywgZGlnZ30gZnJvbSBcImRpZ2dlcml6ZVwiXG5pbXBvcnQgZXJyb3JNZXNzYWdlcyBmcm9tIFwiLi9lcnJvci1tZXNzYWdlcy5qc1wiXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gQmFzZUVycm9yQXJnc1R5cGVcbiAqIEBwcm9wZXJ0eSB7Ym9vbGVhbn0gW2FkZFJlc3BvbnNlRXJyb3JzVG9FcnJvck1lc3NhZ2VdXG4gKiBAcHJvcGVydHkge2ltcG9ydChcIi4vYmFzZS1tb2RlbC5qc1wiKS5kZWZhdWx0fSBbbW9kZWxdXG4gKiBAcHJvcGVydHkge29iamVjdH0gcmVzcG9uc2VcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nW119IFtyZXNwb25zZS52YWxpZGF0aW9uX2Vycm9yc11cbiAqIEBwcm9wZXJ0eSB7aW1wb3J0KFwiLi9lcnJvci1tZXNzYWdlcy5qc1wiKS5FcnJvck1lc3NhZ2VzQXJnc1R5cGV9IFtyZXNwb25zZS5lcnJvcnNdXG4gKi9cblxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgQmFzZUVycm9yIGV4dGVuZHMgRXJyb3Ige1xuICBzdGF0aWMgYXBpTWFrZXJUeXBlID0gXCJCYXNlRXJyb3JcIlxuICBhcGlNYWtlclR5cGUgPSBcIkJhc2VFcnJvclwiXG5cbiAgLyoqXG4gICAqIEBwYXJhbSB7c3RyaW5nfSBtZXNzYWdlXG4gICAqIEBwYXJhbSB7QmFzZUVycm9yQXJnc1R5cGV9IFthcmdzXVxuICAgKi9cbiAgY29uc3RydWN0b3IobWVzc2FnZSwgYXJncykge1xuICAgIGxldCBtZXNzYWdlVG9Vc2UgPSBtZXNzYWdlXG5cbiAgICBpZiAoYXJncyAmJiBcImFkZFJlc3BvbnNlRXJyb3JzVG9FcnJvck1lc3NhZ2VcIiBpbiBhcmdzICYmICFhcmdzLmFkZFJlc3BvbnNlRXJyb3JzVG9FcnJvck1lc3NhZ2UpIHtcbiAgICAgIG1lc3NhZ2VUb1VzZSA9IG1lc3NhZ2VcbiAgICB9IGVsc2Uge1xuICAgICAgaWYgKHR5cGVvZiBhcmdzLnJlc3BvbnNlID09IFwib2JqZWN0XCIgJiYgZGlnKGFyZ3MsIFwicmVzcG9uc2VcIiwgXCJlcnJvcnNcIikpIHtcbiAgICAgICAgaWYgKG1lc3NhZ2UpIHtcbiAgICAgICAgICBtZXNzYWdlVG9Vc2UgPSBgJHttZXNzYWdlVG9Vc2V9OiAke2Vycm9yTWVzc2FnZXMoYXJncykuam9pbihcIi4gXCIpfWBcbiAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICBtZXNzYWdlVG9Vc2UgPSBlcnJvck1lc3NhZ2VzKGFyZ3MpLmpvaW4oXCIuIFwiKVxuICAgICAgICB9XG4gICAgICB9XG4gICAgfVxuXG4gICAgc3VwZXIobWVzc2FnZVRvVXNlKVxuICAgIHRoaXMuYXJncyA9IGFyZ3NcblxuICAgIC8vIE1haW50YWlucyBwcm9wZXIgc3RhY2sgdHJhY2UgZm9yIHdoZXJlIG91ciBlcnJvciB3YXMgdGhyb3duIChvbmx5IGF2YWlsYWJsZSBvbiBWOClcbiAgICBpZiAoRXJyb3IuY2FwdHVyZVN0YWNrVHJhY2UpIEVycm9yLmNhcHR1cmVTdGFja1RyYWNlKHRoaXMsIEJhc2VFcnJvcilcbiAgfVxuXG4gIC8qKiBAcmV0dXJucyB7c3RyaW5nW119ICovXG4gIGVycm9yTWVzc2FnZXMoKSB7XG4gICAgcmV0dXJuIGVycm9yTWVzc2FnZXModGhpcy5hcmdzKVxuICB9XG5cbiAgLyoqIEByZXR1cm5zIHtzdHJpbmdbXX0gKi9cbiAgZXJyb3JUeXBlcygpIHtcbiAgICBpZiAodHlwZW9mIHRoaXMuYXJncy5yZXNwb25zZSA9PSBcIm9iamVjdFwiKSB7XG4gICAgICByZXR1cm4gZGlnZyh0aGlzLCBcImFyZ3NcIiwgXCJyZXNwb25zZVwiLCBcImVycm9yc1wiKS5tYXAoKGVycm9yKSA9PiBkaWdnKGVycm9yLCBcInR5cGVcIikpXG4gICAgfVxuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,6 +1,6 @@
 /**
  * @typedef {object} ColumnArgType
- * @property {any} [default]
+ * @property {boolean | number | string | null} [default]
  * @property {string} [name]
  * @property {boolean} [null]
  * @property {string | null} type
@@ -13,7 +13,7 @@ export default class ApiMakerBaseModelColumn {
     getType(): string;
 }
 export type ColumnArgType = {
-    default?: any;
+    default?: boolean | number | string | null;
     name?: string;
     null?: boolean;
     type: string | null;

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

@@ -1 +1 @@
-{"version":3,"file":"column.d.ts","sourceRoot":"/src/","sources":["base-model/column.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;IACE,wCAAwC;IACxC,wBADY,aAAa,EAOxB;IADC,0BAA4B;IAI9B,wBAAwB;IACxB,WADc,MAAM,CACqB;CAC1C;;cAnBa,GAAG;WACH,MAAM;WACN,OAAO;UACP,MAAM,GAAG,IAAI"}
+{"version":3,"file":"column.d.ts","sourceRoot":"/src/","sources":["base-model/column.js"],"names":[],"mappings":"AACA;;;;;;GAMG;AAEH;IACE,wCAAwC;IACxC,wBADY,aAAa,EAOxB;IADC,0BAA4B;IAI9B,wBAAwB;IACxB,WADc,MAAM,CACqB;CAC1C;;cAnBa,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI;WAChC,MAAM;WACN,OAAO;UACP,MAAM,GAAG,IAAI"}

package/build/base-model/column.js

@@ -1,6 +1,7 @@
+// @ts-check
 /**
  * @typedef {object} ColumnArgType
- * @property {any} [default]
+ * @property {boolean | number | string | null} [default]
  * @property {string} [name]
  * @property {boolean} [null]
  * @property {string | null} type
@@ -16,4 +17,4 @@ export default class ApiMakerBaseModelColumn {
     /** @returns {string} */
     getType() { return this.columnData.type; }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sdW1uLmpzIiwic291cmNlUm9vdCI6Ii9zcmMvIiwic291cmNlcyI6WyJiYXNlLW1vZGVsL2NvbHVtbi5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxNQUFNLENBQUMsT0FBTyxPQUFPLHVCQUF1QjtJQUMxQyx3Q0FBd0M7SUFDeEMsWUFBWSxVQUFVO1FBQ3BCLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztZQUNoQixNQUFNLElBQUksS0FBSyxDQUFDLDBCQUEwQixDQUFDLENBQUE7UUFDN0MsQ0FBQztRQUVELElBQUksQ0FBQyxVQUFVLEdBQUcsVUFBVSxDQUFBO0lBQzlCLENBQUM7SUFHRCx3QkFBd0I7SUFDeEIsT0FBTyxLQUFLLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUEsQ0FBQyxDQUFDO0NBQzFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBDb2x1bW5BcmdUeXBlXG4gKiBAcHJvcGVydHkge2FueX0gW2RlZmF1bHRdXG4gKiBAcHJvcGVydHkge3N0cmluZ30gW25hbWVdXG4gKiBAcHJvcGVydHkge2Jvb2xlYW59IFtudWxsXVxuICogQHByb3BlcnR5IHtzdHJpbmcgfCBudWxsfSB0eXBlXG4gKi9cblxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgQXBpTWFrZXJCYXNlTW9kZWxDb2x1bW4ge1xuICAvKiogQHBhcmFtIHtDb2x1bW5BcmdUeXBlfSBjb2x1bW5EYXRhICovXG4gIGNvbnN0cnVjdG9yKGNvbHVtbkRhdGEpIHtcbiAgICBpZiAoIWNvbHVtbkRhdGEpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcihcIk5vIGNvbHVtbiBkYXRhIHdhcyBnaXZlblwiKVxuICAgIH1cblxuICAgIHRoaXMuY29sdW1uRGF0YSA9IGNvbHVtbkRhdGFcbiAgfVxuXG5cbiAgLyoqIEByZXR1cm5zIHtzdHJpbmd9ICovXG4gIGdldFR5cGUoKSB7IHJldHVybiB0aGlzLmNvbHVtbkRhdGEudHlwZSB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sdW1uLmpzIiwic291cmNlUm9vdCI6Ii9zcmMvIiwic291cmNlcyI6WyJiYXNlLW1vZGVsL2NvbHVtbi5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBQ1o7Ozs7OztHQU1HO0FBRUgsTUFBTSxDQUFDLE9BQU8sT0FBTyx1QkFBdUI7SUFDMUMsd0NBQXdDO0lBQ3hDLFlBQVksVUFBVTtRQUNwQixJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7WUFDaEIsTUFBTSxJQUFJLEtBQUssQ0FBQywwQkFBMEIsQ0FBQyxDQUFBO1FBQzdDLENBQUM7UUFFRCxJQUFJLENBQUMsVUFBVSxHQUFHLFVBQVUsQ0FBQTtJQUM5QixDQUFDO0lBR0Qsd0JBQXdCO0lBQ3hCLE9BQU8sS0FBSyxPQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFBLENBQUMsQ0FBQztDQUMxQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1jaGVja1xuLyoqXG4gKiBAdHlwZWRlZiB7b2JqZWN0fSBDb2x1bW5BcmdUeXBlXG4gKiBAcHJvcGVydHkge2Jvb2xlYW4gfCBudW1iZXIgfCBzdHJpbmcgfCBudWxsfSBbZGVmYXVsdF1cbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBbbmFtZV1cbiAqIEBwcm9wZXJ0eSB7Ym9vbGVhbn0gW251bGxdXG4gKiBAcHJvcGVydHkge3N0cmluZyB8IG51bGx9IHR5cGVcbiAqL1xuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBBcGlNYWtlckJhc2VNb2RlbENvbHVtbiB7XG4gIC8qKiBAcGFyYW0ge0NvbHVtbkFyZ1R5cGV9IGNvbHVtbkRhdGEgKi9cbiAgY29uc3RydWN0b3IoY29sdW1uRGF0YSkge1xuICAgIGlmICghY29sdW1uRGF0YSkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKFwiTm8gY29sdW1uIGRhdGEgd2FzIGdpdmVuXCIpXG4gICAgfVxuXG4gICAgdGhpcy5jb2x1bW5EYXRhID0gY29sdW1uRGF0YVxuICB9XG5cblxuICAvKiogQHJldHVybnMge3N0cmluZ30gKi9cbiAgZ2V0VHlwZSgpIHsgcmV0dXJuIHRoaXMuY29sdW1uRGF0YS50eXBlIH1cbn1cbiJdfQ==