@criticalbridge/brain-client 1.0.0

package/dist/client.d.ts

@@ -0,0 +1,604 @@
+import type { AgentActionResponse, AssignAgentParams, AssignAgentResponse, BrainClientConfig, CancelDispatchResponse, CreateDispatchRequest, CreateDispatchResponse, DeleteAgentResponse, EnqueueWorkItemRequest, EnqueueWorkItemResponse, GetAgentResponse, GetAssignmentResponse, GetDecisionLineageResponse, GetDispatchResponse, GetEntityLicenseUsageResponse, GetLicenseAwareUtilizationResponse, GetSeatLicenseUsageResponse, ListAgentGroupsResponse, ListAgentsParams, ListAgentsResponse, ListAgentWorkItemsParams, ListAgentWorkItemsResponse, ListDecisionLineageParams, ListDecisionLineageResponse, ListDispatchesResponse, ListEventsParams, ListEventsResponse, ListOperatorSignalsParams, ListOperatorSignalsResponse, ListWorkAssignmentEventsParams, ListWorkAssignmentEventsResponse, MeshSubscriptionHealthResponse, SystemHealthResponse, ListProcessInstancesParams, ListProcessInstancesResponse, ListUsersResponse, ReassignWorkItemRequest, ReassignWorkItemResponse, RecordDecisionLineageRequest, RecordDecisionLineageResponse, GetMyRbacRolesResponse, AssignRbacRoleResponse, CreateDelegationResponse, GetDelegationsResponse, GetSelfSuperUserResponse, GrantSuperUserRequest, GrantSuperUserResponse, ListSuperUsersResponse, RbacRole, GetEntityMetadataResponse, BootstrapLoginResponse, RegisterAgentRequest, RegisterAgentResponse, ResolveTenantResponse, UnassignAgentResponse, UpdateAgentRequest, UpdateAgentResponse } from './types/api.types';
+import type { ActivityResponse, AdvanceStageRequest, AdvanceStageResponse, DashboardMetricsResponse, GetProcessStagesResponse, LatencyResponse, LicensePoolResponse, QueueDepthsResponse, RunVolumeResponse, SeatLicense, SeatLicensesResponse, TopCapabilitiesResponse, TopCapabilitiesWindow, UsageHistoryResponse } from './types/dashboard.types';
+import type { DriftDashboardSnapshotResponse } from './types/drift-dashboard.types';
+import type { GetEntityInfoResponse } from './types/entity.types';
+import type { DeletePipelineResponse, ListPipelineRunsResponse, ListPipelinesResponse } from './types/pipeline.types';
+import type { DocumentIngestionStatusResponse, TriggerDocumentIngestionInput, TriggerDocumentIngestionResponse } from './types/document-ingestion.types';
+import type { ChangeApprovalRiskTier, ClearChangeApprovalPolicyOverrideBody, GetChangeApprovalPolicyAuditResponse, GetChangeApprovalPolicyResponse, GetChangeApprovalVerdictResponse, ListChangeApprovalDecisionsResponse, ListChangeApprovalPoliciesResponse, RecordChangeApprovalDecisionBody, RecordChangeApprovalDecisionResponse, SetChangeApprovalPolicyOverrideBody } from './types/change-approval-gate.types';
+import type { AgentSkillEntityKind, GetLifecycleStatusResponse, TransitionLifecycleBody, TransitionLifecycleResponse } from './types/agent-skill-lifecycle.types';
+import type { ClassifyAgentBody, ClassifyAgentResponse } from './types/risk-classification.types';
+import type { WizardAssistantTurnBody, WizardAssistantTurnResponse } from './types/wizard-assistant.types';
+import type { GetEffectiveControlProfileResponse } from './types/effective-control-profile.types';
+import type { GetBiasThresholdPolicyResponse, UpdateBiasThresholdPolicyBody, UpdateBiasThresholdPolicyResponse } from './types/bias-threshold-policy.types';
+import type { ClearControlProfileOverrideBody, ControlProfileRiskTier, GetControlProfileAuditResponse, GetControlProfileResponse, ListControlProfilesResponse, SetControlProfileOverrideBody } from './types/control-profile.types';
+import type { GetAgentPolicyHistoryParams, GetAgentPolicyHistoryResponse, GetPolicyCatalogResponse } from './types/policy.types';
+import type { RecentFailuresOptions, RecentFailuresResponse } from './types/failure.types';
+import type { AckIncidentRequest, AckIncidentResponse, AssignIncidentRequest, AssignIncidentResponse, CreateIncidentInput, CreateIncidentResponse, GetIncidentResponse, IncidentListFilter, ListIncidentsResponse, ResolveIncidentRequest, ResolveIncidentResponse } from './types/incident.types';
+import type { A2AVendor, A2AVendorId, ListA2AAgentsResponse, ListA2AVendorsResponse, ProvenanceMix, RegisterA2AVendorRequest } from './types/a2a.types';
+import type { ConnectionCreateBody, ConnectionUpdateBody, ConnectionWriteResponse, GetConnectionResponse, ListConnectionsResponse, PutCredentialResponse, RefreshedCredentialResponse, ScopedCredential } from './types/connection.types';
+import type { IntrospectTableBody, IntrospectTableResponse, ListTablesResponse, SampleValuesBody, SampleValuesResponse } from './types/introspection.types';
+import type { GetMappingConfigResponse, GetSourceDefinitionResponse, ListMappingConfigsResponse, ListSourceDefinitionsResponse, MappingConfigWriteResponse, SourceDefinitionInput, SourceDefinitionWriteResponse, SourceMappingConfigInput } from './types/source-mapping.types';
+import type { EntityModelEntityType, EntityModelMutationResponse, EntityModelRelationship, GetEntityModelResponse, ListEntityModelsResponse } from './types/entity-model-graph.types';
+import type { AILearnFromImportBody, AIParameterSuggestionsBody, AIRecordNodeUsageBody, AIScoreQualityBody, AISimilarWorkflowsBody, AISmartDefaultsBody, AISuggestNextNodesBody, NodeSuggestion, ParameterSuggestion, PatternMatch, QualityScore, SmartDefaults } from './types/ai-knowledge.types';
+import type { BPKGConflictDetectionResult, BPKGDetectConflictsBody, BPKGGraphTraversalResult, BPKGRecommendationResult, BPKGRecommendationsBody, BPKGRelationshipWithDetails, BPKGRelationshipsForPracticeBody, BPKGShortestPathBody, BPKGStatistics, BPKGTraverseBody } from './types/best-practices-kg.types';
+import type { KBKGDocumentNode, KBKGFindByEntityBody, KBKGFindRelatedBody, KBKGRelatedDocument, KBKGStatistics } from './types/kb-kg.types';
+import type { EKGEntity, EKGFindEntitiesBody, EKGFindPathBody, EKGGetEntityBody, EKGGetEntityRelationshipsBody, EKGGraphTraversalResult, EKGHealthCheck, EKGRawReadQueryBody, EKGRelationshipWithDetails, EKGRelationshipsByEntityIdsBody, EKGSearchEntitiesBody, EKGShortestPathResult, EKGStatistics, EKGTraverseBody } from './types/entity-kg.types';
+import type { AppendDomainEventBatchResponse, AppendDomainEventResponse, BrainDomainEvent } from './types/domain-event.types';
+import type { CheckSourceReferencesResponse, CreateSourceRequest, DiscoverEntitiesResponse, EntityModelSourceWriteResponse, GetEntityModelSourceResponse, ListEntityModelSourcesResponse, SyncDispatchResponse, TestConnectionResponse, UpdateSourceRequest } from './types/entity-model-sources.types';
+import { type ListObjectsResponse, type ObjectMetadataResponse, type SignObjectUrlRequest, type SignObjectUrlResponse } from './types/object-store.types';
+export declare const ENTITY_ADMIN_CONFIG_KINDS: readonly ["sso", "ldap", "log-streaming", "rules-engine"];
+export type EntityAdminConfigKind = (typeof ENTITY_ADMIN_CONFIG_KINDS)[number];
+export interface BrainBreakGlassGrant {
+    id: string;
+    expiresAt: string;
+    supervisorNotificationRequired: boolean;
+    targetSchema?: string;
+}
+export interface BrainBreakGlassRequestBody {
+    userId?: string;
+    emergencyType: string;
+    justification: string;
+    targetSchema?: string;
+    targetTable?: string;
+    targetRecordId?: string;
+    durationHours?: number;
+}
+export declare const HEALTHCARE_COMPLIANCE_COLLECTIONS: readonly ["access-log", "consents", "relationships", "purpose-permissions", "hipaa-checklist"];
+export type HealthcareComplianceCollection = (typeof HEALTHCARE_COMPLIANCE_COLLECTIONS)[number];
+export interface HealthcarePHIAccessResult {
+    granted: boolean;
+    data?: Record<string, unknown>;
+    denialReason?: string;
+    auditId?: string;
+}
+export interface FinancePCIAccessRequest {
+    userId: string;
+    tenantId: string;
+    dataType: string;
+    recordId: string;
+    purpose: string;
+    justification?: string;
+}
+export interface FinancePCIAccessResult {
+    granted: boolean;
+    denialReason?: string;
+    auditId: string;
+    data?: {
+        id: string;
+        recordId: string;
+        dataType: string;
+        value: string;
+    };
+}
+export interface FinanceSOXAccessRequest {
+    userId: string;
+    tenantId: string;
+    action: string;
+    recordId: string;
+    fiscalPeriod: string;
+    requiresApproval: boolean;
+}
+export interface FinanceSOXAccessResult {
+    granted: boolean;
+    denialReason?: string;
+    auditId: string;
+    data?: {
+        id: string;
+        recordId: string;
+        fiscalPeriod: string;
+        data: Record<string, unknown>;
+    };
+}
+export interface FinanceSoDVerifyRequest {
+    userId: string;
+    tenantId?: string;
+    action: string;
+    recordId?: string;
+}
+export interface FinanceSoDVerifyResult {
+    allowed: boolean;
+    conflictingActions: string[];
+    reason?: string;
+}
+export interface InsuranceAccessPolicyholderRequest {
+    userId: string;
+    policyholderId: string;
+    purpose: string;
+    tenantId?: string;
+    decisionLineageSignalId?: string;
+}
+export interface InsuranceAccessPolicyholderData {
+    id?: string;
+    policyholderId?: string;
+    externalId?: string;
+    dataClassification?: string;
+    regulatoryFrameworks?: string[];
+    riskTier?: string;
+    customerSegment?: string;
+    marketingConsent?: boolean;
+    dataSharingConsent?: boolean;
+    ssn?: string;
+    dateOfBirth?: string;
+    contactInfo?: {
+        city?: string;
+        state?: string;
+        zipPrefix?: string;
+        [key: string]: unknown;
+    };
+}
+export interface InsuranceAccessPolicyholderResult {
+    granted: boolean;
+    denialReason?: string;
+    auditId: string;
+    data?: InsuranceAccessPolicyholderData;
+}
+export declare const INSURANCE_COMPLIANCE_COLLECTIONS: readonly ["user-tiers", "claims", "siu-investigations", "underwriting", "regulatory-status", "policyholders"];
+export type InsuranceComplianceCollection = (typeof INSURANCE_COMPLIANCE_COLLECTIONS)[number];
+export declare class BrainAPIClient {
+    private readonly baseUrl;
+    private readonly entityId;
+    private readonly apiKey?;
+    private readonly getAccessToken?;
+    private readonly fetchImpl;
+    private readonly requestTimeoutMs;
+    constructor(config: BrainClientConfig);
+    getEntityId(): string;
+    getEntityInfo(): Promise<GetEntityInfoResponse>;
+    registerAgent<TAgent>(body: RegisterAgentRequest<TAgent>): Promise<RegisterAgentResponse>;
+    resolveTenant(): Promise<ResolveTenantResponse>;
+    getMyRbacRoles(): Promise<GetMyRbacRolesResponse>;
+    getUserRbacRoles(userId: string): Promise<GetMyRbacRolesResponse>;
+    assignRbacRole(userId: string, roleName: string): Promise<AssignRbacRoleResponse>;
+    removeRbacRole(userId: string, roleName: string): Promise<void>;
+    createDelegation(userId: string, roleName: string, expiresAt?: string): Promise<CreateDelegationResponse>;
+    revokeDelegation(userId: string, roleName: string): Promise<void>;
+    getDelegations(userId: string): Promise<GetDelegationsResponse>;
+    grantSuperUser(userId: string, body: GrantSuperUserRequest): Promise<GrantSuperUserResponse>;
+    revokeSuperUser(userId: string, reason: string): Promise<void>;
+    listSuperUsers(): Promise<ListSuperUsersResponse>;
+    getSelfSuperUserAccess(): Promise<GetSelfSuperUserResponse>;
+    getUserEntities(): Promise<RbacRole[]>;
+    getEntityMetadata(): Promise<GetEntityMetadataResponse>;
+    bootstrapRbacLogin(): Promise<BootstrapLoginResponse>;
+    getAgent(agentId: string): Promise<GetAgentResponse>;
+    getDriftDashboard(): Promise<DriftDashboardSnapshotResponse>;
+    deleteAgent(agentId: string): Promise<DeleteAgentResponse>;
+    updateAgent<TAgent = Record<string, unknown>>(agentId: string, body: UpdateAgentRequest<TAgent>): Promise<UpdateAgentResponse>;
+    listAgents<T = unknown>(params?: ListAgentsParams): Promise<ListAgentsResponse<T>>;
+    listUsers(): Promise<ListUsersResponse>;
+    assignAgent(agentId: string, params: AssignAgentParams): Promise<AssignAgentResponse>;
+    unassignAgent(agentId: string): Promise<UnassignAgentResponse>;
+    getAgentAssignment(agentId: string): Promise<GetAssignmentResponse>;
+    listProcessInstances<T = unknown>(params?: ListProcessInstancesParams): Promise<ListProcessInstancesResponse<T>>;
+    listEvents(params?: ListEventsParams): Promise<ListEventsResponse>;
+    getProcessStages(processId: string): Promise<GetProcessStagesResponse>;
+    advanceStage(processId: string, stageId: string, body: AdvanceStageRequest): Promise<AdvanceStageResponse>;
+    getDashboardMetrics(): Promise<DashboardMetricsResponse>;
+    getRecentActivity(limit?: number): Promise<ActivityResponse>;
+    getQueueDepths(): Promise<QueueDepthsResponse>;
+    getRecentFailures(opts?: RecentFailuresOptions): Promise<RecentFailuresResponse>;
+    getRunVolume(opts: {
+        window: '1h' | '24h' | '7d' | '30d' | '60m';
+        bucket: '1m' | '5m' | '15m' | '1h' | '1d';
+    }): Promise<RunVolumeResponse>;
+    getLatencySeries(opts: {
+        window: '1h' | '24h' | '7d' | '30d' | '60m';
+        bucket: '1m' | '5m' | '15m' | '1h' | '1d';
+    }): Promise<LatencyResponse>;
+    getTopCapabilities(opts?: {
+        window?: TopCapabilitiesWindow;
+        limit?: number;
+    }): Promise<TopCapabilitiesResponse>;
+    getEntityLicenseUsage<T = unknown>(): Promise<GetEntityLicenseUsageResponse<T>>;
+    getLicensePool(): Promise<LicensePoolResponse>;
+    getSeatLicenses(): Promise<SeatLicensesResponse>;
+    createSeatLicense(body: {
+        userId: string;
+        userEmail: string;
+        maxConcurrentAgents: number;
+    }): Promise<SeatLicense>;
+    updateSeatLicense(seatId: string, body: {
+        maxConcurrentAgents: number;
+    }): Promise<SeatLicense>;
+    deleteSeatLicense(seatId: string): Promise<{
+        deleted: boolean;
+        seatId: string;
+        alreadyAbsent?: boolean;
+    }>;
+    getLicenseUsageHistory(period?: '24h' | '7d' | '30d'): Promise<UsageHistoryResponse>;
+    getLicenseAwareUtilization(): Promise<GetLicenseAwareUtilizationResponse>;
+    listAgentGroups<T = unknown>(): Promise<ListAgentGroupsResponse<T>>;
+    getSeatLicenseUsage<T = unknown>(seatLicenseId: string): Promise<GetSeatLicenseUsageResponse<T>>;
+    listDispatches(): Promise<ListDispatchesResponse>;
+    getDispatch(dispatchId: string): Promise<GetDispatchResponse>;
+    cancelDispatch(dispatchId: string): Promise<CancelDispatchResponse>;
+    listMeshSubscriptionHealth(): Promise<MeshSubscriptionHealthResponse>;
+    stopAgent(agentId: string): Promise<AgentActionResponse>;
+    restartAgent(agentId: string): Promise<AgentActionResponse>;
+    dispatch<TWorkItem = Record<string, unknown>>(body: CreateDispatchRequest<TWorkItem>): Promise<CreateDispatchResponse>;
+    getAgentWorkItems(agentId: string, params?: ListAgentWorkItemsParams): Promise<ListAgentWorkItemsResponse>;
+    enqueueWorkItem(agentId: string, body: EnqueueWorkItemRequest): Promise<EnqueueWorkItemResponse>;
+    reassignWorkItem(agentId: string, workItemId: string, body?: ReassignWorkItemRequest): Promise<ReassignWorkItemResponse>;
+    listOperatorSignals(params?: ListOperatorSignalsParams): Promise<ListOperatorSignalsResponse>;
+    getSystemHealth(): Promise<SystemHealthResponse>;
+    getPolicyCatalog(): Promise<GetPolicyCatalogResponse>;
+    getAgentPolicyHistory(agentId: string, params?: GetAgentPolicyHistoryParams): Promise<GetAgentPolicyHistoryResponse>;
+    listControlProfiles(): Promise<ListControlProfilesResponse>;
+    getControlProfile(tier: ControlProfileRiskTier): Promise<GetControlProfileResponse>;
+    getControlProfileAudit(tier: ControlProfileRiskTier, opts?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<GetControlProfileAuditResponse>;
+    setControlProfileOverride(tier: ControlProfileRiskTier, body: SetControlProfileOverrideBody): Promise<GetControlProfileResponse>;
+    clearControlProfileOverride(tier: ControlProfileRiskTier, body: ClearControlProfileOverrideBody): Promise<GetControlProfileResponse>;
+    listChangeApprovalPolicies(): Promise<ListChangeApprovalPoliciesResponse>;
+    getChangeApprovalPolicy(tier: ChangeApprovalRiskTier): Promise<GetChangeApprovalPolicyResponse>;
+    getChangeApprovalPolicyAudit(tier: ChangeApprovalRiskTier): Promise<GetChangeApprovalPolicyAuditResponse>;
+    setChangeApprovalPolicyOverride(tier: ChangeApprovalRiskTier, body: SetChangeApprovalPolicyOverrideBody): Promise<GetChangeApprovalPolicyResponse>;
+    clearChangeApprovalPolicyOverride(tier: ChangeApprovalRiskTier, body: ClearChangeApprovalPolicyOverrideBody): Promise<GetChangeApprovalPolicyResponse>;
+    recordChangeApprovalDecision(changeId: string, body: RecordChangeApprovalDecisionBody): Promise<RecordChangeApprovalDecisionResponse>;
+    listChangeApprovalDecisions(changeId: string): Promise<ListChangeApprovalDecisionsResponse>;
+    getChangeApprovalVerdict(changeId: string, tier: ChangeApprovalRiskTier): Promise<GetChangeApprovalVerdictResponse>;
+    wizardAssistantTurn(agentId: string, body: WizardAssistantTurnBody): Promise<WizardAssistantTurnResponse>;
+    transitionLifecycle(entityKind: AgentSkillEntityKind, targetId: string, body: TransitionLifecycleBody): Promise<TransitionLifecycleResponse>;
+    getLifecycleStatus(entityKind: AgentSkillEntityKind, targetId: string): Promise<GetLifecycleStatusResponse>;
+    classifyAgent(agentId: string, body: ClassifyAgentBody): Promise<ClassifyAgentResponse>;
+    getEffectiveControlProfile(agentId: string): Promise<GetEffectiveControlProfileResponse>;
+    getBiasThresholdPolicy(): Promise<GetBiasThresholdPolicyResponse>;
+    updateBiasThresholdPolicy(body: UpdateBiasThresholdPolicyBody): Promise<UpdateBiasThresholdPolicyResponse>;
+    getWorkAssignmentEvents(params?: ListWorkAssignmentEventsParams): Promise<ListWorkAssignmentEventsResponse>;
+    getDecisionLineage(signalId: string): Promise<GetDecisionLineageResponse>;
+    recordDecisionLineage(signalId: string, body: RecordDecisionLineageRequest): Promise<RecordDecisionLineageResponse>;
+    listDecisionLineage(params?: ListDecisionLineageParams): Promise<ListDecisionLineageResponse>;
+    listEntityPipelines(): Promise<ListPipelinesResponse>;
+    listPipelineRuns(pipelineId: string, options?: {
+        limit?: number;
+    }): Promise<ListPipelineRunsResponse>;
+    deletePipeline(pipelineId: string): Promise<DeletePipelineResponse>;
+    listIncidents(filter?: IncidentListFilter): Promise<ListIncidentsResponse>;
+    getIncident(incidentId: string): Promise<GetIncidentResponse>;
+    createIncident(body: Omit<CreateIncidentInput, 'entityId'>): Promise<CreateIncidentResponse>;
+    ackIncident(incidentId: string, body: AckIncidentRequest): Promise<AckIncidentResponse>;
+    assignIncident(incidentId: string, body: AssignIncidentRequest): Promise<AssignIncidentResponse>;
+    resolveIncident(incidentId: string, body: ResolveIncidentRequest): Promise<ResolveIncidentResponse>;
+    listA2AVendors(): Promise<ListA2AVendorsResponse>;
+    registerA2AVendor(req: RegisterA2AVendorRequest): Promise<A2AVendor>;
+    suspendA2AVendor(vendor: A2AVendorId): Promise<void>;
+    getProvenanceMix(): Promise<ProvenanceMix>;
+    listA2AAgents(): Promise<ListA2AAgentsResponse>;
+    listConnections(): Promise<ListConnectionsResponse>;
+    getConnection(connectionId: string): Promise<GetConnectionResponse>;
+    createConnection(body: ConnectionCreateBody): Promise<ConnectionWriteResponse>;
+    updateConnection(connectionId: string, body: ConnectionUpdateBody): Promise<ConnectionWriteResponse>;
+    deleteConnection(connectionId: string): Promise<void>;
+    putCredential(connectionId: string, secret: Record<string, unknown>): Promise<PutCredentialResponse>;
+    deleteCredential(connectionId: string): Promise<void>;
+    mintScopedCredential(connectionId: string): Promise<ScopedCredential>;
+    persistRefreshedCredential(connectionId: string, refreshedCredential: Record<string, unknown>): Promise<RefreshedCredentialResponse>;
+    introspectListTables(connectionId: string): Promise<ListTablesResponse>;
+    introspectTable(body: IntrospectTableBody): Promise<IntrospectTableResponse>;
+    introspectSampleValues(body: SampleValuesBody): Promise<SampleValuesResponse>;
+    listSourceDefinitions(): Promise<ListSourceDefinitionsResponse>;
+    getSourceDefinition(sourceId: string): Promise<GetSourceDefinitionResponse>;
+    putSourceDefinition(sourceId: string, body: SourceDefinitionInput): Promise<SourceDefinitionWriteResponse>;
+    deleteSourceDefinition(sourceId: string): Promise<void>;
+    listMappingConfigs(): Promise<ListMappingConfigsResponse>;
+    getMappingConfig(configId: string): Promise<GetMappingConfigResponse>;
+    putMappingConfig(configId: string, body: SourceMappingConfigInput): Promise<MappingConfigWriteResponse>;
+    deleteMappingConfig(configId: string): Promise<void>;
+    listEntityModels(): Promise<ListEntityModelsResponse>;
+    getEntityModel(modelId: string): Promise<GetEntityModelResponse>;
+    upsertEntityModelType(modelId: string, entityType: EntityModelEntityType): Promise<EntityModelMutationResponse>;
+    deleteEntityModelType(modelId: string, entityTypeId: string): Promise<EntityModelMutationResponse>;
+    upsertEntityModelRelationship(modelId: string, relationship: EntityModelRelationship): Promise<EntityModelMutationResponse>;
+    deleteEntityModelRelationship(modelId: string, relationshipId: string): Promise<EntityModelMutationResponse>;
+    private aiKnowledge;
+    aiSimilarWorkflows(body: AISimilarWorkflowsBody): Promise<PatternMatch[]>;
+    aiSuggestNextNodes(body: AISuggestNextNodesBody): Promise<NodeSuggestion[]>;
+    aiParameterSuggestions(body: AIParameterSuggestionsBody): Promise<ParameterSuggestion[]>;
+    aiSmartDefaults(body: AISmartDefaultsBody): Promise<SmartDefaults>;
+    aiScoreQuality(body: AIScoreQualityBody): Promise<QualityScore>;
+    aiLearnFromImport(body: AILearnFromImportBody): Promise<void>;
+    aiRecordNodeUsage(body: AIRecordNodeUsageBody): Promise<void>;
+    private bestPracticesKg;
+    bpkgStatistics(): Promise<BPKGStatistics>;
+    bpkgTraverse(body: BPKGTraverseBody): Promise<BPKGGraphTraversalResult>;
+    bpkgRelationshipsForPractice(body: BPKGRelationshipsForPracticeBody): Promise<BPKGRelationshipWithDetails[]>;
+    bpkgRecommendations(body: BPKGRecommendationsBody): Promise<BPKGRecommendationResult>;
+    bpkgShortestPath(body: BPKGShortestPathBody): Promise<BPKGGraphTraversalResult | null>;
+    bpkgDetectConflicts(body: BPKGDetectConflictsBody): Promise<BPKGConflictDetectionResult>;
+    private kbKg;
+    kbKgFindRelated(body: KBKGFindRelatedBody): Promise<KBKGRelatedDocument[]>;
+    kbKgFindByEntity(body: KBKGFindByEntityBody): Promise<KBKGDocumentNode[]>;
+    kbKgStatistics(): Promise<KBKGStatistics>;
+    private entityKg;
+    entityKgHealthCheck(): Promise<EKGHealthCheck>;
+    entityKgStatistics(): Promise<EKGStatistics>;
+    entityKgGetEntity(body: EKGGetEntityBody): Promise<EKGEntity | null>;
+    entityKgFindEntities(body: EKGFindEntitiesBody): Promise<EKGEntity[]>;
+    entityKgSearchEntities(body: EKGSearchEntitiesBody): Promise<EKGEntity[]>;
+    entityKgGetEntityRelationships(body: EKGGetEntityRelationshipsBody): Promise<EKGRelationshipWithDetails[]>;
+    entityKgRelationshipsByEntityIds(body: EKGRelationshipsByEntityIdsBody): Promise<EKGRelationshipWithDetails[][]>;
+    entityKgTraverse(body: EKGTraverseBody): Promise<EKGGraphTraversalResult>;
+    entityKgFindPath(body: EKGFindPathBody): Promise<EKGShortestPathResult>;
+    entityKgRawReadQuery(body: EKGRawReadQueryBody): Promise<Array<Record<string, unknown>>>;
+    listEntityModelSources(): Promise<ListEntityModelSourcesResponse>;
+    getEntityModelSource(sourceId: string): Promise<GetEntityModelSourceResponse>;
+    createEntityModelSource(body: CreateSourceRequest): Promise<EntityModelSourceWriteResponse>;
+    updateEntityModelSource(sourceId: string, body: UpdateSourceRequest): Promise<EntityModelSourceWriteResponse>;
+    deleteEntityModelSource(sourceId: string): Promise<void>;
+    syncEntityModelSource(sourceId: string): Promise<SyncDispatchResponse>;
+    checkEntityModelSourceReferences(sourceId: string): Promise<CheckSourceReferencesResponse>;
+    discoverEntityModelSourceEntities(sourceId: string): Promise<DiscoverEntitiesResponse>;
+    testEntityModelSourceConnection(sourceId: string): Promise<TestConnectionResponse>;
+    triggerDocumentIngestion(input: TriggerDocumentIngestionInput): Promise<TriggerDocumentIngestionResponse>;
+    getDocumentIngestionStatus(jobId: string): Promise<DocumentIngestionStatusResponse>;
+    appendDomainEvent(event: BrainDomainEvent): Promise<AppendDomainEventResponse>;
+    appendDomainEventBatch(events: BrainDomainEvent[]): Promise<AppendDomainEventBatchResponse>;
+    getDomainEvent(eventId: string): Promise<BrainDomainEvent>;
+    private objectsPath;
+    getObject(bucket: string, objectPath: string): Promise<{
+        data: Buffer;
+        contentType: string;
+    }>;
+    putObject(bucket: string, objectPath: string, data: Uint8Array, opts?: {
+        contentType?: string;
+        cacheControl?: string;
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    deleteObject(bucket: string, objectPath: string): Promise<void>;
+    headObject(bucket: string, objectPath: string): Promise<ObjectMetadataResponse>;
+    listObjects(bucket: string, prefix: string): Promise<ListObjectsResponse>;
+    signObjectUrl(bucket: string, body: SignObjectUrlRequest): Promise<SignObjectUrlResponse>;
+    private rawFetch;
+    getEntityAdminConfig(kind: EntityAdminConfigKind): Promise<{
+        config: Record<string, unknown> | null;
+        source: string;
+    }>;
+    putEntityAdminConfig(kind: EntityAdminConfigKind, config: Record<string, unknown>): Promise<void>;
+    getExternalSecretsConfig(): Promise<{
+        config: Record<string, unknown> | null;
+        source: string;
+    }>;
+    putExternalSecretsConfig(config: Record<string, unknown>): Promise<void>;
+    testExternalSecretsProvider(providerId: string): Promise<{
+        ok: true;
+        audit: Record<string, unknown>;
+    }>;
+    rotateExternalSecretsProvider(providerId: string): Promise<{
+        ok: true;
+        audit: Record<string, unknown>;
+    }>;
+    getExternalAdapterConfig(): Promise<{
+        config: Record<string, unknown> | null;
+        source: string;
+    }>;
+    putExternalAdapterConfig(config: Record<string, unknown>): Promise<void>;
+    getFieldSecurityPolicies(): Promise<{
+        config: Record<string, unknown> | null;
+        source: string;
+    }>;
+    putFieldSecurityPolicies(config: Record<string, unknown>): Promise<void>;
+    applyFieldSecurityPolicyChange(body: {
+        kind: 'upsert';
+        policy: Record<string, unknown>;
+    } | {
+        kind: 'delete';
+        policyId: string;
+    }): Promise<{
+        ok: true;
+        change: {
+            ts: string;
+            actor: string;
+            kind: 'upsert' | 'delete';
+            policyId: string;
+            fieldPath?: string;
+            resourceType?: string;
+        };
+        policies: Record<string, unknown>[];
+        changeLog: Array<{
+            ts: string;
+            actor: string;
+            kind: 'upsert' | 'delete';
+            policyId: string;
+            fieldPath?: string;
+            resourceType?: string;
+        }>;
+    }>;
+    private healthcarePath;
+    getHealthcareComplianceCollection(collection: HealthcareComplianceCollection): Promise<{
+        records: Record<string, unknown>[];
+    }>;
+    accessHealthcarePHI(request: Record<string, unknown>): Promise<HealthcarePHIAccessResult>;
+    createHealthcareRelationship(params: Record<string, unknown>): Promise<{
+        id: string;
+    }>;
+    toggleHealthcareRelationship(relationshipId: string, active: boolean): Promise<void>;
+    revokeHealthcareConsent(consentId: string): Promise<void>;
+    grantHealthcarePurpose(params: Record<string, unknown>): Promise<{
+        id: string;
+    }>;
+    revokeHealthcarePurpose(permissionId: string): Promise<void>;
+    getFinanceComplianceDoc(): Promise<{
+        config: Record<string, unknown> | null;
+        source: string;
+    }>;
+    putFinanceComplianceDoc(config: Record<string, unknown>): Promise<void>;
+    getComplianceSettings(): Promise<{
+        config: Record<string, unknown> | null;
+        source: string;
+        generation?: number;
+    }>;
+    putComplianceSettings(config: Record<string, unknown>, opts?: {
+        ifGenerationMatch?: number;
+    }): Promise<{
+        generation?: number;
+    }>;
+    financeAccessPCI(request: FinancePCIAccessRequest): Promise<FinancePCIAccessResult>;
+    insuranceAccessPolicyholder(request: InsuranceAccessPolicyholderRequest): Promise<InsuranceAccessPolicyholderResult>;
+    getComplianceAuditLogs(query?: {
+        schema?: string;
+        operation?: string;
+        userId?: string;
+        startDate?: string;
+        endDate?: string;
+        emergencyOnly?: boolean;
+        chainIntegrity?: 'valid' | 'invalid' | 'all';
+        search?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        entries: Array<Record<string, unknown>>;
+        total: number;
+        partialContentHashCoverage?: boolean;
+        source: string;
+    }>;
+    putComplianceAuditLog(doc: Record<string, unknown>): Promise<void>;
+    verifyComplianceAuditChain(): Promise<{
+        valid: boolean;
+        totalEntries: number;
+        validEntries: number;
+        invalidEntries: number;
+        firstInvalidId?: string;
+        entriesWithContentHash?: number;
+        partialContentHashCoverage?: boolean;
+        source: string;
+    }>;
+    exportComplianceAuditCsv(query?: {
+        schema?: string;
+        operation?: string;
+        userId?: string;
+        startDate?: string;
+        endDate?: string;
+        emergencyOnly?: boolean;
+        chainIntegrity?: 'valid' | 'invalid';
+        search?: string;
+    }): Promise<Response>;
+    getComplianceDashboardOverview(): Promise<{
+        config: Record<string, unknown> | null;
+        source: string;
+    }>;
+    putComplianceDashboardOverview(config: Record<string, unknown>): Promise<void>;
+    financeAccessSOX(request: FinanceSOXAccessRequest): Promise<FinanceSOXAccessResult>;
+    financeVerifySoD(request: FinanceSoDVerifyRequest): Promise<FinanceSoDVerifyResult>;
+    getInsuranceComplianceDoc(collection: InsuranceComplianceCollection): Promise<{
+        config: Record<string, unknown> | null;
+        source: string;
+        generation?: number;
+    }>;
+    putInsuranceComplianceDoc(collection: InsuranceComplianceCollection, config: Record<string, unknown>, opts?: {
+        ifGenerationMatch?: number;
+    }): Promise<void>;
+    requestBreakGlassAccess(body: BrainBreakGlassRequestBody): Promise<{
+        grant: BrainBreakGlassGrant;
+    }>;
+    getActiveBreakGlassGrants(): Promise<{
+        grants: BrainBreakGlassGrant[];
+    }>;
+    getBreakGlassPendingReviews(): Promise<{
+        grants: BrainBreakGlassGrant[];
+    }>;
+    revokeBreakGlassGrant(grantId: string, revokedBy?: string): Promise<void>;
+    approveBreakGlassPostHoc(grantId: string, body: {
+        supervisorId?: string;
+        approved: boolean;
+        notes?: string;
+    }): Promise<void>;
+    recordIntegrityHash(body: {
+        recordType: string;
+        recordId: string;
+        content: Record<string, unknown>;
+        gcsPath?: string;
+    }): Promise<{
+        hash: Record<string, unknown>;
+    }>;
+    getRecordIntegrityHash(recordType: string, recordId: string): Promise<{
+        hash: Record<string, unknown> | null;
+    }>;
+    verifyRecordIntegrity(body: {
+        recordType: string;
+        recordId: string;
+        content: Record<string, unknown>;
+    }): Promise<{
+        result: Record<string, unknown>;
+    }>;
+    verifyRecordIntegrityChain(body: {
+        recordType: string;
+        limit?: number;
+    }): Promise<{
+        result: Record<string, unknown>;
+    }>;
+    private breakGlassBase;
+    getRulesEngineConfig(): Promise<{
+        config: Record<string, unknown> | null;
+        source: string;
+    }>;
+    putRulesEngineConfig(config: Record<string, unknown>): Promise<void>;
+    triggerRulesEngineConnectionTest(opts: {
+        connectionId: string;
+    }): Promise<{
+        ok: true;
+        auditEntry: Record<string, unknown>;
+        auditLogs: Array<Record<string, unknown>>;
+    }>;
+    createSSOProvider(body: {
+        id?: string;
+        name: string;
+        type: 'saml' | 'oidc';
+        domain?: string;
+        config?: Record<string, unknown>;
+    }): Promise<{
+        ok: true;
+        provider: Record<string, unknown>;
+        auditLog: Record<string, unknown>;
+    }>;
+    updateSSOProvider(providerId: string, patch: {
+        name?: string;
+        domain?: string;
+        status?: 'active' | 'inactive' | 'pending';
+        config?: Record<string, unknown>;
+    }): Promise<{
+        ok: true;
+        provider: Record<string, unknown>;
+        auditLog: Record<string, unknown>;
+    }>;
+    deleteSSOProvider(providerId: string): Promise<{
+        ok: true;
+        auditLog: Record<string, unknown>;
+    }>;
+    getLdapConfig(): Promise<{
+        config: Record<string, unknown> | null;
+        source: string;
+    }>;
+    putLdapConfig(config: Record<string, unknown>): Promise<void>;
+    triggerLdapSync(opts?: {
+        syncType?: 'manual' | 'full' | 'delta';
+    }): Promise<{
+        ok: true;
+        syncLog: Record<string, unknown>;
+    }>;
+    getLogStreamingConfig(): Promise<{
+        config: Record<string, unknown> | null;
+        source: string;
+    }>;
+    putLogStreamingConfig(config: Record<string, unknown>): Promise<void>;
+    testLogStreamingDestination(destinationId: string): Promise<{
+        ok: true;
+        testLog: Record<string, unknown>;
+        testLogs: Array<Record<string, unknown>>;
+    }>;
+    getLicensePlatformDoc(subPath: string): Promise<{
+        config: unknown | null;
+    }>;
+    putLicensePlatformDoc(subPath: string, config: unknown): Promise<void>;
+    listLicenseTierHistory(tier: string, limit: number): Promise<{
+        entries: unknown[];
+    }>;
+    appendLicenseTierHistory(tier: string, entry: Record<string, unknown>): Promise<void>;
+    getAdminSecret(key: string): Promise<{
+        config: Record<string, unknown> | null;
+    }>;
+    putAdminSecret(key: string, config: Record<string, unknown>): Promise<void>;
+    private request;
+}
+export declare function createBrainClient(config: BrainClientConfig): BrainAPIClient;