@hashgraphonline/standards-sdk 0.0.73 → 0.0.75

package/dist/es/standards-sdk.es55.js

@@ -1,224 +1,796 @@
-import utils from "./standards-sdk.es41.js";
-import parseHeaders from "./standards-sdk.es89.js";
-const $internals = Symbol("internals");
-function normalizeHeader(header) {
-  return header && String(header).trim().toLowerCase();
-}
-function normalizeValue(value) {
-  if (value === false || value == null) {
-    return value;
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _options;
+import { assertPrivate } from "./standards-sdk.es37.js";
+import { defineProperties } from "./standards-sdk.es52.js";
+const _gaurd = {};
+function n(value, width) {
+  let signed = false;
+  if (width < 0) {
+    signed = true;
+    width *= -1;
   }
-  return utils.isArray(value) ? value.map(normalizeValue) : String(value);
+  return new Typed(_gaurd, `${signed ? "" : "u"}int${width}`, value, { signed, width });
 }
-function parseTokens(str) {
-  const tokens = /* @__PURE__ */ Object.create(null);
-  const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
-  let match;
-  while (match = tokensRE.exec(str)) {
-    tokens[match[1]] = match[2];
-  }
-  return tokens;
+function b(value, size) {
+  return new Typed(_gaurd, `bytes${size ? size : ""}`, value, { size });
 }
-const isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
-function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
-  if (utils.isFunction(filter)) {
-    return filter.call(this, value, header);
+const _typedSymbol = Symbol.for("_ethers_typed");
+const _Typed = class _Typed {
+  /**
+   *  @_ignore:
+   */
+  constructor(gaurd, type, value, options) {
+    /**
+     *  The type, as a Solidity-compatible type.
+     */
+    __publicField(this, "type");
+    /**
+     *  The actual value.
+     */
+    __publicField(this, "value");
+    __privateAdd(this, _options);
+    /**
+     *  @_ignore:
+     */
+    __publicField(this, "_typedSymbol");
+    if (options == null) {
+      options = null;
+    }
+    assertPrivate(_gaurd, gaurd, "Typed");
+    defineProperties(this, { _typedSymbol, type, value });
+    __privateSet(this, _options, options);
+    this.format();
   }
-  if (isHeaderNameFilter) {
-    value = header;
+  /**
+   *  Format the type as a Human-Readable type.
+   */
+  format() {
+    if (this.type === "array") {
+      throw new Error("");
+    } else if (this.type === "dynamicArray") {
+      throw new Error("");
+    } else if (this.type === "tuple") {
+      return `tuple(${this.value.map((v) => v.format()).join(",")})`;
+    }
+    return this.type;
   }
-  if (!utils.isString(value)) return;
-  if (utils.isString(filter)) {
-    return value.indexOf(filter) !== -1;
+  /**
+   *  The default value returned by this type.
+   */
+  defaultValue() {
+    return 0;
   }
-  if (utils.isRegExp(filter)) {
-    return filter.test(value);
+  /**
+   *  The minimum value for numeric types.
+   */
+  minValue() {
+    return 0;
   }
-}
-function formatHeader(header) {
-  return header.trim().toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => {
-    return char.toUpperCase() + str;
-  });
-}
-function buildAccessors(obj, header) {
-  const accessorName = utils.toCamelCase(" " + header);
-  ["get", "set", "has"].forEach((methodName) => {
-    Object.defineProperty(obj, methodName + accessorName, {
-      value: function(arg1, arg2, arg3) {
-        return this[methodName].call(this, header, arg1, arg2, arg3);
-      },
-      configurable: true
-    });
-  });
-}
-class AxiosHeaders {
-  constructor(headers) {
-    headers && this.set(headers);
-  }
-  set(header, valueOrRewrite, rewrite) {
-    const self = this;
-    function setHeader(_value, _header, _rewrite) {
-      const lHeader = normalizeHeader(_header);
-      if (!lHeader) {
-        throw new Error("header name must be a non-empty string");
-      }
-      const key = utils.findKey(self, lHeader);
-      if (!key || self[key] === void 0 || _rewrite === true || _rewrite === void 0 && self[key] !== false) {
-        self[key || _header] = normalizeValue(_value);
-      }
-    }
-    const setHeaders = (headers, _rewrite) => utils.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
-    if (utils.isPlainObject(header) || header instanceof this.constructor) {
-      setHeaders(header, valueOrRewrite);
-    } else if (utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
-      setHeaders(parseHeaders(header), valueOrRewrite);
-    } else if (utils.isHeaders(header)) {
-      for (const [key, value] of header.entries()) {
-        setHeader(value, key, rewrite);
-      }
-    } else {
-      header != null && setHeader(valueOrRewrite, header, rewrite);
-    }
-    return this;
-  }
-  get(header, parser) {
-    header = normalizeHeader(header);
-    if (header) {
-      const key = utils.findKey(this, header);
-      if (key) {
-        const value = this[key];
-        if (!parser) {
-          return value;
-        }
-        if (parser === true) {
-          return parseTokens(value);
-        }
-        if (utils.isFunction(parser)) {
-          return parser.call(this, value, key);
-        }
-        if (utils.isRegExp(parser)) {
-          return parser.exec(value);
-        }
-        throw new TypeError("parser must be boolean|regexp|function");
-      }
-    }
+  /**
+   *  The maximum value for numeric types.
+   */
+  maxValue() {
+    return 0;
+  }
+  /**
+   *  Returns ``true`` and provides a type guard is this is a [[TypedBigInt]].
+   */
+  isBigInt() {
+    return !!this.type.match(/^u?int[0-9]+$/);
+  }
+  /**
+   *  Returns ``true`` and provides a type guard is this is a [[TypedData]].
+   */
+  isData() {
+    return this.type.startsWith("bytes");
   }
-  has(header, matcher) {
-    header = normalizeHeader(header);
-    if (header) {
-      const key = utils.findKey(this, header);
-      return !!(key && this[key] !== void 0 && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
+  /**
+   *  Returns ``true`` and provides a type guard is this is a [[TypedString]].
+   */
+  isString() {
+    return this.type === "string";
+  }
+  /**
+   *  Returns the tuple name, if this is a tuple. Throws otherwise.
+   */
+  get tupleName() {
+    if (this.type !== "tuple") {
+      throw TypeError("not a tuple");
     }
-    return false;
-  }
-  delete(header, matcher) {
-    const self = this;
-    let deleted = false;
-    function deleteHeader(_header) {
-      _header = normalizeHeader(_header);
-      if (_header) {
-        const key = utils.findKey(self, _header);
-        if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {
-          delete self[key];
-          deleted = true;
-        }
-      }
+    return __privateGet(this, _options);
+  }
+  // Returns the length of this type as an array
+  // - `null` indicates the length is unforced, it could be dynamic
+  // - `-1` indicates the length is dynamic
+  // - any other value indicates it is a static array and is its length
+  /**
+   *  Returns the length of the array type or ``-1`` if it is dynamic.
+   *
+   *  Throws if the type is not an array.
+   */
+  get arrayLength() {
+    if (this.type !== "array") {
+      throw TypeError("not an array");
     }
-    if (utils.isArray(header)) {
-      header.forEach(deleteHeader);
-    } else {
-      deleteHeader(header);
+    if (__privateGet(this, _options) === true) {
+      return -1;
     }
-    return deleted;
-  }
-  clear(matcher) {
-    const keys = Object.keys(this);
-    let i = keys.length;
-    let deleted = false;
-    while (i--) {
-      const key = keys[i];
-      if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
-        delete this[key];
-        deleted = true;
-      }
+    if (__privateGet(this, _options) === false) {
+      return this.value.length;
     }
-    return deleted;
-  }
-  normalize(format) {
-    const self = this;
-    const headers = {};
-    utils.forEach(this, (value, header) => {
-      const key = utils.findKey(headers, header);
-      if (key) {
-        self[key] = normalizeValue(value);
-        delete self[header];
-        return;
-      }
-      const normalized = format ? formatHeader(header) : String(header).trim();
-      if (normalized !== header) {
-        delete self[header];
-      }
-      self[normalized] = normalizeValue(value);
-      headers[normalized] = true;
-    });
-    return this;
-  }
-  concat(...targets) {
-    return this.constructor.concat(this, ...targets);
-  }
-  toJSON(asStrings) {
-    const obj = /* @__PURE__ */ Object.create(null);
-    utils.forEach(this, (value, header) => {
-      value != null && value !== false && (obj[header] = asStrings && utils.isArray(value) ? value.join(", ") : value);
-    });
-    return obj;
-  }
-  [Symbol.iterator]() {
-    return Object.entries(this.toJSON())[Symbol.iterator]();
-  }
-  toString() {
-    return Object.entries(this.toJSON()).map(([header, value]) => header + ": " + value).join("\n");
-  }
-  get [Symbol.toStringTag]() {
-    return "AxiosHeaders";
-  }
-  static from(thing) {
-    return thing instanceof this ? thing : new this(thing);
-  }
-  static concat(first, ...targets) {
-    const computed = new this(first);
-    targets.forEach((target) => computed.set(target));
-    return computed;
-  }
-  static accessor(header) {
-    const internals = this[$internals] = this[$internals] = {
-      accessors: {}
-    };
-    const accessors = internals.accessors;
-    const prototype = this.prototype;
-    function defineAccessor(_header) {
-      const lHeader = normalizeHeader(_header);
-      if (!accessors[lHeader]) {
-        buildAccessors(prototype, _header);
-        accessors[lHeader] = true;
+    return null;
+  }
+  /**
+   *  Returns a new **Typed** of %%type%% with the %%value%%.
+   */
+  static from(type, value) {
+    return new _Typed(_gaurd, type, value);
+  }
+  /**
+   *  Return a new ``uint8`` type for %%v%%.
+   */
+  static uint8(v) {
+    return n(v, 8);
+  }
+  /**
+   *  Return a new ``uint16`` type for %%v%%.
+   */
+  static uint16(v) {
+    return n(v, 16);
+  }
+  /**
+   *  Return a new ``uint24`` type for %%v%%.
+   */
+  static uint24(v) {
+    return n(v, 24);
+  }
+  /**
+   *  Return a new ``uint32`` type for %%v%%.
+   */
+  static uint32(v) {
+    return n(v, 32);
+  }
+  /**
+   *  Return a new ``uint40`` type for %%v%%.
+   */
+  static uint40(v) {
+    return n(v, 40);
+  }
+  /**
+   *  Return a new ``uint48`` type for %%v%%.
+   */
+  static uint48(v) {
+    return n(v, 48);
+  }
+  /**
+   *  Return a new ``uint56`` type for %%v%%.
+   */
+  static uint56(v) {
+    return n(v, 56);
+  }
+  /**
+   *  Return a new ``uint64`` type for %%v%%.
+   */
+  static uint64(v) {
+    return n(v, 64);
+  }
+  /**
+   *  Return a new ``uint72`` type for %%v%%.
+   */
+  static uint72(v) {
+    return n(v, 72);
+  }
+  /**
+   *  Return a new ``uint80`` type for %%v%%.
+   */
+  static uint80(v) {
+    return n(v, 80);
+  }
+  /**
+   *  Return a new ``uint88`` type for %%v%%.
+   */
+  static uint88(v) {
+    return n(v, 88);
+  }
+  /**
+   *  Return a new ``uint96`` type for %%v%%.
+   */
+  static uint96(v) {
+    return n(v, 96);
+  }
+  /**
+   *  Return a new ``uint104`` type for %%v%%.
+   */
+  static uint104(v) {
+    return n(v, 104);
+  }
+  /**
+   *  Return a new ``uint112`` type for %%v%%.
+   */
+  static uint112(v) {
+    return n(v, 112);
+  }
+  /**
+   *  Return a new ``uint120`` type for %%v%%.
+   */
+  static uint120(v) {
+    return n(v, 120);
+  }
+  /**
+   *  Return a new ``uint128`` type for %%v%%.
+   */
+  static uint128(v) {
+    return n(v, 128);
+  }
+  /**
+   *  Return a new ``uint136`` type for %%v%%.
+   */
+  static uint136(v) {
+    return n(v, 136);
+  }
+  /**
+   *  Return a new ``uint144`` type for %%v%%.
+   */
+  static uint144(v) {
+    return n(v, 144);
+  }
+  /**
+   *  Return a new ``uint152`` type for %%v%%.
+   */
+  static uint152(v) {
+    return n(v, 152);
+  }
+  /**
+   *  Return a new ``uint160`` type for %%v%%.
+   */
+  static uint160(v) {
+    return n(v, 160);
+  }
+  /**
+   *  Return a new ``uint168`` type for %%v%%.
+   */
+  static uint168(v) {
+    return n(v, 168);
+  }
+  /**
+   *  Return a new ``uint176`` type for %%v%%.
+   */
+  static uint176(v) {
+    return n(v, 176);
+  }
+  /**
+   *  Return a new ``uint184`` type for %%v%%.
+   */
+  static uint184(v) {
+    return n(v, 184);
+  }
+  /**
+   *  Return a new ``uint192`` type for %%v%%.
+   */
+  static uint192(v) {
+    return n(v, 192);
+  }
+  /**
+   *  Return a new ``uint200`` type for %%v%%.
+   */
+  static uint200(v) {
+    return n(v, 200);
+  }
+  /**
+   *  Return a new ``uint208`` type for %%v%%.
+   */
+  static uint208(v) {
+    return n(v, 208);
+  }
+  /**
+   *  Return a new ``uint216`` type for %%v%%.
+   */
+  static uint216(v) {
+    return n(v, 216);
+  }
+  /**
+   *  Return a new ``uint224`` type for %%v%%.
+   */
+  static uint224(v) {
+    return n(v, 224);
+  }
+  /**
+   *  Return a new ``uint232`` type for %%v%%.
+   */
+  static uint232(v) {
+    return n(v, 232);
+  }
+  /**
+   *  Return a new ``uint240`` type for %%v%%.
+   */
+  static uint240(v) {
+    return n(v, 240);
+  }
+  /**
+   *  Return a new ``uint248`` type for %%v%%.
+   */
+  static uint248(v) {
+    return n(v, 248);
+  }
+  /**
+   *  Return a new ``uint256`` type for %%v%%.
+   */
+  static uint256(v) {
+    return n(v, 256);
+  }
+  /**
+   *  Return a new ``uint256`` type for %%v%%.
+   */
+  static uint(v) {
+    return n(v, 256);
+  }
+  /**
+   *  Return a new ``int8`` type for %%v%%.
+   */
+  static int8(v) {
+    return n(v, -8);
+  }
+  /**
+   *  Return a new ``int16`` type for %%v%%.
+   */
+  static int16(v) {
+    return n(v, -16);
+  }
+  /**
+   *  Return a new ``int24`` type for %%v%%.
+   */
+  static int24(v) {
+    return n(v, -24);
+  }
+  /**
+   *  Return a new ``int32`` type for %%v%%.
+   */
+  static int32(v) {
+    return n(v, -32);
+  }
+  /**
+   *  Return a new ``int40`` type for %%v%%.
+   */
+  static int40(v) {
+    return n(v, -40);
+  }
+  /**
+   *  Return a new ``int48`` type for %%v%%.
+   */
+  static int48(v) {
+    return n(v, -48);
+  }
+  /**
+   *  Return a new ``int56`` type for %%v%%.
+   */
+  static int56(v) {
+    return n(v, -56);
+  }
+  /**
+   *  Return a new ``int64`` type for %%v%%.
+   */
+  static int64(v) {
+    return n(v, -64);
+  }
+  /**
+   *  Return a new ``int72`` type for %%v%%.
+   */
+  static int72(v) {
+    return n(v, -72);
+  }
+  /**
+   *  Return a new ``int80`` type for %%v%%.
+   */
+  static int80(v) {
+    return n(v, -80);
+  }
+  /**
+   *  Return a new ``int88`` type for %%v%%.
+   */
+  static int88(v) {
+    return n(v, -88);
+  }
+  /**
+   *  Return a new ``int96`` type for %%v%%.
+   */
+  static int96(v) {
+    return n(v, -96);
+  }
+  /**
+   *  Return a new ``int104`` type for %%v%%.
+   */
+  static int104(v) {
+    return n(v, -104);
+  }
+  /**
+   *  Return a new ``int112`` type for %%v%%.
+   */
+  static int112(v) {
+    return n(v, -112);
+  }
+  /**
+   *  Return a new ``int120`` type for %%v%%.
+   */
+  static int120(v) {
+    return n(v, -120);
+  }
+  /**
+   *  Return a new ``int128`` type for %%v%%.
+   */
+  static int128(v) {
+    return n(v, -128);
+  }
+  /**
+   *  Return a new ``int136`` type for %%v%%.
+   */
+  static int136(v) {
+    return n(v, -136);
+  }
+  /**
+   *  Return a new ``int144`` type for %%v%%.
+   */
+  static int144(v) {
+    return n(v, -144);
+  }
+  /**
+   *  Return a new ``int52`` type for %%v%%.
+   */
+  static int152(v) {
+    return n(v, -152);
+  }
+  /**
+   *  Return a new ``int160`` type for %%v%%.
+   */
+  static int160(v) {
+    return n(v, -160);
+  }
+  /**
+   *  Return a new ``int168`` type for %%v%%.
+   */
+  static int168(v) {
+    return n(v, -168);
+  }
+  /**
+   *  Return a new ``int176`` type for %%v%%.
+   */
+  static int176(v) {
+    return n(v, -176);
+  }
+  /**
+   *  Return a new ``int184`` type for %%v%%.
+   */
+  static int184(v) {
+    return n(v, -184);
+  }
+  /**
+   *  Return a new ``int92`` type for %%v%%.
+   */
+  static int192(v) {
+    return n(v, -192);
+  }
+  /**
+   *  Return a new ``int200`` type for %%v%%.
+   */
+  static int200(v) {
+    return n(v, -200);
+  }
+  /**
+   *  Return a new ``int208`` type for %%v%%.
+   */
+  static int208(v) {
+    return n(v, -208);
+  }
+  /**
+   *  Return a new ``int216`` type for %%v%%.
+   */
+  static int216(v) {
+    return n(v, -216);
+  }
+  /**
+   *  Return a new ``int224`` type for %%v%%.
+   */
+  static int224(v) {
+    return n(v, -224);
+  }
+  /**
+   *  Return a new ``int232`` type for %%v%%.
+   */
+  static int232(v) {
+    return n(v, -232);
+  }
+  /**
+   *  Return a new ``int240`` type for %%v%%.
+   */
+  static int240(v) {
+    return n(v, -240);
+  }
+  /**
+   *  Return a new ``int248`` type for %%v%%.
+   */
+  static int248(v) {
+    return n(v, -248);
+  }
+  /**
+   *  Return a new ``int256`` type for %%v%%.
+   */
+  static int256(v) {
+    return n(v, -256);
+  }
+  /**
+   *  Return a new ``int256`` type for %%v%%.
+   */
+  static int(v) {
+    return n(v, -256);
+  }
+  /**
+   *  Return a new ``bytes1`` type for %%v%%.
+   */
+  static bytes1(v) {
+    return b(v, 1);
+  }
+  /**
+   *  Return a new ``bytes2`` type for %%v%%.
+   */
+  static bytes2(v) {
+    return b(v, 2);
+  }
+  /**
+   *  Return a new ``bytes3`` type for %%v%%.
+   */
+  static bytes3(v) {
+    return b(v, 3);
+  }
+  /**
+   *  Return a new ``bytes4`` type for %%v%%.
+   */
+  static bytes4(v) {
+    return b(v, 4);
+  }
+  /**
+   *  Return a new ``bytes5`` type for %%v%%.
+   */
+  static bytes5(v) {
+    return b(v, 5);
+  }
+  /**
+   *  Return a new ``bytes6`` type for %%v%%.
+   */
+  static bytes6(v) {
+    return b(v, 6);
+  }
+  /**
+   *  Return a new ``bytes7`` type for %%v%%.
+   */
+  static bytes7(v) {
+    return b(v, 7);
+  }
+  /**
+   *  Return a new ``bytes8`` type for %%v%%.
+   */
+  static bytes8(v) {
+    return b(v, 8);
+  }
+  /**
+   *  Return a new ``bytes9`` type for %%v%%.
+   */
+  static bytes9(v) {
+    return b(v, 9);
+  }
+  /**
+   *  Return a new ``bytes10`` type for %%v%%.
+   */
+  static bytes10(v) {
+    return b(v, 10);
+  }
+  /**
+   *  Return a new ``bytes11`` type for %%v%%.
+   */
+  static bytes11(v) {
+    return b(v, 11);
+  }
+  /**
+   *  Return a new ``bytes12`` type for %%v%%.
+   */
+  static bytes12(v) {
+    return b(v, 12);
+  }
+  /**
+   *  Return a new ``bytes13`` type for %%v%%.
+   */
+  static bytes13(v) {
+    return b(v, 13);
+  }
+  /**
+   *  Return a new ``bytes14`` type for %%v%%.
+   */
+  static bytes14(v) {
+    return b(v, 14);
+  }
+  /**
+   *  Return a new ``bytes15`` type for %%v%%.
+   */
+  static bytes15(v) {
+    return b(v, 15);
+  }
+  /**
+   *  Return a new ``bytes16`` type for %%v%%.
+   */
+  static bytes16(v) {
+    return b(v, 16);
+  }
+  /**
+   *  Return a new ``bytes17`` type for %%v%%.
+   */
+  static bytes17(v) {
+    return b(v, 17);
+  }
+  /**
+   *  Return a new ``bytes18`` type for %%v%%.
+   */
+  static bytes18(v) {
+    return b(v, 18);
+  }
+  /**
+   *  Return a new ``bytes19`` type for %%v%%.
+   */
+  static bytes19(v) {
+    return b(v, 19);
+  }
+  /**
+   *  Return a new ``bytes20`` type for %%v%%.
+   */
+  static bytes20(v) {
+    return b(v, 20);
+  }
+  /**
+   *  Return a new ``bytes21`` type for %%v%%.
+   */
+  static bytes21(v) {
+    return b(v, 21);
+  }
+  /**
+   *  Return a new ``bytes22`` type for %%v%%.
+   */
+  static bytes22(v) {
+    return b(v, 22);
+  }
+  /**
+   *  Return a new ``bytes23`` type for %%v%%.
+   */
+  static bytes23(v) {
+    return b(v, 23);
+  }
+  /**
+   *  Return a new ``bytes24`` type for %%v%%.
+   */
+  static bytes24(v) {
+    return b(v, 24);
+  }
+  /**
+   *  Return a new ``bytes25`` type for %%v%%.
+   */
+  static bytes25(v) {
+    return b(v, 25);
+  }
+  /**
+   *  Return a new ``bytes26`` type for %%v%%.
+   */
+  static bytes26(v) {
+    return b(v, 26);
+  }
+  /**
+   *  Return a new ``bytes27`` type for %%v%%.
+   */
+  static bytes27(v) {
+    return b(v, 27);
+  }
+  /**
+   *  Return a new ``bytes28`` type for %%v%%.
+   */
+  static bytes28(v) {
+    return b(v, 28);
+  }
+  /**
+   *  Return a new ``bytes29`` type for %%v%%.
+   */
+  static bytes29(v) {
+    return b(v, 29);
+  }
+  /**
+   *  Return a new ``bytes30`` type for %%v%%.
+   */
+  static bytes30(v) {
+    return b(v, 30);
+  }
+  /**
+   *  Return a new ``bytes31`` type for %%v%%.
+   */
+  static bytes31(v) {
+    return b(v, 31);
+  }
+  /**
+   *  Return a new ``bytes32`` type for %%v%%.
+   */
+  static bytes32(v) {
+    return b(v, 32);
+  }
+  /**
+   *  Return a new ``address`` type for %%v%%.
+   */
+  static address(v) {
+    return new _Typed(_gaurd, "address", v);
+  }
+  /**
+   *  Return a new ``bool`` type for %%v%%.
+   */
+  static bool(v) {
+    return new _Typed(_gaurd, "bool", !!v);
+  }
+  /**
+   *  Return a new ``bytes`` type for %%v%%.
+   */
+  static bytes(v) {
+    return new _Typed(_gaurd, "bytes", v);
+  }
+  /**
+   *  Return a new ``string`` type for %%v%%.
+   */
+  static string(v) {
+    return new _Typed(_gaurd, "string", v);
+  }
+  /**
+   *  Return a new ``array`` type for %%v%%, allowing %%dynamic%% length.
+   */
+  static array(v, dynamic) {
+    throw new Error("not implemented yet");
+  }
+  /**
+   *  Return a new ``tuple`` type for %%v%%, with the optional %%name%%.
+   */
+  static tuple(v, name) {
+    throw new Error("not implemented yet");
+  }
+  /**
+   *  Return a new ``uint8`` type for %%v%%.
+   */
+  static overrides(v) {
+    return new _Typed(_gaurd, "overrides", Object.assign({}, v));
+  }
+  /**
+   *  Returns true only if %%value%% is a [[Typed]] instance.
+   */
+  static isTyped(value) {
+    return value && typeof value === "object" && "_typedSymbol" in value && value._typedSymbol === _typedSymbol;
+  }
+  /**
+   *  If the value is a [[Typed]] instance, validates the underlying value
+   *  and returns it, otherwise returns value directly.
+   *
+   *  This is useful for functions that with to accept either a [[Typed]]
+   *  object or values.
+   */
+  static dereference(value, type) {
+    if (_Typed.isTyped(value)) {
+      if (value.type !== type) {
+        throw new Error(`invalid type: expecetd ${type}, got ${value.type}`);
       }
+      return value.value;
     }
-    utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
-    return this;
+    return value;
   }
-}
-AxiosHeaders.accessor(["Content-Type", "Content-Length", "Accept", "Accept-Encoding", "User-Agent", "Authorization"]);
-utils.reduceDescriptors(AxiosHeaders.prototype, ({ value }, key) => {
-  let mapped = key[0].toUpperCase() + key.slice(1);
-  return {
-    get: () => value,
-    set(headerValue) {
-      this[mapped] = headerValue;
-    }
-  };
-});
-utils.freezeMethods(AxiosHeaders);
+};
+_options = new WeakMap();
+let Typed = _Typed;
 export {
-  AxiosHeaders as default
+  Typed
 };
 //# sourceMappingURL=standards-sdk.es55.js.map