@ensforge/react 0.0.0

package/dist/hooks/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","names":[],"sources":["../../src/hooks/capabilities.ts"],"mappings":"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"}

package/dist/hooks/capabilities.js

@@ -0,0 +1,39 @@
+"use client";
+
+import { makeQueryHook } from "./use-query.js";
+import { makeSuspenseQueryHook } from "./use-suspense-query.js";
+import { getNameCapabilitiesAtom, getOperatorApprovalAtom, getRecordPermissionsAtom, getRegistryCapabilitiesAtom, getRegistryRolesAtom, getRequiredAuthorizationAtom, getResolverCapabilitiesAtom, getResolverDelegateApprovalAtom, getResolverRolesAtom, getTokenApprovalAtom, getWrapperPermissionsAtom, getWriteTargetAtom, hasRegistryRolesAtom, hasResolverRolesAtom } from "../atoms/capabilities.js";
+
+//#region src/hooks/capabilities.ts
+const useNameCapabilities = makeQueryHook(getNameCapabilitiesAtom);
+const useNameCapabilitiesSuspense = makeSuspenseQueryHook(getNameCapabilitiesAtom);
+const useOperatorApproval = makeQueryHook(getOperatorApprovalAtom);
+const useOperatorApprovalSuspense = makeSuspenseQueryHook(getOperatorApprovalAtom);
+const useRecordPermissions = makeQueryHook(getRecordPermissionsAtom);
+const useRecordPermissionsSuspense = makeSuspenseQueryHook(getRecordPermissionsAtom);
+const useRegistryCapabilities = makeQueryHook(getRegistryCapabilitiesAtom);
+const useRegistryCapabilitiesSuspense = makeSuspenseQueryHook(getRegistryCapabilitiesAtom);
+const useRegistryRoles = makeQueryHook(getRegistryRolesAtom);
+const useRegistryRolesSuspense = makeSuspenseQueryHook(getRegistryRolesAtom);
+const useRequiredAuthorization = makeQueryHook(getRequiredAuthorizationAtom);
+const useRequiredAuthorizationSuspense = makeSuspenseQueryHook(getRequiredAuthorizationAtom);
+const useResolverCapabilities = makeQueryHook(getResolverCapabilitiesAtom);
+const useResolverCapabilitiesSuspense = makeSuspenseQueryHook(getResolverCapabilitiesAtom);
+const useResolverDelegateApproval = makeQueryHook(getResolverDelegateApprovalAtom);
+const useResolverDelegateApprovalSuspense = makeSuspenseQueryHook(getResolverDelegateApprovalAtom);
+const useResolverRoles = makeQueryHook(getResolverRolesAtom);
+const useResolverRolesSuspense = makeSuspenseQueryHook(getResolverRolesAtom);
+const useTokenApproval = makeQueryHook(getTokenApprovalAtom);
+const useTokenApprovalSuspense = makeSuspenseQueryHook(getTokenApprovalAtom);
+const useWrapperPermissions = makeQueryHook(getWrapperPermissionsAtom);
+const useWrapperPermissionsSuspense = makeSuspenseQueryHook(getWrapperPermissionsAtom);
+const useWriteTarget = makeQueryHook(getWriteTargetAtom);
+const useWriteTargetSuspense = makeSuspenseQueryHook(getWriteTargetAtom);
+const useHasRegistryRoles = makeQueryHook(hasRegistryRolesAtom);
+const useHasRegistryRolesSuspense = makeSuspenseQueryHook(hasRegistryRolesAtom);
+const useHasResolverRoles = makeQueryHook(hasResolverRolesAtom);
+const useHasResolverRolesSuspense = makeSuspenseQueryHook(hasResolverRolesAtom);
+
+//#endregion
+export { useHasRegistryRoles, useHasRegistryRolesSuspense, useHasResolverRoles, useHasResolverRolesSuspense, useNameCapabilities, useNameCapabilitiesSuspense, useOperatorApproval, useOperatorApprovalSuspense, useRecordPermissions, useRecordPermissionsSuspense, useRegistryCapabilities, useRegistryCapabilitiesSuspense, useRegistryRoles, useRegistryRolesSuspense, useRequiredAuthorization, useRequiredAuthorizationSuspense, useResolverCapabilities, useResolverCapabilitiesSuspense, useResolverDelegateApproval, useResolverDelegateApprovalSuspense, useResolverRoles, useResolverRolesSuspense, useTokenApproval, useTokenApprovalSuspense, useWrapperPermissions, useWrapperPermissionsSuspense, useWriteTarget, useWriteTargetSuspense };
+//# sourceMappingURL=capabilities.js.map

package/dist/hooks/capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.js","names":[],"sources":["../../src/hooks/capabilities.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getNameCapabilitiesAtom,\n  getOperatorApprovalAtom,\n  getRecordPermissionsAtom,\n  getRegistryCapabilitiesAtom,\n  getRegistryRolesAtom,\n  getRequiredAuthorizationAtom,\n  getResolverCapabilitiesAtom,\n  getResolverDelegateApprovalAtom,\n  getResolverRolesAtom,\n  getTokenApprovalAtom,\n  getWrapperPermissionsAtom,\n  getWriteTargetAtom,\n  hasRegistryRolesAtom,\n  hasResolverRolesAtom,\n} from \"../atoms/capabilities.js\";\nimport { makeQueryHook } from \"./use-query.js\";\nimport { makeSuspenseQueryHook } from \"./use-suspense-query.js\";\n\nexport const useNameCapabilities = makeQueryHook(getNameCapabilitiesAtom);\nexport const useNameCapabilitiesSuspense = makeSuspenseQueryHook(getNameCapabilitiesAtom);\nexport const useOperatorApproval = makeQueryHook(getOperatorApprovalAtom);\nexport const useOperatorApprovalSuspense = makeSuspenseQueryHook(getOperatorApprovalAtom);\nexport const useRecordPermissions = makeQueryHook(getRecordPermissionsAtom);\nexport const useRecordPermissionsSuspense = makeSuspenseQueryHook(getRecordPermissionsAtom);\nexport const useRegistryCapabilities = makeQueryHook(getRegistryCapabilitiesAtom);\nexport const useRegistryCapabilitiesSuspense = makeSuspenseQueryHook(getRegistryCapabilitiesAtom);\nexport const useRegistryRoles = makeQueryHook(getRegistryRolesAtom);\nexport const useRegistryRolesSuspense = makeSuspenseQueryHook(getRegistryRolesAtom);\nexport const useRequiredAuthorization = makeQueryHook(getRequiredAuthorizationAtom);\nexport const useRequiredAuthorizationSuspense = makeSuspenseQueryHook(getRequiredAuthorizationAtom);\nexport const useResolverCapabilities = makeQueryHook(getResolverCapabilitiesAtom);\nexport const useResolverCapabilitiesSuspense = makeSuspenseQueryHook(getResolverCapabilitiesAtom);\nexport const useResolverDelegateApproval = makeQueryHook(getResolverDelegateApprovalAtom);\nexport const useResolverDelegateApprovalSuspense = makeSuspenseQueryHook(\n  getResolverDelegateApprovalAtom,\n);\nexport const useResolverRoles = makeQueryHook(getResolverRolesAtom);\nexport const useResolverRolesSuspense = makeSuspenseQueryHook(getResolverRolesAtom);\nexport const useTokenApproval = makeQueryHook(getTokenApprovalAtom);\nexport const useTokenApprovalSuspense = makeSuspenseQueryHook(getTokenApprovalAtom);\nexport const useWrapperPermissions = makeQueryHook(getWrapperPermissionsAtom);\nexport const useWrapperPermissionsSuspense = makeSuspenseQueryHook(getWrapperPermissionsAtom);\nexport const useWriteTarget = makeQueryHook(getWriteTargetAtom);\nexport const useWriteTargetSuspense = makeSuspenseQueryHook(getWriteTargetAtom);\nexport const useHasRegistryRoles = makeQueryHook(hasRegistryRolesAtom);\nexport const useHasRegistryRolesSuspense = makeSuspenseQueryHook(hasRegistryRolesAtom);\nexport const useHasResolverRoles = makeQueryHook(hasResolverRolesAtom);\nexport const useHasResolverRolesSuspense = makeSuspenseQueryHook(hasResolverRolesAtom);\n"],"mappings":";;;;;;;AAqBA,MAAa,sBAAsB,cAAc,uBAAuB;AACxE,MAAa,8BAA8B,sBAAsB,uBAAuB;AACxF,MAAa,sBAAsB,cAAc,uBAAuB;AACxE,MAAa,8BAA8B,sBAAsB,uBAAuB;AACxF,MAAa,uBAAuB,cAAc,wBAAwB;AAC1E,MAAa,+BAA+B,sBAAsB,wBAAwB;AAC1F,MAAa,0BAA0B,cAAc,2BAA2B;AAChF,MAAa,kCAAkC,sBAAsB,2BAA2B;AAChG,MAAa,mBAAmB,cAAc,oBAAoB;AAClE,MAAa,2BAA2B,sBAAsB,oBAAoB;AAClF,MAAa,2BAA2B,cAAc,4BAA4B;AAClF,MAAa,mCAAmC,sBAAsB,4BAA4B;AAClG,MAAa,0BAA0B,cAAc,2BAA2B;AAChF,MAAa,kCAAkC,sBAAsB,2BAA2B;AAChG,MAAa,8BAA8B,cAAc,+BAA+B;AACxF,MAAa,sCAAsC,sBACjD,+BACF;AACA,MAAa,mBAAmB,cAAc,oBAAoB;AAClE,MAAa,2BAA2B,sBAAsB,oBAAoB;AAClF,MAAa,mBAAmB,cAAc,oBAAoB;AAClE,MAAa,2BAA2B,sBAAsB,oBAAoB;AAClF,MAAa,wBAAwB,cAAc,yBAAyB;AAC5E,MAAa,gCAAgC,sBAAsB,yBAAyB;AAC5F,MAAa,iBAAiB,cAAc,kBAAkB;AAC9D,MAAa,yBAAyB,sBAAsB,kBAAkB;AAC9E,MAAa,sBAAsB,cAAc,oBAAoB;AACrE,MAAa,8BAA8B,sBAAsB,oBAAoB;AACrF,MAAa,sBAAsB,cAAc,oBAAoB;AACrE,MAAa,8BAA8B,sBAAsB,oBAAoB"}

package/dist/hooks/dns.d.ts

@@ -0,0 +1,262 @@
+import { UseEnsQueryParameters } from "../query/options.js";
+import { EnsSuspenseQueryResult, UseEnsSuspenseQueryParameters } from "./use-suspense-query.js";
+import { EnsQueryResult } from "../query/result.js";
+import { EnsMutationOptions } from "../mutation/options.js";
+import { EnsMutationResult } from "../mutation/result.js";
+import "../index.js";
+//#region src/hooks/dns.d.ts
+declare const useDnsClaimStatus: <Selected = {
+  readonly status: "unsupported";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly reason: "DNS_REGISTRAR_UNAVAILABLE";
+} | {
+  readonly status: "claimed";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly owner: `0x${string}`;
+  readonly resolver: `0x${string}` | null;
+  readonly previousInception: bigint;
+} | {
+  readonly status: "proof-required";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly previousInception: bigint;
+}>(input: UseEnsQueryParameters<import("@ensforge/core").GetDnsClaimStatusParameters, {
+  readonly status: "unsupported";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly reason: "DNS_REGISTRAR_UNAVAILABLE";
+} | {
+  readonly status: "claimed";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly owner: `0x${string}`;
+  readonly resolver: `0x${string}` | null;
+  readonly previousInception: bigint;
+} | {
+  readonly status: "proof-required";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly previousInception: bigint;
+}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetDnsClaimStatusError>;
+declare const useDnsClaimStatusSuspense: <Selected = {
+  readonly status: "unsupported";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly reason: "DNS_REGISTRAR_UNAVAILABLE";
+} | {
+  readonly status: "claimed";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly owner: `0x${string}`;
+  readonly resolver: `0x${string}` | null;
+  readonly previousInception: bigint;
+} | {
+  readonly status: "proof-required";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly previousInception: bigint;
+}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetDnsClaimStatusParameters, {
+  readonly status: "unsupported";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly reason: "DNS_REGISTRAR_UNAVAILABLE";
+} | {
+  readonly status: "claimed";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly owner: `0x${string}`;
+  readonly resolver: `0x${string}` | null;
+  readonly previousInception: bigint;
+} | {
+  readonly status: "proof-required";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly previousInception: bigint;
+}, Selected>) => EnsSuspenseQueryResult<Selected>;
+declare const useDnsImportPlan: <Selected = {
+  readonly status: "unsupported";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly reason: "DNS_REGISTRAR_UNAVAILABLE";
+} | {
+  readonly status: "already-claimed";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly registrar: `0x${string}`;
+  readonly oracle: `0x${string}`;
+  readonly owner: `0x${string}`;
+  readonly resolver: `0x${string}` | null;
+} | {
+  readonly status: "proof-required";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly registrar: `0x${string}`;
+  readonly oracle: `0x${string}`;
+  readonly proofRequest: {
+    readonly name: `0x${string}` & import("effect/Brand").Brand<"DnsEncodedName">;
+    readonly previousInception: bigint;
+  };
+}>(input: UseEnsQueryParameters<import("@ensforge/core").GetDnsImportPlanParameters, {
+  readonly status: "unsupported";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly reason: "DNS_REGISTRAR_UNAVAILABLE";
+} | {
+  readonly status: "already-claimed";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly registrar: `0x${string}`;
+  readonly oracle: `0x${string}`;
+  readonly owner: `0x${string}`;
+  readonly resolver: `0x${string}` | null;
+} | {
+  readonly status: "proof-required";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly registrar: `0x${string}`;
+  readonly oracle: `0x${string}`;
+  readonly proofRequest: {
+    readonly name: `0x${string}` & import("effect/Brand").Brand<"DnsEncodedName">;
+    readonly previousInception: bigint;
+  };
+}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetDnsClaimStatusError>;
+declare const useDnsImportPlanSuspense: <Selected = {
+  readonly status: "unsupported";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly reason: "DNS_REGISTRAR_UNAVAILABLE";
+} | {
+  readonly status: "already-claimed";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly registrar: `0x${string}`;
+  readonly oracle: `0x${string}`;
+  readonly owner: `0x${string}`;
+  readonly resolver: `0x${string}` | null;
+} | {
+  readonly status: "proof-required";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly registrar: `0x${string}`;
+  readonly oracle: `0x${string}`;
+  readonly proofRequest: {
+    readonly name: `0x${string}` & import("effect/Brand").Brand<"DnsEncodedName">;
+    readonly previousInception: bigint;
+  };
+}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetDnsImportPlanParameters, {
+  readonly status: "unsupported";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly reason: "DNS_REGISTRAR_UNAVAILABLE";
+} | {
+  readonly status: "already-claimed";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly registrar: `0x${string}`;
+  readonly oracle: `0x${string}`;
+  readonly owner: `0x${string}`;
+  readonly resolver: `0x${string}` | null;
+} | {
+  readonly status: "proof-required";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly registrar: `0x${string}`;
+  readonly oracle: `0x${string}`;
+  readonly proofRequest: {
+    readonly name: `0x${string}` & import("effect/Brand").Brand<"DnsEncodedName">;
+    readonly previousInception: bigint;
+  };
+}, Selected>) => EnsSuspenseQueryResult<Selected>;
+declare const useDnsRecord: <Selected = {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly recordName: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resource: number;
+  readonly resolver: `0x${string}` | null;
+  readonly value: `0x${string}` | null;
+}>(input: UseEnsQueryParameters<import("@ensforge/core").GetDnsRecordParameters, {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly recordName: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resource: number;
+  readonly resolver: `0x${string}` | null;
+  readonly value: `0x${string}` | null;
+}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetDnsClaimStatusError>;
+declare const useDnsRecordSuspense: <Selected = {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly recordName: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resource: number;
+  readonly resolver: `0x${string}` | null;
+  readonly value: `0x${string}` | null;
+}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetDnsRecordParameters, {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly recordName: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resource: number;
+  readonly resolver: `0x${string}` | null;
+  readonly value: `0x${string}` | null;
+}, Selected>) => EnsSuspenseQueryResult<Selected>;
+declare const useDnsRecords: <Selected = {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly records: readonly {
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly recordName: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly resource: number;
+    readonly resolver: `0x${string}` | null;
+    readonly value: `0x${string}` | null;
+  }[];
+}>(input: UseEnsQueryParameters<import("@ensforge/core").GetDnsRecordsParameters, {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly records: readonly {
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly recordName: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly resource: number;
+    readonly resolver: `0x${string}` | null;
+    readonly value: `0x${string}` | null;
+  }[];
+}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetDnsClaimStatusError>;
+declare const useDnsRecordsSuspense: <Selected = {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly records: readonly {
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly recordName: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly resource: number;
+    readonly resolver: `0x${string}` | null;
+    readonly value: `0x${string}` | null;
+  }[];
+}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetDnsRecordsParameters, {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly records: readonly {
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly recordName: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly resource: number;
+    readonly resolver: `0x${string}` | null;
+    readonly value: `0x${string}` | null;
+  }[];
+}, Selected>) => EnsSuspenseQueryResult<Selected>;
+declare const useZoneHash: <Selected = {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly value: `0x${string}` | null;
+}>(input: UseEnsQueryParameters<import("@ensforge/core").GetZoneHashParameters, {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly value: `0x${string}` | null;
+}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetDnsClaimStatusError>;
+declare const useZoneHashSuspense: <Selected = {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly value: `0x${string}` | null;
+}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetZoneHashParameters, {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly value: `0x${string}` | null;
+}, Selected>) => EnsSuspenseQueryResult<Selected>;
+declare const useHasDnsRecords: <Selected = {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly recordName: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly exists: boolean;
+}>(input: UseEnsQueryParameters<import("@ensforge/core").HasDnsRecordsParameters, {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly recordName: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly exists: boolean;
+}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetDnsClaimStatusError>;
+declare const useHasDnsRecordsSuspense: <Selected = {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly recordName: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly exists: boolean;
+}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").HasDnsRecordsParameters, {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly recordName: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly resolver: `0x${string}` | null;
+  readonly exists: boolean;
+}, Selected>) => EnsSuspenseQueryResult<Selected>;
+declare const useClaimDnsName: (options?: EnsMutationOptions<import("@ensforge/core").ClaimDnsNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").ClaimDnsNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const useImportDnsName: (options?: EnsMutationOptions<import("@ensforge/core").ImportDnsNameParameters, import("@ensforge/core").ImportDnsNameResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").ImportDnsNameParameters, import("@ensforge/core").ImportDnsNameResult, import("@ensforge/core").WriteError>;
+declare const useSetDnsRecords: (options?: EnsMutationOptions<import("@ensforge/core").SetDnsRecordsParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").SetDnsRecordsParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const useSetZoneHash: (options?: EnsMutationOptions<import("@ensforge/core").SetZoneHashParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>) => EnsMutationResult<import("@ensforge/core").SetZoneHashParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+//#endregion
+export { useClaimDnsName, useDnsClaimStatus, useDnsClaimStatusSuspense, useDnsImportPlan, useDnsImportPlanSuspense, useDnsRecord, useDnsRecordSuspense, useDnsRecords, useDnsRecordsSuspense, useHasDnsRecords, useHasDnsRecordsSuspense, useImportDnsName, useSetDnsRecords, useSetZoneHash, useZoneHash, useZoneHashSuspense };
+//# sourceMappingURL=dns.d.ts.map

package/dist/hooks/dns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dns.d.ts","names":[],"sources":["../../src/hooks/dns.ts"],"mappings":";;;;;;;cAkBa,oBAAiB;;;;;;;;;;;;;;UAAuC;;;;;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cACxD,4BAAyB;;;;;;;;;;;;;;UAA+C;;;;;;;;;;;;;;GAAA,cAAA,uBAAA;cACxE,mBAAgB;;;;;;;;;;;;;;;;;;;;UAAsC;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cACtD,2BAAwB;;;;;;;;;;;;;;;;;;;;UAA8C;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,uBAAA;cACtE,eAAY;;;;;;UAAkC;;;;;;GAAA,cAAA,eAAA,mCAAA;cAC9C,uBAAoB;;;;;;UAA0C;;;;;;GAAA,cAAA,uBAAA;cAC9D,gBAAa;;;;;;;;;;UAAmC;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cAChD,wBAAqB;;;;;;;;;;UAA2C;;;;;;;;;;GAAA,cAAA,uBAAA;cAChE,cAAW;;;;UAAiC;;;;GAAA,cAAA,eAAA,mCAAA;cAC5C,sBAAmB;;;;UAAyC;;;;GAAA,cAAA,uBAAA;cAC5D,mBAAgB;;;;;UAAmC;;;;;GAAA,cAAA,eAAA,mCAAA;cACnD,2BAAwB;;;;;UAA2C;;;;;GAAA,cAAA,uBAAA;cAEnE,kBAAe,UAAf,4CAAe,iDAAA,8CAAA,gBAAA,2CAAA,iDAAA,8CAAA;cACf,mBAAgB,UAAhB,4CAAgB,kDAAA,8CAAA,gBAAA,2CAAA,kDAAA,8CAAA;cAChB,mBAAgB,UAAhB,4CAAgB,kDAAA,8CAAA,gBAAA,2CAAA,kDAAA,8CAAA;cAChB,iBAAc,UAAd,4CAAc,gDAAA,8CAAA,gBAAA,2CAAA,gDAAA,8CAAA"}

package/dist/hooks/dns.js

@@ -0,0 +1,28 @@
+"use client";
+
+import { makeMutationHook } from "./use-mutation.js";
+import { makeQueryHook } from "./use-query.js";
+import { makeSuspenseQueryHook } from "./use-suspense-query.js";
+import { createClaimDnsNameMutationAtom, createImportDnsNameMutationAtom, createSetDnsRecordsMutationAtom, createSetZoneHashMutationAtom, getDnsClaimStatusAtom, getDnsImportPlanAtom, getDnsRecordAtom, getDnsRecordsAtom, getZoneHashAtom, hasDnsRecordsAtom } from "../atoms/dns.js";
+
+//#region src/hooks/dns.ts
+const useDnsClaimStatus = makeQueryHook(getDnsClaimStatusAtom);
+const useDnsClaimStatusSuspense = makeSuspenseQueryHook(getDnsClaimStatusAtom);
+const useDnsImportPlan = makeQueryHook(getDnsImportPlanAtom);
+const useDnsImportPlanSuspense = makeSuspenseQueryHook(getDnsImportPlanAtom);
+const useDnsRecord = makeQueryHook(getDnsRecordAtom);
+const useDnsRecordSuspense = makeSuspenseQueryHook(getDnsRecordAtom);
+const useDnsRecords = makeQueryHook(getDnsRecordsAtom);
+const useDnsRecordsSuspense = makeSuspenseQueryHook(getDnsRecordsAtom);
+const useZoneHash = makeQueryHook(getZoneHashAtom);
+const useZoneHashSuspense = makeSuspenseQueryHook(getZoneHashAtom);
+const useHasDnsRecords = makeQueryHook(hasDnsRecordsAtom);
+const useHasDnsRecordsSuspense = makeSuspenseQueryHook(hasDnsRecordsAtom);
+const useClaimDnsName = makeMutationHook(createClaimDnsNameMutationAtom);
+const useImportDnsName = makeMutationHook(createImportDnsNameMutationAtom);
+const useSetDnsRecords = makeMutationHook(createSetDnsRecordsMutationAtom);
+const useSetZoneHash = makeMutationHook(createSetZoneHashMutationAtom);
+
+//#endregion
+export { useClaimDnsName, useDnsClaimStatus, useDnsClaimStatusSuspense, useDnsImportPlan, useDnsImportPlanSuspense, useDnsRecord, useDnsRecordSuspense, useDnsRecords, useDnsRecordsSuspense, useHasDnsRecords, useHasDnsRecordsSuspense, useImportDnsName, useSetDnsRecords, useSetZoneHash, useZoneHash, useZoneHashSuspense };
+//# sourceMappingURL=dns.js.map

package/dist/hooks/dns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dns.js","names":[],"sources":["../../src/hooks/dns.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getDnsClaimStatusAtom,\n  getDnsImportPlanAtom,\n  getDnsRecordAtom,\n  getDnsRecordsAtom,\n  getZoneHashAtom,\n  hasDnsRecordsAtom,\n  createClaimDnsNameMutationAtom,\n  createImportDnsNameMutationAtom,\n  createSetDnsRecordsMutationAtom,\n  createSetZoneHashMutationAtom,\n} from \"../atoms/dns.js\";\nimport { makeMutationHook } from \"./use-mutation.js\";\nimport { makeQueryHook } from \"./use-query.js\";\nimport { makeSuspenseQueryHook } from \"./use-suspense-query.js\";\n\nexport const useDnsClaimStatus = makeQueryHook(getDnsClaimStatusAtom);\nexport const useDnsClaimStatusSuspense = makeSuspenseQueryHook(getDnsClaimStatusAtom);\nexport const useDnsImportPlan = makeQueryHook(getDnsImportPlanAtom);\nexport const useDnsImportPlanSuspense = makeSuspenseQueryHook(getDnsImportPlanAtom);\nexport const useDnsRecord = makeQueryHook(getDnsRecordAtom);\nexport const useDnsRecordSuspense = makeSuspenseQueryHook(getDnsRecordAtom);\nexport const useDnsRecords = makeQueryHook(getDnsRecordsAtom);\nexport const useDnsRecordsSuspense = makeSuspenseQueryHook(getDnsRecordsAtom);\nexport const useZoneHash = makeQueryHook(getZoneHashAtom);\nexport const useZoneHashSuspense = makeSuspenseQueryHook(getZoneHashAtom);\nexport const useHasDnsRecords = makeQueryHook(hasDnsRecordsAtom);\nexport const useHasDnsRecordsSuspense = makeSuspenseQueryHook(hasDnsRecordsAtom);\n\nexport const useClaimDnsName = makeMutationHook(createClaimDnsNameMutationAtom);\nexport const useImportDnsName = makeMutationHook(createImportDnsNameMutationAtom);\nexport const useSetDnsRecords = makeMutationHook(createSetDnsRecordsMutationAtom);\nexport const useSetZoneHash = makeMutationHook(createSetZoneHashMutationAtom);\n"],"mappings":";;;;;;;;AAkBA,MAAa,oBAAoB,cAAc,qBAAqB;AACpE,MAAa,4BAA4B,sBAAsB,qBAAqB;AACpF,MAAa,mBAAmB,cAAc,oBAAoB;AAClE,MAAa,2BAA2B,sBAAsB,oBAAoB;AAClF,MAAa,eAAe,cAAc,gBAAgB;AAC1D,MAAa,uBAAuB,sBAAsB,gBAAgB;AAC1E,MAAa,gBAAgB,cAAc,iBAAiB;AAC5D,MAAa,wBAAwB,sBAAsB,iBAAiB;AAC5E,MAAa,cAAc,cAAc,eAAe;AACxD,MAAa,sBAAsB,sBAAsB,eAAe;AACxE,MAAa,mBAAmB,cAAc,iBAAiB;AAC/D,MAAa,2BAA2B,sBAAsB,iBAAiB;AAE/E,MAAa,kBAAkB,iBAAiB,8BAA8B;AAC9E,MAAa,mBAAmB,iBAAiB,+BAA+B;AAChF,MAAa,mBAAmB,iBAAiB,+BAA+B;AAChF,MAAa,iBAAiB,iBAAiB,6BAA6B"}

package/dist/hooks/events.d.ts

@@ -0,0 +1,275 @@
+import { UseEnsQueryParameters } from "../query/options.js";
+import { EnsSuspenseQueryResult, UseEnsSuspenseQueryParameters } from "./use-suspense-query.js";
+import { EnsQueryResult } from "../query/result.js";
+import "../index.js";
+//#region src/hooks/events.d.ts
+declare const useEnsEvents: <Selected = readonly {
+  readonly blockNumber: bigint | null;
+  readonly transactionHash: `0x${string}` | null;
+  readonly protocol: "v1" | "v2";
+  readonly raw: {
+    readonly topics: readonly `0x${string}`[];
+    readonly data: `0x${string}`;
+    readonly args: unknown;
+  };
+  readonly kind: "resolver" | "records" | "ownership" | "commitment" | "manager" | "registration" | "renewal" | "subname" | "migration" | "other";
+  readonly contract: `0x${string}`;
+  readonly transactionIndex: number | null;
+  readonly logIndex: number | null;
+  readonly contractKind: "resolver" | "registrar" | "registry" | "name-wrapper" | "migration-controller";
+  readonly eventName: string;
+  readonly removed: boolean;
+  readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
+  readonly to?: `0x${string}` | undefined;
+  readonly from?: `0x${string}` | undefined;
+  readonly resolver?: `0x${string}` | undefined;
+  readonly owner?: `0x${string}` | undefined;
+  readonly node?: `0x${string}` | undefined;
+  readonly label?: string | undefined;
+  readonly tokenId?: bigint | undefined;
+  readonly commitment?: `0x${string}` | undefined;
+}[]>(input: UseEnsQueryParameters<import("@ensforge/core").GetEnsEventsParameters, readonly {
+  readonly blockNumber: bigint | null;
+  readonly transactionHash: `0x${string}` | null;
+  readonly protocol: "v1" | "v2";
+  readonly raw: {
+    readonly topics: readonly `0x${string}`[];
+    readonly data: `0x${string}`;
+    readonly args: unknown;
+  };
+  readonly kind: "resolver" | "records" | "ownership" | "commitment" | "manager" | "registration" | "renewal" | "subname" | "migration" | "other";
+  readonly contract: `0x${string}`;
+  readonly transactionIndex: number | null;
+  readonly logIndex: number | null;
+  readonly contractKind: "resolver" | "registrar" | "registry" | "name-wrapper" | "migration-controller";
+  readonly eventName: string;
+  readonly removed: boolean;
+  readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
+  readonly to?: `0x${string}` | undefined;
+  readonly from?: `0x${string}` | undefined;
+  readonly resolver?: `0x${string}` | undefined;
+  readonly owner?: `0x${string}` | undefined;
+  readonly node?: `0x${string}` | undefined;
+  readonly label?: string | undefined;
+  readonly tokenId?: bigint | undefined;
+  readonly commitment?: `0x${string}` | undefined;
+}[], Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetEnsEventsError>;
+declare const useEnsEventsSuspense: <Selected = readonly {
+  readonly blockNumber: bigint | null;
+  readonly transactionHash: `0x${string}` | null;
+  readonly protocol: "v1" | "v2";
+  readonly raw: {
+    readonly topics: readonly `0x${string}`[];
+    readonly data: `0x${string}`;
+    readonly args: unknown;
+  };
+  readonly kind: "resolver" | "records" | "ownership" | "commitment" | "manager" | "registration" | "renewal" | "subname" | "migration" | "other";
+  readonly contract: `0x${string}`;
+  readonly transactionIndex: number | null;
+  readonly logIndex: number | null;
+  readonly contractKind: "resolver" | "registrar" | "registry" | "name-wrapper" | "migration-controller";
+  readonly eventName: string;
+  readonly removed: boolean;
+  readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
+  readonly to?: `0x${string}` | undefined;
+  readonly from?: `0x${string}` | undefined;
+  readonly resolver?: `0x${string}` | undefined;
+  readonly owner?: `0x${string}` | undefined;
+  readonly node?: `0x${string}` | undefined;
+  readonly label?: string | undefined;
+  readonly tokenId?: bigint | undefined;
+  readonly commitment?: `0x${string}` | undefined;
+}[]>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetEnsEventsParameters, readonly {
+  readonly blockNumber: bigint | null;
+  readonly transactionHash: `0x${string}` | null;
+  readonly protocol: "v1" | "v2";
+  readonly raw: {
+    readonly topics: readonly `0x${string}`[];
+    readonly data: `0x${string}`;
+    readonly args: unknown;
+  };
+  readonly kind: "resolver" | "records" | "ownership" | "commitment" | "manager" | "registration" | "renewal" | "subname" | "migration" | "other";
+  readonly contract: `0x${string}`;
+  readonly transactionIndex: number | null;
+  readonly logIndex: number | null;
+  readonly contractKind: "resolver" | "registrar" | "registry" | "name-wrapper" | "migration-controller";
+  readonly eventName: string;
+  readonly removed: boolean;
+  readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
+  readonly to?: `0x${string}` | undefined;
+  readonly from?: `0x${string}` | undefined;
+  readonly resolver?: `0x${string}` | undefined;
+  readonly owner?: `0x${string}` | undefined;
+  readonly node?: `0x${string}` | undefined;
+  readonly label?: string | undefined;
+  readonly tokenId?: bigint | undefined;
+  readonly commitment?: `0x${string}` | undefined;
+}[], Selected>) => EnsSuspenseQueryResult<Selected>;
+declare const useNameHistory: <Selected = {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly events: readonly {
+    readonly blockNumber: bigint | null;
+    readonly transactionHash: `0x${string}` | null;
+    readonly protocol: "v1" | "v2";
+    readonly raw: {
+      readonly topics: readonly `0x${string}`[];
+      readonly data: `0x${string}`;
+      readonly args: unknown;
+    };
+    readonly kind: "resolver" | "records" | "ownership" | "commitment" | "manager" | "registration" | "renewal" | "subname" | "migration" | "other";
+    readonly contract: `0x${string}`;
+    readonly transactionIndex: number | null;
+    readonly logIndex: number | null;
+    readonly contractKind: "resolver" | "registrar" | "registry" | "name-wrapper" | "migration-controller";
+    readonly eventName: string;
+    readonly removed: boolean;
+    readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
+    readonly to?: `0x${string}` | undefined;
+    readonly from?: `0x${string}` | undefined;
+    readonly resolver?: `0x${string}` | undefined;
+    readonly owner?: `0x${string}` | undefined;
+    readonly node?: `0x${string}` | undefined;
+    readonly label?: string | undefined;
+    readonly tokenId?: bigint | undefined;
+    readonly commitment?: `0x${string}` | undefined;
+  }[];
+}>(input: UseEnsQueryParameters<import("@ensforge/core").GetNameHistoryParameters, {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly events: readonly {
+    readonly blockNumber: bigint | null;
+    readonly transactionHash: `0x${string}` | null;
+    readonly protocol: "v1" | "v2";
+    readonly raw: {
+      readonly topics: readonly `0x${string}`[];
+      readonly data: `0x${string}`;
+      readonly args: unknown;
+    };
+    readonly kind: "resolver" | "records" | "ownership" | "commitment" | "manager" | "registration" | "renewal" | "subname" | "migration" | "other";
+    readonly contract: `0x${string}`;
+    readonly transactionIndex: number | null;
+    readonly logIndex: number | null;
+    readonly contractKind: "resolver" | "registrar" | "registry" | "name-wrapper" | "migration-controller";
+    readonly eventName: string;
+    readonly removed: boolean;
+    readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
+    readonly to?: `0x${string}` | undefined;
+    readonly from?: `0x${string}` | undefined;
+    readonly resolver?: `0x${string}` | undefined;
+    readonly owner?: `0x${string}` | undefined;
+    readonly node?: `0x${string}` | undefined;
+    readonly label?: string | undefined;
+    readonly tokenId?: bigint | undefined;
+    readonly commitment?: `0x${string}` | undefined;
+  }[];
+}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetEnsEventsError>;
+declare const useNameHistorySuspense: <Selected = {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly events: readonly {
+    readonly blockNumber: bigint | null;
+    readonly transactionHash: `0x${string}` | null;
+    readonly protocol: "v1" | "v2";
+    readonly raw: {
+      readonly topics: readonly `0x${string}`[];
+      readonly data: `0x${string}`;
+      readonly args: unknown;
+    };
+    readonly kind: "resolver" | "records" | "ownership" | "commitment" | "manager" | "registration" | "renewal" | "subname" | "migration" | "other";
+    readonly contract: `0x${string}`;
+    readonly transactionIndex: number | null;
+    readonly logIndex: number | null;
+    readonly contractKind: "resolver" | "registrar" | "registry" | "name-wrapper" | "migration-controller";
+    readonly eventName: string;
+    readonly removed: boolean;
+    readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
+    readonly to?: `0x${string}` | undefined;
+    readonly from?: `0x${string}` | undefined;
+    readonly resolver?: `0x${string}` | undefined;
+    readonly owner?: `0x${string}` | undefined;
+    readonly node?: `0x${string}` | undefined;
+    readonly label?: string | undefined;
+    readonly tokenId?: bigint | undefined;
+    readonly commitment?: `0x${string}` | undefined;
+  }[];
+}>(input: UseEnsSuspenseQueryParameters<import("@ensforge/core").GetNameHistoryParameters, {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly events: readonly {
+    readonly blockNumber: bigint | null;
+    readonly transactionHash: `0x${string}` | null;
+    readonly protocol: "v1" | "v2";
+    readonly raw: {
+      readonly topics: readonly `0x${string}`[];
+      readonly data: `0x${string}`;
+      readonly args: unknown;
+    };
+    readonly kind: "resolver" | "records" | "ownership" | "commitment" | "manager" | "registration" | "renewal" | "subname" | "migration" | "other";
+    readonly contract: `0x${string}`;
+    readonly transactionIndex: number | null;
+    readonly logIndex: number | null;
+    readonly contractKind: "resolver" | "registrar" | "registry" | "name-wrapper" | "migration-controller";
+    readonly eventName: string;
+    readonly removed: boolean;
+    readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
+    readonly to?: `0x${string}` | undefined;
+    readonly from?: `0x${string}` | undefined;
+    readonly resolver?: `0x${string}` | undefined;
+    readonly owner?: `0x${string}` | undefined;
+    readonly node?: `0x${string}` | undefined;
+    readonly label?: string | undefined;
+    readonly tokenId?: bigint | undefined;
+    readonly commitment?: `0x${string}` | undefined;
+  }[];
+}, Selected>) => EnsSuspenseQueryResult<Selected>;
+declare const useWatchEnsEvents: <Selected = {
+  readonly blockNumber: bigint | null;
+  readonly transactionHash: `0x${string}` | null;
+  readonly protocol: "v1" | "v2";
+  readonly raw: {
+    readonly topics: readonly `0x${string}`[];
+    readonly data: `0x${string}`;
+    readonly args: unknown;
+  };
+  readonly kind: "resolver" | "records" | "ownership" | "commitment" | "manager" | "registration" | "renewal" | "subname" | "migration" | "other";
+  readonly contract: `0x${string}`;
+  readonly transactionIndex: number | null;
+  readonly logIndex: number | null;
+  readonly contractKind: "resolver" | "registrar" | "registry" | "name-wrapper" | "migration-controller";
+  readonly eventName: string;
+  readonly removed: boolean;
+  readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
+  readonly to?: `0x${string}` | undefined;
+  readonly from?: `0x${string}` | undefined;
+  readonly resolver?: `0x${string}` | undefined;
+  readonly owner?: `0x${string}` | undefined;
+  readonly node?: `0x${string}` | undefined;
+  readonly label?: string | undefined;
+  readonly tokenId?: bigint | undefined;
+  readonly commitment?: `0x${string}` | undefined;
+}>(input: UseEnsQueryParameters<import("@ensforge/core").WatchEnsEventsParameters, {
+  readonly blockNumber: bigint | null;
+  readonly transactionHash: `0x${string}` | null;
+  readonly protocol: "v1" | "v2";
+  readonly raw: {
+    readonly topics: readonly `0x${string}`[];
+    readonly data: `0x${string}`;
+    readonly args: unknown;
+  };
+  readonly kind: "resolver" | "records" | "ownership" | "commitment" | "manager" | "registration" | "renewal" | "subname" | "migration" | "other";
+  readonly contract: `0x${string}`;
+  readonly transactionIndex: number | null;
+  readonly logIndex: number | null;
+  readonly contractKind: "resolver" | "registrar" | "registry" | "name-wrapper" | "migration-controller";
+  readonly eventName: string;
+  readonly removed: boolean;
+  readonly name?: (string & import("effect/Brand").Brand<"NormalizedName">) | undefined;
+  readonly to?: `0x${string}` | undefined;
+  readonly from?: `0x${string}` | undefined;
+  readonly resolver?: `0x${string}` | undefined;
+  readonly owner?: `0x${string}` | undefined;
+  readonly node?: `0x${string}` | undefined;
+  readonly label?: string | undefined;
+  readonly tokenId?: bigint | undefined;
+  readonly commitment?: `0x${string}` | undefined;
+}, Selected>) => EnsQueryResult<Selected, import("@ensforge/core").GetEnsEventsError | import("effect/Cause").NoSuchElementError>;
+//#endregion
+export { useEnsEvents, useEnsEventsSuspense, useNameHistory, useNameHistorySuspense, useWatchEnsEvents };
+//# sourceMappingURL=events.d.ts.map

package/dist/hooks/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","names":[],"sources":["../../src/hooks/events.ts"],"mappings":";;;;;cAMa,eAAY;;;;;;;;;;;;;;;;;;;;;;;;;YAAkC;;;;;;;;;;;;;;;;;;;;;;;;;KAAA,cAAA,eAAA,mCAAA;cAC9C,uBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;YAA0C;;;;;;;;;;;;;;;;;;;;;;;;;KAAA,cAAA,uBAAA;cAC9D,iBAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA;cAClD,yBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,uBAAA;cAClE,oBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;UAAoC;;;;;;;;;;;;;;;;;;;;;;;;;GAAA,cAAA,eAAA,mCAAA,2CAAA"}