@oscarpalmer/atoms 0.203.0 → 0.204.0

package/dist/color/space/hex.mjs

@@ -1,8 +1,9 @@
 import { join } from "../../internal/string/misc.mjs";
-import { COLOR_ALPHA, COLOR_DEFAULTS, COLOR_EXPRESSION, COLOR_LENGTHS, COLOR_MAX, COLOR_TYPE } from "../constants.mjs";
+import { COLOR_ALPHA, COLOR_DEFAULTS, COLOR_EXPRESSION, COLOR_LENGTHS, COLOR_MAX, COLOR_SYMBOL, COLOR_TYPE } from "../constants.mjs";
 import { getHexValue, getPercentage } from "../misc/get.mjs";
 import { isHexColor } from "../misc/is.mjs";
 import { convertRgbToHsla, convertRgbToHwba } from "./rgb.mjs";
+import { getStateValue, setStateValue } from "../misc/state.mjs";
 //#region src/color/space/hex.ts
 function convertHexToRgba(value) {
 	const normalized = getNormalizedHex(value, true);
@@ -29,6 +30,12 @@ function getColorFromHex(state, type) {
 	}
 	return state[type];
 }
+function getHexColor() {
+	return getStateValue(this, COLOR_TYPE.hex, false);
+}
+function getHexaColor() {
+	return getStateValue(this, COLOR_TYPE.hex, true);
+}
 /**
 * Get the normalized hex color from a value
 *
@@ -130,5 +137,17 @@ function hexToRgb(value) {
 function hexToRgba(value) {
 	return convertHexToRgba(value);
 }
+function setHexValue(value) {
+	setHexValueInState(this, value, false);
+}
+function setHexValueInState(instance, value, alpha) {
+	const { values } = instance[COLOR_SYMBOL];
+	if (!isHexColor(value) || !alpha && value === values.hex) return;
+	const normalized = getNormalizedHex(value, true);
+	setStateValue(instance, COLOR_TYPE.hex, normalized.slice(0, COLOR_LENGTHS.hexLong), alpha ? normalized.slice(COLOR_LENGTHS.hexLong) : void 0);
+}
+function setHexaValue(value) {
+	setHexValueInState(this, value, true);
+}
 //#endregion
-export { getColorFromHex, getNormalizedHex, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba };
+export { getColorFromHex, getHexColor, getHexaColor, getNormalizedHex, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, setHexValue, setHexaValue };

package/dist/color/space/hsl.d.mts

@@ -1,7 +1,9 @@
-import { ColorState, ColorType, HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor } from "../models.mjs";
+import { ColorState, ColorType, HSLAColor, HSLColor, HWBAColor, HWBColor, InternalColor, RGBAColor, RGBColor } from "../models.mjs";
 //#region src/color/space/hsl.d.ts
 export declare function getColorFromHsl<Type extends ColorType>(state: ColorState, type: Type): NonNullable<ColorState[Type]>;
-export declare function getHslValue(value: Record<keyof HSLColor, unknown>): HSLColor;
+export declare function getHslValue(this: InternalColor): HSLColor;
+export declare function getHslaValue(this: InternalColor): HSLAColor;
+export declare function getHslValues(value: Record<keyof HSLColor, unknown>): HSLColor;
 /**
  * Convert an _HSL(A)_ color to a hex color _(with optional alpha channel, i.e., opacity)_
  *
@@ -52,4 +54,6 @@ export declare function hslToRgb(hsl: HSLAColor | HSLColor): RGBColor;
  * @returns _RGBA_ color
  */
 export declare function hslToRgba(hsl: HSLAColor | HSLColor): RGBAColor;
+export declare function setHslValue(this: InternalColor, value: unknown): void;
+export declare function setHslaValue(this: InternalColor, value: unknown): void;
 //#endregion

package/dist/color/space/hsl.mjs

@@ -3,9 +3,10 @@ import { getAlphaValue } from "../misc/alpha.mjs";
 import { getDegrees, getHexValue, getPercentage } from "../misc/get.mjs";
 import { isHslLike } from "../misc/is.mjs";
 import { convertRgbToHex } from "./rgb.mjs";
+import { getStateValue, setStateValue } from "../misc/state.mjs";
 //#region src/color/space/hsl.ts
 function convertHslToHwba(input) {
-	let { hue, lightness, saturation } = isHslLike(input) ? getHslValue(input) : { ...COLOR_DEFAULTS.hsl };
+	let { hue, lightness, saturation } = isHslLike(input) ? getHslValues(input) : { ...COLOR_DEFAULTS.hsl };
 	lightness /= COLOR_MAX.percent;
 	saturation /= COLOR_MAX.percent;
 	const value = lightness + saturation * Math.min(lightness, 1 - lightness);
@@ -20,7 +21,7 @@ function convertHslToHwba(input) {
 	};
 }
 function convertHslToRgba(input) {
-	const hsl = isHslLike(input) ? getHslValue(input) : { ...COLOR_DEFAULTS.hsl };
+	const hsl = isHslLike(input) ? getHslValues(input) : { ...COLOR_DEFAULTS.hsl };
 	const hue = hsl.hue % COLOR_MAX.degree;
 	const saturation = hsl.saturation / COLOR_MAX.percent;
 	const lightness = hsl.lightness / COLOR_MAX.percent;
@@ -47,7 +48,13 @@ function getHexyValue(hue, lightness, saturation, value) {
 	const part = (value + hue / 30) % 12;
 	return (lightness - saturation * Math.min(lightness, 1 - lightness) * Math.max(-1, Math.min(part - 3, 9 - part, 1))) * COLOR_MAX.hex;
 }
-function getHslValue(value) {
+function getHslValue() {
+	return getStateValue(this, COLOR_TYPE.hsl, false);
+}
+function getHslaValue() {
+	return getStateValue(this, COLOR_TYPE.hsl, true);
+}
+function getHslValues(value) {
 	return {
 		hue: getDegrees(value.hue),
 		saturation: getPercentage(value.saturation),
@@ -124,5 +131,19 @@ function hslToRgb(hsl) {
 function hslToRgba(hsl) {
 	return convertHslToRgba(hsl);
 }
+function setHslValue(value) {
+	setHSLValueInState(this, value, false);
+}
+function setHSLValueInState(instance, value, alpha) {
+	if (!isHslLike(value)) return;
+	setStateValue(instance, COLOR_TYPE.hsl, {
+		hue: getDegrees(value.hue),
+		saturation: getPercentage(value.saturation),
+		lightness: getPercentage(value.lightness)
+	}, alpha ? value.alpha : void 0);
+}
+function setHslaValue(value) {
+	setHSLValueInState(this, value, true);
+}
 //#endregion
-export { getColorFromHsl, getHslValue, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba };
+export { getColorFromHsl, getHslValue, getHslValues, getHslaValue, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, setHslValue, setHslaValue };

package/dist/color/space/hwb.d.mts

@@ -1,8 +1,10 @@
-import { ColorState, ColorType, HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor } from "../models.mjs";
+import { ColorState, ColorType, HSLAColor, HSLColor, HWBAColor, HWBColor, InternalColor, RGBAColor, RGBColor } from "../models.mjs";
 //#region src/color/space/hwb.d.ts
 export declare function convertHwbToHsl(input: HWBAColor | HWBColor): HSLAColor;
 export declare function getColorFromHwb<Type extends ColorType>(state: ColorState, type: Type): NonNullable<ColorState[Type]>;
-export declare function getHwbValue(value: Record<keyof HWBColor, unknown>): HWBColor;
+export declare function getHwbValue(this: InternalColor): HWBColor;
+export declare function getHwbaValue(this: InternalColor): HWBAColor;
+export declare function getHwbValues(value: Record<keyof HWBColor, unknown>): HWBColor;
 /**
  * Convert an _HWB(A)_ color to a hex color _(with optional alpha channel, i.e., opacity)_
  *
@@ -49,4 +51,6 @@ export declare function hwbToRgb(hwb: HWBAColor | HWBColor): RGBColor;
  * @returns _RGBA_ color
  */
 export declare function hwbToRgba(hwb: HWBAColor | HWBColor): RGBAColor;
+export declare function setHwbValue(this: InternalColor, value: unknown): void;
+export declare function setHwbaValue(this: InternalColor, value: unknown): void;
 //#endregion

package/dist/color/space/hwb.mjs

@@ -4,9 +4,10 @@ import { getDegrees, getPercentage } from "../misc/get.mjs";
 import { isHwbLike } from "../misc/is.mjs";
 import { rgbToHex } from "./rgb.mjs";
 import { hslToRgb, hslToRgba } from "./hsl.mjs";
+import { getStateValue, setStateValue } from "../misc/state.mjs";
 //#region src/color/space/hwb.ts
 function convertHwbToHsl(input) {
-	let { blackness, hue, whiteness } = isHwbLike(input) ? getHwbValue(input) : COLOR_DEFAULTS.hwb;
+	let { blackness, hue, whiteness } = isHwbLike(input) ? getHwbValues(input) : COLOR_DEFAULTS.hwb;
 	blackness /= COLOR_MAX.percent;
 	whiteness /= COLOR_MAX.percent;
 	if (blackness + whiteness > 1) {
@@ -39,7 +40,13 @@ function getHwbSaturation(blackness, whiteness, lightness) {
 	if (hue <= 0) return 0;
 	return hue / Math.min(2 * lightness, 2 - 2 * lightness);
 }
-function getHwbValue(value) {
+function getHwbValue() {
+	return getStateValue(this, COLOR_TYPE.hwb, false);
+}
+function getHwbaValue() {
+	return getStateValue(this, COLOR_TYPE.hwb, true);
+}
+function getHwbValues(value) {
 	return {
 		hue: getDegrees(value.hue),
 		whiteness: getPercentage(value.whiteness),
@@ -107,5 +114,19 @@ function hwbToRgb(hwb) {
 function hwbToRgba(hwb) {
 	return hslToRgba(hwbToHsla(hwb));
 }
+function setHwbValue(value) {
+	setHwbColorValueInState(this, value, false);
+}
+function setHwbColorValueInState(instance, value, alpha) {
+	if (!isHwbLike(value)) return;
+	setStateValue(instance, COLOR_TYPE.hwb, {
+		hue: getDegrees(value.hue),
+		whiteness: getPercentage(value.whiteness),
+		blackness: getPercentage(value.blackness)
+	}, alpha ? value.alpha : void 0);
+}
+function setHwbaValue(value) {
+	setHwbColorValueInState(this, value, true);
+}
 //#endregion
-export { convertHwbToHsl, getColorFromHwb, getHwbValue, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba };
+export { convertHwbToHsl, getColorFromHwb, getHwbValue, getHwbValues, getHwbaValue, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, setHwbValue, setHwbaValue };

package/dist/color/space/rgb.d.mts

@@ -1,10 +1,12 @@
-import { ColorState, ColorType, HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor } from "../models.mjs";
+import { ColorState, ColorType, HSLAColor, HSLColor, HWBAColor, HWBColor, InternalColor, RGBAColor, RGBColor } from "../models.mjs";
 //#region src/color/space/rgb.d.ts
 export declare function convertRgbToHex(rgb: RGBAColor | RGBColor, alpha: boolean): string;
 export declare function convertRgbToHsla(value: unknown): HSLAColor;
 export declare function convertRgbToHwba(value: unknown): HWBAColor;
 export declare function getColorFromRgb<Type extends ColorType>(state: ColorState, type: Type): NonNullable<ColorState[Type]>;
-export declare function getRgbValue(value: Record<keyof RGBColor, unknown>): RGBColor;
+export declare function getRgbColor(this: InternalColor): RGBColor;
+export declare function getRgbaColor(this: InternalColor): RGBAColor;
+export declare function getRgbValues(value: Record<keyof RGBColor, unknown>): RGBColor;
 /**
  * Convert an _RGB(A)_ color to a hex color _(with optional alpha channel, i.e., opacity)_
  *
@@ -58,4 +60,6 @@ export declare function rgbToHwb(rgb: RGBAColor | RGBColor): HWBColor;
  * @returns _HWBA_ color
  */
 export declare function rgbToHwba(rgb: RGBAColor | RGBColor): HWBAColor;
+export declare function setRgbValue(this: InternalColor, value: unknown): void;
+export declare function setRgbaValue(this: InternalColor, value: unknown): void;
 //#endregion

package/dist/color/space/rgb.mjs

@@ -3,6 +3,7 @@ import { COLOR_DEFAULTS, COLOR_MAX, COLOR_TYPE } from "../constants.mjs";
 import { getAlpha, getAlphaValue } from "../misc/alpha.mjs";
 import { getHexValue } from "../misc/get.mjs";
 import { isRgbLike } from "../misc/is.mjs";
+import { getStateValue, setStateValue } from "../misc/state.mjs";
 //#region src/color/space/rgb.ts
 function convertRgbToHex(rgb, alpha) {
 	const hex = `${join([
@@ -18,7 +19,7 @@ function convertRgbToHex(rgb, alpha) {
 	return `${hex}${a}`;
 }
 function convertRgbToHsla(value) {
-	const values = getRgbValues(isRgbLike(value) ? getRgbValue(value) : { ...COLOR_DEFAULTS.rgb });
+	const values = getRgbCalculationValues(isRgbLike(value) ? getRgbValues(value) : { ...COLOR_DEFAULTS.rgb });
 	const { delta, max, min } = values;
 	const lightness = (min + max) / 2;
 	let hue = 0;
@@ -36,7 +37,7 @@ function convertRgbToHsla(value) {
 	};
 }
 function convertRgbToHwba(value) {
-	const values = getRgbValues(isRgbLike(value) ? getRgbValue(value) : { ...COLOR_DEFAULTS.rgb });
+	const values = getRgbCalculationValues(isRgbLike(value) ? getRgbValues(value) : { ...COLOR_DEFAULTS.rgb });
 	const { delta, max, min } = values;
 	let hue = 0;
 	if (delta !== 0) {
@@ -62,22 +63,7 @@ function getColorFromRgb(state, type) {
 	}
 	return state[type];
 }
-function getRgbHue(values) {
-	const { blue, delta, green, max, red } = values;
-	switch (max) {
-		case blue: return (red - green) / delta + 4;
-		case green: return (blue - red) / delta + 2;
-		default: return (green - blue) / delta + (green < blue ? 6 : 0);
-	}
-}
-function getRgbValue(value) {
-	return {
-		blue: getHexValue(value.blue),
-		green: getHexValue(value.green),
-		red: getHexValue(value.red)
-	};
-}
-function getRgbValues(rgb) {
+function getRgbCalculationValues(rgb) {
 	const blue = rgb.blue / COLOR_MAX.hex;
 	const green = rgb.green / COLOR_MAX.hex;
 	const red = rgb.red / COLOR_MAX.hex;
@@ -92,6 +78,27 @@ function getRgbValues(rgb) {
 		red
 	};
 }
+function getRgbColor() {
+	return getStateValue(this, COLOR_TYPE.rgb, false);
+}
+function getRgbaColor() {
+	return getStateValue(this, COLOR_TYPE.rgb, true);
+}
+function getRgbHue(values) {
+	const { blue, delta, green, max, red } = values;
+	switch (max) {
+		case blue: return (red - green) / delta + 4;
+		case green: return (blue - red) / delta + 2;
+		default: return (green - blue) / delta + (green < blue ? 6 : 0);
+	}
+}
+function getRgbValues(value) {
+	return {
+		blue: getHexValue(value.blue),
+		green: getHexValue(value.green),
+		red: getHexValue(value.red)
+	};
+}
 /**
 * Convert an _RGB(A)_ color to a hex color _(with optional alpha channel, i.e., opacity)_
 *
@@ -102,7 +109,7 @@ function getRgbValues(rgb) {
 * @returns Hex color string
 */
 function rgbToHex(rgb, alpha) {
-	return convertRgbToHex(isRgbLike(rgb) ? getRgbValue(rgb) : { ...COLOR_DEFAULTS.rgb }, alpha ?? false);
+	return convertRgbToHex(isRgbLike(rgb) ? getRgbValues(rgb) : { ...COLOR_DEFAULTS.rgb }, alpha ?? false);
 }
 /**
 * Convert an _RGB(A)_ color to an _HSL_ color
@@ -166,5 +173,19 @@ function rgbToHwb(rgb) {
 function rgbToHwba(rgb) {
 	return convertRgbToHwba(rgb);
 }
+function setRgbValue(value) {
+	setRgbColorValueInState(this, value, false);
+}
+function setRgbColorValueInState(instance, value, alpha) {
+	if (!isRgbLike(value)) return;
+	setStateValue(instance, COLOR_TYPE.rgb, {
+		red: getHexValue(value.red),
+		green: getHexValue(value.green),
+		blue: getHexValue(value.blue)
+	}, alpha ? value.alpha : void 0);
+}
+function setRgbaValue(value) {
+	setRgbColorValueInState(this, value, true);
+}
 //#endregion
-export { convertRgbToHex, convertRgbToHsla, convertRgbToHwba, getColorFromRgb, getRgbValue, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba };
+export { convertRgbToHex, convertRgbToHsla, convertRgbToHwba, getColorFromRgb, getRgbColor, getRgbValues, getRgbaColor, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, setRgbValue, setRgbaValue };

package/dist/function/limit.mjs

@@ -54,7 +54,5 @@ function throttle(callback, time) {
 }
 debounce.async = asyncDebounce;
 throttle.async = asyncThrottle;
-Object.defineProperty(debounce, "async", { value: asyncDebounce });
-Object.defineProperty(throttle, "async", { value: asyncThrottle });
 //#endregion
 export { asyncDebounce, asyncThrottle, debounce, throttle };

package/dist/function/once.mjs

@@ -4,7 +4,7 @@ const ONCE_NAME_ASYNC = "asyncOnce";
 const ONCE_NAME_SYNC = "once";
 const ONCE_PROPERTY = "$once";
 function AsyncOnce(callback) {
-	Object.defineProperty(this, ONCE_SYMBOL, { value: {
+	this[ONCE_SYMBOL] = {
 		callback,
 		called: false,
 		cleared: false,
@@ -12,61 +12,49 @@ function AsyncOnce(callback) {
 		finished: false,
 		items: [],
 		value: void 0
-	} });
+	};
 }
+AsyncOnce.prototype[ONCE_PROPERTY] = ONCE_NAME_ASYNC;
+AsyncOnce.prototype.clear = clearOnce;
+AsyncOnce.prototype.run = runOnceAsync;
 Object.defineProperties(AsyncOnce.prototype, {
-	[ONCE_PROPERTY]: { value: ONCE_NAME_ASYNC },
 	called: {
 		enumerable: true,
-		get() {
-			return this[ONCE_SYMBOL].called;
-		}
+		get: getOnceCalled
 	},
-	clear: { value: clearOnce },
 	cleared: {
 		enumerable: true,
-		get() {
-			return this[ONCE_SYMBOL].cleared;
-		}
+		get: getOnceCleared
 	},
 	error: {
 		enumerable: true,
-		get() {
-			return this[ONCE_SYMBOL].error;
-		}
+		get: getAsyncOnceError
 	},
 	finished: {
 		enumerable: true,
-		get() {
-			return this[ONCE_SYMBOL].finished;
-		}
-	},
-	run: { value: runOnceAsync }
+		get: getAsyncOnceFinished
+	}
 });
 function Once(callback) {
-	Object.defineProperty(this, ONCE_SYMBOL, { value: {
+	this[ONCE_SYMBOL] = {
 		callback,
 		called: false,
 		cleared: false,
 		value: void 0
-	} });
+	};
 }
+Once.prototype[ONCE_PROPERTY] = ONCE_NAME_SYNC;
+Once.prototype.clear = clearOnce;
+Once.prototype.run = runOnce;
 Object.defineProperties(Once.prototype, {
-	[ONCE_PROPERTY]: { value: ONCE_NAME_SYNC },
-	clear: { value: clearOnce },
 	called: {
 		enumerable: true,
-		get() {
-			return this[ONCE_SYMBOL].called;
-		}
+		get: getOnceCalled
 	},
 	cleared: {
 		enumerable: true,
-		get() {
-			return this[ONCE_SYMBOL].cleared;
-		}
-	},
-	run: { value: runOnce }
+		get: getOnceCleared
+	}
 });
 /**
 * Create an asynchronous function that can only be called once, rejecting or resolving the same result on subsequent calls
@@ -87,6 +75,18 @@ function clearOnce() {
 	state.cleared = true;
 	state.value = void 0;
 }
+function getAsyncOnceError() {
+	return this[ONCE_SYMBOL].error;
+}
+function getAsyncOnceFinished() {
+	return this[ONCE_SYMBOL].finished;
+}
+function getOnceCalled() {
+	return this[ONCE_SYMBOL].called;
+}
+function getOnceCleared() {
+	return this[ONCE_SYMBOL].cleared;
+}
 function handleOnceResult(state, value, error) {
 	state.error = error;
 	state.finished = true;
@@ -168,11 +168,5 @@ asyncOnce.is = isAsyncOnce;
 once.async = asyncOnce;
 once.is = isOnce;
 once.isAsync = isAsyncOnce;
-Object.defineProperty(asyncOnce, "is", { value: isAsyncOnce });
-Object.defineProperties(once, {
-	async: { value: asyncOnce },
-	is: { value: isOnce },
-	isAsync: { value: isAsyncOnce }
-});
 //#endregion
 export { asyncOnce, isAsyncOnce, isOnce, once };

package/dist/function/retry.mjs

@@ -83,6 +83,5 @@ const RETRY_ERROR_NAME = "RetryError";
 const RETRY_MESSAGE_EXPECTATION = "Retry expected a function";
 const RETRY_MESSAGE_FAILED = "Retry failed";
 retry.async = asyncRetry;
-Object.defineProperty(retry, "async", { value: asyncRetry });
 //#endregion
 export { RetryError, retry };

package/dist/index.d.mts

@@ -4019,7 +4019,7 @@ export declare function assertIs<Value>(condition: (value: unknown) => value is
  * @param error Error constructor _(defaults to `Error`)_
  * @returns _Asserter_
  */
-export declare function assertProperty<Value extends PlainObject, Path extends NestedKeys<Value>, Asserted = NestedPick<Value, Path>>(path: Path, condition: (value: NestedValue<Value, Path>) => boolean, message: string, error?: ErrorConstructor): Asserter<Asserted>;
+export declare function assertProperty<Value extends PlainObject, Path extends NestedKeys<Value>>(path: Path, condition: (value: NestedValue<Value, Path>) => boolean, message: string, error?: ErrorConstructor): Asserter<NestedPick<Value, Path>>;
 //#endregion
 //#region src/internal/function/memoize.d.ts
 /**
@@ -4260,7 +4260,7 @@ export declare namespace compare {
   var deregister: typeof deregisterComparator;
   var handler: {
     base: {
-      handlers: WeakMap<Constructor, string | GenericCallback>;
+      handlers: WeakMap<WeakKey, string | GenericCallback>;
       options: {
         callback: GenericCallback;
         method?: string;
@@ -4388,7 +4388,7 @@ export declare namespace equal {
   var deregister: typeof deregisterEqualizer;
   var handler: {
     base: {
-      handlers: WeakMap<Constructor, string | GenericCallback>;
+      handlers: WeakMap<WeakKey, string | GenericCallback>;
       options: {
         callback: GenericCallback;
         method?: string;
@@ -4596,7 +4596,7 @@ export declare function setValue<Data extends PlainObject, Path extends NestedKe
  */
 export declare function setValue<Data extends PlainObject>(data: Data, path: string, value: unknown, ignoreCase?: boolean): Data;
 //#endregion
-//#region src/internal/abort.d.ts
+//#region src/internal/aborter.d.ts
 type Aborter = {
   callback: GenericCallback;
   signal: AbortSignal;
@@ -5882,7 +5882,7 @@ export declare namespace clone {
   var deregister: typeof deregisterCloner;
   var handlers: {
     base: {
-      handlers: WeakMap<Constructor, string | GenericCallback>;
+      handlers: WeakMap<WeakKey, string | GenericCallback>;
       options: {
         callback: GenericCallback;
         method?: string;