@ai-matrx/sharing 0.0.0 → 0.1.1

package/dist/react.d.ts

@@ -0,0 +1,779 @@
+import * as react from 'react';
+import react__default, { ReactNode, ComponentType } from 'react';
+import { ConfirmOptions } from '@ai-matrx/kit/confirm-opener';
+import { ResourceType, PermissionWithDetails, PermissionLevel, ShareActionResult, SharingCopyContext, AccessSummary, ShownTo, WhoCanSee, LaneChoice, Permission, CheckPermissionOptions } from '@ai-matrx/sharing/core';
+import { EntityTypeToken } from '@ai-matrx/associations';
+
+type LooseProps = {
+    [key: string]: any;
+};
+interface ShareSheetOrganization {
+    id: string;
+    name: string;
+    [key: string]: unknown;
+}
+interface ShareSheetConnection {
+    user_id: string;
+    email: string | null;
+    display_name: string | null;
+    avatar_url: string | null;
+    source: "conversation" | "organization" | "invitation";
+    sourceDetails?: string | undefined;
+}
+interface ShareSheetConnections {
+    connections: ShareSheetConnection[];
+    isLoading: boolean;
+    error: string | null;
+    partialFailures: string[];
+    refresh: () => Promise<void> | void;
+}
+interface ShareSheetToastOptions {
+    title?: ReactNode | undefined;
+    description?: ReactNode | undefined;
+    variant?: "default" | "destructive" | "success" | string | undefined;
+}
+interface ShareSheetUi {
+    /** Messages. Default: `console` + `window.alert` for errors (never swallowed). */
+    toast: (options: ShareSheetToastOptions) => void;
+    /** The signed-in person's id. Default: read once from the sharing client's session. */
+    useCurrentUserId: () => string | null;
+    /** The organizations the person belongs to (`{id, name}`). Default: `organizations` read once. */
+    useOrganizations: () => ShareSheetOrganization[];
+    /** Contacts offered in the People tab. Default: the organization's roster. */
+    useUserConnections: (options: {
+        organizationId?: string;
+    }) => ShareSheetConnections;
+    confirm: (options: ConfirmOptions) => Promise<boolean>;
+    CopyButtons: ComponentType<LooseProps>;
+    csvExportItem: (...args: any[]) => any;
+    jsonExportItem: (...args: any[]) => any;
+    usePageCapture: (build: () => unknown, options?: {
+        enabled?: boolean;
+    }) => void;
+    dialogCapture: (input: any) => unknown;
+    PageCaptureButton: ComponentType<LooseProps>;
+    ErrorAlchemyMenu: ComponentType<LooseProps>;
+    InfoHint: ComponentType<LooseProps>;
+    EntityDoorControls: ComponentType<LooseProps>;
+    EntityRef: ComponentType<LooseProps>;
+    UserAvatarDisplay: ComponentType<LooseProps>;
+    ConnectionsReadNotice: ComponentType<LooseProps>;
+    UserSearchField: ComponentType<LooseProps>;
+    /** The vault identity the secure-link panel seals with (`@ai-matrx/vault`). */
+    vaultIdentity: unknown;
+    humanLines: (...args: any[]) => string;
+    /** Where dialogs portal (the web: its pop-out window container). Default: the document body. */
+    usePortalContainer: () => HTMLElement | null | undefined;
+}
+/** Merge host UI over the defaults (boot-time; tests may call it again). */
+declare function configureShareSheetUi(next: Partial<ShareSheetUi>): void;
+declare function shareSheetUi(): ShareSheetUi;
+/** Test seam: forget every cached answer. */
+declare function resetShareSheetCache(): void;
+
+interface ShareModalProps {
+    /** The level picker's words: "notion" = Full access · Edit · Comment · View. */
+    levelWording?: "roles" | "notion" | undefined;
+    isOpen: boolean;
+    onClose: () => void;
+    resourceType: ResourceType;
+    resourceId: string;
+    resourceName: string;
+    /**
+     * The organization this resource belongs to. Pass it whenever the caller knows: it scopes
+     * the contact picker to that organization's members (FIX-7B), and the share's in-app
+     * notification is filed there (ACCESS-FIX-18) — without it, a share from a page with no
+     * organization picked raised "Which workspace is this for?". It is NOT used for the grant —
+     * the store still resolves a record's organization off the row itself.
+     */
+    organizationId?: string | undefined;
+    /**
+     * What to CALL this thing on screen, when the caller knows better than the
+     * registry does. In the unified store a Table IS a `custom.record` row, so
+     * `resourceType="record"` is correct and the registry's label — "Record" —
+     * is the wrong noun for a table: the seventh-pass verdict read "Share
+     * Record" above a table's own name. Omit it and the registry's label stands.
+     */
+    resourceNoun?: string | undefined;
+    /**
+     * OPTIONAL override. Leave it out — the modal resolves ownership itself.
+     *
+     * Only pass this when the caller already holds an authoritative, resolved
+     * answer (e.g. it just created the row). Passing a stale or defaulted
+     * `false` is what renders this dialog as a dead, empty shell for a user who
+     * owns the record.
+     */
+    isOwner?: boolean | undefined;
+    /**
+     * SHARING WITH SOMEBODY OUTSIDE THE ORGANIZATION (lane SHARE-OUT, 21 September).
+     *
+     * Pass this when the subject is a TABLE in the unified record store and the
+     * caller knows which organization it belongs to. The Users tab then carries
+     * the outside lane: invite by email, "invited, not yet joined", resend and
+     * revoke. Leave it out and the dialog is exactly what it was — this is not a
+     * capability every resource type has, and a panel that could not work is a
+     * panel that must not be drawn.
+     *
+     * It is NOT a second share surface: the grant it produces is an ordinary
+     * `iam.permissions` row read by the same ladder, and the pending state is an
+     * `iam.invitations` row, the platform's one invitation primitive.
+     */
+    outsideShare?: {
+        organizationId: string;
+        tableId: string;
+    };
+}
+/**
+ * ShareModal - Main sharing interface
+ *
+ * Generic modal that works with ANY resource type.
+ * Provides tabs for sharing with people or making public. A share names a PERSON, never an
+ * organization (SHARE-PEOPLE-ONLY, 2026-09-25): the old Organizations tab is gone, and "Add
+ * everyone in <organization>" inside the People tab names each current member instead.
+ *
+ * This is the ONE sharing dialog in the app. Do not build a feature-specific
+ * variant — extend this one. It self-resolves ownership, so every call site is
+ * a three-prop drop-in.
+ *
+ * @example
+ * <ShareModal
+ *   isOpen={isOpen}
+ *   onClose={() => setIsOpen(false)}
+ *   resourceType="workflow"
+ *   resourceId={workflowId}
+ *   resourceName="My Workflow"
+ * />
+ */
+declare function ShareModal({ levelWording, isOpen, onClose, resourceType, resourceId, resourceName, organizationId, resourceNoun, isOwner: isOwnerOverride, outsideShare, }: ShareModalProps): react__default.JSX.Element;
+
+interface PermissionsListProps {
+    permissions: PermissionWithDetails[];
+    isOwner: boolean;
+    onUpdateLevel: (options: {
+        userId?: string | undefined;
+        organizationId?: string | undefined;
+        isPublic?: boolean | undefined;
+    }, newLevel: PermissionLevel) => Promise<ShareActionResult>;
+    onRevoke: (options: {
+        userId?: string | undefined;
+        organizationId?: string | undefined;
+        isPublic?: boolean | undefined;
+    }) => Promise<ShareActionResult>;
+    loading?: boolean | undefined;
+    /**
+     * Identity + the page's leading KPIs, so every copied grant states what it
+     * belongs to. Optional: without it the list still copies, falling back to the
+     * identity carried on the permission rows themselves — but a page that shows
+     * KPIs above this list should pass them so the payloads mirror the screen.
+     */
+    copy?: SharingCopyContext | undefined;
+    /** Which slice this list renders, e.g. "Users" / "Organizations". */
+    listLabel?: string | undefined;
+    /**
+     * 🚨 WHAT ELSE IS ON THIS SCREEN THAT IS NOT A GRANT (FIX-10C, VERIFIER-10
+     * F13, 2026-09-22).
+     *
+     * This list only ever knew about DIRECT grants, and said so honestly in its
+     * scope note. But after an outside invitation lands, the dialog read
+     * "Current Access — Not shared with anyone — No one has been granted access
+     * here" with the invited person's row drawn directly underneath it. Both
+     * halves were true and the screen contradicted itself, which is the one thing
+     * a screen may not do.
+     *
+     * An invitation is not a grant — it confers nothing until it is accepted, and
+     * making this list count it would be the same lie pointing the other way. So
+     * the empty state stays an empty state and simply stops pretending it is the
+     * whole screen: the caller that also draws the pending rows says how many
+     * there are, and the sentence names them.
+     */
+    alsoPending?: {
+        count: number;
+        one: string;
+        many: string;
+    } | undefined;
+}
+/**
+ * PermissionsList - Display and manage current permissions
+ *
+ * Shows all users, organizations, and public access for a resource.
+ * Allows owners to update permission levels or revoke access.
+ *
+ * @example
+ * <PermissionsList
+ *   permissions={permissions}
+ *   isOwner={isOwner}
+ *   onUpdateLevel={updateLevel}
+ *   onRevoke={revokeAccess}
+ * />
+ */
+declare function PermissionsList({ permissions, isOwner, onUpdateLevel, onRevoke, loading, copy, listLabel, alsoPending, }: PermissionsListProps): react__default.JSX.Element;
+
+interface PermissionBadgeProps {
+    level: PermissionLevel | "owner";
+    variant?: "default" | "compact" | undefined;
+    showIcon?: boolean | undefined;
+}
+/**
+ * PermissionBadge - Visual indicator for permission levels
+ *
+ * Displays color-coded badges for different permission levels
+ * Used throughout the app to show user permissions
+ *
+ * @example
+ * <PermissionBadge level="editor" />
+ * <PermissionBadge level="owner" showIcon />
+ */
+declare function PermissionBadge({ level, variant, showIcon, }: PermissionBadgeProps): react__default.JSX.Element;
+/**
+ * PublicBadge - Badge specifically for public resources
+ */
+declare function PublicBadge({ variant, }: {
+    variant?: "default" | "compact" | undefined;
+}): react__default.JSX.Element;
+/**
+ * PermissionLevelDescription - Show what each level can do
+ */
+declare function PermissionLevelDescription({ level, }: {
+    level: PermissionLevel;
+}): react__default.JSX.Element;
+/**
+ * GuestBadge — a person who is not a member of the thing's organization (CLOSE-SHARE, Notion's "Guest").
+ * The store decides (`isGuest` from get_resource_permissions; a Space's presence carries its own answer).
+ * One marker for every share list and avatar row.
+ */
+declare function GuestBadge(): react__default.JSX.Element;
+
+/** What the panel currently knows, for pages that mirror it in their payload. */
+interface AccessSummaryState {
+    summary: AccessSummary | null;
+    error: string | null;
+    loading: boolean;
+}
+interface AccessSummaryPanelProps {
+    entityType: EntityTypeToken;
+    entityId: string | null;
+    /** Load only when the surface is actually visible. */
+    enabled?: boolean | undefined;
+    /**
+     * Change this value to force a refetch. Required on surfaces that mutate
+     * grants beside the panel (a Share tab) — pass a signature of the grant
+     * state so the summary can never contradict the list next to it.
+     */
+    refreshToken?: unknown | undefined;
+    className?: string | undefined;
+    /**
+     * Identity + the page's leading KPIs, mirrored verbatim into this panel's
+     * payloads. Optional — without it the panel derives what it can from the
+     * summary itself.
+     */
+    copy?: SharingCopyContext | undefined;
+    /**
+     * Lets the page that composes this panel mirror the reachability answer it
+     * is rendering, without paying for a second round trip. Pass a stable
+     * callback (a `useState` setter is ideal).
+     */
+    onSummaryChange?: (state: AccessSummaryState) => void;
+}
+declare function AccessSummaryPanel({ entityType, entityId, enabled, refreshToken, className, copy, onSummaryChange, }: AccessSummaryPanelProps): react.JSX.Element | null;
+
+interface RowControlsProps {
+    resourceType: ResourceType;
+    resourceId: string;
+    /** The person may change this thing's sharing. */
+    canChange: boolean;
+    /** `useSharing().shownTo` — undefined when the type does not carry it. */
+    shownTo: ShownTo | null | undefined;
+    /** `useSharing().isPublic` — published to the web. */
+    isPublic: boolean;
+    /** `useSharing().childRecord` — a child follows its parent: nothing is drawn. */
+    childRecord?: boolean | undefined;
+    /**
+     * `false` when this thing is never published to the web although its type is: a whole Table is a
+     * `record` too, and only a ROW has a page (/p/e/record/<id>), so a Table draws no publish switch
+     * at all (access ladder T-40; the database refuses it too). Omitted → the type decides.
+     */
+    publishable?: boolean | undefined;
+    onSetShownTo: (next: ShownTo | null) => Promise<ShareActionResult>;
+    onPublish: () => Promise<ShareActionResult>;
+    onStopPublishing: () => Promise<ShareActionResult>;
+}
+declare function RowControls({ resourceType, resourceId, canChange, shownTo, isPublic, childRecord, publishable, onSetShownTo, onPublish, onStopPublishing, }: RowControlsProps): react__default.JSX.Element | null;
+
+/**
+ * features/sharing/components/WhoCanSeeThis.tsx
+ *
+ * "WHO CAN SEE THIS" — THE LANE CONTROL AT THE TOP OF THE SHARE DIALOG'S PEOPLE TAB
+ * (lane SHARE-LANE-CONTROL, VERIFIER-23 item 3). Record-store things only; every other kind gets
+ * its row controls ("Shown to", "Published to the web") in the same place through `row`.
+ *
+ * The record store has had the door since lane SHARE (`custom.share_lane_set`: mine |
+ * organization | world). Under the access ladder law (T-36, chair ruling 2026-10-01) "mine" is the
+ * hide it is, "Shown to: Only me": the thing leaves coworkers' lists and still opens for members
+ * who have the link. It is never a lock; real separation is another organization or a
+ * Confidential/Private Table type. The words are `SHOWN_TO_WORDS.only_me`, the ones RowControls uses.
+ * Nothing on screen reached it: a door with no control is a dead end. This is that control, ONE
+ * primitive every share host renders (ShareModal, ShareModalWindow, AgentSharePanel,
+ * SiteAccessWorkspace) from `useSharing().whoCanSee` — it never reads or writes on its own.
+ *
+ *   · Only me                       — lane mine: hidden from coworkers' lists; opens by link.
+ *   · Everyone in <organization>    — the organization's default, at the level it grants.
+ *   · Anyone with the link          — the world lane, drawn ONLY where it would be accepted
+ *                                     (`world_open`) or is already the state. Otherwise absent,
+ *                                     never disabled-looking.
+ *
+ * The current state is always shown. A person who cannot change sharing sees it as one line of
+ * text, not as buttons. Hiding takes nobody's access away, so it applies without a confirm.
+ * Named people are never touched.
+ */
+
+interface WhoCanSeeThisProps {
+    /** `useSharing().whoCanSee`. Null → the kind has no lane door, and nothing is drawn. */
+    whoCanSee: WhoCanSee | null;
+    /** The person may change this thing's sharing (the host's owner/Admin answer). */
+    canChange: boolean;
+    /** `useSharing().setWhoCanSee`. */
+    onChoose: (choice: LaneChoice) => Promise<ShareActionResult>;
+    /**
+     * Every kind outside the record store: its row controls ("Shown to", "Published to the web"),
+     * drawn in this same place. `RowControls` draws nothing for a Private, Confidential or child
+     * record (access ladder T-13 phase 5).
+     */
+    row?: Omit<RowControlsProps, "canChange">;
+}
+declare function WhoCanSeeThis({ whoCanSee, canChange, onChoose, row, }: WhoCanSeeThisProps): react__default.JSX.Element | null;
+
+interface ShareLinkPanelProps {
+    resourceType: ResourceType;
+    resourceId: string;
+    isOwner: boolean;
+    /** Whether this resource type offers no-login links (admin policy). Hidden when false. */
+    enabled?: boolean | undefined;
+}
+/**
+ * "Anyone with the link" — mint / copy / revoke no-login share links.
+ *
+ * A share link is an opaque token that lets anyone view the resource with ZERO
+ * sign-in (resolved by the anon `resolve_share_token` RPC). This is the canonical
+ * link-carries-everything path — distinct from publishing to the web (which
+ * needs a public render route). Owner-only.
+ */
+declare function ShareLinkPanel({ resourceType, resourceId, isOwner, enabled, }: ShareLinkPanelProps): react__default.JSX.Element | null;
+
+type GrantableLevels = {
+    loading: boolean;
+    /** Could not be asked (a failure is not a refusal). */
+    error: string | null;
+    /** level -> null when allowed, else the reason. Absent while loading or on error. */
+    levels: Partial<Record<PermissionLevel, string | null>>;
+    /** May share outside the organization: null when allowed, else the reason. */
+    outside: string | null;
+    /** True when at least one level may be given - i.e. the person may share at all. */
+    maySharePeople: boolean;
+};
+declare function useGrantableLevels(resourceType: string, resourceId: string, enabled: boolean, refreshKey?: string | undefined): GrantableLevels;
+
+/** One current member of the chosen organization, as the dialog shows them. */
+interface OrgMemberPerson {
+    userId: string;
+    email: string;
+    name: string;
+}
+interface AddEveryoneInOrgProps {
+    /** Grants ONE person. The same door the single-person share uses. */
+    grantPerson: (person: OrgMemberPerson, level: PermissionLevel) => Promise<ShareActionResult>;
+    /** The level picked in the People tab: the block's own level starts here, and follows it until the person picks one here. */
+    level: PermissionLevel;
+    /** Why a level may not be given on this thing (null: may). Those levels are shown disabled with the reason. */
+    whyNotLevel?: (level: PermissionLevel) => string | null;
+    /** People who already hold a grant on this thing. They are shown, not re-granted. */
+    alreadySharedUserIds?: string[] | undefined;
+    /** Called once after a run that granted at least one person. */
+    onDone?: () => void;
+    /**
+     * The organization the thing lives in, when the dialog knows it. It is chosen first, so "Add
+     * everyone in <that organization>" is one press away; any other organization the person
+     * belongs to stays one pick away.
+     */
+    defaultOrgId?: string | undefined;
+}
+declare function AddEveryoneInOrg({ grantPerson, level: sectionLevel, whyNotLevel, alreadySharedUserIds, onDone, defaultOrgId, }: AddEveryoneInOrgProps): react__default.JSX.Element | null;
+
+interface ShareWithUserTabProps {
+    onShare: (userId: string, level: PermissionLevel) => Promise<ShareActionResult>;
+    onSuccess: () => void;
+    resourceType: ResourceType;
+    resourceId: string;
+    /**
+     * THE ORGANIZATION THIS THING BELONGS TO (FIX-7B). With it, the contact list is that
+     * organization's members and nobody else. Without it the list is every organization the
+     * viewer belongs to, which is what a brand-new organization's share dialog looked like when
+     * the seventh pass found it offering "people from all over the database".
+     */
+    organizationId?: string | undefined;
+    /** Identity + the page's leading KPIs, mirrored into the failure payload. */
+    copy?: SharingCopyContext | undefined;
+    /**
+     * "ADD EVERYONE IN <ORGANIZATION>" (SHARE-PEOPLE-ONLY). How ONE listed member is granted.
+     * Omitted → `onShare(person.userId, level)`, the same door as the form above. A record-store
+     * table passes the outside door here, because its members may sit outside the table's own
+     * organization.
+     */
+    grantEveryonePerson?: (person: OrgMemberPerson, level: PermissionLevel) => Promise<ShareActionResult>;
+    /** People who already hold a grant; "Add everyone" shows them and skips them. */
+    alreadySharedUserIds?: string[] | undefined;
+    /**
+     * "notion": the level picker reads the ladder's sentence labels, highest first — Full access · Edit ·
+     * Comment · View (Spaces copies Notion's Share menu). Default: the role words.
+     */
+    levelWording?: "roles" | "notion" | undefined;
+    /**
+     * The levels the doors will accept from THIS person (iam.may_grant_as). A level with a reason is shown
+     * disabled with that reason; omitted, every level is offered and the door answers (as before).
+     */
+    grantable?: GrantableLevels | undefined;
+}
+/**
+ * ShareWithUserTab - Form to share with a specific user.
+ * Shows the user's contacts from conversations, organizations, and invitations
+ * for quick selection, with a manual email input fallback.
+ */
+declare function ShareWithUserTab({ levelWording, grantable, onShare, onSuccess, resourceType, resourceId, organizationId, copy, grantEveryonePerson, alreadySharedUserIds, }: ShareWithUserTabProps): react__default.JSX.Element;
+
+interface PublicAccessTabProps {
+    /** The public permission row from the permissions table, if any (kept for hosts' tab dot). */
+    publicPermission?: Permission | undefined;
+    isOwner: boolean;
+    resourceType: ResourceType;
+    resourceId: string;
+    resourceName: string;
+    /**
+     * Identity + the page's leading KPIs, mirrored into this tab's payloads so a
+     * copied answer is interpretable on its own.
+     */
+    copy?: SharingCopyContext | undefined;
+}
+/**
+ * What "Anyone" means for this type, in words that never promise more than the
+ * platform delivers. "No sign-in" only where a signed-out page exists
+ * (utils/permissions/publicLane.ts); everywhere else public means every signed-in
+ * person finds it under Public, and a signed-out visitor reaches it only through a
+ * no-login link — when the type has one. Pure — exported for tests.
+ */
+declare function anyoneReachWords(typeLabel: string, reach: {
+    publicPage: boolean;
+    noLoginLink: boolean;
+}): string;
+/**
+ * PublicAccessTab — "Anyone with the link" (access ladder Words table, Link row).
+ *
+ * An Anyone link opens the record at its permission for whoever holds it, at EVERY level —
+ * Private and Confidential records included — and is never indexed. The row controls ("Shown to",
+ * "Published to the web") are not here: they sit at the top of the people tab
+ * (`RowControls`), and only on Organization and Public records (T-13 phase 5).
+ */
+declare function PublicAccessTab({ isOwner, resourceType, resourceId, resourceName, copy, }: PublicAccessTabProps): react__default.JSX.Element;
+
+/** The one sentence a shut lane gets. Exported so the test asserts the words. */
+declare const LANE_CLOSED_SAY = "This organization's administrator has turned off sharing with people outside it.";
+interface OutsideSharePanelProps {
+    organizationId: string;
+    tableId: string;
+    tableName: string;
+    /**
+     * 🚨 SO THE LIST ABOVE CANNOT CONTRADICT THE ROWS BELOW (FIX-10C, VERIFIER-10
+     * F13). The grant list up the page knows only about grants, which is correct
+     * and was still how "Not shared with anyone" came to stand directly over an
+     * invited person. This panel tells its host how many people are invited and
+     * not yet joined; the host passes that to the grant list's empty state.
+     */
+    onPendingChange?: ((count: number) => void) | undefined;
+    /**
+     * An address already inside the organization is GRANTED the table rather than
+     * invited (FIX-10C, VERIFIER-10 F7), and that grant belongs in the list at the
+     * top of this dialog, not here. So the host is told to re-read it — otherwise
+     * the person gets a sentence saying it happened and an unchanged screen.
+     */
+    onGranted?: (() => void) | undefined;
+}
+declare function OutsideSharePanel({ organizationId, tableId, tableName, onPendingChange, onGranted, }: OutsideSharePanelProps): react__default.JSX.Element;
+
+interface SecureLinkPanelProps {
+    resourceType: string;
+    resourceId: string;
+    resourceName: string;
+}
+/**
+ * Sending a password is a reveal: it needs the SAME fresh sign-in the vault asks for, through the
+ * vault's ONE "Confirm it's you" (Google, password or an emailed code) — never a second dialog.
+ */
+declare function SecureLinkPanel(props: SecureLinkPanelProps): react.JSX.Element;
+
+/**
+ * features/sharing/components/OrgAvailabilityNote.tsx
+ *
+ * WHAT AN ORGANIZATION ROW IS NOW (SHARE-PEOPLE-ONLY, chair ruling 2026-09-25). A share names a
+ * person. An organization grantee is written only as organization AVAILABILITY: an agent bound
+ * to an organization's surface, an item contributed to its library, or the HR directory. That is
+ * organization configuration, not something this dialog grants. The row still gives access,
+ * though, so the dialog says so in one read-only line and never hides it. It is changed where it
+ * was set, in the organization.
+ */
+
+declare function OrgAvailabilityNote({ permissions, organizationDefault, }: {
+    permissions: PermissionWithDetails[];
+    /**
+     * SHARE-TAILS (chair ruling 2026-09-25): a thing nobody set to "Only me" is the organization's
+     * default, and every member reaches it without a share. "Not shared with anyone" above is true
+     * of shares; this line says who else really reaches it. Under "Only me" (access ladder T-36,
+     * chair ruling 2026-10-01) members still open it by link but no longer find it in lists, so the
+     * door sends no default and the lane control's "Only me" hint says the rest.
+     */
+    organizationDefault?: {
+        level: string;
+        organizationName: string;
+        organizationId?: string | undefined;
+    } | null;
+}): react__default.JSX.Element | null;
+
+interface Props {
+    resourceType: string;
+    resourceId: string;
+    /**
+     * Re-read whenever this changes — pass the host's own published state so the control
+     * appears the moment the record is published (and leaves when it is unpublished).
+     */
+    publishedHint?: boolean | undefined;
+    className?: string | undefined;
+}
+declare function SearchEngineIndexedSwitch({ resourceType, resourceId, publishedHint, className, }: Props): react.JSX.Element | null;
+
+interface ShareOptions {
+    title: string;
+    text?: string | undefined;
+    /** `null` omits a separate URL field when the reviewed text already contains it. */
+    url?: string | null | undefined;
+    /** Full text to copy when native sharing is unavailable. */
+    copyText?: string | undefined;
+    fallbackTitle?: string | undefined;
+    fallbackDescription?: string | undefined;
+}
+/**
+ * Which door actually opened. Callers that announce the result ("Link copied")
+ * must not guess: a manual-fallback run copied nothing, and a toast claiming
+ * otherwise is a screen that lies.
+ */
+type ShareOutcome = "shared" | "copied" | "manual" | "cancelled";
+interface UseShareResult {
+    share: (options: ShareOptions) => Promise<ShareOutcome>;
+    copy: (text: string, fallback?: {
+        title?: string | undefined;
+        description?: string | undefined;
+    }) => Promise<"copied" | "manual">;
+    copied: boolean;
+    fallbackDialog: ReactNode;
+}
+/** Native share-sheet first, clipboard second, accessible manual copy last. */
+declare function useShare(): UseShareResult;
+
+/**
+ * features/sharing/hooks/useAccessSummary.ts
+ *
+ * One-entity-at-a-time effective-access loader. `enabled` exists so callers can
+ * mount the panel inside a collapsed tab and only pay for the round trip when
+ * the user actually looks — this query is NOT cheap enough to fire per row.
+ */
+
+interface UseAccessSummaryArgs {
+    entityType: EntityTypeToken;
+    entityId: string | null;
+    /** Load only while true. Defaults to true. */
+    enabled?: boolean | undefined;
+    /**
+     * Change this value to force a refetch — for surfaces that mutate grants
+     * beside the panel (a Share tab), pass a signature of the grant state so
+     * the summary can never contradict the freshly-refreshed list next to it.
+     */
+    refreshToken?: unknown | undefined;
+}
+interface UseAccessSummaryResult {
+    summary: AccessSummary | null;
+    loading: boolean;
+    error: string | null;
+    reload: () => void;
+}
+declare function useAccessSummary({ entityType, entityId, enabled, refreshToken, }: UseAccessSummaryArgs): UseAccessSummaryResult;
+
+/**
+ * Permission Hooks
+ *
+ * React hooks for working with permissions in components.
+ * These hooks provide reactive state management for permissions.
+ */
+
+/**
+ * Hook to get all permissions for a resource
+ * @param resourceType Resource type
+ * @param resourceId Resource ID
+ * @returns Permissions, loading state, and refresh function
+ */
+declare function usePermissions(resourceType: ResourceType, resourceId: string, enabled?: boolean): {
+    permissions: PermissionWithDetails[];
+    loading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+};
+/**
+ * Hook to get permissions with user/org details
+ * @param resourceType Resource type
+ * @param resourceId Resource ID
+ * @returns Permissions with details, loading state, and refresh function
+ */
+declare function useResourcePermissions(resourceType: ResourceType, resourceId: string): {
+    permissions: PermissionWithDetails[];
+    loading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+};
+/**
+ * Hook to check if current user has permission for a resource
+ * @param options Check options
+ * @returns Permission check result and loading state
+ */
+declare function usePermissionCheck(options: CheckPermissionOptions): {
+    loading: boolean;
+    hasAccess: boolean;
+    level?: PermissionLevel | undefined;
+    isOwner: boolean;
+    reason?: string | undefined;
+};
+/**
+ * Hook to check if current user can edit a resource
+ * @param resourceType Resource type
+ * @param resourceId Resource ID
+ * @returns Whether user can edit and loading state
+ */
+declare function useCanEdit(resourceType: ResourceType, resourceId: string): {
+    canEdit: boolean;
+    loading: boolean;
+};
+/**
+ * Hook to check if current user can delete/admin a resource
+ * @param resourceType Resource type
+ * @param resourceId Resource ID
+ * @returns Whether user has admin access and loading state
+ */
+declare function useCanAdmin(resourceType: ResourceType, resourceId: string): {
+    canAdmin: boolean;
+    loading: boolean;
+};
+/**
+ * Hook to check whether the current user MAY DECIDE WHO ELSE SEES a resource.
+ *
+ * It kept its name because every call site means "may this person manage
+ * sharing?" and none of them meant "did this person create the row". Since
+ * 2026-09-19 (lane SHARE) it asks the database's own `may_manage_sharing`
+ * predicate — the Owner rung OR the `admin` rung of VIS-17's one ladder, the
+ * same question the six sharing RPCs enforce — instead of reading `created_by`
+ * from the resource table. Before that an `admin` on a thing was shown a
+ * read-only dialog and an empty grant list, and any resource whose table
+ * carries no client SELECT grant (the whole record store) could not be asked at
+ * all.
+ *
+ * Returns three distinct states — `loading` (still resolving), `error`
+ * (could NOT be determined), and `isOwner` — because collapsing them into one
+ * boolean is what makes owner-gated UI render as if the user were a stranger
+ * to their own record. Never gate a surface on `!isOwner` alone; check
+ * `loading` and `error` first.
+ *
+ * @param resourceType Resource type
+ * @param resourceId Resource ID
+ */
+declare function useIsOwner(resourceType: ResourceType, resourceId: string): {
+    isOwner: boolean;
+    loading: boolean;
+    error: string | null;
+};
+/**
+ * Hook for sharing operations
+ * Provides functions to share, revoke, and update permissions
+ * @param resourceType Resource type
+ * @param resourceId Resource ID
+ * @returns Sharing functions and state
+ */
+declare function useSharing(resourceType: ResourceType, resourceId: string, enabled?: boolean, resourceName?: string | undefined, 
+/**
+ * The organization the object lives in, from the page that opened the dialog (its own
+ * resolver). Carried to the share's in-app notification so no action on an object ever asks
+ * which workspace it is for (ACCESS-FIX-18).
+ */
+organizationId?: string | null | undefined): {
+    permissions: PermissionWithDetails[];
+    /** Published to the web (or the card's own publish). */
+    isPublic: boolean;
+    /**
+     * "Shown to" — undefined when the type does not carry it (Private, Confidential, child, or a
+     * table without the column); null when the type's default applies.
+     */
+    shownTo: ShownTo | null | undefined;
+    /** A child record (a file attached to a chat): no row control of its own. */
+    childRecord: boolean;
+    /** Membership alone reaches it — said under Current Access. The record store's door names it. */
+    organizationDefault: {
+        level: string;
+        organizationName: string;
+        organizationId?: string | undefined;
+    } | null;
+    whoCanSee: WhoCanSee | null;
+    /** The thing's own organization, read off its row; null when unknown. */
+    homeOrganizationId: string | null;
+    setWhoCanSee: (choice: LaneChoice) => Promise<ShareActionResult>;
+    loading: boolean;
+    error: string | null;
+    shareWithUser: (userId: string, permissionLevel: PermissionLevel) => Promise<ShareActionResult>;
+    makePublic: (permissionLevel?: PermissionLevel) => Promise<ShareActionResult>;
+    setShownTo: (next: ShownTo | null) => Promise<ShareActionResult>;
+    revokeAccess: (options: {
+        userId?: string | undefined;
+        organizationId?: string | undefined;
+        isPublic?: boolean | undefined;
+    }) => Promise<ShareActionResult>;
+    revokeOrgAccess: (organizationId: string) => Promise<ShareActionResult>;
+    updateLevel: (options: {
+        userId?: string | undefined;
+        organizationId?: string | undefined;
+    }, newLevel: PermissionLevel) => Promise<ShareActionResult>;
+    refresh: () => Promise<void>;
+    refreshRowState: () => Promise<void>;
+};
+/**
+ * Hook to get resources shared with current user
+ * @param resourceType Optional filter by resource type
+ * @returns Shared permissions and loading state
+ */
+declare function useSharedWithMe(resourceType?: ResourceType | undefined): {
+    permissions: Permission[];
+    loading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+};
+/**
+ * Hook to get sharing status summary for a resource.
+ *
+ * Intentionally lightweight — only fetches is_public from the resource row.
+ * Safe to call from list-item components like ShareButton (single cheap query).
+ *
+ * Does NOT call get_resource_permissions (the expensive SECURITY DEFINER RPC).
+ * Full permission details are loaded inside useSharing() when the modal opens.
+ */
+declare function useSharingStatus(resourceType: ResourceType, resourceId: string, enabled?: boolean): {
+    isPublic: any;
+    loading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+};
+
+declare function WhoCouldSeeOn({ recordId }: {
+    recordId: string;
+}): react.JSX.Element;
+
+export { AccessSummaryPanel, type AccessSummaryPanelProps, type AccessSummaryState, AddEveryoneInOrg, type AddEveryoneInOrgProps, type GrantableLevels, GuestBadge, LANE_CLOSED_SAY, OrgAvailabilityNote, type OrgMemberPerson, OutsideSharePanel, type OutsideSharePanelProps, PermissionBadge, PermissionLevelDescription, PermissionsList, PublicAccessTab, PublicBadge, RowControls, type RowControlsProps, SearchEngineIndexedSwitch, SecureLinkPanel, ShareLinkPanel, ShareModal, type ShareOutcome, type ShareSheetConnection, type ShareSheetConnections, type ShareSheetOrganization, type ShareSheetToastOptions, type ShareSheetUi, ShareWithUserTab, type UseAccessSummaryArgs, type UseAccessSummaryResult, type UseShareResult, WhoCanSeeThis, type WhoCanSeeThisProps, WhoCouldSeeOn, anyoneReachWords, configureShareSheetUi, resetShareSheetCache, shareSheetUi, useAccessSummary, useCanAdmin, useCanEdit, useGrantableLevels, useIsOwner, usePermissionCheck, usePermissions, useResourcePermissions, useShare, useSharedWithMe, useSharing, useSharingStatus };