@domainkit/react 0.3.1 → 0.5.0

package/dist/index.d.mts

@@ -1,9 +1,9 @@
-import { Dialog } from "@base-ui/react/dialog";
 import { Transport } from "domainkit";
 import * as Data from "effect/Data";
 import * as Atom from "effect/unstable/reactivity/Atom";
 import { CSSProperties, ComponentPropsWithoutRef, ElementType, ReactElement, ReactNode, RefObject } from "react";
 import { useRender } from "@base-ui/react/use-render";
+import { Dialog } from "@base-ui/react/dialog";
 import * as Layer from "effect/Layer";
 //#region src/atom.d.ts
 type Runtime = Atom.AtomRuntime<Transport.Service>;
@@ -68,7 +68,7 @@ type PartProps<Tag extends ElementType, State extends Record<string, unknown>> =
   readonly style?: Style<State>;
 };
 declare namespace cleanup_d_exports {
-  export { Command$3 as Command, Controller$3 as Controller, Dialog$3 as Dialog, Flow$3 as Flow, FlowProps$3 as FlowProps, Model$3 as Model, Outcome$2 as Outcome, Root$6 as Root, RootProps$6 as RootProps, State$3 as State, useController$3 as useController, useModel$3 as useModel };
+  export { Command$3 as Command, Completion, Controller$3 as Controller, Dialog$3 as Dialog, DialogProps$2 as DialogProps, Flow$3 as Flow, FlowProps$3 as FlowProps, Model$3 as Model, Outcome$2 as Outcome, Root$6 as Root, RootProps$6 as RootProps, State$3 as State, useController$3 as useController, useModel$3 as useModel };
 }
 type LocalState$3 = Data.TaggedEnum<{
   Cleaned: {
@@ -311,27 +311,37 @@ interface Controller$3 {
   readonly apply: () => void;
   readonly dismiss: () => void;
   readonly plan: () => void;
+  readonly retry: () => void;
   readonly state: State$3;
 }
-declare function useModel$3(connection: Transport.Connected, receiptId: string): Model$3;
-declare function useController$3(connection: Transport.Connected, receiptId: string): Controller$3;
+type Completion = Extract<Transport.CleanupResult, {
+  readonly _tag: "Cleaned" | "Partial";
+}>;
+declare function useModel$3(connection: Transport.Connected, receiptId: string, onCleaned?: (result: Completion) => void): Model$3;
+declare function useController$3(connection: Transport.Connected, receiptId: string, onCleaned?: (result: Completion) => void): Controller$3;
 interface RootProps$6 extends PartProps<"div", {
   readonly status: State$3["_tag"];
 }> {
   readonly status: State$3["_tag"];
 }
-declare function Root$6({ status, ...props }: RootProps$6): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+declare function Root$6({ status, ...props }: RootProps$6): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
 declare function Outcome$2({ state }: {
   readonly state: State$3;
 }): import("react/jsx-runtime").JSX.Element | null;
-declare function Dialog$3({ controller }: {
+interface DialogProps$2 {
   readonly controller: Controller$3;
-}): import("react/jsx-runtime").JSX.Element;
+  readonly onOpenChange?: (open: boolean) => void;
+  readonly onOpenChangeComplete?: (open: boolean) => void;
+  readonly trigger?: ReactElement | null;
+}
+declare function Dialog$3({ controller, onOpenChange, onOpenChangeComplete, trigger }: DialogProps$2): import("react/jsx-runtime").JSX.Element;
 interface FlowProps$3 extends Omit<RootProps$6, "status"> {
   readonly connection: Transport.Connected;
+  readonly onCleaned?: (result: Completion) => void;
   readonly receiptId: string;
+  readonly trigger?: ReactElement;
 }
-declare function Flow$3({ connection, receiptId, ...props }: FlowProps$3): import("react/jsx-runtime").JSX.Element;
+declare function Flow$3({ connection, onCleaned, receiptId, trigger, ...props }: FlowProps$3): import("react/jsx-runtime").JSX.Element;
 declare namespace provider_d_exports {
   export { Mark, MarkElementProps, MarkProps, MarkState, Marks, ProviderDescriptor as Provider };
 }
@@ -346,9 +356,12 @@ interface MarkProps extends PartProps<"span", MarkState> {
 declare function Mark({ provider, ...props }: MarkProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
 type MarkElementProps = ComponentPropsWithoutRef<"span">;
 declare namespace connection_d_exports {
-  export { ActionState, Command$2 as Command, ConnectTrigger, ConnectTriggerProps, Connected, Controller$2 as Controller, Dialog$2 as Dialog, DialogProps, DisconnectAction, DisconnectActionProps, DisconnectState, Flow$2 as Flow, FlowProps$2 as FlowProps, Model$2 as Model, OAuthAction, OAuthActionProps, RetryAction$1 as RetryAction, RetryActionProps, ReuseAction, ReuseActionProps, Root$5 as Root, RootProps$5 as RootProps, RootState$1 as RootState, State$2 as State, Status$2 as Status, StatusProps$2 as StatusProps, StatusState, TokenAction, TokenActionProps, Trigger, TriggerProps, useController$2 as useController, useDisconnect, useModel$2 as useModel };
+  export { ActionState, AttachAction, AttachActionProps, Card$1 as Card, CardActions, CardActionsProps, CardIdentity, CardIdentityProps, CardProps$1 as CardProps, Command$2 as Command, ConnectTrigger, ConnectTriggerProps, Connected, Controller$2 as Controller, Dialog$2 as Dialog, DialogProps$1 as DialogProps, DisconnectDialog, DisconnectDialogProps, Flow$2 as Flow, FlowProps$2 as FlowProps, IntegrationAction, IntegrationActionProps, Model$2 as Model, OAuthAction, OAuthActionProps, RetryAction$1 as RetryAction, RetryActionProps, Root$5 as Root, RootProps$5 as RootProps, RootState$1 as RootState, State$2 as State, Status$2 as Status, StatusProps$2 as StatusProps, StatusState, TokenAction, TokenActionProps, Trigger, TriggerProps, targetLabel, useController$2 as useController, useModel$2 as useModel };
 }
 type LocalState$2 = Data.TaggedEnum<{
+  Detaching: {
+    readonly snapshot: Transport.Connected;
+  };
   Loading: {};
   Redirecting: {
     readonly snapshot: Disconnected;
@@ -358,7 +371,12 @@ type LocalState$2 = Data.TaggedEnum<{
   };
 }>;
 declare const State$2: {
-  readonly $is: <Tag extends "Loading" | "Redirecting" | "Submitting">(tag: Tag) => (u: unknown) => u is Extract<{
+  readonly $is: <Tag extends "Detaching" | "Loading" | "Redirecting" | "Submitting">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Detaching";
+    readonly snapshot: Transport.Connected;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
     readonly _tag: "Loading";
   }, {
     readonly _tag: Tag;
@@ -374,7 +392,10 @@ declare const State$2: {
     readonly _tag: Tag;
   }>;
   readonly $match: {
-    <Cases extends { readonly [Tag in "Loading" | "Redirecting" | "Submitting"]: (args: Extract<{
+    <Cases extends { readonly [Tag in "Detaching" | "Loading" | "Redirecting" | "Submitting"]: (args: Extract<{
+      readonly _tag: "Detaching";
+      readonly snapshot: Transport.Connected;
+    } | {
       readonly _tag: "Loading";
     } | {
       readonly _tag: "Redirecting";
@@ -385,6 +406,9 @@ declare const State$2: {
     }, {
       readonly _tag: Tag;
     }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Detaching";
+      readonly snapshot: Transport.Connected;
+    } | {
       readonly _tag: "Loading";
     } | {
       readonly _tag: "Redirecting";
@@ -392,8 +416,11 @@ declare const State$2: {
     } | {
       readonly _tag: "Submitting";
       readonly snapshot: Disconnected;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Loading" | "Redirecting" | "Submitting"]>>;
-    <Cases extends { readonly [Tag in "Loading" | "Redirecting" | "Submitting"]: (args: Extract<{
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Detaching" | "Loading" | "Redirecting" | "Submitting"]>>;
+    <Cases extends { readonly [Tag in "Detaching" | "Loading" | "Redirecting" | "Submitting"]: (args: Extract<{
+      readonly _tag: "Detaching";
+      readonly snapshot: Transport.Connected;
+    } | {
       readonly _tag: "Loading";
     } | {
       readonly _tag: "Redirecting";
@@ -404,6 +431,9 @@ declare const State$2: {
     }, {
       readonly _tag: Tag;
     }>) => any; }>(value: {
+      readonly _tag: "Detaching";
+      readonly snapshot: Transport.Connected;
+    } | {
       readonly _tag: "Loading";
     } | {
       readonly _tag: "Redirecting";
@@ -411,8 +441,12 @@ declare const State$2: {
     } | {
       readonly _tag: "Submitting";
       readonly snapshot: Disconnected;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Loading" | "Redirecting" | "Submitting"]>>;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Detaching" | "Loading" | "Redirecting" | "Submitting"]>>;
   };
+  readonly Detaching: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Detaching";
+    readonly snapshot: Transport.Connected;
+  }, "_tag">;
   readonly Loading: Data.TaggedEnum.ConstructorFrom<{
     readonly _tag: "Loading";
   }, "_tag">;
@@ -430,79 +464,111 @@ type Disconnected = Extract<Transport.ConnectionSnapshot, {
   readonly _tag: "Disconnected";
 }>;
 interface Controller$2 {
+  readonly attach: (connection: Transport.ReusableConnection, target: Transport.ProviderTarget) => void;
   readonly connect: (method: Transport.Method) => void;
+  readonly detach: () => void;
   readonly retry: () => void;
-  readonly reuse: () => void;
   readonly state: State$2;
 }
 type Command$2 = Data.TaggedEnum<{
+  Attach: {
+    readonly connectionId: string;
+    readonly target: Transport.ProviderTarget;
+  };
   Connect: {
     readonly method: Transport.Method;
   };
+  Detach: {};
   Retry: {};
-  Reuse: {};
 }>;
 declare const Command$2: {
-  readonly $is: <Tag extends "Connect" | "Retry" | "Reuse">(tag: Tag) => (u: unknown) => u is Extract<{
+  readonly $is: <Tag extends "Attach" | "Connect" | "Detach" | "Retry">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Attach";
+    readonly connectionId: string;
+    readonly target: Transport.ProviderTarget;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
     readonly _tag: "Connect";
     readonly method: Transport.Method;
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "Retry";
+    readonly _tag: "Detach";
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "Reuse";
+    readonly _tag: "Retry";
   }, {
     readonly _tag: Tag;
   }>;
   readonly $match: {
-    <Cases extends { readonly [Tag in "Connect" | "Retry" | "Reuse"]: (args: Extract<{
+    <Cases extends { readonly [Tag in "Attach" | "Connect" | "Detach" | "Retry"]: (args: Extract<{
+      readonly _tag: "Attach";
+      readonly connectionId: string;
+      readonly target: Transport.ProviderTarget;
+    } | {
       readonly _tag: "Connect";
       readonly method: Transport.Method;
     } | {
-      readonly _tag: "Retry";
+      readonly _tag: "Detach";
     } | {
-      readonly _tag: "Reuse";
+      readonly _tag: "Retry";
     }, {
       readonly _tag: Tag;
     }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Attach";
+      readonly connectionId: string;
+      readonly target: Transport.ProviderTarget;
+    } | {
       readonly _tag: "Connect";
       readonly method: Transport.Method;
+    } | {
+      readonly _tag: "Detach";
     } | {
       readonly _tag: "Retry";
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Attach" | "Connect" | "Detach" | "Retry"]>>;
+    <Cases extends { readonly [Tag in "Attach" | "Connect" | "Detach" | "Retry"]: (args: Extract<{
+      readonly _tag: "Attach";
+      readonly connectionId: string;
+      readonly target: Transport.ProviderTarget;
     } | {
-      readonly _tag: "Reuse";
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Connect" | "Retry" | "Reuse"]>>;
-    <Cases extends { readonly [Tag in "Connect" | "Retry" | "Reuse"]: (args: Extract<{
       readonly _tag: "Connect";
       readonly method: Transport.Method;
     } | {
-      readonly _tag: "Retry";
+      readonly _tag: "Detach";
     } | {
-      readonly _tag: "Reuse";
+      readonly _tag: "Retry";
     }, {
       readonly _tag: Tag;
     }>) => any; }>(value: {
+      readonly _tag: "Attach";
+      readonly connectionId: string;
+      readonly target: Transport.ProviderTarget;
+    } | {
       readonly _tag: "Connect";
       readonly method: Transport.Method;
     } | {
-      readonly _tag: "Retry";
+      readonly _tag: "Detach";
     } | {
-      readonly _tag: "Reuse";
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Connect" | "Retry" | "Reuse"]>>;
+      readonly _tag: "Retry";
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Attach" | "Connect" | "Detach" | "Retry"]>>;
   };
+  readonly Attach: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Attach";
+    readonly connectionId: string;
+    readonly target: Transport.ProviderTarget;
+  }, "_tag">;
   readonly Connect: Data.TaggedEnum.ConstructorFrom<{
     readonly _tag: "Connect";
     readonly method: Transport.Method;
   }, "_tag">;
+  readonly Detach: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Detach";
+  }, "_tag">;
   readonly Retry: Data.TaggedEnum.ConstructorFrom<{
     readonly _tag: "Retry";
   }, "_tag">;
-  readonly Reuse: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Reuse";
-  }, "_tag">;
 };
 interface Model$2 {
   readonly command: Atom.AtomResultFn<Command$2, void>;
@@ -516,14 +582,14 @@ interface RootState$1 extends Record<string, unknown> {
 interface RootProps$5 extends PartProps<"div", RootState$1> {
   readonly status?: State$2["_tag"];
 }
-declare function Root$5({ children, status, ...props }: RootProps$5): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+declare function Root$5({ children, status, ...props }: RootProps$5): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
 interface StatusState extends Record<string, unknown> {
   readonly status: State$2["_tag"];
 }
 interface StatusProps$2 extends PartProps<"div", StatusState> {
   readonly state: State$2;
 }
-declare function Status$2({ children, state, ...props }: StatusProps$2): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+declare function Status$2({ children, state, ...props }: StatusProps$2): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
 interface TriggerProps extends Omit<ComponentPropsWithoutRef<typeof Dialog.Trigger>, "children"> {
   readonly children: ReactNode;
 }
@@ -534,30 +600,38 @@ interface ConnectTriggerProps extends Omit<TriggerProps, "children"> {
 declare function Trigger({ children, ...props }: TriggerProps): import("react/jsx-runtime").JSX.Element;
 declare function ConnectTrigger({ children, provider, ...props }: ConnectTriggerProps): import("react/jsx-runtime").JSX.Element;
 interface ActionState extends Record<string, unknown> {
-  readonly authentication: "oauth" | "reuse" | "token";
+  readonly authentication: "attach" | "integration" | "oauth" | "token";
 }
 interface OAuthActionProps extends PartProps<"button", ActionState> {
   readonly controller: Controller$2;
   readonly label: string;
 }
-declare function OAuthAction({ controller, label, ...props }: OAuthActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-interface ReuseActionProps extends PartProps<"button", ActionState> {
+declare function OAuthAction({ controller, label, ...props }: OAuthActionProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+interface IntegrationActionProps extends PartProps<"button", ActionState> {
   readonly controller: Controller$2;
   readonly label: string;
 }
-declare function ReuseAction({ controller, label, ...props }: ReuseActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+declare function IntegrationAction({ controller, label, ...props }: IntegrationActionProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+interface AttachActionProps extends PartProps<"button", ActionState> {
+  readonly connection: Transport.ReusableConnection;
+  readonly controller: Controller$2;
+  readonly label: string;
+  readonly target: Transport.ProviderTarget;
+}
+declare function AttachAction({ connection, controller, label, target, ...props }: AttachActionProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
 interface TokenActionProps extends Omit<PartProps<"form", ActionState>, "method"> {
   readonly controller: Controller$2;
   readonly method: Extract<Transport.AuthenticationMethod, {
     readonly _tag: "Token";
   }>;
 }
-declare function TokenAction({ controller, method, ...props }: TokenActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-interface DialogProps {
+declare function TokenAction({ controller, method, ...props }: TokenActionProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+interface DialogProps$1 {
   readonly controller: Controller$2;
   readonly snapshot: Disconnected;
 }
-declare function Dialog$2({ controller, snapshot }: DialogProps): import("react/jsx-runtime").JSX.Element;
+declare const targetLabel: (target: Transport.ProviderTarget) => string;
+declare function Dialog$2({ controller, snapshot }: DialogProps$1): import("react/jsx-runtime").JSX.Element;
 interface FlowProps$2 extends Omit<RootProps$5, "children"> {
   readonly domain: string;
 }
@@ -568,80 +642,310 @@ interface RetryActionProps extends PartProps<"button", {
   readonly controller: Controller$2;
   readonly kind?: "after-user-action" | "retry";
 }
-declare function RetryAction$1({ controller, kind, ...props }: RetryActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-type LocalDisconnectState = Data.TaggedEnum<{
-  Disconnecting: {};
-  Idle: {};
+declare function RetryAction$1({ controller, kind, ...props }: RetryActionProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+interface CardProps$1 extends PartProps<"div", {
+  readonly status: State$2["_tag"];
+}> {
+  readonly status: State$2["_tag"];
+}
+declare function Card$1({ status, ...props }: CardProps$1): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+interface CardIdentityProps extends PartProps<"div", {
+  readonly status: State$2["_tag"];
+}> {
+  readonly status: State$2["_tag"];
+}
+declare function CardIdentity({ status, ...props }: CardIdentityProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+interface CardActionsProps extends PartProps<"div", {
+  readonly status: State$2["_tag"];
+}> {
+  readonly status: State$2["_tag"];
+}
+declare function CardActions({ status, ...props }: CardActionsProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+interface DisconnectDialogProps {
+  readonly connection: Transport.Connected;
+  readonly controller: Controller$2;
+  readonly onOpenChange?: (open: boolean) => void;
+  readonly open?: boolean;
+  readonly trigger?: ReactElement | null;
+}
+declare function DisconnectDialog({ connection, controller, onOpenChange, open: openProp, trigger }: DisconnectDialogProps): import("react/jsx-runtime").JSX.Element;
+type Connected = Transport.Connected;
+declare namespace domain_d_exports {
+  export { Flow$1 as Flow, FlowProps$1 as FlowProps };
+}
+interface FlowProps$1 {
+  readonly domain: string;
+  readonly receiptId?: string;
+  readonly records: ReadonlyArray<Transport.DnsRecord>;
+}
+declare function Flow$1({ domain, receiptId, records }: FlowProps$1): import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/icons.d.ts
+type Icons = {
+  readonly copied: ReactNode;
+  readonly copy: ReactNode;
+  readonly download: ReactNode;
+};
+declare namespace lifecycle_d_exports {
+  export { Event, Listener };
+}
+/** User-action lifecycle events suitable for host notifications and telemetry. */
+type Event = Data.TaggedEnum<{
+  ConnectionEstablished: {
+    readonly connection: Transport.Connected;
+    readonly source: "attach" | "connect";
+  };
+  DomainDetached: {
+    readonly connection: Transport.Connected;
+    readonly result: Transport.DetachResult;
+  };
+  RecordsApplied: {
+    readonly connection: Transport.Connected;
+    readonly result: Extract<Transport.ApplyResult, {
+      readonly _tag: "Applied";
+    }>;
+  };
+  RecordsCleaned: {
+    readonly connection: Transport.Connected;
+    readonly result: Extract<Transport.CleanupResult, {
+      readonly _tag: "Cleaned";
+    }>;
+  };
+  RecordsPartiallyApplied: {
+    readonly connection: Transport.Connected;
+    readonly result: Extract<Transport.ApplyResult, {
+      readonly _tag: "Partial";
+    }>;
+  };
+  RecordsPartiallyCleaned: {
+    readonly connection: Transport.Connected;
+    readonly result: Extract<Transport.CleanupResult, {
+      readonly _tag: "Partial";
+    }>;
+  };
 }>;
-declare const DisconnectState: {
-  readonly $is: <Tag extends "Disconnecting" | "Idle">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Disconnecting";
+declare const Event: {
+  readonly $is: <Tag extends "ConnectionEstablished" | "DomainDetached" | "RecordsApplied" | "RecordsCleaned" | "RecordsPartiallyApplied" | "RecordsPartiallyCleaned">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "ConnectionEstablished";
+    readonly connection: Transport.Connected;
+    readonly source: "attach" | "connect";
   }, {
     readonly _tag: Tag;
   }> | Extract<{
-    readonly _tag: "Idle";
+    readonly _tag: "DomainDetached";
+    readonly connection: Transport.Connected;
+    readonly result: Transport.DetachResult;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "RecordsApplied";
+    readonly connection: Transport.Connected;
+    readonly result: Extract<Transport.ApplyResult, {
+      readonly _tag: "Applied";
+    }>;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "RecordsCleaned";
+    readonly connection: Transport.Connected;
+    readonly result: Extract<Transport.CleanupResult, {
+      readonly _tag: "Cleaned";
+    }>;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "RecordsPartiallyApplied";
+    readonly connection: Transport.Connected;
+    readonly result: Extract<Transport.ApplyResult, {
+      readonly _tag: "Partial";
+    }>;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "RecordsPartiallyCleaned";
+    readonly connection: Transport.Connected;
+    readonly result: Extract<Transport.CleanupResult, {
+      readonly _tag: "Partial";
+    }>;
   }, {
     readonly _tag: Tag;
   }>;
   readonly $match: {
-    <Cases extends { readonly [Tag in "Disconnecting" | "Idle"]: (args: Extract<{
-      readonly _tag: "Disconnecting";
+    <Cases extends { readonly [Tag in "ConnectionEstablished" | "DomainDetached" | "RecordsApplied" | "RecordsCleaned" | "RecordsPartiallyApplied" | "RecordsPartiallyCleaned"]: (args: Extract<{
+      readonly _tag: "ConnectionEstablished";
+      readonly connection: Transport.Connected;
+      readonly source: "attach" | "connect";
     } | {
-      readonly _tag: "Idle";
+      readonly _tag: "DomainDetached";
+      readonly connection: Transport.Connected;
+      readonly result: Transport.DetachResult;
+    } | {
+      readonly _tag: "RecordsApplied";
+      readonly connection: Transport.Connected;
+      readonly result: Extract<Transport.ApplyResult, {
+        readonly _tag: "Applied";
+      }>;
+    } | {
+      readonly _tag: "RecordsCleaned";
+      readonly connection: Transport.Connected;
+      readonly result: Extract<Transport.CleanupResult, {
+        readonly _tag: "Cleaned";
+      }>;
+    } | {
+      readonly _tag: "RecordsPartiallyApplied";
+      readonly connection: Transport.Connected;
+      readonly result: Extract<Transport.ApplyResult, {
+        readonly _tag: "Partial";
+      }>;
+    } | {
+      readonly _tag: "RecordsPartiallyCleaned";
+      readonly connection: Transport.Connected;
+      readonly result: Extract<Transport.CleanupResult, {
+        readonly _tag: "Partial";
+      }>;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Disconnecting";
+      readonly _tag: "ConnectionEstablished";
+      readonly connection: Transport.Connected;
+      readonly source: "attach" | "connect";
     } | {
-      readonly _tag: "Idle";
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Disconnecting" | "Idle"]>>;
-    <Cases extends { readonly [Tag in "Disconnecting" | "Idle"]: (args: Extract<{
-      readonly _tag: "Disconnecting";
+      readonly _tag: "DomainDetached";
+      readonly connection: Transport.Connected;
+      readonly result: Transport.DetachResult;
     } | {
-      readonly _tag: "Idle";
+      readonly _tag: "RecordsApplied";
+      readonly connection: Transport.Connected;
+      readonly result: Extract<Transport.ApplyResult, {
+        readonly _tag: "Applied";
+      }>;
+    } | {
+      readonly _tag: "RecordsCleaned";
+      readonly connection: Transport.Connected;
+      readonly result: Extract<Transport.CleanupResult, {
+        readonly _tag: "Cleaned";
+      }>;
+    } | {
+      readonly _tag: "RecordsPartiallyApplied";
+      readonly connection: Transport.Connected;
+      readonly result: Extract<Transport.ApplyResult, {
+        readonly _tag: "Partial";
+      }>;
+    } | {
+      readonly _tag: "RecordsPartiallyCleaned";
+      readonly connection: Transport.Connected;
+      readonly result: Extract<Transport.CleanupResult, {
+        readonly _tag: "Partial";
+      }>;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["ConnectionEstablished" | "DomainDetached" | "RecordsApplied" | "RecordsCleaned" | "RecordsPartiallyApplied" | "RecordsPartiallyCleaned"]>>;
+    <Cases extends { readonly [Tag in "ConnectionEstablished" | "DomainDetached" | "RecordsApplied" | "RecordsCleaned" | "RecordsPartiallyApplied" | "RecordsPartiallyCleaned"]: (args: Extract<{
+      readonly _tag: "ConnectionEstablished";
+      readonly connection: Transport.Connected;
+      readonly source: "attach" | "connect";
+    } | {
+      readonly _tag: "DomainDetached";
+      readonly connection: Transport.Connected;
+      readonly result: Transport.DetachResult;
+    } | {
+      readonly _tag: "RecordsApplied";
+      readonly connection: Transport.Connected;
+      readonly result: Extract<Transport.ApplyResult, {
+        readonly _tag: "Applied";
+      }>;
+    } | {
+      readonly _tag: "RecordsCleaned";
+      readonly connection: Transport.Connected;
+      readonly result: Extract<Transport.CleanupResult, {
+        readonly _tag: "Cleaned";
+      }>;
+    } | {
+      readonly _tag: "RecordsPartiallyApplied";
+      readonly connection: Transport.Connected;
+      readonly result: Extract<Transport.ApplyResult, {
+        readonly _tag: "Partial";
+      }>;
+    } | {
+      readonly _tag: "RecordsPartiallyCleaned";
+      readonly connection: Transport.Connected;
+      readonly result: Extract<Transport.CleanupResult, {
+        readonly _tag: "Partial";
+      }>;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(value: {
-      readonly _tag: "Disconnecting";
+      readonly _tag: "ConnectionEstablished";
+      readonly connection: Transport.Connected;
+      readonly source: "attach" | "connect";
     } | {
-      readonly _tag: "Idle";
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Disconnecting" | "Idle"]>>;
+      readonly _tag: "DomainDetached";
+      readonly connection: Transport.Connected;
+      readonly result: Transport.DetachResult;
+    } | {
+      readonly _tag: "RecordsApplied";
+      readonly connection: Transport.Connected;
+      readonly result: Extract<Transport.ApplyResult, {
+        readonly _tag: "Applied";
+      }>;
+    } | {
+      readonly _tag: "RecordsCleaned";
+      readonly connection: Transport.Connected;
+      readonly result: Extract<Transport.CleanupResult, {
+        readonly _tag: "Cleaned";
+      }>;
+    } | {
+      readonly _tag: "RecordsPartiallyApplied";
+      readonly connection: Transport.Connected;
+      readonly result: Extract<Transport.ApplyResult, {
+        readonly _tag: "Partial";
+      }>;
+    } | {
+      readonly _tag: "RecordsPartiallyCleaned";
+      readonly connection: Transport.Connected;
+      readonly result: Extract<Transport.CleanupResult, {
+        readonly _tag: "Partial";
+      }>;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["ConnectionEstablished" | "DomainDetached" | "RecordsApplied" | "RecordsCleaned" | "RecordsPartiallyApplied" | "RecordsPartiallyCleaned"]>>;
   };
-  readonly Disconnecting: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Disconnecting";
+  readonly ConnectionEstablished: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "ConnectionEstablished";
+    readonly connection: Transport.Connected;
+    readonly source: "attach" | "connect";
   }, "_tag">;
-  readonly Idle: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Idle";
+  readonly DomainDetached: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "DomainDetached";
+    readonly connection: Transport.Connected;
+    readonly result: Transport.DetachResult;
+  }, "_tag">;
+  readonly RecordsApplied: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "RecordsApplied";
+    readonly connection: Transport.Connected;
+    readonly result: Extract<Transport.ApplyResult, {
+      readonly _tag: "Applied";
+    }>;
+  }, "_tag">;
+  readonly RecordsCleaned: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "RecordsCleaned";
+    readonly connection: Transport.Connected;
+    readonly result: Extract<Transport.CleanupResult, {
+      readonly _tag: "Cleaned";
+    }>;
+  }, "_tag">;
+  readonly RecordsPartiallyApplied: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "RecordsPartiallyApplied";
+    readonly connection: Transport.Connected;
+    readonly result: Extract<Transport.ApplyResult, {
+      readonly _tag: "Partial";
+    }>;
+  }, "_tag">;
+  readonly RecordsPartiallyCleaned: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "RecordsPartiallyCleaned";
+    readonly connection: Transport.Connected;
+    readonly result: Extract<Transport.CleanupResult, {
+      readonly _tag: "Partial";
+    }>;
   }, "_tag">;
 };
-type DisconnectState = LocalDisconnectState | Transport.RemoveDomainResult | Failure;
-declare function useDisconnect(connection: Transport.Connected): {
-  readonly disconnect: () => void;
-  readonly state: DisconnectState;
-};
-interface DisconnectActionProps extends PartProps<"div", {
-  readonly status: DisconnectState["_tag"];
-}> {
-  readonly connection: Transport.Connected;
-}
-declare function DisconnectAction({ connection, ...props }: DisconnectActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
-type Connected = Transport.Connected;
-declare namespace domain_d_exports {
-  export { Flow$1 as Flow, FlowProps$1 as FlowProps };
-}
-interface FlowProps$1 {
-  readonly domain: string;
-  readonly receiptId?: string;
-  readonly records: ReadonlyArray<Transport.DnsRecord>;
-}
-declare function Flow$1({ domain, receiptId, records }: FlowProps$1): import("react/jsx-runtime").JSX.Element;
-//#endregion
-//#region src/icons.d.ts
-type Icons = {
-  readonly copied: ReactNode;
-  readonly copy: ReactNode;
-  readonly download: ReactNode;
-};
+type Listener = (event: Event) => void;
 declare namespace messages_d_exports {
   export { Catalog, english, merge };
 }
@@ -649,12 +953,12 @@ interface Catalog {
   readonly applyCleanup: string;
   readonly applyDns: string;
   readonly applyingDns: string;
+  readonly authenticationAlternative: string;
   readonly automaticUnavailable: string;
   readonly cancel: string;
   readonly checkAgain: string;
   readonly checkingDns: string;
   readonly checkDns: string;
-  readonly cleanupComplete: string;
   readonly cleanupConsent: string;
   readonly cleanupPartial: string;
   readonly cleaningDns: string;
@@ -665,20 +969,25 @@ interface Catalog {
   readonly close: string;
   readonly detectingProvider: string;
   readonly disconnectDomain: string;
+  readonly disconnectConsent: string;
   readonly disconnecting: string;
+  readonly detaching: string;
+  readonly disconnectTitle: (provider: string) => string;
   readonly domainDisconnected: string;
   readonly dialogDescription: (domain: string) => string;
   readonly dialogTitle: (provider: string) => string;
   readonly openingAuthorization: string;
+  readonly moreActions: string;
   readonly planConsent: string;
   readonly planningCleanup: string;
   readonly planningDns: string;
-  readonly recordsApplied: string;
   readonly recordsPartiallyApplied: string;
   readonly reviewCleanup: string;
   readonly reviewDns: string;
   readonly retry: string;
-  readonly reuseConnection: (connection: string) => string;
+  readonly existingConnection: string;
+  readonly targetUnavailable: string;
+  readonly attachTarget: (target: string) => string;
   readonly tokenLabel: string;
 }
 declare const english: Catalog;
@@ -689,9 +998,11 @@ declare namespace theme_d_exports {
 interface Theme {
   readonly accent?: string;
   readonly accentContrast?: string;
+  readonly backdrop?: string;
   readonly background?: string;
   readonly border?: string;
   readonly danger?: string;
+  readonly dangerContrast?: string;
   readonly fill?: string;
   readonly fontFamily?: string;
   readonly muted?: string;
@@ -714,6 +1025,7 @@ interface RootProps$4 extends Omit<PartProps<"div", RootState>, "children"> {
   readonly messages?: Partial<Catalog>;
   readonly marks?: Marks;
   readonly navigate?: (url: string) => void;
+  readonly onEvent?: Listener;
   readonly portalContainer?: HTMLElement | null;
   readonly theme?: Theme;
   readonly transport: Layer.Layer<Transport.Service>;
@@ -723,11 +1035,12 @@ interface ContextValue {
   readonly navigate: (url: string) => void;
   readonly marks: Marks;
   readonly messages: Catalog;
+  readonly emit: Listener;
   readonly portalContainer: RefObject<HTMLElement | null>;
   readonly themeStyle: ReturnType<typeof toStyle>;
   readonly runtime: Runtime;
 }
-declare function Root$4({ children, colorScheme, icons, marks, messages, navigate, portalContainer, theme, transport, ...props }: RootProps$4): import("react/jsx-runtime").JSX.Element;
+declare function Root$4({ children, colorScheme, icons, marks, messages, navigate, onEvent, portalContainer, theme, transport, ...props }: RootProps$4): import("react/jsx-runtime").JSX.Element;
 declare function useDomainKit(): ContextValue;
 declare namespace operations_d_exports {
   export { Item, ItemProps, Kind, Lifecycle, List, ListProps, Name, Operation, Priority$1 as Priority, Reason, Record$1 as Record, Root$3 as Root, RootProps$3 as RootProps, Type, Value$1 as Value };
@@ -761,7 +1074,7 @@ interface ListProps extends Omit<RootProps$3, "children" | "count"> {
 }
 declare function List({ lifecycle, operations, ...props }: ListProps): import("react/jsx-runtime").JSX.Element;
 declare namespace provisioning_d_exports {
-  export { Command$1 as Command, Controller$1 as Controller, Dialog$1 as Dialog, Flow, FlowProps, Model$1 as Model, Outcome$1 as Outcome, RetryAction, Root$2 as Root, RootProps$2 as RootProps, State$1 as State, useController$1 as useController, useModel$1 as useModel };
+  export { Command$1 as Command, Controller$1 as Controller, Dialog$1 as Dialog, DialogProps, Flow, FlowProps, Model$1 as Model, Outcome$1 as Outcome, RetryAction, Root$2 as Root, RootProps$2 as RootProps, State$1 as State, useController$1 as useController, useModel$1 as useModel };
 }
 type LocalState$1 = Data.TaggedEnum<{
   Applying: {
@@ -1018,13 +1331,15 @@ interface RootProps$2 extends PartProps<"div", {
 }> {
   readonly status: State$1["_tag"];
 }
-declare function Root$2({ status, ...props }: RootProps$2): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+declare function Root$2({ status, ...props }: RootProps$2): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
 declare function Outcome$1({ state }: {
   readonly state: State$1;
 }): import("react/jsx-runtime").JSX.Element | null;
-declare function Dialog$1({ controller }: {
+interface DialogProps {
   readonly controller: Controller$1;
-}): import("react/jsx-runtime").JSX.Element;
+  readonly trigger?: ReactElement;
+}
+declare function Dialog$1({ controller, trigger }: DialogProps): import("react/jsx-runtime").JSX.Element;
 declare function RetryAction({ controller }: {
   readonly controller: Controller$1;
 }): import("react/jsx-runtime").JSX.Element | null;
@@ -1035,8 +1350,9 @@ interface FlowProps extends Omit<RootProps$2, "status"> {
   }>) => void;
   readonly records: ReadonlyArray<Transport.DnsRecord>;
   readonly showRecords?: boolean;
+  readonly trigger?: ReactElement;
 }
-declare function Flow({ connection, onApplied, records, showRecords, ...props }: FlowProps): import("react/jsx-runtime").JSX.Element;
+declare function Flow({ connection, onApplied, records, showRecords, trigger, ...props }: FlowProps): import("react/jsx-runtime").JSX.Element;
 declare namespace records_d_exports {
   export { Body, Caption, Card, CardContent, CardHeader, CardProps, CardTitle, Cell, CopyController, CopyValue, CopyValueProps, DnsRecord, Footer, Head, Header, ObservationEvidence, Priority, PriorityProps, Root$1 as Root, RootProps$1 as RootProps, Row, Status$1 as Status, StatusProps$1 as StatusProps, Table, TableProps, Value, ZoneFile, ZoneFileProps, copyText, downloadZoneFile, toZoneFile, useCopy };
 }
@@ -1122,13 +1438,13 @@ declare const downloadZoneFile: (domain: string, records: ReadonlyArray<Transpor
 type DnsRecord = Transport.DnsRecord;
 type ObservationEvidence = Transport.ObservationEvidence;
 declare namespace testing_d_exports {
-  export { FakeOptions, FakeTransport, makeFakeTransport, provider$1 as provider };
+  export { FakeOptions, FakeTransport, attachment, connected, connection$1 as connection, makeFakeTransport, provider$1 as provider, target$1 as target };
 }
 interface FakeOptions {
   readonly connect?: Transport.ConnectionResult;
   readonly inspect: Transport.ConnectionSnapshot | FakeFailure | ReadonlyArray<Transport.ConnectionSnapshot | FakeFailure>;
-  readonly reuse?: Transport.Connected;
-  readonly removeDomain?: Transport.RemoveDomainResult;
+  readonly attach?: Transport.Connected;
+  readonly detach?: Transport.DetachResult;
   readonly plan?: Transport.ProvisioningPlan;
   readonly apply?: Transport.ApplyResult;
   readonly observe?: Transport.Observation;
@@ -1143,10 +1459,10 @@ interface FakeFailure {
 }
 interface FakeTransport extends Transport.AsyncInterface, Layer.Layer<Transport.Service> {
   readonly calls: {
+    readonly attach: Array<Transport.AttachInput>;
     readonly connect: Array<Transport.ConnectInput>;
+    readonly detach: Array<Transport.DetachInput>;
     readonly inspect: Array<Transport.InspectInput>;
-    readonly reuse: Array<Transport.ReuseInput>;
-    readonly removeDomain: Array<Transport.RemoveDomainInput>;
     readonly plan: Array<Transport.ProvisioningPlanInput>;
     readonly apply: Array<Transport.ProvisioningApplyInput>;
     readonly observe: Array<Transport.ObserveInput>;
@@ -1155,56 +1471,99 @@ interface FakeTransport extends Transport.AsyncInterface, Layer.Layer<Transport.
   };
 }
 declare const provider$1: (overrides?: Partial<Transport.Provider>) => Transport.Provider;
+declare const target$1: (overrides?: Partial<Transport.ProviderTarget>) => Transport.ProviderTarget;
+declare const connection$1: (overrides?: Partial<Transport.ProviderConnection>) => Transport.ProviderConnection;
+declare const attachment: (overrides?: Partial<Transport.DomainAttachment>) => Transport.DomainAttachment;
+declare const connected: (overrides?: Partial<Transport.Connected>) => Transport.Connected;
 declare function makeFakeTransport(options: FakeOptions): FakeTransport;
 declare namespace verification_d_exports {
-  export { Command, Controller, Evidence, Model, Observation, ObserveAction, ObserveConfig, Outcome, Root, RootProps, State, Status, StatusProps, useController, useModel };
+  export { Command, Controller, Evidence, Model, Observation, ObserveAction, ObserveActionProps, ObserveConfig, Outcome, Root, RootProps, State, Status, StatusProps, useController, useModel };
 }
 type LocalState = Data.TaggedEnum<{
+  Failed: {
+    readonly failure: Failure;
+    readonly previous?: Transport.Observation;
+  };
   Idle: {};
-  Observing: {};
+  Observing: {
+    readonly previous?: Transport.Observation;
+  };
 }>;
 declare const State: {
-  readonly $is: <Tag extends "Idle" | "Observing">(tag: Tag) => (u: unknown) => u is Extract<{
+  readonly $is: <Tag extends "Failed" | "Idle" | "Observing">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Failed";
+    readonly failure: Failure;
+    readonly previous?: Transport.Observation;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
     readonly _tag: "Idle";
   }, {
     readonly _tag: Tag;
   }> | Extract<{
     readonly _tag: "Observing";
+    readonly previous?: Transport.Observation;
   }, {
     readonly _tag: Tag;
   }>;
   readonly $match: {
-    <Cases extends { readonly [Tag in "Idle" | "Observing"]: (args: Extract<{
+    <Cases extends { readonly [Tag in "Failed" | "Idle" | "Observing"]: (args: Extract<{
+      readonly _tag: "Failed";
+      readonly failure: Failure;
+      readonly previous?: Transport.Observation;
+    } | {
       readonly _tag: "Idle";
     } | {
       readonly _tag: "Observing";
+      readonly previous?: Transport.Observation;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Failed";
+      readonly failure: Failure;
+      readonly previous?: Transport.Observation;
+    } | {
       readonly _tag: "Idle";
     } | {
       readonly _tag: "Observing";
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Idle" | "Observing"]>>;
-    <Cases extends { readonly [Tag in "Idle" | "Observing"]: (args: Extract<{
+      readonly previous?: Transport.Observation;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Failed" | "Idle" | "Observing"]>>;
+    <Cases extends { readonly [Tag in "Failed" | "Idle" | "Observing"]: (args: Extract<{
+      readonly _tag: "Failed";
+      readonly failure: Failure;
+      readonly previous?: Transport.Observation;
+    } | {
       readonly _tag: "Idle";
     } | {
       readonly _tag: "Observing";
+      readonly previous?: Transport.Observation;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(value: {
+      readonly _tag: "Failed";
+      readonly failure: Failure;
+      readonly previous?: Transport.Observation;
+    } | {
       readonly _tag: "Idle";
     } | {
       readonly _tag: "Observing";
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Idle" | "Observing"]>>;
+      readonly previous?: Transport.Observation;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Failed" | "Idle" | "Observing"]>>;
   };
+  readonly Failed: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Failed";
+    readonly failure: Failure;
+    readonly previous?: Transport.Observation;
+  }, "_tag">;
   readonly Idle: Data.TaggedEnum.ConstructorFrom<{
     readonly _tag: "Idle";
   }, "_tag">;
   readonly Observing: Data.TaggedEnum.ConstructorFrom<{
     readonly _tag: "Observing";
+    readonly previous?: Transport.Observation;
   }, "_tag">;
 };
-type State = LocalState | Transport.Observation | Failure;
+type State = LocalState | Transport.Observation;
 interface ObserveConfig {
   readonly connection?: Transport.Connected;
   readonly domain: string;
@@ -1282,14 +1641,17 @@ declare function Evidence({ observation }: {
 declare function Outcome({ state }: {
   readonly state: State;
 }): import("react/jsx-runtime").JSX.Element | null;
-declare function ObserveAction({ controller }: {
+interface ObserveActionProps extends PartProps<"button", {
+  readonly status: State["_tag"];
+}> {
   readonly controller: Controller;
-}): import("react/jsx-runtime").JSX.Element;
+}
+declare function ObserveAction({ controller, ...props }: ObserveActionProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
 interface StatusProps extends Omit<RootProps, "status"> {
   readonly config: ObserveConfig;
 }
 declare function Status({ config, ...props }: StatusProps): import("react/jsx-runtime").JSX.Element;
 type Observation = Transport.Observation;
 //#endregion
-export { cleanup_d_exports as Cleanup, connection_d_exports as Connection, domain_d_exports as Domain, domain_kit_d_exports as DomainKit, messages_d_exports as Messages, operations_d_exports as Operations, provider_d_exports as Provider, provisioning_d_exports as Provisioning, records_d_exports as Records, testing_d_exports as Testing, theme_d_exports as Theme, verification_d_exports as Verification };
+export { cleanup_d_exports as Cleanup, connection_d_exports as Connection, domain_d_exports as Domain, domain_kit_d_exports as DomainKit, lifecycle_d_exports as Lifecycle, messages_d_exports as Messages, operations_d_exports as Operations, provider_d_exports as Provider, provisioning_d_exports as Provisioning, records_d_exports as Records, testing_d_exports as Testing, theme_d_exports as Theme, verification_d_exports as Verification };
 //# sourceMappingURL=index.d.mts.map