@forg3t/sdk 0.1.3 → 0.1.5

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 interface Forg3tClientOptions {
     apiUrl?: string;
     apiKey?: string;
+    bearerToken?: string;
     timeoutMs?: number;
 }
 interface PaginationParams {
@@ -15,6 +16,57 @@ interface Project {
     createdAt: string;
     updatedAt: string;
 }
+interface CurrentUserResponse {
+    userId: string | null;
+    email: string | null;
+    tenantId: string;
+    defaultProjectId: string | null;
+    projectsCount: number;
+    projectName?: string;
+}
+interface BootstrapTenantRequest {
+    tenantName: string;
+    projectName?: string;
+    integrationType?: string;
+    integrationName?: string;
+    dataRetentionDays?: number | null;
+    regulatoryScope?: unknown;
+}
+interface BootstrapTenantResponse {
+    created: boolean;
+    tenant: {
+        id: string;
+        name: string;
+        status: string;
+        regulatoryScope: unknown;
+        createdAt: string;
+    };
+    membership: {
+        userId: string;
+        email: string | null;
+        role: string;
+    };
+    bootstrap: {
+        tenantId: string;
+        project: {
+            id: string;
+            name: string;
+            created: boolean;
+        };
+        apiKey: {
+            id: string;
+            keyPrefix: string;
+            created: boolean;
+            plaintextKey?: string;
+        };
+        integration: {
+            id: string;
+            type: string;
+            name: string;
+            created: boolean;
+        };
+    };
+}
 interface ApiKey {
     id: string;
     name: string;
@@ -30,7 +82,12 @@ interface CreateApiKeyRequest {
     expiresAt?: string;
 }
 interface CreateApiKeyResponse extends ApiKey {
-    plaintextKey: string;
+    key: string;
+    plaintextKey?: string;
+}
+interface RevokeApiKeyResponse {
+    status: 'revoked' | string;
+    revokedAt?: string | null;
 }
 interface AuditEvent {
     id: string;
@@ -55,8 +112,8 @@ interface AuditEventListResponse {
     events: AuditEvent[];
     nextCursor?: string;
 }
-type JobStatus = 'queued' | 'running' | 'completed' | 'failed' | 'aborted';
-type JobType = 'VERIFY' | 'RAG_UNLEARN' | 'ADAPTER_UNLEARN' | 'MODEL_UNLEARN';
+type JobStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'canceled';
+type JobType = 'VERIFY' | 'BLACKBOX_SUPPRESS' | 'RAG_UNLEARN' | 'ADAPTER_UNLEARN' | 'MODEL_UNLEARN';
 type ClaimType = 'PII' | 'CONCEPT' | 'ENTITY' | 'DOCUMENT' | 'EMBEDDING_CLUSTER';
 type ClaimScope = 'global' | 'project' | 'tenant' | 'adapter' | 'index';
 type ClaimAssertion = 'must_not_be_recalled' | 'must_be_refused' | 'must_return_null';
@@ -76,6 +133,7 @@ interface JobConfig {
 interface Job {
     id: string;
     projectId: string;
+    tenantId?: string;
     type: JobType;
     status: JobStatus;
     payload: {
@@ -88,24 +146,51 @@ interface Job {
         false_positive_rate?: number;
         [key: string]: any;
     } | null;
-    created_at: string;
-    updated_at: string;
+    createdAt?: string;
+    updatedAt?: string;
+    startedAt?: string | null;
+    completedAt?: string | null;
+    workerId?: string | null;
+    lastClaimId?: string | null;
+    leaseExpiresAt?: string | null;
+    heartbeatAt?: string | null;
+    nextClaimAfter?: string | null;
+    attempts?: number;
+    maxAttempts?: number;
+    error?: string | null;
+    created_at?: string;
+    updated_at?: string;
     started_at?: string | null;
     completed_at?: string | null;
 }
-interface SubmitJobRequest {
+type SubmitJobRequest = {
     type: JobType;
     claim: UnlearningClaim;
     config: JobConfig;
-}
+    idempotencyKey?: string;
+} | {
+    type: JobType;
+    payload: {
+        claim?: UnlearningClaim;
+        config?: JobConfig;
+        [key: string]: unknown;
+    };
+    idempotencyKey?: string;
+};
 interface ClaimJobsRequest {
     limit?: number;
+    types?: JobType[];
 }
 interface JobResult {
     result: Record<string, unknown>;
+    claimId?: string;
 }
 interface JobError {
     error: Record<string, unknown>;
+    claimId?: string;
+}
+interface JobMutationOptions {
+    claimId?: string;
 }
 interface Webhook {
     id: string;
@@ -153,6 +238,20 @@ interface EvidenceArtifact {
     createdAt: string;
     artifacts: unknown[];
 }
+interface EvidenceStatusResponse {
+    jobId: string;
+    status: string;
+    evidenceReady: boolean;
+    retryAfterSeconds?: number;
+    reportHash?: string;
+    evidenceJsonHash?: string;
+    evidence?: Record<string, unknown>;
+    error?: string;
+    errorCode?: string;
+    errorMessage?: string | null;
+    failedAt?: string | null;
+    durationMs?: number | null;
+}
 interface EvidencePdfResponse {
     data: Uint8Array;
     headers: {
@@ -161,37 +260,200 @@ interface EvidencePdfResponse {
         'x-forg3t-report-hash': string;
     };
 }
+declare enum IntegrationType {
+    SLACK = "slack",
+    CONFLUENCE = "confluence",
+    GOOGLE_DRIVE = "google_drive",
+    ZENDESK = "zendesk",
+    NOTION = "notion",
+    LANGCHAIN = "langchain",
+    OPENROUTER = "openrouter",
+    OPENAI = "openai",
+    CUSTOM = "custom"
+}
+declare enum IntegrationMode {
+    MODE_A_BLACKBOX = "mode_a_blackbox",// System level (RAG/Deletion)
+    MODE_B_WHITEBOX = "mode_b_whitebox"
+}
+interface BaseAdapterConfig {
+    adapterId?: string;
+    modelName?: string;
+    temperature?: number;
+    integrationMode?: IntegrationMode;
+    [key: string]: unknown;
+}
+interface LangChainAdapterConfig extends BaseAdapterConfig {
+    chainType: 'retrieval' | 'conversational' | 'agent';
+    vectorStoreId?: string;
+}
+interface OpenRouterAdapterConfig extends BaseAdapterConfig {
+    routingStrategy: 'cost' | 'latency' | 'quality';
+    fallbackModels?: string[];
+}
+interface Integration {
+    id: string;
+    projectId: string;
+    type: IntegrationType;
+    name: string;
+    description?: string;
+    status: 'active' | 'disconnected' | 'error' | 'pending';
+    config: BaseAdapterConfig | LangChainAdapterConfig | OpenRouterAdapterConfig | Record<string, unknown>;
+    capabilities: string[];
+    createdAt: string;
+    updatedAt: string;
+    lastSyncedAt?: string;
+}
+interface CreateIntegrationRequest {
+    type: IntegrationType;
+    name: string;
+    config: Record<string, unknown>;
+}
+declare enum AccessLevel {
+    LAYER_A_ONLY = "layer_a_only",// Control-plane actions (black-box suppression, gateway/policy enforcement)
+    LAYER_A_AND_B = "layer_a_and_b"
+}
+interface UnlearningTarget {
+    type: 'user_id' | 'email' | 'document_id' | 'phrase' | 'concept';
+    value: string;
+    aliases?: string[];
+}
+interface UnlearningScope {
+    integrationIds?: string[];
+}
+interface ExecutionStep {
+    id: string;
+    name: string;
+    layer: 'A' | 'B';
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+    logs: string[];
+    startedAt?: string;
+    completedAt?: string;
+}
+interface ExecutionPlan {
+    steps: ExecutionStep[];
+    estimatedDurationMs?: number;
+}
+interface UnlearningExecutionModelRef {
+    uri: string;
+    format?: string;
+    sha256?: string;
+    version?: string;
+    metadata?: Record<string, unknown>;
+}
+interface UnlearningExecutionPlanSpec {
+    method: string;
+    hyperparameters?: Record<string, unknown>;
+    dryRun?: boolean;
+}
+interface UnlearningExecutionTargetSpec {
+    provider: 'openai' | 'groq' | 'http_generic' | 'custom';
+    model?: string;
+    endpoint?: string;
+    headers?: Record<string, string>;
+    responsePath?: string;
+    apiKey?: string;
+}
+interface UnlearningExecutionSpec {
+    target?: UnlearningExecutionTargetSpec;
+    model?: UnlearningExecutionModelRef;
+    plan?: UnlearningExecutionPlanSpec;
+}
+interface UnlearningJobSummary {
+    id: string;
+    type: JobType | string;
+    status: JobStatus | string;
+    createdAt?: string;
+    updatedAt?: string;
+    startedAt?: string | null;
+    completedAt?: string | null;
+}
+interface UnlearningRequest {
+    id: string;
+    projectId: string;
+    name?: string;
+    target: UnlearningTarget;
+    scope: UnlearningScope;
+    accessLevel: AccessLevel;
+    status: 'draft' | 'submitted' | 'processing' | 'completed' | 'failed';
+    rawStatus?: string;
+    execution?: UnlearningExecutionSpec;
+    job?: UnlearningJobSummary | null;
+    plan?: ExecutionPlan;
+    evidenceArtifacts: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateUnlearningRequestParams {
+    name?: string;
+    target: UnlearningTarget;
+    scope: UnlearningScope;
+    accessLevel: AccessLevel;
+    execution?: UnlearningExecutionSpec;
+}
 
 declare class Forg3tClient {
     private transport;
     constructor(options?: Forg3tClientOptions);
+    /**
+     * Get the current user context and their default project.
+     * Used by the Admin Dashboard for bootstrap and session verification.
+     */
+    getCurrentUser(requestId?: string): Promise<CurrentUserResponse>;
+    /**
+     * Bootstraps a tenant for an authenticated dashboard user.
+     * Requires a bearer token from the user's session instead of an API key.
+     */
+    bootstrapTenant(data: BootstrapTenantRequest, requestId?: string): Promise<BootstrapTenantResponse>;
     getProjectOverview(projectId: string, requestId?: string): Promise<Project>;
     listAuditEvents(projectId: string, filters?: AuditEventFilters, requestId?: string): Promise<AuditEventListResponse>;
+    listIntegrations(projectId: string, requestId?: string): Promise<Integration[]>;
+    createIntegration(projectId: string, data: CreateIntegrationRequest, requestId?: string): Promise<Integration>;
+    testIntegration(projectId: string, integrationId: string, requestId?: string): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    createUnlearningRequest(projectId: string, data: CreateUnlearningRequestParams, requestId?: string): Promise<UnlearningRequest>;
+    listUnlearningRequests(projectId: string, requestId?: string): Promise<UnlearningRequest[]>;
+    getUnlearningRequest(projectId: string, unlearningRequestId: string, requestId?: string): Promise<UnlearningRequest>;
     listApiKeys(projectId: string, requestId?: string): Promise<ApiKey[]>;
     createApiKey(projectId: string, data: CreateApiKeyRequest, requestId?: string): Promise<CreateApiKeyResponse>;
-    rotateApiKey(keyId: string, requestId?: string): Promise<CreateApiKeyResponse>;
-    revokeApiKey(keyId: string, requestId?: string): Promise<ApiKey>;
+    rotateApiKey(projectId: string, keyId: string, requestId?: string): Promise<CreateApiKeyResponse>;
+    revokeApiKey(projectId: string, keyId: string, requestId?: string): Promise<RevokeApiKeyResponse>;
     submitJob(projectId: string, data: SubmitJobRequest, requestId?: string): Promise<Job>;
+    /**
+     * Creates a new job with deduplication support via an optional idempotency key.
+     * This wrapper cleanly exposes the core parameters for the production job queue.
+     */
+    createJob(projectId: string, type: JobType, claim: UnlearningClaim, config: JobConfig, idempotencyKey?: string, requestId?: string): Promise<Job>;
     getJob(projectId: string, jobId: string, requestId?: string): Promise<Job>;
+    /**
+     * Polls the job status continuously until a terminal state (succeeded, failed, canceled) is reached,
+     * or the specified timeout limits are exceeded.
+     */
+    pollJobStatus(projectId: string, jobId: string, timeoutMs?: number, pollIntervalMs?: number, requestId?: string): Promise<Job>;
     listJobs(projectId: string, query?: {
         status?: string;
         limit?: number;
         offset?: number;
     }, requestId?: string): Promise<Job[]>;
     claimJobs(projectId: string, data?: ClaimJobsRequest, requestId?: string): Promise<Job[]>;
-    heartbeatJob(projectId: string, jobId: string, requestId?: string): Promise<Job>;
-    completeJob(projectId: string, jobId: string, result: JobResult, requestId?: string): Promise<Job>;
-    failJob(projectId: string, jobId: string, error: JobError, requestId?: string): Promise<Job>;
+    heartbeatJob(projectId: string, jobId: string, optionsOrRequestId?: JobMutationOptions | string, requestId?: string): Promise<Job>;
+    completeJob(projectId: string, jobId: string, result: JobResult, optionsOrRequestId?: JobMutationOptions | string, requestId?: string): Promise<Job>;
+    failJob(projectId: string, jobId: string, error: JobError, optionsOrRequestId?: JobMutationOptions | string, requestId?: string): Promise<Job>;
     listDeadJobs(projectId: string, requestId?: string): Promise<Job[]>;
     replayJob(projectId: string, jobId: string, requestId?: string): Promise<Job>;
-    getEvidence(jobId: string, requestId?: string): Promise<EvidenceArtifact>;
+    getEvidence(jobId: string, requestId?: string): Promise<EvidenceStatusResponse | EvidenceArtifact>;
+    getEvidenceJson(jobId: string, requestId?: string): Promise<Record<string, unknown>>;
+    getArtifactDownloadUrl(projectId: string, jobId: string, filename: string, requestId?: string): Promise<{
+        downloadUrl: string;
+    }>;
     getEvidencePdf(jobId: string, options?: {
         saveToPath?: string;
     }): Promise<EvidencePdfResponse>;
     private savePdfToFile;
     /**
      * @deprecated The current Control Plane version does not support direct artifact downloads.
-     * Please use getEvidence() to retrieve the artifact metadata and content.
+     * Please use getArtifactDownloadUrl(), getEvidencePdf(), or getEvidenceJson().
      */
     downloadEvidenceArtifact(_jobId: string, _requestId?: string): Promise<void>;
     listWebhooks(projectId: string, requestId?: string): Promise<Webhook[]>;
@@ -216,6 +478,8 @@ declare class Forg3tClient {
         report_hash: string;
         false_positive_rate: number;
     }, requestId?: string): Promise<void>;
+    private assertCreateUnlearningRequest;
+    private assertModelUnlearnPreflight;
 }
 
 declare class Forg3tError extends Error {
@@ -237,5 +501,262 @@ declare class Forg3tRateLimitError extends Forg3tError {
 declare class Forg3tApiConnectionError extends Forg3tError {
     constructor(message: string);
 }
+declare class Forg3tNotImplementedError extends Forg3tError {
+    constructor(message: string, endpoint?: string, requestId?: string);
+}
+
+interface WhiteboxQualityGatePolicy {
+    /**
+     * Require an evaluation stage output from adapter.runEvaluation.
+     * If true and evaluation is missing, the quality gate fails.
+     */
+    requireEvaluation?: boolean;
+    /**
+     * Maximum leak score accepted for automatic pass.
+     */
+    maxLeakScore?: number;
+    /**
+     * Allowed evaluation verdicts for pass.
+     */
+    allowedVerdicts?: Array<'PASS' | 'FAIL' | 'REVIEW'>;
+    /**
+     * Minimum number of tensors that must be modified by unlearning.
+     */
+    minChangedTensorCount?: number;
+    /**
+     * Minimum number of parameters that must be modified by unlearning.
+     */
+    minChangedParamCount?: number;
+    /**
+     * Require before/after model hash transition and mismatch.
+     */
+    requireModelHashTransition?: boolean;
+    /**
+     * Require localization object from whitebox output.
+     */
+    requireLocalization?: boolean;
+    /**
+     * Minimum localization token coverage in [0, 1].
+     */
+    minLocalizationTokenCoverage?: number;
+    /**
+     * Minimum localized parameter count.
+     */
+    minLocalizedParamCount?: number;
+    /**
+     * Minimum localization confidence in [0, 1].
+     */
+    minLocalizationConfidence?: number;
+}
+interface WhiteboxQualityGateDecision {
+    pass: boolean;
+    reasons: string[];
+    policy: WhiteboxQualityGatePolicy;
+}
+type WhiteboxQualityGatePreset = 'balanced' | 'strict';
+declare const WHITEBOX_QUALITY_GATE_PRESETS: Record<WhiteboxQualityGatePreset, Required<WhiteboxQualityGatePolicy>>;
+declare const WHITEBOX_QUALITY_GATE_PRESET_EXPLANATIONS: Record<WhiteboxQualityGatePreset, string>;
+declare const DEFAULT_WHITEBOX_QUALITY_GATE_POLICY: Required<WhiteboxQualityGatePolicy>;
+declare const resolveWhiteboxQualityGatePolicy: (preset?: WhiteboxQualityGatePreset, overrides?: WhiteboxQualityGatePolicy) => WhiteboxQualityGatePolicy;
+declare const evaluateWhiteboxQualityGate: (unlearning: WhiteboxUnlearningOutput, evaluation: WhiteboxEvaluationOutput | undefined, policyOverrides?: WhiteboxQualityGatePolicy) => WhiteboxQualityGateDecision;
+
+interface ModelArtifactReference {
+    uri: string;
+    format?: string;
+    sha256?: string;
+    version?: string;
+    metadata?: Record<string, unknown>;
+}
+interface WhiteboxTargetSpec {
+    text?: string;
+    tokenIds?: number[];
+    aliases?: string[];
+    selector?: Record<string, unknown>;
+}
+interface WhiteboxUnlearningPlan {
+    method: string;
+    hyperparameters?: Record<string, unknown>;
+    dryRun?: boolean;
+}
+interface WhiteboxUnlearningInput {
+    model: ModelArtifactReference;
+    target: WhiteboxTargetSpec;
+    plan: WhiteboxUnlearningPlan;
+    claim: UnlearningClaim;
+    config: JobConfig;
+}
+interface WhiteboxUnlearningOutput {
+    updatedModel: ModelArtifactReference;
+    changedTensorCount: number;
+    changedParamCount?: number;
+    modelBeforeSha256?: string;
+    modelAfterSha256?: string;
+    localization?: {
+        strategy: string;
+        tokenIds: number[];
+        tokenCoverage?: number;
+        localizedTensorCount?: number;
+        localizedParamCount?: number;
+        confidence?: number;
+        aliasCount?: number;
+        candidateTextCount?: number;
+        localizationMode?: string;
+        reportUri?: string;
+        reportSha256?: string;
+        hits?: Array<{
+            tensor: string;
+            tensorRole?: string;
+            tokenId?: number;
+            token?: string;
+            tokenSourceKind?: string;
+            matchedFromTextSha256?: string;
+            rowIndex?: number;
+            rowParamCount?: number;
+        }>;
+        [key: string]: unknown;
+    };
+    metrics?: Record<string, unknown>;
+    artifacts?: Array<{
+        name: string;
+        uri: string;
+        sha256?: string;
+        sizeBytes?: number;
+    }>;
+}
+interface WhiteboxEvaluationInput {
+    model: ModelArtifactReference;
+    baselineModel?: ModelArtifactReference;
+    claim: UnlearningClaim;
+    probes?: string[];
+    config: JobConfig;
+}
+interface WhiteboxEvaluationOutput {
+    finalVerdict: 'PASS' | 'FAIL' | 'REVIEW';
+    leakScore: number;
+    details?: Record<string, unknown>;
+}
+interface WhiteboxJobContext {
+    projectId: string;
+    jobId: string;
+    correlationId?: string;
+}
+interface TrainingBackendAdapter {
+    name: string;
+    runUnlearning(input: WhiteboxUnlearningInput, context: WhiteboxJobContext): Promise<WhiteboxUnlearningOutput>;
+    runEvaluation?(input: WhiteboxEvaluationInput, context: WhiteboxJobContext): Promise<WhiteboxEvaluationOutput>;
+}
+interface WhiteboxWorkerLogger {
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+    error(message: string, meta?: Record<string, unknown>): void;
+}
+interface WhiteboxWorkerOptions {
+    projectId: string;
+    pollIntervalMs?: number;
+    claimBatchSize?: number;
+    heartbeatIntervalMs?: number;
+    supportedJobTypes?: JobType[];
+    qualityGatePolicy?: WhiteboxQualityGatePolicy;
+    qualityGateOnFailure?: 'fail_job' | 'review';
+    /**
+     * Controls how claim payload is reflected back to control-plane result payload.
+     * `hash` (default): stores sha256 hash + length, no raw payload.
+     * `omit`: stores claim metadata but omits payload/hash.
+     * `raw`: stores original claim payload verbatim.
+     */
+    resultClaimMode?: 'hash' | 'omit' | 'raw';
+    logger?: WhiteboxWorkerLogger;
+}
+interface BuildModelUnlearningJobInput {
+    claim: UnlearningClaim;
+    model: ModelArtifactReference;
+    target: WhiteboxTargetSpec;
+    plan: WhiteboxUnlearningPlan;
+    targetAdapter?: string;
+    sensitivity?: string;
+    extraParameters?: Record<string, unknown>;
+}
+declare const buildModelUnlearningPayload: (input: BuildModelUnlearningJobInput) => {
+    claim: UnlearningClaim;
+    config: JobConfig;
+};
+declare class WhiteboxWorker {
+    private readonly client;
+    private readonly adapter;
+    private readonly options;
+    private running;
+    private loopPromise;
+    private readonly pollIntervalMs;
+    private readonly claimBatchSize;
+    private readonly heartbeatIntervalMs;
+    private readonly supportedJobTypes;
+    private readonly qualityGatePolicy;
+    private readonly qualityGateOnFailure;
+    private readonly resultClaimMode;
+    private readonly logger;
+    constructor(client: Forg3tClient, adapter: TrainingBackendAdapter, options: WhiteboxWorkerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    runOnce(): Promise<void>;
+    private runLoop;
+    private processClaimedJob;
+}
+
+interface AdapterCommandSpec {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    stdinMode?: 'json' | 'none';
+}
+type CommandResolver<TInput> = AdapterCommandSpec | ((input: TInput, context: WhiteboxJobContext) => AdapterCommandSpec);
+interface LocalCommandAdapterOptions {
+    name?: string;
+    unlearning: CommandResolver<WhiteboxUnlearningInput>;
+    evaluation?: CommandResolver<WhiteboxEvaluationInput>;
+    timeoutMs?: number;
+}
+declare class LocalCommandTrainingAdapter implements TrainingBackendAdapter {
+    private readonly options;
+    readonly name: string;
+    constructor(options: LocalCommandAdapterOptions);
+    runUnlearning(input: WhiteboxUnlearningInput, context: WhiteboxJobContext): Promise<WhiteboxUnlearningOutput>;
+    runEvaluation(input: WhiteboxEvaluationInput, context: WhiteboxJobContext): Promise<WhiteboxEvaluationOutput>;
+}
+interface HttpTrainingAdapterOptions {
+    name?: string;
+    unlearningUrl: string;
+    evaluationUrl?: string;
+    timeoutMs?: number;
+    headers?: Record<string, string>;
+}
+declare class HttpTrainingAdapter implements TrainingBackendAdapter {
+    private readonly options;
+    readonly name: string;
+    constructor(options: HttpTrainingAdapterOptions);
+    runUnlearning(input: WhiteboxUnlearningInput, context: WhiteboxJobContext): Promise<WhiteboxUnlearningOutput>;
+    runEvaluation(input: WhiteboxEvaluationInput, context: WhiteboxJobContext): Promise<WhiteboxEvaluationOutput>;
+}
+type NativeAdapterConfig = ({
+    provider: 'local_command';
+} & LocalCommandAdapterOptions) | ({
+    provider: 'http';
+} & HttpTrainingAdapterOptions);
+declare const createNativeTrainingAdapter: (config: NativeAdapterConfig) => TrainingBackendAdapter;
+
+type Forg3tDeploymentProfile = 'cloud_managed' | 'customer_online' | 'customer_airgapped';
+type Forg3tAdapterMode = 'local_command' | 'http';
+interface DeploymentCompatibilityOptions {
+    profile: Forg3tDeploymentProfile;
+    adapterMode: Forg3tAdapterMode;
+    apiUrl: string;
+    allowedApiHosts?: string[];
+    allowHttpInAirgapped?: boolean;
+}
+type WhiteboxWorkerBaseOptions = Pick<WhiteboxWorkerOptions, 'projectId'> & Partial<Omit<WhiteboxWorkerOptions, 'projectId'>>;
+declare const ENTERPRISE_STRICT_QUALITY_GATE_POLICY: Required<WhiteboxQualityGatePolicy>;
+declare function assertDeploymentCompatibility(options: DeploymentCompatibilityOptions): void;
+declare function buildWhiteboxWorkerOptions(profile: Forg3tDeploymentProfile, baseOptions: WhiteboxWorkerBaseOptions): WhiteboxWorkerOptions;
 
-export { type ApiKey, type AuditEvent, type AuditEventFilters, type AuditEventListResponse, type ClaimAssertion, type ClaimJobsRequest, type ClaimScope, type ClaimType, type CreateApiKeyRequest, type CreateApiKeyResponse, type CreateWebhookRequest, type EvidenceArtifact, type EvidencePdfResponse, Forg3tApiConnectionError, Forg3tAuthenticationError, Forg3tClient, type Forg3tClientOptions, Forg3tError, Forg3tNotFoundError, Forg3tRateLimitError, type Job, type JobConfig, type JobError, type JobResult, type JobStatus, type JobType, type PaginationParams, type Project, type SubmitJobRequest, type UnlearningClaim, type UpdateWebhookRequest, type Webhook, type WebhookDelivery, type WebhookDeliveryFilters };
+export { AccessLevel, type AdapterCommandSpec, type ApiKey, type AuditEvent, type AuditEventFilters, type AuditEventListResponse, type BaseAdapterConfig, type BootstrapTenantRequest, type BootstrapTenantResponse, type BuildModelUnlearningJobInput, type ClaimAssertion, type ClaimJobsRequest, type ClaimScope, type ClaimType, type CreateApiKeyRequest, type CreateApiKeyResponse, type CreateIntegrationRequest, type CreateUnlearningRequestParams, type CreateWebhookRequest, type CurrentUserResponse, DEFAULT_WHITEBOX_QUALITY_GATE_POLICY, type DeploymentCompatibilityOptions, ENTERPRISE_STRICT_QUALITY_GATE_POLICY, type EvidenceArtifact, type EvidencePdfResponse, type EvidenceStatusResponse, type ExecutionPlan, type ExecutionStep, type Forg3tAdapterMode, Forg3tApiConnectionError, Forg3tAuthenticationError, Forg3tClient, type Forg3tClientOptions, type Forg3tDeploymentProfile, Forg3tError, Forg3tNotFoundError, Forg3tNotImplementedError, Forg3tRateLimitError, HttpTrainingAdapter, type HttpTrainingAdapterOptions, type Integration, IntegrationMode, IntegrationType, type Job, type JobConfig, type JobError, type JobMutationOptions, type JobResult, type JobStatus, type JobType, type LangChainAdapterConfig, type LocalCommandAdapterOptions, LocalCommandTrainingAdapter, type ModelArtifactReference, type NativeAdapterConfig, type OpenRouterAdapterConfig, type PaginationParams, type Project, type RevokeApiKeyResponse, type SubmitJobRequest, type TrainingBackendAdapter, type UnlearningClaim, type UnlearningExecutionModelRef, type UnlearningExecutionPlanSpec, type UnlearningExecutionSpec, type UnlearningExecutionTargetSpec, type UnlearningJobSummary, type UnlearningRequest, type UnlearningScope, type UnlearningTarget, type UpdateWebhookRequest, WHITEBOX_QUALITY_GATE_PRESETS, WHITEBOX_QUALITY_GATE_PRESET_EXPLANATIONS, type Webhook, type WebhookDelivery, type WebhookDeliveryFilters, type WhiteboxEvaluationInput, type WhiteboxEvaluationOutput, type WhiteboxJobContext, type WhiteboxQualityGateDecision, type WhiteboxQualityGatePolicy, type WhiteboxQualityGatePreset, type WhiteboxTargetSpec, type WhiteboxUnlearningInput, type WhiteboxUnlearningOutput, type WhiteboxUnlearningPlan, WhiteboxWorker, type WhiteboxWorkerBaseOptions, type WhiteboxWorkerLogger, type WhiteboxWorkerOptions, assertDeploymentCompatibility, buildModelUnlearningPayload, buildWhiteboxWorkerOptions, createNativeTrainingAdapter, evaluateWhiteboxQualityGate, resolveWhiteboxQualityGatePolicy };