@galacticcouncil/descriptors 1.4.0-pr193-4adb9c7 → 1.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (12) hide show
  1. package/build/common-types.d.ts +885 -707
  2. package/build/descriptors-TCMSBHWH.mjs +27 -0
  3. package/build/hydration.d.ts +773 -889
  4. package/build/hydration_metadata-QN4QUJWP.mjs +6 -0
  5. package/build/index.js +4 -4
  6. package/build/index.mjs +4 -4
  7. package/build/metadataTypes-GLMI47Y2.mjs +6 -0
  8. package/build/metadataTypes.d.ts +1 -1
  9. package/package.json +1 -1
  10. package/build/descriptors-TQ7UPY4I.mjs +0 -27
  11. package/build/hydration_metadata-R2ASQUSJ.mjs +0 -6
  12. package/build/metadataTypes-IZSQ4W7X.mjs +0 -6
package/build/hydration_metadata-QN4QUJWP.mjs ADDED
@@ -0,0 +1,6 @@
1
+ // .papi/descriptors/src/hydration_metadata.ts
2
+ var binMeta = "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";
3
+ var hydration_metadata_default = binMeta;
4
+ export {
5
+ hydration_metadata_default as default
6
+ };