@galacticcouncil/descriptors 1.0.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 +7636 -0
  2. package/build/descriptors-4VWMSC3A.mjs +27 -0
  3. package/build/descriptors.d.ts +1 -0
  4. package/build/hydration.d.ts +398 -0
  5. package/build/hydration_metadata-DO4ISWNV.mjs +6 -0
  6. package/build/hydration_metadata.d.ts +2 -0
  7. package/build/index.d.ts +3 -0
  8. package/build/index.js +218 -0
  9. package/build/index.mjs +129 -0
  10. package/build/metadataTypes-KXIFXX2S.mjs +6 -0
  11. package/build/metadataTypes.d.ts +2 -0
  12. package/package.json +49 -0
package/build/hydration_metadata-DO4ISWNV.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
+ };