@ensforge/react 0.0.0

package/dist/atoms/events.d.ts

@@ -0,0 +1,86 @@
+import { EnsQueryAtomFactory } from "./query.js";
+//#region src/atoms/events.d.ts
+declare const getEnsEventsAtom: EnsQueryAtomFactory<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;
+}[], import("@ensforge/core").GetEnsEventsError>;
+declare const getNameHistoryAtom: EnsQueryAtomFactory<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;
+  }[];
+}, import("@ensforge/core").GetEnsEventsError>;
+declare const watchEnsEventsAtom: EnsQueryAtomFactory<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;
+}, import("@ensforge/core").GetEnsEventsError | import("effect/Cause").NoSuchElementError>;
+//#endregion
+export { getEnsEventsAtom, getNameHistoryAtom, watchEnsEventsAtom };
+//# sourceMappingURL=events.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","names":[],"sources":["../../src/atoms/events.ts"],"mappings":";;cAGa,kBAAA,6CAAgB;;;;;;;;;;;;;;;;;;;;;;;;;8BAA4D;cAC5E,oBAAA,6CAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAA8D;cAChF,oBAAA,6CAAkB;;;;;;;;;;;;;;;;;;;;;;;;;4BAA+D,2CAAA"}

package/dist/atoms/events.js

@@ -0,0 +1,11 @@
+import { makeQueryAtom } from "./query.js";
+import { makeStreamAtom } from "./stream.js";
+
+//#region src/atoms/events.ts
+const getEnsEventsAtom = makeQueryAtom("events", (sdk) => sdk.events.getEnsEvents);
+const getNameHistoryAtom = makeQueryAtom("events", (sdk) => sdk.events.getNameHistory);
+const watchEnsEventsAtom = makeStreamAtom("events", (sdk) => sdk.events.watchEnsEvents);
+
+//#endregion
+export { getEnsEventsAtom, getNameHistoryAtom, watchEnsEventsAtom };
+//# sourceMappingURL=events.js.map

package/dist/atoms/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","names":[],"sources":["../../src/atoms/events.ts"],"sourcesContent":["import { makeQueryAtom } from \"./query.js\";\nimport { makeStreamAtom } from \"./stream.js\";\n\nexport const getEnsEventsAtom = makeQueryAtom(\"events\", (sdk) => sdk.events.getEnsEvents);\nexport const getNameHistoryAtom = makeQueryAtom(\"events\", (sdk) => sdk.events.getNameHistory);\nexport const watchEnsEventsAtom = makeStreamAtom(\"events\", (sdk) => sdk.events.watchEnsEvents);\n"],"mappings":";;;;AAGA,MAAa,mBAAmB,cAAc,WAAW,QAAQ,IAAI,OAAO,YAAY;AACxF,MAAa,qBAAqB,cAAc,WAAW,QAAQ,IAAI,OAAO,cAAc;AAC5F,MAAa,qBAAqB,eAAe,WAAW,QAAQ,IAAI,OAAO,cAAc"}

package/dist/atoms/generic.d.ts

@@ -0,0 +1,14 @@
+import { EnsQueryAtom, QueryAtomOptions } from "./query.js";
+import { EnsReadRequest, Ensforge, GetRecordsError, GetRecordsParameters, GetRecordsResult, GetRecordsSelection, ReadBatchError, ReadBatchOptions, ReadBatchResult, ReadBatchSettledResult, RpcError } from "@ensforge/sdk";
+//#region src/atoms/generic.d.ts
+type ReadRequests = Readonly<Record<string, EnsReadRequest<unknown, unknown>>>;
+interface ReadBatchAtomParameters<Requests extends ReadRequests> {
+  readonly options?: ReadBatchOptions;
+  readonly requests: Requests;
+}
+declare const getRecordsAtom: <const Selection extends GetRecordsSelection>(sdk: Ensforge, parameters: GetRecordsParameters<Selection>, options: QueryAtomOptions) => EnsQueryAtom<GetRecordsResult<Selection>, GetRecordsError>;
+declare const readBatchAtom: <const Requests extends ReadRequests>(sdk: Ensforge, parameters: ReadBatchAtomParameters<Requests>, options: QueryAtomOptions) => EnsQueryAtom<ReadBatchResult<Requests>, ReadBatchError<Requests>>;
+declare const readBatchSettledAtom: <const Requests extends ReadRequests>(sdk: Ensforge, parameters: ReadBatchAtomParameters<Requests>, options: QueryAtomOptions) => EnsQueryAtom<ReadBatchSettledResult<Requests>, RpcError>;
+//#endregion
+export { ReadBatchAtomParameters, getRecordsAtom, readBatchAtom, readBatchSettledAtom };
+//# sourceMappingURL=generic.d.ts.map

package/dist/atoms/generic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic.d.ts","names":[],"sources":["../../src/atoms/generic.ts"],"mappings":";;;KAgBK,eAAe,SAAS,eAAe;UAE3B,wBAAwB,iBAAiB;WAC/C,UAAU;WACV,UAAU;;cAQR,uBAAwB,kBAAkB,qBACrD,KAAK,UACL,YAAY,qBAAqB,YACjC,SAAS,qBACR,aAAa,iBAAiB,YAAY;cAchC,sBAAuB,iBAAiB,cACnD,KAAK,UACL,YAAY,wBAAwB,WACpC,SAAS,qBACR,aAAa,gBAAgB,WAAW,eAAe;cAc7C,6BAA8B,iBAAiB,cAC1D,KAAK,UACL,YAAY,wBAAwB,WACpC,SAAS,qBACR,aAAa,uBAAuB,WAAW"}

package/dist/atoms/generic.js

@@ -0,0 +1,13 @@
+import { makeQueryAtom } from "./query.js";
+
+//#region src/atoms/generic.ts
+const getRecordsAtomBase = makeQueryAtom("records", (sdk) => sdk.records.getRecords);
+const getRecordsAtom = (sdk, parameters, options) => getRecordsAtomBase(sdk, parameters, options);
+const readBatchAtomBase = makeQueryAtom("batch", (sdk) => ({ effect: ({ options, requests }) => sdk.batch.readBatch.effect(requests, options) }));
+const readBatchAtom = (sdk, parameters, options) => readBatchAtomBase(sdk, parameters, options);
+const readBatchSettledAtomBase = makeQueryAtom("batch", (sdk) => ({ effect: ({ options, requests }) => sdk.batch.readBatchSettled.effect(requests, options) }));
+const readBatchSettledAtom = (sdk, parameters, options) => readBatchSettledAtomBase(sdk, parameters, options);
+
+//#endregion
+export { getRecordsAtom, readBatchAtom, readBatchSettledAtom };
+//# sourceMappingURL=generic.js.map

package/dist/atoms/generic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic.js","names":[],"sources":["../../src/atoms/generic.ts"],"sourcesContent":["import type {\n  EnsReadRequest,\n  GetRecordsError,\n  GetRecordsParameters,\n  GetRecordsResult,\n  GetRecordsSelection,\n  ReadBatchError,\n  ReadBatchOptions,\n  ReadBatchResult,\n  ReadBatchSettledResult,\n  RpcError,\n} from \"@ensforge/sdk\";\nimport type { Ensforge } from \"@ensforge/sdk\";\n\nimport { makeQueryAtom, type EnsQueryAtom, type QueryAtomOptions } from \"./query.js\";\n\ntype ReadRequests = Readonly<Record<string, EnsReadRequest<unknown, unknown>>>;\n\nexport interface ReadBatchAtomParameters<Requests extends ReadRequests> {\n  readonly options?: ReadBatchOptions;\n  readonly requests: Requests;\n}\n\nconst getRecordsAtomBase = makeQueryAtom<GetRecordsParameters, GetRecordsResult, GetRecordsError>(\n  \"records\",\n  (sdk) => sdk.records.getRecords,\n);\n\nexport const getRecordsAtom = <const Selection extends GetRecordsSelection>(\n  sdk: Ensforge,\n  parameters: GetRecordsParameters<Selection>,\n  options: QueryAtomOptions,\n): EnsQueryAtom<GetRecordsResult<Selection>, GetRecordsError> =>\n  getRecordsAtomBase(sdk, parameters, options) as EnsQueryAtom<\n    GetRecordsResult<Selection>,\n    GetRecordsError\n  >;\n\nconst readBatchAtomBase = makeQueryAtom<\n  ReadBatchAtomParameters<ReadRequests>,\n  ReadBatchResult<ReadRequests>,\n  ReadBatchError<ReadRequests>\n>(\"batch\", (sdk) => ({\n  effect: ({ options, requests }) => sdk.batch.readBatch.effect(requests, options),\n}));\n\nexport const readBatchAtom = <const Requests extends ReadRequests>(\n  sdk: Ensforge,\n  parameters: ReadBatchAtomParameters<Requests>,\n  options: QueryAtomOptions,\n): EnsQueryAtom<ReadBatchResult<Requests>, ReadBatchError<Requests>> =>\n  readBatchAtomBase(sdk, parameters, options) as EnsQueryAtom<\n    ReadBatchResult<Requests>,\n    ReadBatchError<Requests>\n  >;\n\nconst readBatchSettledAtomBase = makeQueryAtom<\n  ReadBatchAtomParameters<ReadRequests>,\n  ReadBatchSettledResult<ReadRequests>,\n  RpcError\n>(\"batch\", (sdk) => ({\n  effect: ({ options, requests }) => sdk.batch.readBatchSettled.effect(requests, options),\n}));\n\nexport const readBatchSettledAtom = <const Requests extends ReadRequests>(\n  sdk: Ensforge,\n  parameters: ReadBatchAtomParameters<Requests>,\n  options: QueryAtomOptions,\n): EnsQueryAtom<ReadBatchSettledResult<Requests>, RpcError> =>\n  readBatchSettledAtomBase(sdk, parameters, options) as EnsQueryAtom<\n    ReadBatchSettledResult<Requests>,\n    RpcError\n  >;\n"],"mappings":";;;AAuBA,MAAM,qBAAqB,cACzB,YACC,QAAQ,IAAI,QAAQ,UACvB;AAEA,MAAa,kBACX,KACA,YACA,YAEA,mBAAmB,KAAK,YAAY,OAAO;AAK7C,MAAM,oBAAoB,cAIxB,UAAU,SAAS,EACnB,SAAS,EAAE,SAAS,eAAe,IAAI,MAAM,UAAU,OAAO,UAAU,OAAO,EACjF,EAAE;AAEF,MAAa,iBACX,KACA,YACA,YAEA,kBAAkB,KAAK,YAAY,OAAO;AAK5C,MAAM,2BAA2B,cAI/B,UAAU,SAAS,EACnB,SAAS,EAAE,SAAS,eAAe,IAAI,MAAM,iBAAiB,OAAO,UAAU,OAAO,EACxF,EAAE;AAEF,MAAa,wBACX,KACA,YACA,YAEA,yBAAyB,KAAK,YAAY,OAAO"}

package/dist/atoms/migration.d.ts

@@ -0,0 +1,171 @@
+import { EnsQueryAtomFactory } from "./query.js";
+import { EnsMutationAtomFactory } from "./mutation.js";
+//#region src/atoms/migration.d.ts
+declare const getMigrationEligibilityAtom: EnsQueryAtomFactory<import("@ensforge/core").GetMigrationEligibilityParameters, {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly eligible: boolean;
+  readonly status: {
+    readonly status: "unsupported";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly reason: "ENSV2_NOT_ACTIVE" | "NOT_ETH_NAME" | "NAME_NOT_RESERVED";
+  } | {
+    readonly status: "not-required";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly reason: "V2_NATIVE" | "AVAILABLE";
+  } | {
+    readonly status: "reserved-unwrapped";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  } | {
+    readonly status: "locked-child-pending-parent";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly parent: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly fuses: number;
+  } | {
+    readonly status: "reserved-wrapped-unlocked";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly fuses: number;
+  } | {
+    readonly status: "reserved-wrapped-locked";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly fuses: number;
+  } | {
+    readonly status: "mirrored-child";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly parentRegistry: `0x${string}`;
+    readonly fuses: number;
+  } | {
+    readonly status: "migrated-unlocked";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  } | {
+    readonly status: "migrated-locked";
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly registry: `0x${string}`;
+  };
+  readonly target: {
+    readonly supported: false;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly reason: "MIGRATION_UNSUPPORTED" | "MIGRATION_NOT_REQUIRED" | "PARENT_NOT_MIGRATED";
+  } | {
+    readonly supported: true;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly route: "unwrapped" | "wrapped-unlocked" | "wrapped-locked" | "locked-child";
+    readonly tokenContract: `0x${string}`;
+    readonly tokenId: bigint;
+    readonly tokenStandard: "erc721" | "erc1155";
+    readonly receiver: `0x${string}`;
+  };
+  readonly account: `0x${string}`;
+  readonly owner: `0x${string}` | null;
+  readonly authorized: boolean;
+  readonly blockers: readonly ("ENSV2_NOT_ACTIVE" | "NOT_ETH_NAME" | "NAME_NOT_RESERVED" | "PARENT_NOT_MIGRATED" | "NAME_ALREADY_MIGRATED" | "NAME_AVAILABLE" | "ACCOUNT_NOT_OWNER_OR_OPERATOR" | "INVALID_WRAPPER_STATE" | "FROZEN_TOKEN_APPROVAL" | "TRANSFER_DISABLED")[];
+}, import("@ensforge/core").GetCanonicalResourceError>;
+declare const getMigrationPlanAtom: EnsQueryAtomFactory<import("@ensforge/core").GetMigrationPlanParameters, {
+  readonly status: "unsupported";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly blockers: readonly ("ENSV2_NOT_ACTIVE" | "NOT_ETH_NAME" | "NAME_NOT_RESERVED" | "PARENT_NOT_MIGRATED" | "NAME_ALREADY_MIGRATED" | "NAME_AVAILABLE" | "ACCOUNT_NOT_OWNER_OR_OPERATOR" | "INVALID_WRAPPER_STATE" | "FROZEN_TOKEN_APPROVAL" | "TRANSFER_DISABLED")[];
+} | {
+  readonly status: "not-required";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly reason: "V2_NATIVE" | "AVAILABLE" | "ALREADY_MIGRATED";
+} | {
+  readonly status: "blocked";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly blockers: readonly ("ENSV2_NOT_ACTIVE" | "NOT_ETH_NAME" | "NAME_NOT_RESERVED" | "PARENT_NOT_MIGRATED" | "NAME_ALREADY_MIGRATED" | "NAME_AVAILABLE" | "ACCOUNT_NOT_OWNER_OR_OPERATOR" | "INVALID_WRAPPER_STATE" | "FROZEN_TOKEN_APPROVAL" | "TRANSFER_DISABLED")[];
+} | {
+  readonly status: "authorization-required";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly account: `0x${string}`;
+  readonly owner: `0x${string}`;
+  readonly target: {
+    readonly supported: false;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly reason: "MIGRATION_UNSUPPORTED" | "MIGRATION_NOT_REQUIRED" | "PARENT_NOT_MIGRATED";
+  } | {
+    readonly supported: true;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly route: "unwrapped" | "wrapped-unlocked" | "wrapped-locked" | "locked-child";
+    readonly tokenContract: `0x${string}`;
+    readonly tokenId: bigint;
+    readonly tokenStandard: "erc721" | "erc1155";
+    readonly receiver: `0x${string}`;
+  };
+} | {
+  readonly status: "ready";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly target: {
+    readonly supported: false;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly reason: "MIGRATION_UNSUPPORTED" | "MIGRATION_NOT_REQUIRED" | "PARENT_NOT_MIGRATED";
+  } | {
+    readonly supported: true;
+    readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+    readonly route: "unwrapped" | "wrapped-unlocked" | "wrapped-locked" | "locked-child";
+    readonly tokenContract: `0x${string}`;
+    readonly tokenId: bigint;
+    readonly tokenStandard: "erc721" | "erc1155";
+    readonly receiver: `0x${string}`;
+  };
+  readonly migration: {
+    readonly label: string;
+    readonly owner: `0x${string}`;
+    readonly resolver: `0x${string}`;
+    readonly subregistry: `0x${string}`;
+  };
+  readonly warnings: readonly ("SUBREGISTRY_IGNORED_FOR_LOCKED_NAME" | "RESOLVER_MAY_BE_PRESERVED")[];
+}, import("@ensforge/core").GetCanonicalResourceError>;
+declare const getMigrationStatusAtom: EnsQueryAtomFactory<import("@ensforge/core").GetMigrationStatusParameters, {
+  readonly status: "unsupported";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly reason: "ENSV2_NOT_ACTIVE" | "NOT_ETH_NAME" | "NAME_NOT_RESERVED";
+} | {
+  readonly status: "not-required";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly reason: "V2_NATIVE" | "AVAILABLE";
+} | {
+  readonly status: "reserved-unwrapped";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+} | {
+  readonly status: "locked-child-pending-parent";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly parent: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly fuses: number;
+} | {
+  readonly status: "reserved-wrapped-unlocked";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly fuses: number;
+} | {
+  readonly status: "reserved-wrapped-locked";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly fuses: number;
+} | {
+  readonly status: "mirrored-child";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly parentRegistry: `0x${string}`;
+  readonly fuses: number;
+} | {
+  readonly status: "migrated-unlocked";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+} | {
+  readonly status: "migrated-locked";
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly registry: `0x${string}`;
+}, import("@ensforge/core").GetCanonicalResourceError>;
+declare const getMigrationTargetAtom: EnsQueryAtomFactory<import("@ensforge/core").GetMigrationStatusParameters, {
+  readonly supported: false;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly reason: "MIGRATION_UNSUPPORTED" | "MIGRATION_NOT_REQUIRED" | "PARENT_NOT_MIGRATED";
+} | {
+  readonly supported: true;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly route: "unwrapped" | "wrapped-unlocked" | "wrapped-locked" | "locked-child";
+  readonly tokenContract: `0x${string}`;
+  readonly tokenId: bigint;
+  readonly tokenStandard: "erc721" | "erc1155";
+  readonly receiver: `0x${string}`;
+}, import("@ensforge/core").GetCanonicalResourceError>;
+declare const createApproveMigrationMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ApproveMigrationParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createMigrateNameMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").MigrateNameParameters, import("@ensforge/core").MigrateNameResult, import("@ensforge/core").WriteError>;
+declare const createMigrateNamesMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").MigrateNamesParameters, import("@ensforge/core").MigrationBatchProgress, import("@ensforge/core").WriteError>;
+//#endregion
+export { createApproveMigrationMutationAtom, createMigrateNameMutationAtom, createMigrateNamesMutationAtom, getMigrationEligibilityAtom, getMigrationPlanAtom, getMigrationStatusAtom, getMigrationTargetAtom };
+//# sourceMappingURL=migration.d.ts.map

package/dist/atoms/migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration.d.ts","names":[],"sources":["../../src/atoms/migration.ts"],"mappings":";;;cAGa,6BAAA,6CAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGvC;cACY,sBAAA,6CAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGhC;cACY,wBAAA,6CAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGlC;cACY,wBAAA,6CAAsB;;;;;;;;;;;;4BAGlC;cAEY,oCAAA,gDAAkC,qDAAA,8CAAA;cAIlC,+BAAA,gDAA6B,gDAAA,4CAAA;cAI7B,gCAAA,gDAA8B,iDAAA,iDAAA"}

package/dist/atoms/migration.js

@@ -0,0 +1,15 @@
+import { makeMutationAtom } from "./mutation.js";
+import { makeQueryAtom } from "./query.js";
+
+//#region src/atoms/migration.ts
+const getMigrationEligibilityAtom = makeQueryAtom("migration", (sdk) => sdk.migration.getMigrationEligibility);
+const getMigrationPlanAtom = makeQueryAtom("migration", (sdk) => sdk.migration.getMigrationPlan);
+const getMigrationStatusAtom = makeQueryAtom("migration", (sdk) => sdk.migration.getMigrationStatus);
+const getMigrationTargetAtom = makeQueryAtom("migration", (sdk) => sdk.migration.getMigrationTarget);
+const createApproveMigrationMutationAtom = makeMutationAtom("migration", (sdk) => sdk.migration.approveMigration);
+const createMigrateNameMutationAtom = makeMutationAtom("migration", (sdk) => sdk.migration.migrateName);
+const createMigrateNamesMutationAtom = makeMutationAtom("migration", (sdk) => sdk.migration.migrateNames);
+
+//#endregion
+export { createApproveMigrationMutationAtom, createMigrateNameMutationAtom, createMigrateNamesMutationAtom, getMigrationEligibilityAtom, getMigrationPlanAtom, getMigrationStatusAtom, getMigrationTargetAtom };
+//# sourceMappingURL=migration.js.map

package/dist/atoms/migration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration.js","names":[],"sources":["../../src/atoms/migration.ts"],"sourcesContent":["import { makeMutationAtom } from \"./mutation.js\";\nimport { makeQueryAtom } from \"./query.js\";\n\nexport const getMigrationEligibilityAtom = makeQueryAtom(\n  \"migration\",\n  (sdk) => sdk.migration.getMigrationEligibility,\n);\nexport const getMigrationPlanAtom = makeQueryAtom(\n  \"migration\",\n  (sdk) => sdk.migration.getMigrationPlan,\n);\nexport const getMigrationStatusAtom = makeQueryAtom(\n  \"migration\",\n  (sdk) => sdk.migration.getMigrationStatus,\n);\nexport const getMigrationTargetAtom = makeQueryAtom(\n  \"migration\",\n  (sdk) => sdk.migration.getMigrationTarget,\n);\n\nexport const createApproveMigrationMutationAtom = makeMutationAtom(\n  \"migration\",\n  (sdk) => sdk.migration.approveMigration,\n);\nexport const createMigrateNameMutationAtom = makeMutationAtom(\n  \"migration\",\n  (sdk) => sdk.migration.migrateName,\n);\nexport const createMigrateNamesMutationAtom = makeMutationAtom(\n  \"migration\",\n  (sdk) => sdk.migration.migrateNames,\n);\n"],"mappings":";;;;AAGA,MAAa,8BAA8B,cACzC,cACC,QAAQ,IAAI,UAAU,uBACzB;AACA,MAAa,uBAAuB,cAClC,cACC,QAAQ,IAAI,UAAU,gBACzB;AACA,MAAa,yBAAyB,cACpC,cACC,QAAQ,IAAI,UAAU,kBACzB;AACA,MAAa,yBAAyB,cACpC,cACC,QAAQ,IAAI,UAAU,kBACzB;AAEA,MAAa,qCAAqC,iBAChD,cACC,QAAQ,IAAI,UAAU,gBACzB;AACA,MAAa,gCAAgC,iBAC3C,cACC,QAAQ,IAAI,UAAU,WACzB;AACA,MAAa,iCAAiC,iBAC5C,cACC,QAAQ,IAAI,UAAU,YACzB"}

package/dist/atoms/mutation.d.ts

@@ -0,0 +1,12 @@
+import { BoundEffectAction } from "../internal/action-types.js";
+import { Ensforge } from "@ensforge/sdk";
+import { Atom } from "effect/unstable/reactivity";
+//#region src/atoms/mutation.d.ts
+type EnsMutationAtom<Parameters, Success, Failure> = Atom.AtomResultFn<Parameters, Success, Failure>;
+interface EnsMutationAtomFactory<Parameters, Success, Failure> {
+  (sdk: Ensforge): EnsMutationAtom<Parameters, Success, Failure>;
+}
+declare const makeMutationAtom: <Parameters, Success, Failure>(group: string, getAction: (sdk: Ensforge) => BoundEffectAction<Parameters, Success, Failure>) => EnsMutationAtomFactory<Parameters, Success, Failure>;
+//#endregion
+export { EnsMutationAtom, EnsMutationAtomFactory, makeMutationAtom };
+//# sourceMappingURL=mutation.d.ts.map

package/dist/atoms/mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation.d.ts","names":[],"sources":["../../src/atoms/mutation.ts"],"mappings":";;;;KASY,gBAAgB,YAAY,SAAS,WAAW,KAAK,aAC/D,YACA,SACA;UAGe,uBAAuB,YAAY,SAAS;GAC1D,KAAK,WAAW,gBAAgB,YAAY,SAAS;;cAG3C,mBACV,YAAY,SAAS,SACpB,eACA,YAAY,KAAK,aAAa,kBAAkB,YAAY,SAAS,aACpE,uBAAuB,YAAY,SAAS"}

package/dist/atoms/mutation.js

@@ -0,0 +1,11 @@
+import { atomRuntime } from "../internal/runtime.js";
+import { makeReactivityKeys } from "../query/keys.js";
+import { Effect } from "effect";
+import { Reactivity } from "effect/unstable/reactivity";
+
+//#region src/atoms/mutation.ts
+const makeMutationAtom = (group, getAction) => (sdk) => atomRuntime.fn((parameters) => Effect.suspend(() => getAction(sdk).effect(parameters)).pipe(Reactivity.mutation(makeReactivityKeys(sdk, group, parameters))), { concurrent: false });
+
+//#endregion
+export { makeMutationAtom };
+//# sourceMappingURL=mutation.js.map

package/dist/atoms/mutation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation.js","names":[],"sources":["../../src/atoms/mutation.ts"],"sourcesContent":["import { Effect } from \"effect\";\nimport { Reactivity, type Atom } from \"effect/unstable/reactivity\";\n\nimport type { Ensforge } from \"@ensforge/sdk\";\n\nimport type { BoundEffectAction } from \"../internal/action-types.js\";\nimport { atomRuntime } from \"../internal/runtime.js\";\nimport { makeReactivityKeys } from \"../query/keys.js\";\n\nexport type EnsMutationAtom<Parameters, Success, Failure> = Atom.AtomResultFn<\n  Parameters,\n  Success,\n  Failure\n>;\n\nexport interface EnsMutationAtomFactory<Parameters, Success, Failure> {\n  (sdk: Ensforge): EnsMutationAtom<Parameters, Success, Failure>;\n}\n\nexport const makeMutationAtom =\n  <Parameters, Success, Failure>(\n    group: string,\n    getAction: (sdk: Ensforge) => BoundEffectAction<Parameters, Success, Failure>,\n  ): EnsMutationAtomFactory<Parameters, Success, Failure> =>\n  (sdk) =>\n    atomRuntime.fn(\n      (parameters: Parameters) =>\n        Effect.suspend(() => getAction(sdk).effect(parameters)).pipe(\n          Reactivity.mutation(makeReactivityKeys(sdk, group, parameters)),\n        ),\n      { concurrent: false },\n    );\n"],"mappings":";;;;;;AAmBA,MAAa,oBAET,OACA,eAED,QACC,YAAY,IACT,eACC,OAAO,cAAc,UAAU,GAAG,CAAC,CAAC,OAAO,UAAU,CAAC,CAAC,CAAC,KACtD,WAAW,SAAS,mBAAmB,KAAK,OAAO,UAAU,CAAC,CAChE,GACF,EAAE,YAAY,MAAM,CACtB"}

package/dist/atoms/name.d.ts

@@ -0,0 +1,141 @@
+import { EnsQueryAtomFactory } from "./query.js";
+//#region src/atoms/name.d.ts
+declare const getCanonicalResourceAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, bigint | null, import("@ensforge/core").GetCanonicalResourceError>;
+declare const getExpiryAtom: EnsQueryAtomFactory<import("@ensforge/core").GetExpiryParameters, {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly expiry: bigint;
+  readonly gracePeriod: bigint;
+  readonly gracePeriodEnd: bigint;
+  readonly protocol: "v1" | "v2";
+  readonly source: "registry" | "nameWrapper" | "baseRegistrar";
+} | null, import("@ensforge/core").GetExpiryError>;
+declare const getManagerAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, `0x${string}` | null, import("@ensforge/core").GetCanonicalResourceError>;
+declare const getNameStateAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, {
+  readonly kind: "available";
+  readonly protocol: "v1" | "v2";
+  readonly wrapped: false;
+  readonly migrated: false;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly status: "available" | "reserved" | "active" | "grace" | "expired";
+  readonly owner: `0x${string}` | null;
+  readonly manager: `0x${string}` | null;
+  readonly registrant: `0x${string}` | null;
+  readonly registry: `0x${string}`;
+  readonly resolver: `0x${string}` | null;
+  readonly expiry: bigint | null;
+  readonly gracePeriodEnd: bigint | null;
+  readonly tokenId: bigint | null;
+  readonly resource: bigint | null;
+  readonly available: boolean;
+  readonly renewable: boolean;
+} | {
+  readonly kind: "v1-unwrapped";
+  readonly protocol: "v1";
+  readonly wrapped: false;
+  readonly migrated: false;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly status: "available" | "reserved" | "active" | "grace" | "expired";
+  readonly owner: `0x${string}` | null;
+  readonly manager: `0x${string}` | null;
+  readonly registrant: `0x${string}` | null;
+  readonly registry: `0x${string}`;
+  readonly resolver: `0x${string}` | null;
+  readonly expiry: bigint | null;
+  readonly gracePeriodEnd: bigint | null;
+  readonly tokenId: bigint | null;
+  readonly resource: bigint | null;
+  readonly available: boolean;
+  readonly renewable: boolean;
+} | {
+  readonly kind: "v1-wrapped";
+  readonly protocol: "v1";
+  readonly wrapped: true;
+  readonly migrated: false;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly status: "available" | "reserved" | "active" | "grace" | "expired";
+  readonly owner: `0x${string}` | null;
+  readonly manager: `0x${string}` | null;
+  readonly registrant: `0x${string}` | null;
+  readonly registry: `0x${string}`;
+  readonly resolver: `0x${string}` | null;
+  readonly expiry: bigint | null;
+  readonly gracePeriodEnd: bigint | null;
+  readonly tokenId: bigint | null;
+  readonly resource: bigint | null;
+  readonly available: boolean;
+  readonly renewable: boolean;
+} | {
+  readonly kind: "v2-native";
+  readonly protocol: "v2";
+  readonly wrapped: boolean;
+  readonly migrated: false;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly status: "available" | "reserved" | "active" | "grace" | "expired";
+  readonly owner: `0x${string}` | null;
+  readonly manager: `0x${string}` | null;
+  readonly registrant: `0x${string}` | null;
+  readonly registry: `0x${string}`;
+  readonly resolver: `0x${string}` | null;
+  readonly expiry: bigint | null;
+  readonly gracePeriodEnd: bigint | null;
+  readonly tokenId: bigint | null;
+  readonly resource: bigint | null;
+  readonly available: boolean;
+  readonly renewable: boolean;
+} | {
+  readonly kind: "v2-migrated";
+  readonly protocol: "v2";
+  readonly wrapped: boolean;
+  readonly migrated: true;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly status: "available" | "reserved" | "active" | "grace" | "expired";
+  readonly owner: `0x${string}` | null;
+  readonly manager: `0x${string}` | null;
+  readonly registrant: `0x${string}` | null;
+  readonly registry: `0x${string}`;
+  readonly resolver: `0x${string}` | null;
+  readonly expiry: bigint | null;
+  readonly gracePeriodEnd: bigint | null;
+  readonly tokenId: bigint | null;
+  readonly resource: bigint | null;
+  readonly available: boolean;
+  readonly renewable: boolean;
+} | {
+  readonly kind: "v2-reserved";
+  readonly protocol: "v1";
+  readonly wrapped: boolean;
+  readonly migrated: false;
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly status: "available" | "reserved" | "active" | "grace" | "expired";
+  readonly owner: `0x${string}` | null;
+  readonly manager: `0x${string}` | null;
+  readonly registrant: `0x${string}` | null;
+  readonly registry: `0x${string}`;
+  readonly resolver: `0x${string}` | null;
+  readonly expiry: bigint | null;
+  readonly gracePeriodEnd: bigint | null;
+  readonly tokenId: bigint | null;
+  readonly resource: bigint | null;
+  readonly available: boolean;
+  readonly renewable: boolean;
+}, import("@ensforge/core").GetCanonicalResourceError>;
+declare const getNameStatusAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, "available" | "reserved" | "active" | "grace" | "expired", import("@ensforge/core").GetCanonicalResourceError>;
+declare const getOwnerAtom: EnsQueryAtomFactory<import("@ensforge/core").GetOwnerParameters, {
+  readonly name: string & import("effect/Brand").Brand<"NormalizedName">;
+  readonly owner: `0x${string}` | null;
+  readonly registrant: `0x${string}` | null;
+  readonly protocol: "v1" | "v2";
+  readonly ownershipLevel: "registrar" | "registry" | "nameWrapper";
+} | null, import("@ensforge/core").GetOwnerError>;
+declare const getProtocolAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, "v1" | "v2", import("@ensforge/core").GetCanonicalResourceError>;
+declare const getRegistrantAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, `0x${string}` | null, import("@ensforge/core").GetCanonicalResourceError>;
+declare const getRegistryAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, `0x${string}`, import("@ensforge/core").GetCanonicalResourceError>;
+declare const getTokenIdAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, bigint | null, import("@ensforge/core").GetCanonicalResourceError>;
+declare const isAvailableAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>;
+declare const isMigratedAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>;
+declare const isRenewableAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>;
+declare const isReservedAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>;
+declare const isWrappedAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, boolean, import("@ensforge/core").GetCanonicalResourceError>;
+//#endregion
+export { getCanonicalResourceAtom, getExpiryAtom, getManagerAtom, getNameStateAtom, getNameStatusAtom, getOwnerAtom, getProtocolAtom, getRegistrantAtom, getRegistryAtom, getTokenIdAtom, isAvailableAtom, isMigratedAtom, isRenewableAtom, isReservedAtom, isWrappedAtom };
+//# sourceMappingURL=name.d.ts.map

package/dist/atoms/name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"name.d.ts","names":[],"sources":["../../src/atoms/name.ts"],"mappings":";;cAEa,0BAAA,6CAAwB,wEAAA;cAIxB,eAAA,6CAAa;;;;;;;mCAAqD;cAClE,gBAAA,6CAAc,+EAAA;cACd,kBAAA,6CAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAwD;cACxE,mBAAA,6CAAiB,oHAAA;cACjB,cAAA,6CAAY;;;;;;mCAAoD;cAChE,iBAAA,6CAAe,sEAAA;cACf,mBAAA,6CAAiB,+EAAA;cACjB,iBAAA,6CAAe,wEAAA;cACf,gBAAA,6CAAc,wEAAA;cACd,iBAAA,6CAAe,kEAAA;cACf,gBAAA,6CAAc,kEAAA;cACd,iBAAA,6CAAe,kEAAA;cACf,gBAAA,6CAAc,kEAAA;cACd,eAAA,6CAAa,kEAAA"}

package/dist/atoms/name.js

@@ -0,0 +1,22 @@
+import { makeQueryAtom } from "./query.js";
+
+//#region src/atoms/name.ts
+const getCanonicalResourceAtom = makeQueryAtom("name", (sdk) => sdk.name.getCanonicalResource);
+const getExpiryAtom = makeQueryAtom("name", (sdk) => sdk.name.getExpiry);
+const getManagerAtom = makeQueryAtom("name", (sdk) => sdk.name.getManager);
+const getNameStateAtom = makeQueryAtom("name", (sdk) => sdk.name.getNameState);
+const getNameStatusAtom = makeQueryAtom("name", (sdk) => sdk.name.getNameStatus);
+const getOwnerAtom = makeQueryAtom("name", (sdk) => sdk.name.getOwner);
+const getProtocolAtom = makeQueryAtom("name", (sdk) => sdk.name.getProtocol);
+const getRegistrantAtom = makeQueryAtom("name", (sdk) => sdk.name.getRegistrant);
+const getRegistryAtom = makeQueryAtom("name", (sdk) => sdk.name.getRegistry);
+const getTokenIdAtom = makeQueryAtom("name", (sdk) => sdk.name.getTokenId);
+const isAvailableAtom = makeQueryAtom("name", (sdk) => sdk.name.isAvailable);
+const isMigratedAtom = makeQueryAtom("name", (sdk) => sdk.name.isMigrated);
+const isRenewableAtom = makeQueryAtom("name", (sdk) => sdk.name.isRenewable);
+const isReservedAtom = makeQueryAtom("name", (sdk) => sdk.name.isReserved);
+const isWrappedAtom = makeQueryAtom("name", (sdk) => sdk.name.isWrapped);
+
+//#endregion
+export { getCanonicalResourceAtom, getExpiryAtom, getManagerAtom, getNameStateAtom, getNameStatusAtom, getOwnerAtom, getProtocolAtom, getRegistrantAtom, getRegistryAtom, getTokenIdAtom, isAvailableAtom, isMigratedAtom, isRenewableAtom, isReservedAtom, isWrappedAtom };
+//# sourceMappingURL=name.js.map

package/dist/atoms/name.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"name.js","names":[],"sources":["../../src/atoms/name.ts"],"sourcesContent":["import { makeQueryAtom } from \"./query.js\";\n\nexport const getCanonicalResourceAtom = makeQueryAtom(\n  \"name\",\n  (sdk) => sdk.name.getCanonicalResource,\n);\nexport const getExpiryAtom = makeQueryAtom(\"name\", (sdk) => sdk.name.getExpiry);\nexport const getManagerAtom = makeQueryAtom(\"name\", (sdk) => sdk.name.getManager);\nexport const getNameStateAtom = makeQueryAtom(\"name\", (sdk) => sdk.name.getNameState);\nexport const getNameStatusAtom = makeQueryAtom(\"name\", (sdk) => sdk.name.getNameStatus);\nexport const getOwnerAtom = makeQueryAtom(\"name\", (sdk) => sdk.name.getOwner);\nexport const getProtocolAtom = makeQueryAtom(\"name\", (sdk) => sdk.name.getProtocol);\nexport const getRegistrantAtom = makeQueryAtom(\"name\", (sdk) => sdk.name.getRegistrant);\nexport const getRegistryAtom = makeQueryAtom(\"name\", (sdk) => sdk.name.getRegistry);\nexport const getTokenIdAtom = makeQueryAtom(\"name\", (sdk) => sdk.name.getTokenId);\nexport const isAvailableAtom = makeQueryAtom(\"name\", (sdk) => sdk.name.isAvailable);\nexport const isMigratedAtom = makeQueryAtom(\"name\", (sdk) => sdk.name.isMigrated);\nexport const isRenewableAtom = makeQueryAtom(\"name\", (sdk) => sdk.name.isRenewable);\nexport const isReservedAtom = makeQueryAtom(\"name\", (sdk) => sdk.name.isReserved);\nexport const isWrappedAtom = makeQueryAtom(\"name\", (sdk) => sdk.name.isWrapped);\n"],"mappings":";;;AAEA,MAAa,2BAA2B,cACtC,SACC,QAAQ,IAAI,KAAK,oBACpB;AACA,MAAa,gBAAgB,cAAc,SAAS,QAAQ,IAAI,KAAK,SAAS;AAC9E,MAAa,iBAAiB,cAAc,SAAS,QAAQ,IAAI,KAAK,UAAU;AAChF,MAAa,mBAAmB,cAAc,SAAS,QAAQ,IAAI,KAAK,YAAY;AACpF,MAAa,oBAAoB,cAAc,SAAS,QAAQ,IAAI,KAAK,aAAa;AACtF,MAAa,eAAe,cAAc,SAAS,QAAQ,IAAI,KAAK,QAAQ;AAC5E,MAAa,kBAAkB,cAAc,SAAS,QAAQ,IAAI,KAAK,WAAW;AAClF,MAAa,oBAAoB,cAAc,SAAS,QAAQ,IAAI,KAAK,aAAa;AACtF,MAAa,kBAAkB,cAAc,SAAS,QAAQ,IAAI,KAAK,WAAW;AAClF,MAAa,iBAAiB,cAAc,SAAS,QAAQ,IAAI,KAAK,UAAU;AAChF,MAAa,kBAAkB,cAAc,SAAS,QAAQ,IAAI,KAAK,WAAW;AAClF,MAAa,iBAAiB,cAAc,SAAS,QAAQ,IAAI,KAAK,UAAU;AAChF,MAAa,kBAAkB,cAAc,SAAS,QAAQ,IAAI,KAAK,WAAW;AAClF,MAAa,iBAAiB,cAAc,SAAS,QAAQ,IAAI,KAAK,UAAU;AAChF,MAAa,gBAAgB,cAAc,SAAS,QAAQ,IAAI,KAAK,SAAS"}

package/dist/atoms/ownership.d.ts

@@ -0,0 +1,12 @@
+import { EnsQueryAtomFactory } from "./query.js";
+import { EnsMutationAtomFactory } from "./mutation.js";
+//#region src/atoms/ownership.d.ts
+declare const getTtlAtom: EnsQueryAtomFactory<import("@ensforge/core").GetCanonicalResourceParameters, import("@ensforge/core").GetTtlResult, import("@ensforge/core").GetCanonicalResourceError>;
+declare const createReclaimNameMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").ReclaimNameParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createSetManagerMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetManagerParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createSetTtlMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").SetTtlParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+declare const createTransferNameMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").TransferNameParameters, import("@ensforge/core").TransferNameProgress, import("@ensforge/core").WriteError>;
+declare const createTransferRegistrantMutationAtom: EnsMutationAtomFactory<import("@ensforge/core").TransferRegistrantParameters, import("@ensforge/core").CallExecutionResult, import("@ensforge/core").WriteError>;
+//#endregion
+export { createReclaimNameMutationAtom, createSetManagerMutationAtom, createSetTtlMutationAtom, createTransferNameMutationAtom, createTransferRegistrantMutationAtom, getTtlAtom };
+//# sourceMappingURL=ownership.d.ts.map

package/dist/atoms/ownership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ownership.d.ts","names":[],"sources":["../../src/atoms/ownership.ts"],"mappings":";;;cAGa,YAAA,6CAAU,yDAAA,uCAAA;cAEV,+BAAA,gDAA6B,gDAAA,8CAAA;cAI7B,8BAAA,gDAA4B,+CAAA,8CAAA;cAI5B,0BAAA,gDAAwB,2CAAA,8CAAA;cAIxB,gCAAA,gDAA8B,iDAAA,+CAAA;cAI9B,sCAAA,gDAAoC,uDAAA,8CAAA"}

package/dist/atoms/ownership.js

@@ -0,0 +1,14 @@
+import { makeMutationAtom } from "./mutation.js";
+import { makeQueryAtom } from "./query.js";
+
+//#region src/atoms/ownership.ts
+const getTtlAtom = makeQueryAtom("ownership", (sdk) => sdk.ownership.getTtl);
+const createReclaimNameMutationAtom = makeMutationAtom("ownership", (sdk) => sdk.ownership.reclaimName);
+const createSetManagerMutationAtom = makeMutationAtom("ownership", (sdk) => sdk.ownership.setManager);
+const createSetTtlMutationAtom = makeMutationAtom("ownership", (sdk) => sdk.ownership.setTtl);
+const createTransferNameMutationAtom = makeMutationAtom("ownership", (sdk) => sdk.ownership.transferName);
+const createTransferRegistrantMutationAtom = makeMutationAtom("ownership", (sdk) => sdk.ownership.transferRegistrant);
+
+//#endregion
+export { createReclaimNameMutationAtom, createSetManagerMutationAtom, createSetTtlMutationAtom, createTransferNameMutationAtom, createTransferRegistrantMutationAtom, getTtlAtom };
+//# sourceMappingURL=ownership.js.map

package/dist/atoms/ownership.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ownership.js","names":[],"sources":["../../src/atoms/ownership.ts"],"sourcesContent":["import { makeMutationAtom } from \"./mutation.js\";\nimport { makeQueryAtom } from \"./query.js\";\n\nexport const getTtlAtom = makeQueryAtom(\"ownership\", (sdk) => sdk.ownership.getTtl);\n\nexport const createReclaimNameMutationAtom = makeMutationAtom(\n  \"ownership\",\n  (sdk) => sdk.ownership.reclaimName,\n);\nexport const createSetManagerMutationAtom = makeMutationAtom(\n  \"ownership\",\n  (sdk) => sdk.ownership.setManager,\n);\nexport const createSetTtlMutationAtom = makeMutationAtom(\n  \"ownership\",\n  (sdk) => sdk.ownership.setTtl,\n);\nexport const createTransferNameMutationAtom = makeMutationAtom(\n  \"ownership\",\n  (sdk) => sdk.ownership.transferName,\n);\nexport const createTransferRegistrantMutationAtom = makeMutationAtom(\n  \"ownership\",\n  (sdk) => sdk.ownership.transferRegistrant,\n);\n"],"mappings":";;;;AAGA,MAAa,aAAa,cAAc,cAAc,QAAQ,IAAI,UAAU,MAAM;AAElF,MAAa,gCAAgC,iBAC3C,cACC,QAAQ,IAAI,UAAU,WACzB;AACA,MAAa,+BAA+B,iBAC1C,cACC,QAAQ,IAAI,UAAU,UACzB;AACA,MAAa,2BAA2B,iBACtC,cACC,QAAQ,IAAI,UAAU,MACzB;AACA,MAAa,iCAAiC,iBAC5C,cACC,QAAQ,IAAI,UAAU,YACzB;AACA,MAAa,uCAAuC,iBAClD,cACC,QAAQ,IAAI,UAAU,kBACzB"}