@remnic/core 9.54.5 → 9.54.7

package/dist/support-passport/index.d.ts

@@ -0,0 +1,518 @@
+import { S as SupportPassportExternalRequestHandler } from '../public-http-D3GBeII4.js';
+export { a as SUPPORT_PASSPORT_PUBLIC_HTTP_ROUTES, b as SupportPassportPublicHandlerOptions, c as buildSupportPassportPublicRequestHandler, d as composeSupportPassportExternalRequestHandlers, n as normalizeSupportPassportNetworkAddress } from '../public-http-D3GBeII4.js';
+import { OfflineSyncExcludeFile } from '../offline-sync-file-io.js';
+import { M as MemoryFile, c3 as SupportPassportConfig } from '../types-ed-SvS2t.js';
+import { $ as SupportPassportCard, a6 as SupportPassportCardServiceDependencies, av as SupportPassportManualDraftInput, ah as SupportPassportDraftCard, aT as SupportPassportOwnerScope, aX as SupportPassportReplaceCardInput, a3 as SupportPassportCardMutationInput, ap as SupportPassportGrantCardRef, ar as SupportPassportGrantState, aa as SupportPassportCreateGrantInput, af as SupportPassportCreatedGrant, aR as SupportPassportOwnerGrant, aZ as SupportPassportRevokeGrantInput, aV as SupportPassportPublicGuide, aK as SupportPassportModelRoute, az as SupportPassportModelAdapter, aD as SupportPassportModelAuditSink, Y as SupportPassportAnswerOutput } from '../access-service-DK82xdNi.js';
+export { S as SUPPORT_PASSPORT_CARD_CATEGORIES, N as SUPPORT_PASSPORT_CARD_STATUSES, O as SUPPORT_PASSPORT_DRAFT_MAX_CONTENT_CHARACTERS, Q as SUPPORT_PASSPORT_DRAFT_MAX_MEMORIES, R as SUPPORT_PASSPORT_NOT_IN_GUIDE_ANSWER, T as SUPPORT_PASSPORT_SOURCE_MEMORY_ID_MAX_LENGTH, U as SupportPassportAccessSurface, V as SupportPassportAccessSurfaceDependencies, W as SupportPassportAnswerModelInput, X as SupportPassportAnswerModelInputSchema, Z as SupportPassportAnswerOutputSchema, _ as SupportPassportAnswerResult, a0 as SupportPassportCardCategory, a1 as SupportPassportCardCategorySchema, a2 as SupportPassportCardListSchema, a4 as SupportPassportCardMutationInputSchema, a5 as SupportPassportCardSchema, a7 as SupportPassportCardStatus, a8 as SupportPassportCardStatusSchema, a9 as SupportPassportCardTitleSchema, ab as SupportPassportCreateGrantInputSchema, ac as SupportPassportCreateGrantRequest, ad as SupportPassportCreateGrantRequestSchema, ae as SupportPassportCreateGrantResult, ag as SupportPassportCreatedGrantSchema, ai as SupportPassportDraftCardSchema, aj as SupportPassportDraftModelInput, ak as SupportPassportDraftModelInputSchema, al as SupportPassportDraftOutputSchema, am as SupportPassportDraftResult, an as SupportPassportError, ao as SupportPassportErrorCode, aq as SupportPassportGrantCardRefSchema, as as SupportPassportGrantStateSchema, at as SupportPassportListCardsInputSchema, au as SupportPassportListGrantsInputSchema, aw as SupportPassportManualDraftInputSchema, ax as SupportPassportMemoryIdSchema, ay as SupportPassportMemoryPreview, aA as SupportPassportModelAdapterOptions, aB as SupportPassportModelAuditRecord, aC as SupportPassportModelAuditRecordSchema, aE as SupportPassportModelAuditStore, aF as SupportPassportModelCallError, aG as SupportPassportModelClients, aH as SupportPassportModelFailureMetadata, aI as SupportPassportModelMessage, aJ as SupportPassportModelResultMetadata, aL as SupportPassportModelRouteKind, aM as SupportPassportModelRouteResult, aN as SupportPassportModelUsage, aO as SupportPassportNamespaceSchema, aP as SupportPassportOwnerCreateGrantRequest, aQ as SupportPassportOwnerCreateGrantRequestSchema, aS as SupportPassportOwnerGrantSchema, aU as SupportPassportPublicCardSchema, aW as SupportPassportPublicGuideSchema, aY as SupportPassportReplaceCardInputSchema, a_ as SupportPassportRevokeGrantInputSchema, a$ as SupportPassportRevokeGrantResult, b0 as SupportPassportSourceMemoryIdSchema, b1 as acceptsSupportPassportModelResponse, b2 as buildSupportPassportDirectGatewayConfig, b4 as computeSupportPassportCardRevision, b5 as createSupportPassportModelAdapter, b7 as hashSupportPassportAuditValues, b8 as resolveSupportPassportModelRoutePlan } from '../access-service-DK82xdNi.js';
+import { S as StorageManager } from '../storage-qOnaJ1Lw.js';
+import { FileHandle } from 'node:fs/promises';
+import { withHeldFileLock } from '../utils/serialize-mutations.js';
+import { z } from 'zod';
+import 'node:http';
+import '../message-parts/index.js';
+import '../bounded-jsonl-state.js';
+import '../operator-doctor-types.js';
+import '../external-wiki-config.js';
+import '../contradiction-config.js';
+import '../graph-path-scoring-config.js';
+import '../types-continuity.js';
+import '../catalog-DGFf8mD9.js';
+import '../access-namespace-preflight-CCNn_6NE.js';
+import '../access-token-capabilities.js';
+import 'node:async_hooks';
+import '../scope-profiles-DICK7GtN.js';
+import '../types-B1VHaf2w.js';
+import '../recall-explain-renderer.js';
+import '../recall-state.js';
+import '../search/port.js';
+import '../recall-xray.js';
+import '../memory-provenance.js';
+import '../user-model.js';
+import '../access-citation.js';
+import '../access-health-types.js';
+import '../corpus-watermark.js';
+import '../replica-divergence.js';
+import '../resolve-auth-token.js';
+import '../orchestrator-D85CzDDY.js';
+import '../briefing.js';
+import '../corpus-read-cancellation.js';
+import '../artifact-search.js';
+import '../entity-id-normalization.js';
+import '../page-versioning.js';
+import '../consolidation-operator.js';
+import '../memory-projection-store.js';
+import '../maintenance/memory-governance.js';
+import '../runtime/better-sqlite.js';
+import 'better-sqlite3';
+import '../write-envelope.js';
+import '../structured-attributes.js';
+import '../buffer.js';
+import '../extraction-faithfulness.js';
+import '../local-llm.js';
+import '../model-registry.js';
+import '../fallback-llm.js';
+import '../resolve-provider-secret.js';
+import '../transcript.js';
+import '../session-integrity.js';
+import '../summarizer.js';
+import '../maintenance-C8aRWfhq.js';
+import '../namespaces/search.js';
+import '../compounding/engine.js';
+import '../shared-context/manager.js';
+import '../capabilities.js';
+import '../utility-runtime.js';
+import '../tier-routing.js';
+import '../lifecycle.js';
+import '../orchestration/compression-guideline-coordinator.js';
+import '../semantic-consolidation-BP7NAX0N.js';
+import '../connectors/codex-materialize.js';
+import '../logger.js';
+import '../embedding-fallback.js';
+import '../extraction.js';
+import '../schemas.js';
+import '../profiling.js';
+import '../extraction-error-classification.js';
+import '../objective-state.js';
+import '../causal-trajectory.js';
+import '../trust-zones.js';
+import '../harmonic-retrieval.js';
+import '../abstraction-nodes.js';
+import '../cue-anchors.js';
+import '../verified-recall.js';
+import '../boxes.js';
+import '../semantic-rule-verifier.js';
+import '../work-product-ledger.js';
+import '../trust-score-stage.js';
+import '../trust-score.js';
+import '../conversation-index/chunker.js';
+import '../conversation-index/backend.js';
+import '../faiss-adapter-BHecI1fF.js';
+import '../runtime/child-process.js';
+import '../dependency-propagation-delivery-CzEfB31P.js';
+import '../namespaces/storage.js';
+import '../threading.js';
+import '../graph-444E-DrF.js';
+import '../recall-context-composition.js';
+import '../live-connectors-runner.js';
+import '../framework-CNDn2164.js';
+import '../relevance.js';
+import '../negative.js';
+import '../session-observer-state.js';
+import '../semantic-TddhF0y7.js';
+import '../replay/types.js';
+import '../service-DT-pJyda.js';
+import '../extraction-judge.js';
+import '../lcm/engine.js';
+import '../lcm/archive.js';
+import '../lcm/summarizer.js';
+import '../lcm/dag.js';
+import '../lcm/recall.js';
+import '../lcm/queue.js';
+import '../policy-runtime.js';
+import '../cross-namespace-budget.js';
+import '../explicit-capture.js';
+import '../recall-audit-anomaly.js';
+import '../recall-audit.js';
+import '../access-wearables-meetings-surface.js';
+import '../graph-snapshot.js';
+import '../access-offline-manifest.js';
+import '../reconcile/manifest.js';
+import '../reconcile/plan.js';
+import '../offline-sync.js';
+import '../action-confidence.js';
+import '../capsule-cli.js';
+import '../memory-worth-outcomes.js';
+import '../transfer/capsule-export.js';
+import '../transfer/types.js';
+import '../transfer/capsule-import.js';
+import '../access-errors.js';
+
+declare const SUPPORT_PASSPORT_CARD_TAG = "support-passport-card";
+declare const SUPPORT_PASSPORT_AUDIT_TAG = "support-passport-audit";
+declare function isSupportPassportPrivateMemory(memory: {
+    frontmatter: {
+        tags?: readonly string[];
+        structuredAttributes?: Readonly<Record<string, string>>;
+    };
+}): boolean;
+declare function excludeSupportPassportPrivateMemories<T extends Pick<MemoryFile, "frontmatter">>(memories: readonly T[]): T[];
+declare function createSupportPassportPrivateFileExclusion(storage: {
+    readMemoryByPath(filePath: string): Promise<MemoryFile | null>;
+}): OfflineSyncExcludeFile;
+declare const SUPPORT_PASSPORT_ATTRIBUTE_KEYS: Readonly<{
+    namespace: "support-passport-namespace";
+    namespaceEncoding: "support-passport-namespace-encoding";
+    owner: "support-passport-owner";
+    title: "support-passport-title";
+    category: "support-passport-category";
+    order: "support-passport-order";
+    reviewBy: "support-passport-review-by";
+    sourceMemoryIds: "support-passport-source-ids";
+    replacesDraftId: "support-passport-replaces-draft-id";
+    replacedRevision: "support-passport-replaced-revision";
+    draftReplacementPrepared: "support-passport-draft-replacement-prepared";
+    replacementComplete: "support-passport-replacement-complete";
+    generatedBatchId: "support-passport-generated-batch-id";
+    generatedBatchSize: "support-passport-generated-batch-size";
+}>;
+declare function encodeSupportPassportNamespaceAttributes(namespace: string): Record<string, string>;
+declare function decodeSupportPassportNamespaceAttributes(attributes: Readonly<Record<string, string>>): string | null;
+interface StoredSupportPassportCard {
+    card: SupportPassportCard;
+    memory: MemoryFile;
+    order: number;
+    sourceMemoryIds: string[];
+    namespace: string;
+    owner: string;
+    replacesDraftId?: string;
+    replacedRevision?: string;
+    draftReplacementPrepared: boolean;
+    generatedBatchId?: string;
+    generatedBatchSize?: number;
+}
+declare function computeSupportPassportOwnerKey(principal: string): string;
+declare function activeSupportPassportReplacementPredecessorIds(cards: readonly StoredSupportPassportCard[]): Set<string>;
+declare function hasLiveSupportPassportCard(memory: Pick<MemoryFile, "frontmatter" | "content">): boolean;
+declare function projectSupportPassportCard(memory: MemoryFile): StoredSupportPassportCard | null;
+
+declare class SupportPassportCardService {
+    private readonly resolveOwner;
+    private readonly now;
+    constructor(dependencies: SupportPassportCardServiceDependencies);
+    listCards(input: {
+        principal: string;
+    }): Promise<SupportPassportCard[]>;
+    createManualDraft(input: SupportPassportManualDraftInput, options?: {
+        signal?: AbortSignal;
+        onCommitted?: () => void;
+    }): Promise<SupportPassportCard>;
+    createGeneratedDrafts(input: {
+        principal: string;
+        cards: SupportPassportDraftCard[];
+    }): Promise<SupportPassportCard[]>;
+    createGeneratedDraftsForOwner(input: {
+        authenticatedPrincipal: string;
+        owner: SupportPassportOwnerScope;
+        cards: SupportPassportDraftCard[];
+        signal?: AbortSignal;
+        onCommitted?: () => void;
+        commitWithValidatedSources?: (commit: () => Promise<void>) => Promise<void>;
+    }): Promise<SupportPassportCard[]>;
+    replaceCard(input: SupportPassportReplaceCardInput, options?: {
+        signal?: AbortSignal;
+        onCommitted?: () => void;
+    }): Promise<SupportPassportCard>;
+    approveCard(input: SupportPassportCardMutationInput, options?: {
+        signal?: AbortSignal;
+        onCommitted?: () => void;
+    }): Promise<SupportPassportCard>;
+    rejectCard(input: SupportPassportCardMutationInput, options?: {
+        signal?: AbortSignal;
+        onCommitted?: () => void;
+    }): Promise<SupportPassportCard>;
+    withdrawCard(input: SupportPassportCardMutationInput, options?: {
+        signal?: AbortSignal;
+        onCommitted?: () => void;
+    }): Promise<SupportPassportCard>;
+    private createDraft;
+    private persistDraft;
+    private changeStatus;
+    private resolveOwnerScope;
+    private rejectCreatedDraft;
+    private rejectGeneratedDraft;
+    private readStoredCards;
+    private generatedBatchContext;
+    private rejectPendingReplacementForPredecessor;
+    private recoverReplacementTransition;
+    private completeReplacementAfterActivation;
+    private finishCommittedApproval;
+    private rollbackConflictedApproval;
+    private recoverReplacedDraft;
+    private finishPreparedDraftReplacement;
+    private rejectOrphanedReplacement;
+    private restorePriorAfterApprovalFailure;
+    private markReplacementComplete;
+    private requireOwnerLock;
+    private requireCard;
+}
+
+declare const DEFAULT_SUPPORT_PASSPORT_CONFIG: SupportPassportConfig;
+declare function parseSupportPassportConfig(raw: unknown): SupportPassportConfig;
+
+interface SupportPassportGrantStoreOptions {
+    memoryDir: string;
+    now?: () => Date;
+    makeSecret?: () => Buffer;
+    makeGrantId?: () => string;
+    withHeldFileLock?: typeof withHeldFileLock;
+    syncDirectory?: typeof syncDirectoryForDurability;
+}
+interface CreateStoredGrantInput {
+    namespace: string;
+    principal: string;
+    cards: SupportPassportGrantCardRef[];
+    expiresAt: string;
+    requestedAt?: Date;
+}
+interface SupportPassportGrantMutationHooks {
+    beforeCommit?: () => Promise<void>;
+    onCommitted?: () => void | Promise<void>;
+}
+type SupportPassportGrantCreateHooks = SupportPassportGrantMutationHooks | (() => Promise<void>);
+type SupportPassportGrantRevokeHooks = SupportPassportGrantMutationHooks | (() => Promise<void>);
+declare function notifySupportPassportCommitted(callback: (() => void | Promise<void>) | undefined): void;
+declare function syncDirectoryForDurability(directory: string, openDirectory?: (directory: string) => Promise<Pick<FileHandle, "sync" | "close">>): Promise<void>;
+declare class SupportPassportGrantStore {
+    private memoryDir;
+    private grantsDir;
+    private ownerIndexesDir;
+    private memoryRootReady?;
+    private safeDirectoriesReady?;
+    private readonly now;
+    private readonly makeSecret;
+    private readonly makeGrantId;
+    private readonly runWithHeldFileLock;
+    private readonly syncDirectory;
+    constructor(options: SupportPassportGrantStoreOptions);
+    create(input: CreateStoredGrantInput, hooks?: SupportPassportGrantCreateHooks): Promise<{
+        state: SupportPassportGrantState;
+        secret: string;
+    }>;
+    authenticate(grantId: string, secret: string): Promise<SupportPassportGrantState>;
+    withAuthenticatedGrant<T>(grantId: string, secret: string, task: (state: SupportPassportGrantState) => Promise<T>, beforeReturn?: (state: SupportPassportGrantState) => Promise<void>): Promise<T>;
+    listForOwner(namespace: string, principal: string): Promise<SupportPassportGrantState[]>;
+    revoke(input: {
+        grantId: string;
+        namespace: string;
+        principal: string;
+        expectedStateVersion?: number;
+    }, hooks?: SupportPassportGrantRevokeHooks): Promise<SupportPassportGrantState>;
+    private filePath;
+    private ownerIndexPath;
+    private ownerHash;
+    private addToOwnerIndex;
+    private removeGrantStates;
+    private ownerMembershipDirectory;
+    private ensureOwnerMembershipDirectory;
+    private writeOwnerMembership;
+    private removeOwnerMembership;
+    private removeStoredGrant;
+    private writeOwnerIndexWhileLocked;
+    private reconcileCreateAfterOwnerIndexLockLoss;
+    private reconcileCommittedGrant;
+    private retainedOwnerStates;
+    private listedOwnerStates;
+    private requireAvailableOwnerGrantSlot;
+    private readOwnerMembershipStates;
+    private readOwnerIndexByHash;
+    private writeOwnerIndex;
+    private readState;
+    private writeState;
+    private ensureSafeDirectories;
+    private ensureMemoryRoot;
+    private withMutationLock;
+    private withGrantLock;
+    private withOwnerIndexLock;
+    private withExclusiveLock;
+    private requireMutationLock;
+    private requireOwnerIndexLock;
+    private requireActiveState;
+}
+
+interface SupportPassportGrantServiceDependencies {
+    grantStore: SupportPassportGrantStore;
+    resolveOwner(principal: string): Promise<{
+        principal: string;
+        namespace: string;
+        storage: StorageManager;
+    }>;
+    resolveNamespace(namespace: string): Promise<StorageManager>;
+    now?: () => Date;
+}
+declare class SupportPassportGrantService {
+    private readonly grantStore;
+    private readonly resolveOwner;
+    private readonly resolveNamespace;
+    private readonly now;
+    private readonly ownerCardCache;
+    constructor(dependencies: SupportPassportGrantServiceDependencies);
+    createGrant(input: SupportPassportCreateGrantInput, options?: {
+        signal?: AbortSignal;
+        onCommitted?: () => void | Promise<void>;
+    }): Promise<SupportPassportCreatedGrant>;
+    listGrants(input: {
+        principal: string;
+    }): Promise<SupportPassportOwnerGrant[]>;
+    revokeGrant(input: SupportPassportRevokeGrantInput, options?: {
+        signal?: AbortSignal;
+        onCommitted?: () => void | Promise<void>;
+    }): Promise<SupportPassportOwnerGrant>;
+    readGrant(input: {
+        grantId: string;
+        secret: string;
+    }): Promise<SupportPassportPublicGuide>;
+    private readGrantAttempt;
+    private readGrantCards;
+    private readStoredCardSnapshot;
+    private projectOwnedCards;
+    private cacheOwnerCards;
+    private cardSnapshotVersion;
+    private revokeCommittedGrant;
+    private publicCard;
+    private expiryFromDuration;
+    private resolveOwnerScope;
+    private ownerGrant;
+}
+
+declare const SUPPORT_PASSPORT_MODEL_JOB_PATH = "/engram/v1/support-passport/internal/model/jobs/next";
+declare const SUPPORT_PASSPORT_MODEL_ACK_PATH = "/engram/v1/support-passport/internal/model/jobs/ack";
+declare const SUPPORT_PASSPORT_MODEL_RESULT_PATH = "/engram/v1/support-passport/internal/model/jobs/result";
+declare const ModelJobSchema: z.ZodObject<{
+    id: z.ZodString;
+    claimId: z.ZodOptional<z.ZodString>;
+    messages: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<["system", "user", "assistant"]>;
+        content: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        content: string;
+        role: "user" | "assistant" | "system";
+    }, {
+        content: string;
+        role: "user" | "assistant" | "system";
+    }>, "many">;
+    temperature: z.ZodNumber;
+    maxTokens: z.ZodNumber;
+    timeoutMs: z.ZodNumber;
+    claimAckTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    executionLeaseTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    operation: z.ZodEnum<["support-passport-draft", "support-passport-answer"]>;
+    jsonSchema: z.ZodObject<{
+        name: z.ZodString;
+        schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        schema: Record<string, unknown>;
+    }, {
+        name: string;
+        schema: Record<string, unknown>;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    messages: {
+        content: string;
+        role: "user" | "assistant" | "system";
+    }[];
+    temperature: number;
+    maxTokens: number;
+    timeoutMs: number;
+    operation: "support-passport-draft" | "support-passport-answer";
+    jsonSchema: {
+        name: string;
+        schema: Record<string, unknown>;
+    };
+    claimId?: string | undefined;
+    claimAckTimeoutMs?: number | undefined;
+    executionLeaseTimeoutMs?: number | undefined;
+}, {
+    id: string;
+    messages: {
+        content: string;
+        role: "user" | "assistant" | "system";
+    }[];
+    temperature: number;
+    maxTokens: number;
+    timeoutMs: number;
+    operation: "support-passport-draft" | "support-passport-answer";
+    jsonSchema: {
+        name: string;
+        schema: Record<string, unknown>;
+    };
+    claimId?: string | undefined;
+    claimAckTimeoutMs?: number | undefined;
+    executionLeaseTimeoutMs?: number | undefined;
+}>;
+type SupportPassportModelJob = z.infer<typeof ModelJobSchema>;
+declare function parseSupportPassportModelJob(value: unknown): SupportPassportModelJob | undefined;
+interface SupportPassportModelBridgeOptions {
+    maxPendingJobs?: number;
+    claimAckTimeoutMs?: number;
+    executionLeaseTimeoutMs?: number;
+}
+/**
+ * In-memory transport between a standalone Remnic daemon and its OpenClaw
+ * delegate. The transport carries provider-neutral model jobs only.
+ */
+declare class SupportPassportModelBridge {
+    readonly route: SupportPassportModelRoute;
+    readonly requestHandler: SupportPassportExternalRequestHandler;
+    private readonly maxPendingJobs;
+    private readonly claimAckTimeoutMs;
+    private readonly executionLeaseTimeoutMs;
+    private readonly pending;
+    private readonly available;
+    private readonly waiters;
+    private readonly claimed;
+    private lastConsumerPollAt;
+    private closed;
+    constructor(options?: SupportPassportModelBridgeOptions);
+    close(): void;
+    private invoke;
+    private claimedJob;
+    private claimPending;
+    private armClaimTimer;
+    private takeAvailable;
+    private nextJob;
+    private handleRequest;
+}
+
+declare function computeSupportPassportSourceRevision(content: string, structuredAttributes?: Record<string, string>): string;
+interface SupportPassportDraftServiceDependencies {
+    cardService: SupportPassportCardService;
+    modelAdapter: SupportPassportModelAdapter;
+    resolveOwner(principal: string): Promise<SupportPassportOwnerScope>;
+    audit: SupportPassportModelAuditSink;
+    now?: () => Date;
+}
+interface SupportPassportQuestionServiceDependencies {
+    grantService: SupportPassportGrantService;
+    modelAdapter: SupportPassportModelAdapter;
+    audit: SupportPassportModelAuditSink;
+    now?: () => Date;
+}
+declare function isSupportPassportSourceEligible(memory: MemoryFile): boolean;
+declare class SupportPassportDraftService {
+    private readonly cardService;
+    private readonly modelAdapter;
+    private readonly resolveOwner;
+    private readonly audit;
+    private readonly now;
+    constructor(dependencies: SupportPassportDraftServiceDependencies);
+    draftCards(input: {
+        principal: string;
+        sourceMemoryIds: string[];
+        sourceMemoryRevisions: Array<{
+            memoryId: string;
+            revision: string;
+        }>;
+        consent: boolean;
+        signal?: AbortSignal;
+        onCommitted?: () => void;
+    }): Promise<SupportPassportCard[]>;
+    private revalidateSources;
+    private validateOwnerScope;
+}
+declare class SupportPassportQuestionService {
+    private readonly grantService;
+    private readonly modelAdapter;
+    private readonly audit;
+    private readonly now;
+    constructor(dependencies: SupportPassportQuestionServiceDependencies);
+    askGrant(input: {
+        grantId: string;
+        secret: string;
+        question: string;
+        signal?: AbortSignal;
+    }): Promise<SupportPassportAnswerOutput>;
+}
+
+export { type CreateStoredGrantInput, DEFAULT_SUPPORT_PASSPORT_CONFIG, SUPPORT_PASSPORT_ATTRIBUTE_KEYS, SUPPORT_PASSPORT_AUDIT_TAG, SUPPORT_PASSPORT_CARD_TAG, SUPPORT_PASSPORT_MODEL_ACK_PATH, SUPPORT_PASSPORT_MODEL_JOB_PATH, SUPPORT_PASSPORT_MODEL_RESULT_PATH, type StoredSupportPassportCard, SupportPassportAnswerOutput, SupportPassportCard, SupportPassportCardMutationInput, SupportPassportCardService, SupportPassportCardServiceDependencies, SupportPassportCreateGrantInput, SupportPassportCreatedGrant, SupportPassportDraftCard, SupportPassportDraftService, type SupportPassportDraftServiceDependencies, SupportPassportExternalRequestHandler, SupportPassportGrantCardRef, type SupportPassportGrantMutationHooks, SupportPassportGrantService, type SupportPassportGrantServiceDependencies, SupportPassportGrantState, SupportPassportGrantStore, type SupportPassportGrantStoreOptions, SupportPassportManualDraftInput, SupportPassportModelAdapter, SupportPassportModelAuditSink, SupportPassportModelBridge, type SupportPassportModelBridgeOptions, type SupportPassportModelJob, SupportPassportModelRoute, SupportPassportOwnerGrant, SupportPassportOwnerScope, SupportPassportPublicGuide, SupportPassportQuestionService, type SupportPassportQuestionServiceDependencies, SupportPassportReplaceCardInput, SupportPassportRevokeGrantInput, activeSupportPassportReplacementPredecessorIds, computeSupportPassportOwnerKey, computeSupportPassportSourceRevision, createSupportPassportPrivateFileExclusion, decodeSupportPassportNamespaceAttributes, encodeSupportPassportNamespaceAttributes, excludeSupportPassportPrivateMemories, hasLiveSupportPassportCard, isSupportPassportPrivateMemory, isSupportPassportSourceEligible, notifySupportPassportCommitted, parseSupportPassportConfig, parseSupportPassportModelJob, projectSupportPassportCard, syncDirectoryForDurability };