import * as lit_html from 'lit-html';
import * as lit from 'lit';
import { LitElement, nothing, TemplateResult } from 'lit';
import { Configure } from 'configure/browser';
import { IconNode } from 'lucide';

type AuthVerifyOptions = {
    externalId?: string;
    embed?: boolean;
};
type AuthVerifyResult = {
    token: string;
    userId: string;
    embedReceipt?: string;
};
/**
 * Base class for all Configure Web Components.
 * Provides shared SDK wiring, design tokens, and event helpers.
 */
declare class ConfigureBase extends LitElement {
    apiKey: string;
    baseUrl: string;
    authToken: string;
    userId: string;
    agent: string;
    agentName: string;
    agentLogo: string;
    copyMode: string;
    font: string;
    presentation: 'card' | 'bare';
    theme: string;
    authPattern: string;
    protected _client: Configure | null;
    static baseStyles: lit.CSSResult;
    protected get hasApiKey(): boolean;
    protected get isConfigureOwnedSurface(): boolean;
    protected get canUseAuth(): boolean;
    protected renderApiKeyNotice(): typeof nothing | lit_html.TemplateResult<1>;
    protected get client(): Configure;
    protected authEndpoint(path: string): string;
    protected sendAuthOtp(phone: string): Promise<void>;
    protected verifyAuthOtp(phone: string, code: string, options?: AuthVerifyOptions): Promise<AuthVerifyResult>;
    protected updated(changed: Map<string, unknown>): void;
    connectedCallback(): void;
    disconnectedCallback(): void;
    private _handleAuth;
    private _seedOAuthPopupStorage;
    protected _reserveOAuthPopup(statusLabel?: string): Window | null;
    protected _openOAuthPopup(url: string, reservedPopup?: Window | null): Window | null;
    protected emit<T>(name: string, detail: T): void;
    protected _shouldSkipFocus(): boolean;
}

declare const ICONS: {
    'arrow-left': IconNode;
    'chevron-down': IconNode;
    'circle-check': IconNode;
    ellipsis: IconNode;
    eye: IconNode;
    'file-text': IconNode;
    'globe-2': IconNode;
    lock: IconNode;
    'lock-simple': IconNode;
    'mail-x': IconNode;
    plus: IconNode;
    search: IconNode;
    'shield-check': IconNode;
    'trash-2': IconNode;
    'user-round': IconNode;
    x: IconNode;
    zap: IconNode;
};
type ConfigureIconName = keyof typeof ICONS;
declare class ConfigureIcon extends ConfigureBase {
    name: ConfigureIconName | '';
    size: number;
    strokeWidth: number;
    static styles: lit.CSSResult[];
    render(): typeof nothing | TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'configure-icon': ConfigureIcon;
    }
}

declare class ConfigurePhoneInput extends ConfigureBase {
    loading: boolean;
    error: string;
    disabled: boolean;
    agent: string;
    loginHint: string;
    fixture: boolean;
    private _rawDigits;
    private _formatted;
    private _selectedCountry;
    private _showPicker;
    private _pickerSearch;
    private _invalid;
    private _appliedLoginHint;
    private _input;
    private _pickerInput;
    private _clickOutsideHandler?;
    private _viewedAt;
    private _firstInputAt;
    connectedCallback(): void;
    disconnectedCallback(): void;
    updated(changed: Map<string, unknown>): void;
    static styles: lit.CSSResult[];
    private _format;
    private _applyLoginHint;
    private _getPlaceholder;
    private _isValid;
    private _getE164;
    private _digitIndexAt;
    private _caretForDigitIndex;
    private _renderDigits;
    private _handleInput;
    private _handleKeydown;
    private _handleBlur;
    private _handleFocus;
    private _submit;
    private _handleSubmit;
    private _fixtureEnabled;
    private _togglePicker;
    private _selectCountry;
    private _handlePickerSearch;
    private _filteredCountries;
    private _addClickOutside;
    private _removeClickOutside;
    render(): lit_html.TemplateResult<1>;
}

declare class ConfigureOtpInput extends ConfigureBase {
    phone: string;
    externalId: string;
    embedFlow: boolean;
    loading: boolean;
    error: string;
    fixture: boolean;
    private _code;
    private _canResend;
    private _countdown;
    private _verified;
    private _hiddenInput;
    private _timer?;
    private _viewedAt;
    private _firstInputAt;
    static styles: lit.CSSResult[];
    private _otpAbort?;
    private _emitVerified;
    connectedCallback(): void;
    disconnectedCallback(): void;
    firstUpdated(): Promise<void>;
    private _tryWebOTP;
    private _startCountdown;
    private _handleInput;
    private _showVerifiedState;
    private _handleKeydown;
    private _focusInput;
    private _fixtureEnabled;
    private _resend;
    render(): lit_html.TemplateResult<1>;
}

interface AuthenticatedDetail {
    token: string;
    userId?: string;
}
interface PhoneSubmitDetail {
    phone: string;
}
interface OtpVerifyDetail {
    code: string;
}
interface ToolConnectDetail {
    tool: string;
}
interface ToolDisconnectDetail {
    tool: string;
}
interface ToolApprovalDetail {
    actionId: string;
}
interface MemoryEditDetail {
    key: string;
}
interface MemoryDeleteDetail {
    key: string;
}
interface IdentityUpdateDetail {
    field: string;
    value: string;
}
interface ErrorDetail {
    message: string;
    code?: string;
}
interface ConnectionData {
    id: string;
    name: string;
    connected: boolean;
    accountEmail?: string;
    accountName?: string;
    accountUsername?: string;
    reconnectRequired?: boolean;
    error?: string;
    loading?: boolean;
}
interface MemoryData {
    key: string;
    value: string;
}
interface ToolApprovalParams {
    to?: string;
    subject?: string;
    body?: string;
    title?: string;
    start_time?: string;
    end_time?: string;
    location?: string;
    description?: string;
}
interface ConfirmationDetail {
    confirmed: boolean;
}
type ExportProvider = 'chatgpt' | 'claude' | 'gemini';
interface ExportClickDetail {
    provider: string;
}
interface ImportStartDetail {
    provider: string;
    stageId: string;
}
interface ImportCompleteDetail {
    provider: string;
    source: string;
}
interface ImportErrorDetail {
    message: string;
    phase: 'stage' | 'auth' | 'claim' | 'processing';
}
interface PromptCopiedDetail {
    prompt: string;
}
interface ProfileApprovedDetail {
    userId: string;
    agent: string;
    approvedCategories?: string[];
    subtitle?: string;
}
interface OtpVerifiedDetail {
    token: string;
    userId: string;
    phone: string;
}
interface AccessRequestDetail {
    tool: string;
    agent: string;
}
interface PersonalizationOpenDetail {
    agent: string;
    agentName?: string;
}
interface PersonalizationAssetSelectDetail {
    agent: string;
    agentName?: string;
}
interface PersonalizationMenuToggleDetail {
    open: boolean;
}
interface PersonalizationToggleDetail {
    enabled: boolean;
    agent: string;
    agentName?: string;
}

declare class ConfigureConnectionRow extends ConfigureBase {
    name: string;
    description: string;
    toolId: string;
    connected: boolean;
    loading: boolean;
    userScoped: boolean;
    reconnectRequired: boolean;
    forceNew: boolean;
    reconnectAccountId: string;
    capability: string;
    error: string;
    variant: 'row' | 'action';
    actionLabel: string;
    loadingLabel: string;
    fallbackLabel: string;
    errorLabel: string;
    iconId: string;
    returnUrl: string;
    fixture: boolean;
    private _connectionRequestId;
    private _error;
    private _pendingUrl;
    private _preservedMessage;
    private _pollTimer?;
    private _visibilityHandler?;
    private _focusHandler?;
    private _pageshowHandler?;
    private _polling;
    private _connectAttempt;
    private _connectStartedAt;
    private _connectTransportRetries;
    private _pollStartedAt;
    private _pollAttempts;
    private _oauthPopup;
    private _oauthPopupClosedAt;
    static styles: lit.CSSResult[];
    disconnectedCallback(): void;
    cancelPendingConnection(): void;
    updated(changed: Map<string, unknown>): void;
    private get _pendingKey();
    private _storePendingConnection;
    private _clearPendingConnection;
    private _restorePendingConnection;
    private _confirmPendingOnce;
    private _stopPolling;
    private _friendlyError;
    private _statusError;
    private _closePopup;
    private _handleClick;
    private _fixtureEnabled;
    private _connectUserScoped;
    private _confirmConnection;
    private _requestUserTool;
    private _isPendingOAuthError;
    private _isExplicitConnectionFailure;
    private _failureMessage;
    private _markConnectionFailed;
    private _markConnected;
    private _markPreserved;
    private _startPolling;
    render(): lit_html.TemplateResult<1>;
}

declare class ConfigureExportButton extends ConfigureBase {
    provider: string;
    prompt: string;
    label: string;
    static styles: lit.CSSResult[];
    private get _url();
    private get _label();
    private _handleClick;
    render(): lit_html.TemplateResult<1>;
}

declare class ConfigureExportPrompt extends ConfigureBase {
    prompt: string;
    private _copied;
    static styles: lit.CSSResult[];
    private get _prompt();
    private _handleCopy;
    render(): lit_html.TemplateResult<1>;
}

declare class ConfigureMemoryImport extends ConfigureBase {
    providers: string;
    agent: string;
    sectionLabel: string;
    importedProviders: string;
    /** True when the export prompt reached the clipboard on the last launch. */
    private _promptCopied;
    embedded: boolean;
    direct: boolean;
    startProvider: string;
    pasteTitle: string;
    pasteCopy: string;
    private _phase;
    private _selectedProvider;
    private _stageId;
    private _pasteValue;
    private _phone;
    private _errorMessage;
    private _importSource;
    private _claimedStage;
    private _statusTimer?;
    private _statusInFlight;
    private _baselineImportMarker;
    private _claimedAt;
    static styles: lit.CSSResult[];
    connectedCallback(): void;
    disconnectedCallback(): void;
    updated(changed: Map<string, unknown>): void;
    private get _apiBase();
    private get _isAuthenticated();
    private get _providerList();
    private get _storageKey();
    private _providerName;
    private _providerUrl;
    private _importedSet;
    private _normalizeProvider;
    private _startDirectImportIfNeeded;
    private _restoreDraft;
    private _persistDraft;
    private _selectProvider;
    private _handlePasteInput;
    private _focusPaste;
    private _onFocus;
    private _onVisibility;
    private _resumeImportStatus;
    private _handleSubmit;
    private _claim;
    private _pollStatus;
    private _stopStatusPolling;
    private _importMarker;
    private _currentImportMarker;
    private _profileShowsFreshImportedSource;
    private _claimedImportExpired;
    private _expireClaimedImport;
    private _completeImport;
    private _failImport;
    private _handlePhoneSubmit;
    private _handleAuthenticated;
    private _reset;
    private _copyPrompt;
    private _renderRows;
    private _renderPastePanel;
    render(): typeof nothing | lit_html.TemplateResult<1>;
}

interface GmailAccountSummary {
    id: string;
    label: string;
    status: 'ready' | 'reconnect';
}
declare class ConfigureConnectionList extends ConfigureBase {
    connections: ConnectionData[];
    connectors: string;
    importedProviders: string;
    showActions: boolean;
    /** Overrides the continue button's label. The component otherwise GUESSES the
     *  next step from its own state, which is wrong wherever continuing does not
     *  lead to a permissions review -- the hosted MCP connect page just ends the
     *  flow, so it said "Review permissions" and then said "you can close this
     *  tab". A host that knows what comes next should say so. */
    continueLabel: string;
    userScoped: boolean;
    reconnectMode: boolean;
    capability: string;
    optional: boolean;
    fixture: boolean;
    gmailAccounts: GmailAccountSummary[];
    gmailSkipped: boolean;
    gmailMultiAccount: boolean;
    returnUrl: string;
    private _connectionStates;
    private _connectionMeta;
    private _importedProviders;
    private _fetched;
    private _dropdownOpen;
    private _searchQuery;
    private _searchMode;
    private _gmailMenuId;
    private _gmailRemovingId;
    static styles: lit.CSSResult[];
    connectedCallback(): void;
    disconnectedCallback(): void;
    updated(changed: Map<string, unknown>): void;
    private _onToolStateChange;
    private _fetchConnectionStates;
    private _fetchUserProfileState;
    private _fetchProfileImports;
    private _getConnections;
    private _requestedConnectors;
    private _connectedFor;
    private _asReconnectTarget;
    private _metaFor;
    private _imported;
    private _importName;
    private _onImportComplete;
    private _emitContinue;
    private _emitSkip;
    private _emitShowProfile;
    private _emitAddAccount;
    private _onSearchInput;
    private _enterSearch;
    private _exitSearch;
    private _onSearchKeydown;
    private _onSearchExitPointerDown;
    private _toggleGmailMenu;
    private _removeGmailAccount;
    private _removeProviderAccount;
    private _onReconnectedGmailAccount;
    private _onAdditionalGmailPreserved;
    /** The capability to hand a row: only when it names that row's connector
     *  (a "gmail:send" upgrade must not attach to the calendar row). */
    private _rowCapability;
    render(): lit_html.TemplateResult<1>;
    private _renderConnection;
    private _renderSsoHub;
    private _renderSsoConnectedAccounts;
    private _renderSsoGmailAccountRows;
    private _renderSsoProviderAccountRow;
    private _renderSsoConnection;
    private _renderSsoAssistantImporter;
}

/**
 * Shared "you're connected / approved" surface.
 *
 * Pure render — no fetches, no event listeners, no internal state.
 * Used by:
 *  - configure-auth (success step)
 *  - configure-profile-editor (approved state)
 *  - apps/web/embed/auth/index.html (showComplete)
 *
 * The embed page mounts this via document.createElement('configure-success-card')
 * so the visual treatment stays consistent between the production iframe path and
 * the dev/lab component path.
 */
declare class ConfigureSuccessCard extends ConfigureBase {
    title: string;
    subtitle: string;
    showProgress: boolean;
    showProfileAction: boolean;
    static styles: lit.CSSResult[];
    private _showProfile;
    render(): lit_html.TemplateResult<1>;
}

interface KnownGmailAccount {
    id?: string;
    connectedAccountId?: string;
    providerAccountId?: string;
    accountEmail?: string;
    accountUsername?: string;
    label?: string;
}
declare class ConfigureProfileEditor extends ConfigureBase {
    agent: string;
    gmailAccounts: KnownGmailAccount[];
    demo: boolean;
    demoGmailConnected: boolean;
    private _loading;
    private _error;
    private _sessionRequired;
    private _categories;
    private _details;
    private _showDetails;
    private _expandedCategory;
    private _saving;
    private _leaving;
    private _permissions;
    private _approved;
    private _saveTimer;
    private _lastSaveFailed;
    private _categoryOverrides;
    private _touchedDetails;
    private _permissionsDegraded;
    private _loadAttempt;
    private _permissionSaves;
    private _pendingPermissionSaves;
    static styles: lit.CSSResult[];
    connectedCallback(): void;
    updated(changed: Map<string, unknown>): void;
    private _loadDemo;
    private _valueLabel;
    private _isDenied;
    private _pathDenied;
    private _globMatch;
    private _isAggregateCategoryPath;
    private _categoryHasAggregateDeny;
    private _managedPermissionOverrides;
    private _removeAgentFromOverrideRule;
    private _normalizePermissions;
    private _fetchJson;
    private _statusFromError;
    private _recordPermissionsFallback;
    private _fetchProfile;
    private _toggleCategory;
    private _toggleDetail;
    private _toggleExpandedCategory;
    private _debouncedSave;
    private _queuePermissionSave;
    requestBack(): Promise<void>;
    private _back;
    private _persistPermissions;
    private _approve;
    private _iconFor;
    private _formatApprovedLabels;
    private _displayCategory;
    private _approvalSubtitle;
    private _renderShell;
    render(): lit_html.TemplateResult<1>;
}

declare class ConfigureAuth extends ConfigureBase {
    agent: string;
    userName: string;
    externalId: string;
    connectors: string;
    private _step;
    private _phone;
    private _hasProfileData;
    private _successSubtitle;
    static styles: lit.CSSResult[];
    connectedCallback(): void;
    disconnectedCallback(): void;
    private _restoreSession;
    private _onPhoneSubmit;
    private _onOtpVerified;
    private _checkProfileData;
    private _onProfileApproved;
    private _onConnectionsContinue;
    private _onProfileBack;
    private _onConnectionsSkip;
    /** Returns the current auth token, or null if not authenticated. */
    getToken(): string | null;
    /** Returns the current user ID, or null if not authenticated. */
    getUserId(): string | null;
    /** Clears stored auth and resets to the phone input step. */
    logout(): void;
    render(): lit_html.TemplateResult<1>;
}

type HostedStep = 'phone' | 'otp' | 'verified' | 'gmail' | 'email' | 'connections' | 'profile' | 'complete' | 'blocked' | 'unsupported';
interface HostedInit {
    agentToken?: string;
    userId?: string;
    externalId?: string;
    baseUrl?: string;
    theme?: string;
    agentName?: string;
    agentLogo?: string;
    copyMode?: string;
    loginHint?: string;
    methods?: string[] | string | null;
    font?: string;
    connectors?: string[] | string | null;
    connectorOnly?: boolean;
    reconnectMode?: boolean;
    gmailMultiAccount?: boolean;
    fixture?: boolean;
}
interface GmailAccountView {
    id: string;
    providerAccountId?: string;
    label: string;
    status: 'ready' | 'reconnect';
}
interface FixturePreviewState {
    step: HostedStep;
    phone: string;
    verified: boolean;
    gmailConnected: boolean;
    outlookConnected: boolean;
    gmailNeedsPermissions: boolean;
    gmailSkipped: boolean;
    gmailAccounts: GmailAccountView[];
}
/**
 * Canonical Configure-owned authentication and connection flow.
 * First-party surfaces should mount this orchestrator in SSO mode instead of
 * recomposing phone, OTP, Gmail, connection, or permission steps themselves.
 */
declare class ConfigureHostedAuthFlow extends LitElement {
    apiKey: string;
    baseUrl: string;
    agent: string;
    agentName: string;
    agentLogo: string;
    valueProposition: string;
    copyMode: string;
    externalId: string;
    loginHint: string;
    methods: string;
    connectors: string;
    connectorOnly: boolean;
    skipConnections: boolean;
    requireEmail: boolean;
    private _email;
    private _givenName;
    private _familyName;
    private _emailError;
    private _emailSubmitting;
    reconnectMode: boolean;
    gmailMultiAccount: boolean;
    capability: string;
    font: string;
    theme: string;
    presentation: 'card' | 'bare';
    intent: 'link' | 'signin' | 'reconnect';
    authPattern: 'inline' | 'sso';
    agentToken: string;
    initialUserId: string;
    ignoreSession: boolean;
    requirePhoneEvidence: boolean;
    resetOnComplete: boolean;
    fixtureState: string;
    fixture: boolean;
    private _step;
    private _phone;
    private _userToken;
    private _userId;
    private _embedReceipt;
    private _gmailConnected;
    private _outlookConnected;
    private _outlookLimitNotice;
    private _gmailNeedsPermissions;
    private _gmailSkipped;
    private _gmailAccounts;
    private _stepHistory;
    private _navigatingHistory;
    private _flowStartedAt;
    private _stepEnteredAt;
    private _flowStartedRecorded;
    private _trackedStep;
    private _trackedStepExitRecorded;
    private _flowCompleted;
    private _lastVisibilityState;
    private _gmailRefreshVersion;
    private _connectorCompletionPromise;
    private _completedConnectorTools;
    private _journeyResume;
    private _requestedResumeStep;
    private _authJourneyId;
    static styles: lit.CSSResult[];
    connectedCallback(): void;
    disconnectedCallback(): void;
    firstUpdated(): void;
    start(): Promise<void>;
    refresh(): void;
    getFixturePreviewState(): FixturePreviewState | null;
    restoreFixturePreviewState(state: Partial<FixturePreviewState>): boolean;
    useDifferentPhone(): void;
    goBack(): Promise<void>;
    applyInit(data?: HostedInit): void;
    protected updated(changed: Map<string, unknown>): void;
    private _hostedViewName;
    private _restorePreviousStep;
    restoreSession(options?: {
        checkProfile?: boolean;
    }): boolean;
    clearSession(): void;
    private _resetFlowView;
    private _apiBase;
    private _recordFlowStarted;
    private _recordStepView;
    private _recordTerminalStep;
    private _onPageHide;
    private _onVisibilityChange;
    private _stageForStep;
    private get _isSso();
    private _normalizeMethods;
    private _normalizeList;
    private _supportsPhoneMethod;
    private _postVerificationStep;
    private _skipCompleteStarted;
    private _profileCheckedStep;
    private _journeyStorageKey;
    private _requestedStageFromUrl;
    private _hydrateJourneyResume;
    private _persistJourneyResume;
    private _clearJourneyResume;
    private _validatedResumeStep;
    private _requestedAuthenticatedStep;
    private _oauthReturnUrl;
    private _syncStageUrl;
    private _writeSession;
    private _clearStoredSession;
    private _sessionBase;
    private _firstPartyApiBase;
    private _createFirstPartySession;
    private _verifyFirstPartySession;
    private _restoreFirstPartySession;
    private _legacyProfileCookieDomain;
    private _legacyProfileCookieAttributes;
    private _clearLegacyProfileAuthCookie;
    private _readSession;
    private _stopUserTokenPersistence;
    private _onPhoneSubmit;
    private _onOtpChange;
    private _onOtpVerified;
    private _checkProfileData;
    private _restoredSessionLacksPhoneEvidence;
    private _fetchConnectedGmailAccounts;
    private _fetchOwnerToolState;
    private _isEmailLabel;
    private _gmailAccountLabel;
    private _mergeGmailAccounts;
    private _onToolConnected;
    private _onToolDisconnected;
    private _showOutlookLimitNotice;
    private _onGmailAccountRemove;
    private _onGmailAccountAdd;
    private _onToolPreserved;
    private _onToolError;
    private _fixtureAccountsForState;
    private _skipGmail;
    private _onAddAccount;
    private _refreshConnectedGmailAccounts;
    private _resumeAfterPhoneVerification;
    private _onConnectionsContinue;
    private _onConnectionsSkip;
    private _onProfileBack;
    private _onShowProfile;
    private _onProfileApproved;
    private _connectorCompletionId;
    private _completeConnectorOnly;
    private _mintAgentToken;
    private _emitLinked;
    private emitError;
    private _fixtureAllowed;
    private _fixtureEnabled;
    private _renderProviderChoice;
    private _handleDisclosureToggle;
    private _isValidEmail;
    private _submitEmail;
    private _renderEmailStep;
    private _renderVerifiedPhone;
    render(): typeof nothing | lit_html.TemplateResult<1>;
    private _renderState;
}

declare class ConfigureSingleConnector extends ConfigureBase {
    toolId: string;
    message: string;
    name: string;
    connected: boolean;
    loading: boolean;
    reconnectRequired: boolean;
    error: string;
    static styles: lit.CSSResult[];
    private _getName;
    render(): lit_html.TemplateResult<1>;
}

declare class ConfigureToolApproval extends ConfigureBase {
    actionId: string;
    tool: string;
    params: ToolApprovalParams;
    timeoutSeconds: number;
    private _decided;
    private _secondsLeft;
    private _timer?;
    static styles: lit.CSSResult[];
    connectedCallback(): void;
    disconnectedCallback(): void;
    private _approve;
    private _deny;
    private _alwaysAllow;
    private _getTitle;
    private _getResultText;
    render(): lit_html.TemplateResult<1>;
}

declare class ConfigureConfirmation extends ConfigureBase {
    message: string;
    confirmLabel: string;
    cancelLabel: string;
    private _decided;
    static styles: lit.CSSResult[];
    private _confirm;
    private _cancel;
    render(): lit_html.TemplateResult<1>;
}

declare class ConfigureAccessRequest extends ConfigureBase {
    agent: string;
    tool: string;
    message: string;
    description: string;
    private _decided;
    private _saving;
    static styles: lit.CSSResult[];
    private _allow;
    private _deny;
    private _removeAgentFromExactOverrides;
    private _saveDecision;
    private _showProfile;
    render(): lit_html.TemplateResult<1>;
}

declare class ConfigureMemoryCard extends ConfigureBase {
    memories: MemoryData[];
    maxVisible: number;
    showSettings: boolean;
    showActions: boolean;
    private _expanded;
    static styles: lit.CSSResult[];
    private _toggle;
    render(): lit_html.TemplateResult<1>;
}

declare class ConfigureRuntimeReading extends ConfigureBase {
    label: string;
    private _head;
    private _hue;
    private _timer?;
    static styles: lit.CSSResult[];
    connectedCallback(): void;
    disconnectedCallback(): void;
    private _dotStyle;
    render(): lit_html.TemplateResult<1>;
}

declare class ConfigurePersonalizationButton extends ConfigureBase {
    placeholder: string;
    variant: 'menu' | 'integration';
    personalizationLabel: string;
    imageLabel: string;
    fileLabel: string;
    connectors: string;
    externalId: string;
    hideImages: boolean;
    hideFiles: boolean;
    manual: boolean;
    private _menuOpen;
    private _linkOpen;
    private _linked;
    private _enabled;
    private _linkFrame;
    private _handleDocumentPointerDown;
    private _handleDocumentKeydown;
    static styles: lit.CSSResult[];
    disconnectedCallback(): void;
    connectedCallback(): void;
    updated(changed: Map<string, unknown>): void;
    private _toggleMenu;
    private _destroyLink;
    private _closeLinkSurface;
    private _emitToggle;
    private _selectImage;
    private _selectFile;
    private _openPersonalization;
    private _togglePersonalization;
    private _icon;
    render(): lit_html.TemplateResult<1>;
}

declare const EXPORT_PROMPT = "Export all of my stored memories and any context you've learned about me from past conversations. Preserve my words verbatim where possible, especially for instructions and preferences.\n\nOutput EXACTLY this format. Use these EXACT section markers on their own line. Do NOT add extra headings, bullets, or formatting.\n\n---SECTION:Instructions---\n[YYYY-MM-DD] Entry content here\n[unknown] Entry with no known date\n\n---SECTION:Identity---\n[YYYY-MM-DD] Entry content here\n\n---SECTION:Career---\n[YYYY-MM-DD] Entry content here\n\n---SECTION:Projects---\n[YYYY-MM-DD] Entry content here\n\n---SECTION:Preferences---\n[YYYY-MM-DD] Entry content here\n\n---END---\n\nRULES:\n- Each entry is ONE line starting with [YYYY-MM-DD] or [unknown]\n- Do NOT use bullet points, dashes, asterisks, or numbering before the date bracket\n- Do NOT add sub-headings within sections\n- Do NOT wrap output in a code block\n- If a section has no entries, include the section marker with no entries below it\n- Sort entries oldest first within each section\n- After ---END--- state whether this is the complete set or if more remain";
/** Provider URL builders */
declare const PROVIDER_URLS: Record<string, (prompt: string) => string>;
/** Default labels per provider */
declare const PROVIDER_LABELS: Record<string, string>;
/** Which prompt each provider uses */
declare const PROVIDER_PROMPTS: Record<string, string>;

declare class ConfigureAuthModal extends ConfigureBase {
    open: boolean;
    connectors: string;
    agent: string;
    private _step;
    private _phone;
    private _error;
    private _hasProfileData;
    static styles: lit.CSSResult[];
    connectedCallback(): void;
    disconnectedCallback(): void;
    private _onPhoneSubmit;
    private _onOtpVerified;
    private _checkProfileData;
    private _onProfileApproved;
    private _close;
    private _continueFromConnections;
    private _skipConnections;
    private _backToConnections;
    private _showProfile;
    render(): typeof nothing | lit_html.TemplateResult<1>;
}

export { type AccessRequestDetail, type AuthenticatedDetail, ConfigureAccessRequest, ConfigureAuth, ConfigureAuthModal, ConfigureBase, ConfigureConfirmation, ConfigureConnectionList, ConfigureConnectionRow, ConfigureExportButton, ConfigureExportPrompt, ConfigureHostedAuthFlow, ConfigureMemoryCard, ConfigureMemoryImport, ConfigureOtpInput, ConfigurePersonalizationButton, ConfigurePhoneInput, ConfigureProfileEditor, ConfigureRuntimeReading, ConfigureSingleConnector, ConfigureSuccessCard, ConfigureToolApproval, type ConfirmationDetail, type ConnectionData, EXPORT_PROMPT, type ErrorDetail, type ExportClickDetail, type ExportProvider, type IdentityUpdateDetail, type ImportCompleteDetail, type ImportErrorDetail, type ImportStartDetail, type MemoryData, type MemoryDeleteDetail, type MemoryEditDetail, type OtpVerifiedDetail, type OtpVerifyDetail, PROVIDER_LABELS, PROVIDER_PROMPTS, PROVIDER_URLS, type PersonalizationAssetSelectDetail, type PersonalizationMenuToggleDetail, type PersonalizationOpenDetail, type PersonalizationToggleDetail, type PhoneSubmitDetail, type ProfileApprovedDetail, type PromptCopiedDetail, type ToolApprovalDetail, type ToolApprovalParams, type ToolConnectDetail, type ToolDisconnectDetail };