@gebsecure01/sdk 0.2.1

package/dist/index.d.ts

@@ -0,0 +1,2378 @@
+/** Time source used for token expiry, backoff and approval polling. Injectable for tests. */
+interface Clock {
+    /** Milliseconds since the epoch. */
+    now(): number;
+    /** Resolves after `ms`; rejects with the signal's reason if aborted. */
+    sleep(ms: number, signal?: AbortSignal): Promise<void>;
+}
+declare const systemClock: Clock;
+
+/** Agent lifecycle status. Unknown future values are preserved as plain strings. */
+declare const AgentStatus: {
+    readonly ACTIVE: "active";
+    readonly SUSPENDED: "suspended";
+    readonly DISABLED: "disabled";
+    readonly QUARANTINED: "quarantined";
+};
+type AgentStatus = (typeof AgentStatus)[keyof typeof AgentStatus] | (string & {});
+/** Security alert lifecycle status. Unknown future values are preserved as plain strings. */
+declare const AlertStatus: {
+    readonly OPEN: "open";
+    readonly ACKNOWLEDGED: "acknowledged";
+    readonly INVESTIGATING: "investigating";
+    readonly RESOLVED: "resolved";
+    readonly DISMISSED: "dismissed";
+};
+type AlertStatus = (typeof AlertStatus)[keyof typeof AlertStatus] | (string & {});
+/** Approval request status. Unknown future values are preserved as plain strings. */
+declare const ApprovalStatus: {
+    readonly PENDING: "pending";
+    readonly APPROVED: "approved";
+    readonly REJECTED: "rejected";
+    readonly EXPIRED: "expired";
+    readonly CANCELLED: "cancelled";
+    readonly CONSUMED: "consumed";
+};
+type ApprovalStatus = (typeof ApprovalStatus)[keyof typeof ApprovalStatus] | (string & {});
+/** An approver's verdict. Unknown future values are preserved as plain strings. */
+declare const ApprovalVerdict: {
+    readonly APPROVE: "approve";
+    readonly REJECT: "reject";
+};
+type ApprovalVerdict = (typeof ApprovalVerdict)[keyof typeof ApprovalVerdict] | (string & {});
+/** Where inspected content came from (determines its trust level). Unknown future values are preserved as plain strings. */
+declare const ContentSource: {
+    readonly PROMPT: "prompt";
+    readonly WEB: "web";
+    readonly EMAIL: "email";
+    readonly DOCUMENT: "document";
+    readonly RAG: "rag";
+    readonly MCP_RESPONSE: "mcp_response";
+    readonly TOOL_OUTPUT: "tool_output";
+};
+type ContentSource = (typeof ContentSource)[keyof typeof ContentSource] | (string & {});
+/** Authorization decision. Unknown future values are preserved as plain strings. */
+declare const Decision: {
+    readonly ALLOW: "ALLOW";
+    readonly DENY: "DENY";
+    readonly APPROVAL_REQUIRED: "APPROVAL_REQUIRED";
+};
+type Decision = (typeof Decision)[keyof typeof Decision] | (string & {});
+/** Scopes that may be delegated to another agent. Unknown future values are preserved as plain strings. */
+declare const DelegationScope: {
+    readonly AUTHORIZE: "authorize";
+    readonly EXECUTE: "execute";
+    readonly MCP_CONNECT: "mcp:connect";
+    readonly SECRETS_USE: "secrets:use";
+    readonly BROWSER_USE: "browser:use";
+    readonly DATABASE_USE: "database:use";
+    readonly DELEGATIONS_MANAGE: "delegations:manage";
+};
+type DelegationScope = (typeof DelegationScope)[keyof typeof DelegationScope] | (string & {});
+/** DLP enforcement action. Unknown future values are preserved as plain strings. */
+declare const DlpAction: {
+    readonly ALLOW: "ALLOW";
+    readonly MASK: "MASK";
+    readonly REDACT: "REDACT";
+    readonly BLOCK: "BLOCK";
+    readonly REQUIRE_APPROVAL: "REQUIRE_APPROVAL";
+};
+type DlpAction = (typeof DlpAction)[keyof typeof DlpAction] | (string & {});
+/** Direction of data flow for DLP. Unknown future values are preserved as plain strings. */
+declare const DlpDirection: {
+    readonly INBOUND: "inbound";
+    readonly OUTBOUND: "outbound";
+};
+type DlpDirection = (typeof DlpDirection)[keyof typeof DlpDirection] | (string & {});
+/** Execution mode. Unknown future values are preserved as plain strings. */
+declare const ExecuteMode: {
+    readonly SYNC: "sync";
+    readonly ASYNC: "async";
+};
+type ExecuteMode = (typeof ExecuteMode)[keyof typeof ExecuteMode] | (string & {});
+/** Execution lifecycle status. Unknown future values are preserved as plain strings. */
+declare const ExecutionStatus: {
+    readonly PENDING: "pending";
+    readonly RUNNING: "running";
+    readonly SUCCEEDED: "succeeded";
+    readonly FAILED: "failed";
+    readonly DENIED: "denied";
+    readonly AWAITING_APPROVAL: "awaiting_approval";
+    readonly CANCELLED: "cancelled";
+    readonly CANCELLING: "cancelling";
+    readonly SIMULATED: "simulated";
+};
+type ExecutionStatus = (typeof ExecutionStatus)[keyof typeof ExecutionStatus] | (string & {});
+/** Prompt-injection severity level. Unknown future values are preserved as plain strings. */
+declare const InjectionLevel: {
+    readonly NONE: "none";
+    readonly LOW: "low";
+    readonly MEDIUM: "medium";
+    readonly HIGH: "high";
+    readonly CRITICAL: "critical";
+};
+type InjectionLevel = (typeof InjectionLevel)[keyof typeof InjectionLevel] | (string & {});
+/** Risk level. Unknown future values are preserved as plain strings. */
+declare const RiskLevel: {
+    readonly LOW: "low";
+    readonly MEDIUM: "medium";
+    readonly HIGH: "high";
+    readonly CRITICAL: "critical";
+};
+type RiskLevel = (typeof RiskLevel)[keyof typeof RiskLevel] | (string & {});
+/** Risk engine recommendation. Unknown future values are preserved as plain strings. */
+declare const RiskRecommendation: {
+    readonly ALLOW: "allow";
+    readonly APPROVAL_REQUIRED: "approval_required";
+    readonly DENY: "deny";
+};
+type RiskRecommendation = (typeof RiskRecommendation)[keyof typeof RiskRecommendation] | (string & {});
+/** Agent risk tier. Unknown future values are preserved as plain strings. */
+declare const RiskTier: {
+    readonly LOW: "low";
+    readonly STANDARD: "standard";
+    readonly ELEVATED: "elevated";
+    readonly CRITICAL: "critical";
+};
+type RiskTier = (typeof RiskTier)[keyof typeof RiskTier] | (string & {});
+/** Vault secret type. Unknown future values are preserved as plain strings. */
+declare const SecretType: {
+    readonly API_KEY: "api_key";
+    readonly OAUTH_TOKEN: "oauth_token";
+    readonly DATABASE: "database";
+    readonly CERTIFICATE: "certificate";
+    readonly CLOUD: "cloud";
+    readonly SSH_KEY: "ssh_key";
+    readonly GENERIC: "generic";
+};
+type SecretType = (typeof SecretType)[keyof typeof SecretType] | (string & {});
+/** Outcome of a simulation run. Unknown future values are preserved as plain strings. */
+declare const SimulationStatus: {
+    readonly PASSED: "passed";
+    readonly FAILED: "failed";
+    readonly ERROR: "error";
+};
+type SimulationStatus = (typeof SimulationStatus)[keyof typeof SimulationStatus] | (string & {});
+/** OpenTelemetry span kind. Unknown future values are preserved as plain strings. */
+declare const SpanKind: {
+    readonly SERVER: "server";
+    readonly CLIENT: "client";
+    readonly INTERNAL: "internal";
+    readonly PRODUCER: "producer";
+    readonly CONSUMER: "consumer";
+};
+type SpanKind = (typeof SpanKind)[keyof typeof SpanKind] | (string & {});
+/** Span status. Unknown future values are preserved as plain strings. */
+declare const SpanStatus: {
+    readonly UNSET: "unset";
+    readonly OK: "ok";
+    readonly ERROR: "error";
+};
+type SpanStatus = (typeof SpanStatus)[keyof typeof SpanStatus] | (string & {});
+/** Credential metadata of an agent (never the secret). */
+interface AgentCredential {
+    id: string;
+    type: string;
+    name?: string;
+    status?: string;
+    scopes?: Array<string>;
+    expiresAt?: string | null;
+    graceUntil?: string | null;
+    lastUsedAt?: string | null;
+    createdAt?: string;
+    revokedAt?: string | null;
+    principalType?: string;
+    principalId?: string;
+    publicJwk?: Record<string, unknown> | null;
+    rotatedFrom?: string | null;
+    revokedReason?: string | null;
+    createdBy?: string | null;
+}
+/** An agent identity (GET /v1/agents, GET /v1/agents/{id}). */
+interface Agent {
+    id: string;
+    name: string;
+    description?: string;
+    status: AgentStatus;
+    statusReason?: string | null;
+    projectId?: string;
+    environmentId?: string;
+    applicationId?: string | null;
+    ownerUserId?: string | null;
+    ownerTeamId?: string | null;
+    ownerEmail?: string | null;
+    framework?: string | null;
+    model?: string | null;
+    riskTier?: string;
+    tags?: Array<string>;
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+    updatedAt?: string;
+    lastSeenAt?: string | null;
+    credentials?: Array<AgentCredential>;
+}
+/** Response of GET /v1/agents/{id}/credentials. */
+interface AgentCredentialList {
+    data: Array<AgentCredential>;
+}
+/** Response of GET /v1/agents. */
+interface AgentPage {
+    data: Array<Agent>;
+    nextCursor?: string | null;
+}
+/**  */
+interface SpanEvent {
+    name: string;
+    time: string;
+    /** Default: {}. */
+    attributes?: Record<string, unknown>;
+}
+/**  */
+interface AgentSpan {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string | null;
+    name: string;
+    /** Default: "internal". */
+    kind?: SpanKind;
+    startTime: string;
+    durationMs: number;
+    /** Default: "unset". */
+    status?: SpanStatus;
+    statusMessage?: string | null;
+    /** Default: {}. */
+    attributes?: Record<string, unknown>;
+    /** Default: []. */
+    events?: Array<SpanEvent>;
+}
+/** Input to POST /v1/agents/{id}/status. (api: POST /v1/agents/{id}/status) */
+interface AgentStatusRequest {
+    status: AgentStatus;
+    reason?: string;
+}
+/** A security alert (GET /v1/alerts, GET/PATCH /v1/alerts/{id}). */
+interface Alert {
+    id: string;
+    projectId?: string | null;
+    environmentId?: string | null;
+    kind: string;
+    severity: RiskLevel;
+    score?: number;
+    title?: string;
+    summary?: string;
+    principalType?: string | null;
+    principalId?: string | null;
+    status: AlertStatus;
+    assigneeId?: string | null;
+    dedupeKey?: string;
+    occurrences?: number;
+    evidence?: Array<unknown>;
+    response?: Record<string, unknown>;
+    resolution?: string | null;
+    firstSeenAt?: string;
+    lastSeenAt?: string;
+    acknowledgedAt?: string | null;
+    resolvedAt?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+    notes?: Array<unknown>;
+    investigation?: Record<string, unknown>;
+}
+/** Response of GET /v1/alerts. */
+interface AlertPage {
+    data: Array<Alert>;
+    nextCursor?: string | null;
+}
+/** An approval request. GET {gateway}/v1/approvals/{id} returns the agent-facing subset; the control-plane API returns the full record. */
+interface Approval {
+    id: string;
+    status: ApprovalStatus;
+    action?: string;
+    resource?: string;
+    summary?: string;
+    reason?: string;
+    snapshotHash?: string;
+    agentId?: string | null;
+    projectId?: string;
+    environmentId?: string;
+    requesterType?: string;
+    requesterId?: string;
+    riskScore?: number | null;
+    riskLevel?: string | null;
+    expiresAt?: string;
+    resolvedAt?: string | null;
+    resolvedBy?: string | null;
+    resolutionComment?: string | null;
+    executionId?: string | null;
+    createdAt?: string;
+    signatureValid?: boolean;
+    steps?: Array<unknown>;
+    decisions?: Array<unknown>;
+    comments?: Array<unknown>;
+    history?: Array<unknown>;
+    canDecide?: boolean;
+}
+/** Response of POST /v1/approvals/{id}/decision. */
+interface ApprovalDecisionResult {
+    approvalId: string;
+    status: ApprovalStatus;
+    stepIndex?: number;
+}
+/** Response of GET /v1/approvals. */
+interface ApprovalPage {
+    data: Array<Approval>;
+    nextCursor?: string | null;
+}
+/** Approval request associated with a decision. */
+interface ApprovalRef {
+    id: string;
+    status: ApprovalStatus;
+    expiresAt: string;
+    snapshotHash: string;
+    url: string;
+    created: boolean;
+}
+/** An approval requirement contributed by a policy or risk threshold. */
+interface ApprovalRequirement {
+    policyId: string;
+    policyName: string;
+    approvers?: Array<unknown>;
+    min?: number;
+    mode?: string;
+    expiresMs?: number | null;
+}
+/** A broken link in the audit hash chain. */
+interface AuditChainError {
+    seq: number;
+    id?: string;
+    problem?: string;
+}
+/** One tamper-evident audit record. */
+interface AuditEvent {
+    id: string;
+    seq: number;
+    occurredAt?: string;
+    category?: string;
+    action?: string;
+    outcome?: string;
+    actorType?: string;
+    actorId?: string | null;
+    onBehalfOf?: string | null;
+    agentId?: string | null;
+    sessionId?: string | null;
+    projectId?: string | null;
+    environmentId?: string | null;
+    resourceType?: string | null;
+    resourceId?: string | null;
+    decision?: string | null;
+    policyIds?: Array<string>;
+    riskScore?: number | null;
+    approvalId?: string | null;
+    executionId?: string | null;
+    argsHash?: string | null;
+    requestId?: string | null;
+    traceId?: string | null;
+    ip?: string | null;
+    userAgent?: string | null;
+    details?: Record<string, unknown>;
+    prevHash?: string;
+    hash?: string;
+}
+/** Query parameters for GET /v1/audit/export. (api: GET /v1/audit/export) */
+interface AuditExportParams {
+    from?: string;
+    to?: string;
+    category?: string;
+    action?: string;
+    outcome?: string;
+    actorId?: string;
+    agentId?: string;
+    resourceType?: string;
+    resourceId?: string;
+    projectId?: string;
+    environmentId?: string;
+    decision?: string;
+    traceId?: string;
+    approvalId?: string;
+    executionId?: string;
+    minRisk?: number;
+    q?: string;
+    afterSeq?: number;
+    /** Default: 100. */
+    limit?: number;
+    cursor?: string;
+    /** Default: "ndjson". */
+    format?: string;
+}
+/** Response of GET /v1/audit/events. */
+interface AuditPage {
+    data: Array<AuditEvent>;
+    nextCursor?: string | null;
+}
+/** Query parameters for GET /v1/audit/events (afterSeq = tail: records after that sequence number, oldest first). (api: GET /v1/audit/events) */
+interface AuditSearchParams {
+    from?: string;
+    to?: string;
+    category?: string;
+    action?: string;
+    outcome?: string;
+    actorId?: string;
+    agentId?: string;
+    resourceType?: string;
+    resourceId?: string;
+    projectId?: string;
+    environmentId?: string;
+    decision?: string;
+    traceId?: string;
+    approvalId?: string;
+    executionId?: string;
+    minRisk?: number;
+    q?: string;
+    afterSeq?: number;
+    /** Default: 100. */
+    limit?: number;
+    cursor?: string;
+}
+/** Response of POST /v1/audit/verify. */
+interface AuditVerification {
+    valid: boolean;
+    checked: number;
+    firstSeq?: number | null;
+    lastSeq?: number | null;
+    headMatches?: boolean;
+    errors?: Array<AuditChainError>;
+}
+/** A user account. */
+interface AuthUser {
+    id: string;
+    email?: string;
+    name?: string;
+    createdAt?: string;
+}
+/** Error for one entry of a batch authorization. */
+interface BatchError {
+    code: string;
+    message: string;
+}
+/** Environment the request was evaluated in. */
+interface EnvironmentRef {
+    id: string;
+    slug: string;
+    tier: string;
+}
+/** One policy considered during evaluation. */
+interface TraceEntry {
+    policyId: string;
+    versionId?: string | null;
+    name: string;
+    effect: string;
+    source?: string;
+    scope?: unknown;
+    outcome: string;
+    detail?: string;
+}
+/** Why the decision was made. */
+interface Explanation {
+    trace: Array<TraceEntry>;
+    approvals: Array<ApprovalRequirement>;
+    grantingPolicyId?: string | null;
+    candidates: number;
+    policyDecision: Decision;
+}
+/** A rate/amount limit of the granting policy and its current usage. */
+interface LimitState {
+    policyId: string;
+    key: string;
+    measure: string;
+    amount: number;
+    max: number;
+    windowMs: number;
+    subject?: string;
+    used: number;
+    remaining: number;
+}
+/** The principal the decision applies to. */
+interface PrincipalRef {
+    type: string;
+    id: string;
+}
+/** One explainable contribution to a risk score. */
+interface RiskSignal {
+    category: string;
+    code: string;
+    points: number;
+    reason: string;
+}
+/** Risk thresholds in effect. */
+interface RiskThresholds {
+    approvalAbove: number;
+    denyAbove: number;
+}
+/** Risk assessment attached to a decision. */
+interface Risk {
+    score: number;
+    level: RiskLevel;
+    recommendation: RiskRecommendation;
+    signals: Array<RiskSignal>;
+    thresholds: RiskThresholds;
+}
+/** One entry of POST /v1/authorize/batch: either a decision (all AuthorizeResult fields) or an error. */
+interface AuthorizeBatchEntry {
+    decision?: Decision;
+    decisionId?: string;
+    reason?: string;
+    risk?: Risk;
+    approval?: ApprovalRef | null;
+    explanation?: Explanation;
+    limits?: Array<LimitState>;
+    snapshotHash?: string;
+    environment?: EnvironmentRef;
+    principal?: PrincipalRef;
+    dryRun?: boolean;
+    evaluatedAt?: string;
+    durationMs?: number;
+    error?: BatchError;
+}
+/**  */
+interface OnBehalfOf {
+    agentId: string;
+}
+/** Input to POST /v1/authorize. (gateway: POST /v1/authorize) */
+interface AuthorizeRequest {
+    action: string;
+    resource: string;
+    /** Default: {}. */
+    resourceAttributes?: Record<string, unknown>;
+    /** Default: {}. */
+    context?: Record<string, unknown>;
+    environmentId?: string;
+    onBehalfOf?: OnBehalfOf;
+    approvalId?: string;
+    /** Default: false. */
+    dryRun?: boolean;
+    execution?: Record<string, unknown> | null;
+}
+/** Input to POST /v1/authorize/batch (1-100 requests). (gateway: POST /v1/authorize/batch) */
+interface AuthorizeBatchRequest {
+    requests: Array<AuthorizeRequest>;
+}
+/** Response of POST /v1/authorize/batch (results are in request order). */
+interface AuthorizeBatchResult {
+    results: Array<AuthorizeBatchEntry>;
+}
+/** Response of POST /v1/authorize. */
+interface AuthorizeResult {
+    decision: Decision;
+    decisionId: string;
+    reason: string;
+    risk: Risk;
+    approval?: ApprovalRef | null;
+    explanation?: Explanation;
+    limits?: Array<LimitState>;
+    snapshotHash?: string;
+    environment?: EnvironmentRef;
+    principal?: PrincipalRef;
+    dryRun?: boolean;
+    evaluatedAt?: string;
+    durationMs?: number;
+}
+/** Response of POST /v1/executions/{id}/cancel. */
+interface CancelExecutionResult {
+    executionId: string;
+    status: ExecutionStatus;
+}
+/** Input to POST /v1/connections/{id}/oauth/client-credentials. (api: POST /v1/connections/{id}/oauth/client-credentials) */
+interface ClientCredentialsInstallRequest {
+    clientId: string;
+    clientSecret: string;
+    scopes?: Array<string>;
+}
+/** An action a connector exposes. */
+interface ConnectorAction {
+    name: string;
+    action: string;
+    title?: string;
+    description?: string;
+    risk?: unknown;
+    idempotent?: boolean;
+    input?: Record<string, unknown>;
+    output?: Record<string, unknown> | null;
+}
+/** A connector in the catalog (GET /v1/connectors, GET /v1/connectors/{key}). */
+interface Connector {
+    key: string;
+    name: string;
+    version?: string;
+    description?: string;
+    category?: string;
+    homepage?: string | null;
+    baseUrl?: string | null;
+    allowedHosts?: Array<string>;
+    publicHosts?: Array<string>;
+    auth?: Array<unknown>;
+    config?: Record<string, unknown>;
+    resources?: unknown;
+    securityTemplate?: unknown;
+    actions?: Array<ConnectorAction>;
+}
+/** A connector installed into a project (signing secrets are never returned, except signingSecret once on create). */
+interface Connection {
+    id: string;
+    projectId?: string;
+    environmentId?: string | null;
+    connectorKey?: string;
+    connectorVersion?: string;
+    name: string;
+    description?: string;
+    authType?: string;
+    secretId?: string | null;
+    config?: Record<string, unknown>;
+    allowedHosts?: Array<string>;
+    signRequests?: boolean;
+    timeoutMs?: number;
+    maxRetries?: number;
+    status?: string;
+    health?: Record<string, unknown>;
+    lastHealthAt?: string | null;
+    createdBy?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+    connector?: Connector | null;
+    effectiveAllowedHosts?: Array<string>;
+    securityTemplate?: unknown;
+    /** Request-signing secret, returned once on create when signRequests=true. */
+    signingSecret?: string;
+}
+/**  */
+interface ConnectionCredential {
+    type: string;
+    value: Record<string, unknown>;
+    /** Default: {}. */
+    metadata?: Record<string, unknown>;
+}
+/** Response of POST /v1/connections/{id}/health. */
+interface ConnectionHealth {
+    ok: boolean;
+    detail?: string;
+    latencyMs?: number;
+}
+/** Response of GET /v1/connections. */
+interface ConnectionList {
+    data: Array<Connection>;
+}
+/** Response of GET /v1/connectors. */
+interface ConnectorList {
+    data: Array<Connector>;
+}
+/** Provenance of inspected content. */
+interface ContentProvenance {
+    source: string;
+    origin?: string | null;
+    trust: string;
+    contentHash?: string;
+    retrievedAt?: string;
+}
+/** Input to POST /v1/connections (install a connector into a project). (api: POST /v1/connections) */
+interface CreateConnectionRequest {
+    projectId: string;
+    environmentId?: string;
+    connector: string;
+    name: string;
+    /** Default: "". */
+    description?: string;
+    /** Default: "none". */
+    authType?: string;
+    secretId?: string;
+    credential?: ConnectionCredential;
+    /** Default: {}. */
+    config?: Record<string, unknown>;
+    /** Default: []. */
+    allowedHosts?: Array<string>;
+    /** Default: false. */
+    signRequests?: boolean;
+    /** Default: 15000. */
+    timeoutMs?: number;
+    /** Default: 2. */
+    maxRetries?: number;
+}
+/** Input to POST /v1/agents/{id}/credentials. (api: POST /v1/agents/{id}/credentials) */
+interface CreateCredentialRequest {
+    /** Default: "client_secret". */
+    type?: string;
+    /** Default: "default". */
+    name?: string;
+    publicJwk?: Record<string, unknown>;
+    /** Default: []. */
+    scopes?: Array<string>;
+    expiresInDays?: number;
+}
+/**  */
+interface DelegationConstraints {
+    maxAmount?: number;
+    environments?: Array<string>;
+}
+/** Input to POST /v1/delegations (control plane). (api: POST /v1/delegations) */
+interface CreateDelegationRequest {
+    delegateAgentId: string;
+    scopes: Array<DelegationScope>;
+    /** Default: []. */
+    actions?: Array<string>;
+    /** Default: []. */
+    resources?: Array<string>;
+    /** Default: {}. */
+    constraints?: DelegationConstraints;
+    /** Default: "". */
+    purpose?: string;
+    /** Default: 3600. */
+    expiresInSeconds?: number;
+    /** Default: 3. */
+    maxDepth?: number;
+}
+/** Policy scope: {type: org} | {type: project, projectId} | {type: environment, environmentId}. */
+interface PolicyScope {
+    /** org, project or environment. */
+    type: string;
+    projectId?: string;
+    environmentId?: string;
+}
+/** Input to POST /v1/policies (exactly one of source or templateId). (api: POST /v1/policies) */
+interface CreatePolicyRequest {
+    name: string;
+    /** Default: "". */
+    description?: string;
+    /** Default: {"type":"org"}. */
+    scope?: PolicyScope;
+    source?: string;
+    templateId?: string;
+    templateParams?: Record<string, unknown>;
+    /** Default: "Initial version". */
+    message?: string;
+    /** Default: []. */
+    tags?: Array<string>;
+}
+/**  */
+interface SecretAccessPolicy {
+    agents?: Array<string>;
+    agentTags?: Array<string>;
+    connectors?: Array<string>;
+    actions?: Array<string>;
+    environments?: Array<string>;
+}
+/**  */
+interface SecretRotationPolicy {
+    intervalDays?: number;
+    /** Default: "manual". */
+    strategy?: string;
+}
+/** Input to POST /v1/secrets. `value` is write-only: it is never returned and SDKs never log it. (api: POST /v1/secrets) */
+interface CreateSecretRequest {
+    name: string;
+    type: SecretType;
+    value: Record<string, unknown>;
+    /** Default: "". */
+    description?: string;
+    /** Default: {}. */
+    metadata?: Record<string, unknown>;
+    projectId?: string;
+    environmentId?: string;
+    /** Default: {}. */
+    accessPolicy?: SecretAccessPolicy;
+    expiresAt?: string;
+    /** Default: {"strategy":"manual"}. */
+    rotationPolicy?: SecretRotationPolicy;
+}
+/** Response of POST /v1/secrets (metadata only; the value is never echoed). */
+interface CreatedSecret {
+    id: string;
+    name: string;
+    type: SecretType;
+    mask?: string;
+    version?: number;
+}
+/** Input to POST /v1/approvals/{id}/decision. snapshotHash must be the hash the approver reviewed. (api: POST /v1/approvals/{id}/decision) */
+interface DecideApprovalRequest {
+    decision: ApprovalVerdict;
+    /** Default: "". */
+    comment?: string;
+    snapshotHash: string;
+    /** Default: "console". */
+    channel?: string;
+}
+/** Response of POST /v1/delegations. `token` (gsd_...) is shown once; hand it to the delegate agent. */
+interface Delegation {
+    id: string;
+    token: string;
+    chain?: Array<unknown>;
+    depth?: number;
+    maxDepth?: number;
+    scopes?: Array<string>;
+    actions?: Array<string>;
+    resources?: Array<string>;
+    expiresAt?: string;
+    originatingUserId?: string | null;
+}
+/** Input to POST /v1/policies/{id}/deploy (default: latest version). (api: POST /v1/policies/{id}/deploy) */
+interface DeployPolicyRequest {
+    versionId?: string;
+    /** Default: "". */
+    comment?: string;
+}
+/** One sensitive-data finding (masked, never the raw value). */
+interface DlpFinding {
+    detector: string;
+    category: string;
+    label?: string;
+    confidence?: number;
+    path?: string;
+    masked?: string;
+    enforcement?: DlpAction;
+}
+/** A DLP rule that matched. */
+interface DlpMatchedRule {
+    ruleId: string;
+    name: string;
+    action: DlpAction;
+    findings?: number;
+}
+/** Input to POST /v1/dlp/scan. (gateway: POST /v1/dlp/scan) */
+interface DlpScanRequest {
+    content: unknown;
+    direction: DlpDirection;
+    action?: string;
+    connector?: string;
+    environmentId?: string;
+    dryRun?: boolean;
+}
+/** Response of POST /v1/dlp/scan. */
+interface DlpScanResult {
+    action: DlpAction;
+    /** Transformed payload; null when blocked. */
+    content?: unknown;
+    findings: Array<DlpFinding>;
+    rules?: Array<DlpMatchedRule>;
+    eventId?: string | null;
+    dryRun?: boolean;
+}
+/** Input to POST /v1/execute. (gateway: POST /v1/execute) */
+interface ExecuteRequest {
+    connection: string;
+    action: string;
+    /** Default: {}. */
+    input?: Record<string, unknown>;
+    idempotencyKey?: string;
+    approvalId?: string;
+    /** Default: "sync". */
+    mode?: ExecuteMode;
+    timeoutMs?: number;
+    /** Default: false. */
+    dryRun?: boolean;
+    environmentId?: string;
+    onBehalfOf?: OnBehalfOf;
+}
+/** Error of a failed/denied execution. */
+interface ExecutionError {
+    code: string;
+    message: string;
+    upstreamStatus?: number;
+}
+/** Response of POST /v1/execute (HTTP 200 succeeded/simulated, 202 awaiting_approval/running, 403 denied, 502/504 failed). */
+interface ExecuteResult {
+    executionId?: string | null;
+    status: ExecutionStatus;
+    decision?: Decision;
+    reason?: string;
+    output?: unknown;
+    outputTruncated?: boolean;
+    error?: ExecutionError | null;
+    approval?: ApprovalRef | null;
+    risk?: Risk;
+    durationMs?: number;
+    replayed?: boolean;
+}
+/** One step log line of an execution. */
+interface ExecutionLog {
+    step: string;
+    level?: string;
+    message?: string;
+    data?: Record<string, unknown>;
+    durationMs?: number | null;
+    createdAt?: string;
+}
+/** Response of GET /v1/executions/{id} (execution record with step logs). */
+interface Execution {
+    id: string;
+    status: ExecutionStatus;
+    projectId?: string;
+    environmentId?: string;
+    principalType?: string;
+    principalId?: string;
+    connectionId?: string | null;
+    connectorKey?: string;
+    action?: string;
+    resource?: string;
+    mode?: ExecuteMode;
+    decision?: Decision | null;
+    decisionId?: string | null;
+    approvalId?: string | null;
+    riskScore?: number | null;
+    idempotencyKey?: string | null;
+    output?: unknown;
+    outputTruncated?: boolean;
+    error?: ExecutionError | null;
+    attempts?: number;
+    traceId?: string | null;
+    createdAt?: string;
+    startedAt?: string | null;
+    finishedAt?: string | null;
+    durationMs?: number | null;
+    logs?: Array<ExecutionLog>;
+}
+/** Response of GET /v1/executions. */
+interface ExecutionPage {
+    data: Array<Execution>;
+    nextCursor?: string | null;
+}
+/** One prompt-injection rule match. */
+interface InjectionFinding {
+    rule: string;
+    category: string;
+    excerpt?: string;
+}
+/** ML classifier contribution (when configured). */
+interface InjectionModelResult {
+    used: boolean;
+    score?: number | null;
+    error?: string | null;
+}
+/** Prompt-injection analysis of inspected content. */
+interface InjectionReport {
+    /** 0-100. */
+    score: number;
+    level: InjectionLevel;
+    /** ALLOW, FLAG, SANITIZE or BLOCK. */
+    action: string;
+    findings: Array<InjectionFinding>;
+    provenance?: ContentProvenance;
+    model?: InjectionModelResult;
+    detectionId?: string | null;
+    tainted?: boolean;
+}
+/** Inbound DLP outcome of an inspection. */
+interface InspectDlpReport {
+    action: DlpAction;
+    /** Finding label -> count. */
+    summary?: Record<string, unknown>;
+    rules?: Array<DlpMatchedRule>;
+    eventId?: string | null;
+}
+/** Input to POST /v1/inspect: untrusted content an agent is about to read. (gateway: POST /v1/inspect) */
+interface InspectRequest {
+    content: unknown;
+    source: ContentSource;
+    origin?: string;
+    /** Default: true. */
+    dlp?: boolean;
+    environmentId?: string;
+}
+/** Response of POST /v1/inspect. */
+interface InspectResult {
+    /** Overall action: ALLOW, FLAG, SANITIZE, MASK, REDACT, REQUIRE_APPROVAL or BLOCK. */
+    action: string;
+    /** Content safe to hand to the model (sanitized/masked); null when blocked. */
+    content?: unknown;
+    injection: InjectionReport;
+    dlp?: InspectDlpReport | null;
+}
+/** A newly issued credential. clientSecret (gsa_...) is shown ONCE (null for public_key credentials); SDKs never log it. */
+interface IssuedCredential {
+    credential: AgentCredential;
+    clientId: string;
+    clientSecret?: string | null;
+}
+/** Input to POST /v1/connections/{id}/oauth/jwt-bearer: either serviceAccountJson (Google) or issuer + privateKeyPem. */
+interface JwtBearerInstallRequest {
+    serviceAccountJson?: string;
+    issuer?: string;
+    privateKeyPem?: string;
+    keyId?: string;
+    subject?: string;
+    audience?: string;
+    scopes?: Array<string>;
+}
+/** Query parameters for GET /v1/agents. (api: GET /v1/agents) */
+interface ListAgentsParams {
+    projectId?: string;
+    environmentId?: string;
+    status?: AgentStatus;
+    ownerUserId?: string;
+    tag?: string;
+    q?: string;
+    /** Default: 50. */
+    limit?: number;
+    cursor?: string;
+}
+/** Query parameters for GET /v1/alerts. (api: GET /v1/alerts) */
+interface ListAlertsParams {
+    status?: AlertStatus;
+    severity?: RiskLevel;
+    kind?: string;
+    principalId?: string;
+    active?: string;
+    /** Default: 50. */
+    limit?: number;
+    cursor?: string;
+}
+/** Query parameters for GET /v1/approvals. (api: GET /v1/approvals) */
+interface ListApprovalsParams {
+    status?: ApprovalStatus;
+    inbox?: boolean;
+    agentId?: string;
+    projectId?: string;
+    /** Default: 50. */
+    limit?: number;
+    cursor?: string;
+}
+/** Query parameters for GET /v1/connections. (api: GET /v1/connections) */
+interface ListConnectionsParams {
+    projectId?: string;
+}
+/** Query parameters for GET /v1/executions. (gateway: GET /v1/executions) */
+interface ListExecutionsParams {
+    status?: string;
+    principalId?: string;
+    connectionId?: string;
+    /** Default: 50. */
+    limit?: number;
+    cursor?: string;
+}
+/** Query parameters for GET /v1/policies. (api: GET /v1/policies) */
+interface ListPoliciesParams {
+    projectId?: string;
+    environmentId?: string;
+    status?: string;
+}
+/** Query parameters for GET /v1/secrets. (api: GET /v1/secrets) */
+interface ListSecretsParams {
+    projectId?: string;
+    environmentId?: string;
+    type?: string;
+}
+/** Input to POST /v1/auth/login. SDKs send refreshTokenDelivery=body. (api: POST /v1/auth/login) */
+interface LoginRequest {
+    email: string;
+    password: string;
+    orgId?: string;
+    /** Default: "cookie". */
+    refreshTokenDelivery?: string;
+}
+/** An organization the user belongs to. */
+interface OrgMembership {
+    orgId: string;
+    role?: string;
+    name?: string;
+    slug?: string;
+}
+/** Response of POST /v1/auth/login (refreshTokenDelivery=body). */
+interface LoginResult {
+    accessToken: string;
+    tokenType?: string;
+    /** Access token lifetime in seconds. */
+    expiresIn: number;
+    refreshToken?: string;
+    refreshExpiresAt?: string;
+    familyId?: string;
+    sessionId?: string;
+    user?: AuthUser;
+    orgId?: string | null;
+    orgs?: Array<OrgMembership>;
+}
+/** The authenticated principal. */
+interface MePrincipal {
+    type: string;
+    id: string;
+    orgId?: string | null;
+    orgRole?: string | null;
+    projectId?: string | null;
+    environmentId?: string | null;
+    scopes?: Array<string>;
+}
+/** Response of GET /v1/auth/me. */
+interface Me {
+    principal: MePrincipal;
+    user?: AuthUser | null;
+    orgs?: Array<OrgMembership>;
+    permissions?: Array<string>;
+}
+/** Input to POST /v1/connections/oauth/callback. (api: POST /v1/connections/oauth/callback) */
+interface OAuthCallbackRequest {
+    state: string;
+    code: string;
+    clientSecret?: string;
+}
+/** Response of the OAuth callback and the client-credentials / jwt-bearer installs. */
+interface OAuthInstallResult {
+    connectionId: string;
+    secretId: string;
+    scope?: string | null;
+    expiresAt?: string | null;
+}
+/** Input to POST /v1/connections/{id}/oauth/start (authorization code + PKCE). (api: POST /v1/connections/{id}/oauth/start) */
+interface OAuthStartRequest {
+    redirectUri: string;
+    clientId: string;
+    scopes?: Array<string>;
+}
+/** Response of POST /v1/connections/{id}/oauth/start: send the user to authorizationUrl. */
+interface OAuthStartResult {
+    authorizationUrl: string;
+    expiresInSeconds?: number;
+}
+/** A policy (GET /v1/policies). */
+interface Policy {
+    id: string;
+    name: string;
+    description?: string;
+    status: string;
+    scopeType?: string;
+    scopeId?: string;
+    projectId?: string | null;
+    environmentId?: string | null;
+    latestVersion?: number;
+    activeVersion?: number | null;
+    activeVersionId?: string | null;
+    tags?: Array<string>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+/** Result of running a policy's tests (POST /v1/policies/{id}/tests/run; also embedded in deploy reports). */
+interface PolicyTestRun {
+    versionId?: string;
+    passed: number;
+    failed: number;
+    total: number;
+    results?: Array<unknown>;
+}
+/** Response of POST /v1/policies/{id}/deploy. HTTP 200 when deployed; HTTP 412 with deployed=false when failing tests or blocking conflicts prevent it (returned as a result, not an error). */
+interface PolicyDeployResult {
+    deployed: boolean;
+    deploymentId?: string;
+    versionId?: string;
+    tests?: PolicyTestRun;
+    conflicts?: Array<unknown>;
+}
+/** A deploy/rollback record. */
+interface PolicyDeployment {
+    id: string;
+    policyId?: string;
+    action?: string;
+    fromVersionId?: string | null;
+    toVersionId?: string | null;
+    testsPassed?: boolean | null;
+    testReport?: Record<string, unknown>;
+    simulation?: Record<string, unknown>;
+    comment?: string;
+    actorId?: string | null;
+    createdAt?: string;
+}
+/** Response of GET /v1/policies/{id}/deployments. */
+interface PolicyDeploymentList {
+    data: Array<PolicyDeployment>;
+}
+/** A stored policy test case. */
+interface PolicyTest {
+    id: string;
+    policyId?: string;
+    name: string;
+    request?: Record<string, unknown>;
+    expect: Decision;
+    createdBy?: string | null;
+    createdAt?: string;
+}
+/** An immutable policy version. */
+interface PolicyVersion {
+    id: string;
+    policyId?: string;
+    version: number;
+    source?: string;
+    ast?: Record<string, unknown>;
+    checksum?: string;
+    message?: string;
+    diagnostics?: Array<unknown>;
+    authorId?: string | null;
+    createdAt?: string;
+}
+/** Response of GET /v1/policies/{id}: the policy with its versions, latest version and tests. */
+interface PolicyDetail {
+    id: string;
+    name: string;
+    description?: string;
+    status: string;
+    scopeType?: string;
+    scopeId?: string;
+    projectId?: string | null;
+    environmentId?: string | null;
+    latestVersion?: number;
+    activeVersion?: number | null;
+    activeVersionId?: string | null;
+    tags?: Array<string>;
+    createdAt?: string;
+    updatedAt?: string;
+    templateId?: string | null;
+    versions?: Array<PolicyVersion>;
+    latest?: PolicyVersion | null;
+    tests?: Array<PolicyTest>;
+}
+/** A policy whose clauses changed. */
+interface PolicyDiffChange {
+    name: string;
+    fields?: Array<unknown>;
+}
+/** Response of GET /v1/policies/{id}/diff. */
+interface PolicyDiff {
+    from?: number;
+    to?: number;
+    added?: Array<string>;
+    removed?: Array<string>;
+    changed?: Array<PolicyDiffChange>;
+    unified?: string;
+}
+/** Response of GET /v1/policies. */
+interface PolicyList {
+    data: Array<Policy>;
+}
+/**  */
+interface PolicyOverride {
+    policyId: string;
+    versionId?: string;
+    source?: string;
+}
+/** Response of POST /v1/policies/{id}/rollback. */
+interface PolicyRollbackResult {
+    rolledBack: boolean;
+    versionId: string;
+    previousVersionId?: string | null;
+}
+/**  */
+interface PolicyTestEnvironment {
+    slug: string;
+    tier: string;
+}
+/**  */
+interface PolicyTestPrincipal {
+    type: string;
+    id: string;
+    refs?: Array<string>;
+    attributes?: Record<string, unknown>;
+}
+/**  */
+interface PolicyTestRisk {
+    score: number;
+    level: string;
+}
+/**  */
+interface RelationshipTuple {
+    subject: string;
+    relation: string;
+    object: string;
+}
+/**  */
+interface PolicySimulationCase {
+    principal: PolicyTestPrincipal;
+    action: string;
+    resource: string;
+    resourceAttributes?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+    environment?: PolicyTestEnvironment;
+    risk?: PolicyTestRisk | null;
+    delegation?: Record<string, unknown> | null;
+    now?: string;
+    relationships?: Array<RelationshipTuple>;
+    limitUsage?: Record<string, unknown>;
+    expect?: Decision;
+    label?: string;
+}
+/** Input to POST /v1/policies/simulate (deployed vs candidate policies). (api: POST /v1/policies/simulate) */
+interface PolicySimulateRequest {
+    environmentId: string;
+    /** Default: []. */
+    overrides?: Array<PolicyOverride>;
+    requests: Array<PolicySimulationCase>;
+}
+/** Decision under one policy set. */
+interface PolicySimulationOutcome {
+    decision: Decision;
+    reason?: string;
+    trace?: Array<unknown>;
+    approvals?: Array<unknown>;
+}
+/** One request of a policy simulation. */
+interface PolicySimulationResult {
+    index?: number;
+    label?: string;
+    baseline: PolicySimulationOutcome;
+    candidate: PolicySimulationOutcome;
+    changed?: boolean;
+    expected?: string | null;
+    matchesExpectation?: boolean | null;
+}
+/** Totals of a policy simulation. */
+interface PolicySimulationSummary {
+    total: number;
+    changed?: number;
+    mismatches?: number;
+    byDecision?: Record<string, unknown>;
+}
+/** Response of POST /v1/policies/simulate. */
+interface PolicySimulation {
+    environment?: EnvironmentRef;
+    summary: PolicySimulationSummary;
+    results: Array<PolicySimulationResult>;
+}
+/**  */
+interface PolicyTestRequest {
+    principal: PolicyTestPrincipal;
+    action: string;
+    resource: string;
+    resourceAttributes?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+    environment?: PolicyTestEnvironment;
+    risk?: PolicyTestRisk | null;
+    delegation?: Record<string, unknown> | null;
+    now?: string;
+    relationships?: Array<RelationshipTuple>;
+    limitUsage?: Record<string, unknown>;
+}
+/** A policy test case (POST /v1/policies/{id}/tests, PUT /v1/policies/{id}/tests). (api: POST /v1/policies/{id}/tests) */
+interface PolicyTestCase {
+    name: string;
+    request: PolicyTestRequest;
+    expect: Decision;
+}
+/** Response of PUT /v1/policies/{id}/tests. */
+interface PolicyTestList {
+    data: Array<PolicyTest>;
+}
+/** Response of POST /v1/policies/validate. */
+interface PolicyValidation {
+    ok: boolean;
+    diagnostics?: Array<unknown>;
+    conflicts?: Array<unknown>;
+    formatted?: string | null;
+}
+/** Response of POST /v1/policies and PUT /v1/policies/{id}: the saved version. */
+interface PolicyVersionResult {
+    id: string;
+    versionId: string;
+    version: number;
+    status?: string;
+    source?: string;
+    diagnostics?: Array<unknown>;
+}
+/** The rotated-out credential and when it stops working. */
+interface PreviousCredential {
+    id: string;
+    graceUntil?: string;
+}
+/** RFC 9457 problem details returned for every error. */
+interface Problem {
+    type: string;
+    /** Machine-readable error code (e.g. policy_denied). */
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    details?: Record<string, unknown>;
+    requestId?: string;
+    traceId?: string;
+}
+/** Input to POST /v1/agents. (api: POST /v1/agents) */
+interface RegisterAgentRequest {
+    environmentId: string;
+    name: string;
+    /** Default: "". */
+    description?: string;
+    ownerUserId?: string;
+    ownerTeamId?: string;
+    applicationId?: string;
+    framework?: string;
+    model?: string;
+    /** Default: "standard". */
+    riskTier?: RiskTier;
+    /** Default: []. */
+    tags?: Array<string>;
+    /** Default: {}. */
+    metadata?: Record<string, unknown>;
+    credential?: CreateCredentialRequest;
+}
+/** Response of POST /v1/agents: the agent plus its initial credential (null unless requested). */
+interface RegisteredAgent {
+    id: string;
+    name: string;
+    description?: string;
+    status: AgentStatus;
+    statusReason?: string | null;
+    projectId?: string;
+    environmentId?: string;
+    applicationId?: string | null;
+    ownerUserId?: string | null;
+    ownerTeamId?: string | null;
+    ownerEmail?: string | null;
+    framework?: string | null;
+    model?: string | null;
+    riskTier?: string;
+    tags?: Array<string>;
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+    updatedAt?: string;
+    lastSeenAt?: string | null;
+    credentials?: Array<AgentCredential>;
+    credential?: IssuedCredential | null;
+}
+/** Input to PUT /v1/policies/{id}/tests (replaces the whole suite atomically). (api: PUT /v1/policies/{id}/tests) */
+interface ReplacePolicyTestsRequest {
+    tests: Array<PolicyTestCase>;
+}
+/** Query parameters for GET /v1/replay/{principalId}. (api: GET /v1/replay/{principalId}) */
+interface ReplayParams {
+    from?: string;
+    to?: string;
+    /** Default: 200. */
+    limit?: number;
+}
+/** Input to POST /v1/traces/spans (1-500 agent-side spans). (gateway: POST /v1/traces/spans) */
+interface ReportSpansRequest {
+    spans: Array<AgentSpan>;
+}
+/** Response of POST /v1/traces/spans (spans outside +/-24h of now are rejected). */
+interface ReportSpansResult {
+    accepted: number;
+    rejected: number;
+}
+/** Input to POST /v1/secrets/{id}/revoke (one version, or the whole secret). (api: POST /v1/secrets/{id}/revoke) */
+interface RevokeSecretRequest {
+    version?: number;
+    reason?: string;
+}
+/** Response of POST /v1/secrets/{id}/revoke. */
+interface RevokeSecretResult {
+    revoked: boolean;
+}
+/** Input to POST /v1/policies/{id}/rollback (default: the previously deployed version). (api: POST /v1/policies/{id}/rollback) */
+interface RollbackPolicyRequest {
+    versionId?: string;
+    comment?: string;
+}
+/** Input to POST /v1/credentials/{id}/rotate. (api: POST /v1/credentials/{id}/rotate) */
+interface RotateCredentialRequest {
+    /** Default: 60. */
+    gracePeriodMinutes?: number;
+    publicJwk?: Record<string, unknown>;
+}
+/**  */
+interface SecretGenerateOptions {
+    length?: number;
+}
+/** Input to POST /v1/secrets/{id}/rotate (a new value, or generate one). (api: POST /v1/secrets/{id}/rotate) */
+interface RotateSecretRequest {
+    value?: Record<string, unknown>;
+    generate?: SecretGenerateOptions;
+}
+/** Response of POST /v1/credentials/{id}/rotate. */
+interface RotatedCredential {
+    credential: AgentCredential;
+    clientId: string;
+    clientSecret?: string | null;
+    previous: PreviousCredential;
+}
+/** Response of POST /v1/secrets/{id}/rotate. */
+interface RotatedSecret {
+    id: string;
+    version: number;
+    mask?: string;
+}
+/**  */
+interface ScenarioContent {
+    source: string;
+    text: string;
+    origin?: string;
+}
+/**  */
+interface ScenarioExecution {
+    connectionId: string;
+    action: string;
+    /** Default: {}. */
+    input?: Record<string, unknown>;
+}
+/**  */
+interface ScenarioHistory {
+    velocity1m?: number;
+    velocity5m?: number;
+    recentDenials?: number;
+    openAlerts?: number;
+}
+/** Delegation context of a synthetic principal. */
+interface SyntheticDelegation {
+    depth: number;
+    chain: Array<string>;
+    originatingUserId?: string;
+    scopes?: Array<string>;
+}
+/** A principal that does not exist (simulation only). */
+interface SyntheticPrincipal {
+    /** agent (default), user or service_account. */
+    type?: string;
+    id?: string;
+    tags?: Array<string>;
+    /** low, standard (default), high or critical. */
+    riskTier?: string;
+    ownerUserId?: string;
+    ownerTeamId?: string;
+    orgRole?: string;
+    metadata?: Record<string, unknown>;
+    delegation?: SyntheticDelegation;
+}
+/** Who the scenario runs as: exactly one of agentId (a real agent) or synthetic. */
+interface ScenarioPrincipal {
+    agentId?: string;
+    synthetic?: SyntheticPrincipal;
+}
+/**  */
+interface ScenarioRequest {
+    action: string;
+    resource: string;
+    /** Default: {}. */
+    resourceAttributes?: Record<string, unknown>;
+    /** Default: {}. */
+    context?: Record<string, unknown>;
+    outboundData?: unknown;
+}
+/**  */
+interface ScenarioTaint {
+    score: number;
+    source: string;
+    origin?: string;
+}
+/** Secret version metadata (never ciphertext or value). */
+interface SecretVersionInfo {
+    id: string;
+    version: number;
+    status?: string;
+    kmsKeyId?: string;
+    expiresAt?: string | null;
+    createdBy?: string | null;
+    createdAt?: string;
+    revokedAt?: string | null;
+}
+/** Secret metadata (GET /v1/secrets, GET/PATCH /v1/secrets/{id}). The value is never returned. */
+interface Secret {
+    id: string;
+    projectId?: string | null;
+    environmentId?: string | null;
+    name: string;
+    type: SecretType;
+    description?: string;
+    metadata?: Record<string, unknown>;
+    accessPolicy?: Record<string, unknown>;
+    mask?: string;
+    status?: string;
+    currentVersion?: number;
+    expiresAt?: string | null;
+    rotationPolicy?: Record<string, unknown>;
+    lastRotatedAt?: string | null;
+    lastUsedAt?: string | null;
+    useCount?: number;
+    createdBy?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+    versions?: Array<SecretVersionInfo>;
+}
+/** Response of GET /v1/secrets. */
+interface SecretList {
+    data: Array<Secret>;
+}
+/** Response of GET /v1/replay/{principalId}: everything a principal did in a window. */
+interface SessionReplay {
+    principalId: string;
+    from?: string;
+    to?: string;
+    steps?: Array<unknown>;
+    traces?: Array<string>;
+}
+/** Response of POST /v1/auth/refresh (refresh tokens rotate: store the new one). */
+interface SessionTokens {
+    accessToken: string;
+    tokenType?: string;
+    /** Access token lifetime in seconds. */
+    expiresIn: number;
+    refreshToken?: string;
+    refreshExpiresAt?: string;
+    familyId?: string;
+}
+/**  */
+interface SimulationExpectation {
+    decision?: Decision;
+    decisionIn?: Array<Decision>;
+    riskLevel?: RiskLevel;
+    minRiskScore?: number;
+    maxRiskScore?: number;
+    minApprovers?: number;
+    dlp?: DlpAction;
+    injectionAtLeast?: InjectionLevel;
+    injectionAtMost?: InjectionLevel;
+    reasonIncludes?: string;
+}
+/** A scenario that failed in the previous run and passes now. */
+interface SimulationFixed {
+    key: string;
+    label?: string;
+}
+/** A scenario that passed in the previous run and fails now. */
+interface SimulationRegression {
+    key: string;
+    label?: string;
+    previous?: string | null;
+    now?: string | null;
+}
+/**  */
+interface SimulationScenario {
+    key?: string;
+    label: string;
+    category?: string;
+    description?: string;
+    principal: ScenarioPrincipal;
+    request?: ScenarioRequest;
+    execution?: ScenarioExecution;
+    content?: ScenarioContent;
+    history?: ScenarioHistory;
+    taint?: ScenarioTaint;
+    expect?: SimulationExpectation;
+}
+/** Outcome of one scenario. */
+interface SimulationResult {
+    index?: number;
+    key?: string;
+    label?: string;
+    category?: string | null;
+    scenario?: SimulationScenario;
+    /** Decision, risk, approval plan, DLP/injection outcome (or error). */
+    actual?: Record<string, unknown>;
+    expected?: SimulationExpectation | null;
+    passed?: boolean | null;
+    failures?: Array<string>;
+}
+/** Totals of a simulation run. */
+interface SimulationSummary {
+    total: number;
+    withExpectations?: number;
+    passed?: number;
+    failed?: number;
+    errors?: number;
+    byDecision?: Record<string, unknown>;
+    changedFromBaseline?: number;
+    byCategory?: Array<unknown>;
+    regressions?: number;
+    fixed?: number;
+    previousRunId?: string | null;
+}
+/** Response of POST /v1/simulations/run (also the body of its HTTP 422 with failOnMismatch). */
+interface SimulationRun {
+    /** Null when persist=false. */
+    id?: string | null;
+    name?: string;
+    status: SimulationStatus;
+    environment?: EnvironmentRef;
+    summary: SimulationSummary;
+    regressions?: Array<SimulationRegression>;
+    fixed?: Array<SimulationFixed>;
+    results: Array<SimulationResult>;
+    durationMs?: number;
+}
+/** Input to POST /v1/simulations/run. With failOnMismatch, a failed/errored run is returned with HTTP 422. (api: POST /v1/simulations/run) */
+interface SimulationRunRequest {
+    environmentId: string;
+    name?: string;
+    /** Default: []. */
+    scenarios?: Array<SimulationScenario>;
+    scenarioSetId?: string;
+    /** Default: []. */
+    libraryIds?: Array<string>;
+    /** Default: []. */
+    policyOverrides?: Array<PolicyOverride>;
+    riskOverride?: Record<string, unknown>;
+    /** Default: true. */
+    liveHistory?: boolean;
+    /** Default: "api". */
+    trigger?: string;
+    /** Default: true. */
+    persist?: boolean;
+    /** Default: false. */
+    failOnMismatch?: boolean;
+}
+/** OAuth 2.0 token endpoint response (POST {api}/v1/auth/token). */
+interface TokenResponse {
+    access_token: string;
+    token_type: string;
+    /** Lifetime in seconds. */
+    expires_in: number;
+    scope?: string;
+    refresh_token?: string;
+    issued_token_type?: string;
+}
+/** A stored span (platform or agent-reported). */
+interface TraceSpan {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string | null;
+    name: string;
+    kind?: SpanKind;
+    service?: string;
+    /** platform or agent. */
+    source?: string;
+    principalType?: string | null;
+    principalId?: string | null;
+    startTime?: string;
+    durationMs?: number;
+    status?: SpanStatus;
+    statusMessage?: string | null;
+    attributes?: Record<string, unknown>;
+    events?: Array<unknown>;
+}
+/** Response of GET /v1/traces/{traceId}: span tree, correlated records, timeline and breakdown. */
+interface Trace {
+    traceId: string;
+    startedAt?: string | null;
+    durationMs?: number | null;
+    spans: Array<TraceSpan>;
+    breakdown?: Record<string, unknown>;
+    timeline?: Array<unknown>;
+    records?: Record<string, unknown>;
+}
+/** Query parameters for GET /v1/traces. (api: GET /v1/traces) */
+interface TraceSearchParams {
+    from?: string;
+    to?: string;
+    principalId?: string;
+    name?: string;
+    service?: string;
+    status?: string;
+    minDurationMs?: number;
+    attribute?: string;
+    /** Default: 50. */
+    limit?: number;
+}
+/** One trace in GET /v1/traces. */
+interface TraceSummary {
+    traceId: string;
+    startedAt?: string;
+    durationMs?: number;
+    spanCount?: number;
+    errorCount?: number;
+    rootName?: string | null;
+    principalId?: string | null;
+    services?: Array<string>;
+}
+/** Response of GET /v1/traces. */
+interface TraceSearchResult {
+    data: Array<TraceSummary>;
+}
+/** Input to PATCH /v1/agents/{id}. (api: PATCH /v1/agents/{id}) */
+interface UpdateAgentRequest {
+    name?: string;
+    description?: string;
+    ownerUserId?: string | null;
+    ownerTeamId?: string | null;
+    framework?: string;
+    model?: string;
+    riskTier?: RiskTier;
+    tags?: Array<string>;
+    metadata?: Record<string, unknown>;
+}
+/** Input to PATCH /v1/alerts/{id}. (api: PATCH /v1/alerts/{id}) */
+interface UpdateAlertRequest {
+    status?: AlertStatus;
+    assigneeId?: string | null;
+    resolution?: string;
+    note?: string;
+}
+/** Input to PATCH /v1/connections/{id}. (api: PATCH /v1/connections/{id}) */
+interface UpdateConnectionRequest {
+    description?: string;
+    config?: Record<string, unknown>;
+    allowedHosts?: Array<string>;
+    secretId?: string | null;
+    status?: string;
+    timeoutMs?: number;
+    maxRetries?: number;
+    signRequests?: boolean;
+    connectorVersion?: string;
+}
+/** Input to PUT /v1/policies/{id}: saves a new version (exactly one of source or ast). (api: PUT /v1/policies/{id}) */
+interface UpdatePolicyRequest {
+    source?: string;
+    ast?: Record<string, unknown>;
+    /** Default: "". */
+    message?: string;
+    description?: string;
+}
+/** Input to PATCH /v1/secrets/{id} (metadata only). (api: PATCH /v1/secrets/{id}) */
+interface UpdateSecretRequest {
+    description?: string;
+    metadata?: Record<string, unknown>;
+    accessPolicy?: SecretAccessPolicy;
+    expiresAt?: string | null;
+    /** Default: {"strategy":"manual"}. */
+    rotationPolicy?: SecretRotationPolicy;
+    status?: string;
+}
+/** Input to POST /v1/audit/verify (default: the whole chain). (api: POST /v1/audit/verify) */
+interface VerifyAuditRequest {
+    fromSeq?: number;
+    toSeq?: number;
+    maxEvents?: number;
+}
+
+/** Minimal fetch signature (global fetch, undici, node-fetch, or a test double). */
+type FetchLike = (input: string, init: {
+    method: string;
+    headers: Record<string, string>;
+    body?: string;
+    signal?: AbortSignal;
+}) => Promise<Response>;
+/** Everything a token provider needs from the client (conformance §2). */
+interface AuthContext {
+    /** `{apiUrl}/v1/auth/token`. */
+    readonly tokenUrl: string;
+    readonly clock: Clock;
+    /**
+     * POSTs a grant to the token endpoint (with retries). `buildBody` is invoked once per attempt so
+     * private_key_jwt assertions get a fresh `jti` on every retry.
+     */
+    requestToken(buildBody: () => Promise<Record<string, unknown>>, opts: {
+        idempotent: boolean;
+        signal?: AbortSignal;
+    }): Promise<TokenResponse>;
+}
+/** Supplies the Bearer token for API calls. */
+interface TokenProvider {
+    /** Whether tokens can be re-obtained. If true, a 401 invalidates the cache and the request is replayed once. */
+    readonly refreshable: boolean;
+    getToken(ctx: AuthContext, signal?: AbortSignal): Promise<string>;
+    invalidate(): void;
+}
+/** Retry configuration (conformance §3). */
+interface RetryOptions {
+    /** Retries after the first attempt. Default 3. */
+    maxRetries: number;
+    /** Base backoff delay. Default 500 ms. */
+    baseDelayMs: number;
+    /** Backoff cap. Default 8 s. */
+    maxDelayMs: number;
+    /** Longest server-requested `Retry-After` the SDK will wait for. Default 60 s. */
+    maxRetryAfterMs: number;
+}
+/** Per-call options accepted by every client method. */
+interface RequestOptions {
+    /** Cancels the call, including in-flight requests and backoff sleeps. */
+    signal?: AbortSignal;
+    /** W3C traceparent of the caller's span; its trace id is propagated. */
+    traceparent?: string;
+    /** Overrides the per-attempt timeout for this call. */
+    timeoutMs?: number;
+    /** Overrides maxRetries for this call. */
+    maxRetries?: number;
+    /** Extra headers for this call. */
+    headers?: Record<string, string>;
+    /**
+     * Sent as the `Idempotency-Key` header on every attempt; the call is then retried like an idempotent
+     * request (conformance §3.4). Set it only when repeating the request is safe.
+     */
+    idempotencyKey?: string;
+}
+/** Parses a `Retry-After` header (delta-seconds or HTTP-date) into milliseconds. */
+declare function parseRetryAfter(value: string | null, now: number): number | null;
+/** Equal-jitter exponential backoff: uniform in [d/2, d] with d = min(maxDelay, base·2ⁿ). */
+declare function backoffDelay(attempt: number, o: Pick<RetryOptions, 'baseDelayMs' | 'maxDelayMs'>, random: () => number): number;
+
+/**
+ * No credentials (conformance §2): for `login()` / `refreshSession()` before a token exists. Every other
+ * call fails with `ConfigurationError` before sending a request.
+ */
+declare function unauthenticated(): TokenProvider;
+/** API key (`gsk_…`), sent directly as the Bearer token. */
+declare function apiKey(key: string): TokenProvider;
+/** A pre-obtained access token (not refreshed). */
+declare function staticToken(token: string): TokenProvider;
+/** A cached access token. */
+interface CachedToken {
+    accessToken: string;
+    /** Epoch ms after which the token must not be used (expiry minus skew). */
+    refreshAt: number;
+    scope: string | undefined;
+}
+/**
+ * Base class for providers that obtain tokens from the token endpoint. Tokens are cached and refreshed
+ * `min(60 s, expires_in / 2)` before expiry; concurrent callers share one in-flight request.
+ */
+declare abstract class OAuthTokenProvider implements TokenProvider {
+    readonly refreshable = true;
+    private cached;
+    private inflight;
+    private generation;
+    /** Builds the grant body. Called once per token request attempt. */
+    protected abstract grant(ctx: AuthContext, signal?: AbortSignal): Promise<Record<string, unknown>>;
+    /** Whether the grant may be retried on 5xx/network errors. */
+    protected readonly idempotentGrant: boolean;
+    getToken(ctx: AuthContext, signal?: AbortSignal): Promise<string>;
+    invalidate(): void;
+    private fetchToken;
+}
+interface ClientSecretOptions {
+    /** The `gsa_…` client secret. */
+    clientSecret: string;
+    /** Optional credential or principal id (checked by the server when present). */
+    clientId?: string;
+    /** Space-separated scopes to request (narrowed to the credential's scopes). */
+    scope?: string;
+}
+/** OAuth 2.0 client credentials with a client secret (`gsa_…`). */
+declare function clientSecret(options: ClientSecretOptions): TokenProvider;
+type JwtAlgorithm = 'EdDSA' | 'ES256' | 'RS256';
+/** Custom signer (e.g. a KMS/HSM): signs the JWS signing input and returns the raw JOSE signature. */
+type AssertionSigner = (signingInput: Uint8Array) => Promise<Uint8Array>;
+interface PrivateKeyJwtOptions {
+    /** The agent credential id (`cred_…`): the assertion `iss`, `sub` and `kid`. */
+    credentialId: string;
+    /** PKCS#8 PEM string, private JWK, WebCrypto CryptoKey, or omitted when `signer` is given. */
+    privateKey?: string | JsonWebKey | CryptoKey;
+    /** Required with `signer` or a CryptoKey whose algorithm cannot be inferred. */
+    algorithm?: JwtAlgorithm;
+    /** Custom signer instead of `privateKey`. */
+    signer?: AssertionSigner;
+    /** Assertion audience; defaults to the token URL. Must equal the server's `{PUBLIC_API_URL}/v1/auth/token`. */
+    audience?: string;
+    /** Assertion lifetime in seconds (default 60, max 300). */
+    lifetimeSeconds?: number;
+    /** Space-separated scopes to request. */
+    scope?: string;
+}
+/** Infers the JWS algorithm of a private key. */
+declare function inferAlgorithm(key: string | JsonWebKey): JwtAlgorithm;
+/** Imports a PKCS#8 PEM or private JWK as a WebCrypto signing key. */
+declare function importSigningKey(key: string | JsonWebKey, alg: JwtAlgorithm): Promise<CryptoKey>;
+/** Creates a signed client assertion JWT (RFC 7523). Exposed for custom integrations and tests. */
+declare function createClientAssertion(args: {
+    credentialId: string;
+    audience: string;
+    algorithm: JwtAlgorithm;
+    sign: AssertionSigner;
+    nowMs: number;
+    lifetimeSeconds?: number;
+}): Promise<string>;
+/** OAuth 2.0 client credentials with `private_key_jwt` (Ed25519 / ES256 / RS256). */
+declare function privateKeyJwt(options: PrivateKeyJwtOptions): TokenProvider;
+interface DelegationOptions {
+    /** The delegation token (`gsd_…`) issued by `createDelegation` to this (delegate) agent. */
+    subjectToken: string;
+    /** The delegate agent's own credentials; its access token is sent as `actor_token`. */
+    actor: TokenProvider;
+    /** Subset of the delegated scopes to request. */
+    scope?: string;
+}
+/** Exchanges a delegation token for an access token acting on behalf of the delegator. */
+declare function delegation(options: DelegationOptions): TokenProvider;
+
+interface GebSecureOptions {
+    /** Data-plane gateway base URL. Default `GEBSECURE_GATEWAY_URL` or `https://gateway.gebsecure.dev`. */
+    gatewayUrl?: string;
+    /** Control-plane API base URL. Default `GEBSECURE_API_URL` or `https://api.gebsecure.dev`. */
+    apiUrl?: string;
+    /** Token endpoint. Default `{apiUrl}/v1/auth/token`. */
+    tokenUrl?: string;
+    /** Token provider (`apiKey()`, `clientSecret()`, `privateKeyJwt()`, `delegation()`, `staticToken()`). */
+    auth?: TokenProvider;
+    /** Shorthand for `auth: apiKey(key)`. Defaults to `GEBSECURE_API_KEY`. */
+    apiKey?: string;
+    /** Retries after the first attempt (default 3). 0 disables retries and automatic idempotency keys. */
+    maxRetries?: number;
+    /** Per-attempt timeout in ms (default 30 000). */
+    timeoutMs?: number;
+    /** Backoff base delay in ms (default 500). */
+    baseDelayMs?: number;
+    /** Backoff cap in ms (default 8 000). */
+    maxDelayMs?: number;
+    /** Longest Retry-After (ms) the SDK will wait for (default 60 000). */
+    maxRetryAfterMs?: number;
+    /** Custom fetch implementation. Default: global fetch. */
+    fetch?: FetchLike;
+    /** Custom clock (tests). */
+    clock?: Clock;
+    /** Random source for jitter (tests). */
+    random?: () => number;
+    /** User-Agent header (Node only; browsers ignore it). */
+    userAgent?: string;
+    /** Headers added to every request. */
+    headers?: Record<string, string>;
+}
+interface WaitOptions extends RequestOptions {
+    /** Give up after this many ms (default 10 minutes). */
+    timeoutMs?: number;
+    /** Poll interval in ms (default 2 000). */
+    pollIntervalMs?: number;
+}
+/** Result of `guard()`: whether the action may proceed right now, and the full decision. */
+interface GuardResult {
+    allowed: boolean;
+    decision: AuthorizeResult;
+}
+/**
+ * GebSecure client. Data-plane calls go to the gateway, control-plane calls and token requests to
+ * the API. All methods accept `RequestOptions` (AbortSignal, traceparent, timeout, retries).
+ *
+ * ```ts
+ * const gs = new GebSecure({ auth: privateKeyJwt({ credentialId, privateKey }) });
+ * const { allowed, decision } = await gs.guard('refunds:create', 'stripe:charge/ch_1', { amount: 250 });
+ * ```
+ */
+declare class GebSecure {
+    readonly gatewayUrl: string;
+    readonly apiUrl: string;
+    private readonly core;
+    private readonly auth;
+    private readonly clock;
+    private readonly maxRetries;
+    private readonly options;
+    constructor(options?: GebSecureOptions);
+    /** A client with the same configuration acting under a delegation token (RFC 8693 exchange). */
+    withDelegation(subjectToken: string, opts?: {
+        scope?: string;
+    }): GebSecure;
+    /** Returns a valid access token (cached/refreshed), e.g. to call GebSecure APIs not wrapped by the SDK. */
+    getAccessToken(opts?: RequestOptions): Promise<string>;
+    private call;
+    /** Calls an operation that returns no body (204); resolves to `undefined`. */
+    private callVoid;
+    /** Unauthenticated session endpoints (login/refresh): no Authorization header. */
+    private callAnonymous;
+    /** Decides whether the principal may perform an action. DENY / APPROVAL_REQUIRED are results, not errors. */
+    authorize(request: AuthorizeRequest, opts?: RequestOptions): Promise<AuthorizeResult>;
+    /** Evaluates up to 100 requests in one call. */
+    authorizeBatch(request: AuthorizeBatchRequest, opts?: RequestOptions): Promise<AuthorizeBatchResult>;
+    /** Convenience around `authorize`: `allowed` is true only for ALLOW. Never throws on DENY. */
+    guard(action: string, resource: string, context?: Record<string, unknown>, opts?: RequestOptions & Partial<AuthorizeRequest>): Promise<GuardResult>;
+    /**
+     * Authorizes and executes a connector action. Returns an `ExecuteResult` for succeeded, simulated,
+     * awaiting_approval, running, denied (HTTP 403) and failed (HTTP 502/504) outcomes; problem+json errors throw.
+     * With retries enabled, an idempotency key is generated when none is given.
+     */
+    execute(request: ExecuteRequest, opts?: RequestOptions): Promise<ExecuteResult>;
+    /** Execution status, result and step logs. */
+    getExecution(id: string, opts?: RequestOptions): Promise<Execution>;
+    /** Lists executions visible to the caller. */
+    listExecutions(params?: ListExecutionsParams, opts?: RequestOptions): Promise<ExecutionPage>;
+    /** Cancels a pending, awaiting-approval or running execution. */
+    cancelExecution(id: string, opts?: RequestOptions): Promise<CancelExecutionResult>;
+    /** Status of an approval request (agent-facing, via the gateway). */
+    getApproval(id: string, opts?: RequestOptions): Promise<Approval>;
+    /** Polls an approval until it leaves `pending`; returns it in its terminal state. */
+    waitForApproval(id: string, opts?: WaitOptions): Promise<Approval>;
+    /**
+     * Executes; if human approval is required, waits for it and then follows the execution until it is
+     * terminal. Once the approval is granted the platform resumes the stored execution itself (and consumes
+     * the single-use approval), so this helper never re-executes (conformance §5).
+     * Throws `ApprovalNotGrantedError` when the approval is rejected/expired/cancelled,
+     * `ApprovalTimeoutError` when it stays pending past `timeoutMs`, and `TimeoutError` when the approved
+     * execution has not finished by then. A resumed execution that fails is returned with `status: 'failed'`.
+     */
+    executeWithApproval(request: ExecuteRequest, opts?: WaitOptions): Promise<ExecuteResult>;
+    /** Agent directory. */
+    listAgents(params?: ListAgentsParams, opts?: RequestOptions): Promise<AgentPage>;
+    /** One agent, including credential metadata. */
+    getAgent(id: string, opts?: RequestOptions): Promise<Agent>;
+    /** Policies. */
+    listPolicies(params?: ListPoliciesParams, opts?: RequestOptions): Promise<PolicyList>;
+    /** Approval requests (`inbox: true` = those the caller can act on). */
+    listApprovals(params?: ListApprovalsParams, opts?: RequestOptions): Promise<ApprovalPage>;
+    /** Delegates a subset of authority to another agent. The returned `token` (gsd_…) is shown once. */
+    createDelegation(request: CreateDelegationRequest, opts?: RequestOptions): Promise<Delegation>;
+    /**
+     * Inspects untrusted content (web page, email, RAG chunk, tool output) before the agent reads it:
+     * prompt-injection score/level/action, a sanitized form, and inbound DLP. Hand `result.content`
+     * (null when blocked) to the model instead of the original.
+     */
+    inspect(request: InspectRequest, opts?: RequestOptions): Promise<InspectResult>;
+    /** Scans a payload for sensitive data and applies DLP rules. Retried like a read only when `dryRun` is true. */
+    dlpScan(request: DlpScanRequest, opts?: RequestOptions): Promise<DlpScanResult>;
+    /** Reports agent-side spans (see `buildSpan`) into the shared trace. Safe to retry: duplicates are ignored. */
+    reportSpans(spans: AgentSpan[] | ReportSpansRequest, opts?: RequestOptions): Promise<ReportSpansResult>;
+    /**
+     * Runs simulation scenarios (nothing is executed). With `failOnMismatch: true`, a failed or errored run
+     * throws `SimulationFailedError` whose `run` is the full typed result.
+     */
+    runSimulation(request: SimulationRunRequest, opts?: RequestOptions): Promise<SimulationRun>;
+    /** Logs a user in (works on an `unauthenticated()` client). The refresh token is returned in the body. */
+    login(request: LoginRequest, opts?: RequestOptions): Promise<LoginResult>;
+    /** Exchanges a refresh token for new tokens. The refresh token rotates: persist the returned one. Never retried (except 429). */
+    refreshSession(refreshToken: string, opts?: RequestOptions): Promise<SessionTokens>;
+    /** Revokes the current user session. */
+    logout(opts?: RequestOptions): Promise<void>;
+    /** The authenticated principal, its organizations and effective permissions. */
+    me(opts?: RequestOptions): Promise<Me>;
+    /** A policy with its versions, latest version and tests. */
+    getPolicy(id: string, opts?: RequestOptions): Promise<PolicyDetail>;
+    /** Creates a policy (draft version 1) from GSL source or a template. */
+    createPolicy(request: CreatePolicyRequest, opts?: RequestOptions): Promise<PolicyVersionResult>;
+    /** Saves a new version. Not retried on 5xx/network errors: every call appends a version. */
+    updatePolicy(id: string, request: UpdatePolicyRequest, opts?: RequestOptions): Promise<PolicyVersionResult>;
+    /** Archives a policy (stops enforcing it). */
+    deletePolicy(id: string, opts?: RequestOptions): Promise<void>;
+    /** Validates, lints and formats GSL source. */
+    validatePolicy(source: string, opts?: RequestOptions): Promise<PolicyValidation>;
+    /** One immutable policy version. */
+    getPolicyVersion(id: string, versionId: string, opts?: RequestOptions): Promise<PolicyVersion>;
+    /** Semantic and unified diff between two versions. */
+    diffPolicyVersions(id: string, from: string, to: string, opts?: RequestOptions): Promise<PolicyDiff>;
+    /** Deploy and rollback history. */
+    listPolicyDeployments(id: string, opts?: RequestOptions): Promise<PolicyDeploymentList>;
+    /**
+     * Deploys a version (default: latest). When tests fail or blocking conflicts exist the server answers
+     * 412 with the deploy report; it is returned as a result with `deployed: false`.
+     */
+    deployPolicy(id: string, request?: DeployPolicyRequest, opts?: RequestOptions): Promise<PolicyDeployResult>;
+    /** Rolls back to a version (default: the previously deployed one). */
+    rollbackPolicy(id: string, request?: RollbackPolicyRequest, opts?: RequestOptions): Promise<PolicyRollbackResult>;
+    /** Adds one test case. */
+    addPolicyTest(id: string, test: PolicyTestCase, opts?: RequestOptions): Promise<PolicyTest>;
+    /** Replaces the whole test suite atomically (policy-as-code sync). */
+    replacePolicyTests(id: string, tests: PolicyTestCase[], opts?: RequestOptions): Promise<PolicyTestList>;
+    /** Deletes one test case. */
+    deletePolicyTest(id: string, testId: string, opts?: RequestOptions): Promise<void>;
+    /** Runs the policy's tests against a version (default: latest). */
+    runPolicyTests(id: string, versionId?: string, opts?: RequestOptions): Promise<PolicyTestRun>;
+    /** Evaluates requests against deployed vs candidate policies. */
+    simulatePolicies(request: PolicySimulateRequest, opts?: RequestOptions): Promise<PolicySimulation>;
+    /** Registers an agent; with `credential`, its client secret is returned once in `credential.clientSecret`. */
+    createAgent(request: RegisterAgentRequest, opts?: RequestOptions): Promise<RegisteredAgent>;
+    /** Updates agent metadata. */
+    updateAgent(id: string, request: UpdateAgentRequest, opts?: RequestOptions): Promise<Agent>;
+    /** Activates, suspends, disables or quarantines an agent. */
+    setAgentStatus(id: string, request: AgentStatusRequest, opts?: RequestOptions): Promise<Agent>;
+    /** Deletes an agent. */
+    deleteAgent(id: string, opts?: RequestOptions): Promise<void>;
+    /** Credential metadata of an agent (never secrets). */
+    listAgentCredentials(id: string, opts?: RequestOptions): Promise<AgentCredentialList>;
+    /** Issues an agent credential; the client secret is returned once. */
+    createAgentCredential(id: string, request?: CreateCredentialRequest, opts?: RequestOptions): Promise<IssuedCredential>;
+    /** Rotates a credential; the previous one keeps working until `previous.graceUntil`. */
+    rotateCredential(credentialId: string, request?: RotateCredentialRequest, opts?: RequestOptions): Promise<RotatedCredential>;
+    /** Revokes a credential immediately (idempotent). */
+    revokeCredential(credentialId: string, reason?: string, opts?: RequestOptions): Promise<AgentCredential>;
+    /** Stores a secret. The value is never returned by the API and never logged by the SDK. */
+    createSecret(request: CreateSecretRequest, opts?: RequestOptions): Promise<CreatedSecret>;
+    /** Secret metadata and masks. */
+    listSecrets(params?: ListSecretsParams, opts?: RequestOptions): Promise<SecretList>;
+    /** One secret's metadata and version history (never the value). */
+    getSecret(id: string, opts?: RequestOptions): Promise<Secret>;
+    /** Updates secret metadata, access policy, expiry, rotation policy or status. */
+    updateSecret(id: string, request: UpdateSecretRequest, opts?: RequestOptions): Promise<Secret>;
+    /** Writes a new version (a value, or `generate`). */
+    rotateSecret(id: string, request: RotateSecretRequest, opts?: RequestOptions): Promise<RotatedSecret>;
+    /** Revokes one version or the whole secret. */
+    revokeSecret(id: string, request?: RevokeSecretRequest, opts?: RequestOptions): Promise<RevokeSecretResult>;
+    /** Deletes a secret. */
+    deleteSecret(id: string, opts?: RequestOptions): Promise<void>;
+    /** The connector catalog (actions, schemas, risk metadata, auth methods). */
+    listConnectors(opts?: RequestOptions): Promise<ConnectorList>;
+    /** One connector of the catalog. */
+    getConnector(key: string, opts?: RequestOptions): Promise<Connector>;
+    /** Installed connections. */
+    listConnections(params?: ListConnectionsParams, opts?: RequestOptions): Promise<ConnectionList>;
+    /** One connection with its connector description and effective allowed hosts. */
+    getConnection(id: string, opts?: RequestOptions): Promise<Connection>;
+    /** Installs a connector into a project. */
+    createConnection(request: CreateConnectionRequest, opts?: RequestOptions): Promise<Connection>;
+    /** Updates a connection. */
+    updateConnection(id: string, request: UpdateConnectionRequest, opts?: RequestOptions): Promise<Connection>;
+    /** Deletes a connection. */
+    deleteConnection(id: string, opts?: RequestOptions): Promise<void>;
+    /** Runs the connection health check. */
+    checkConnectionHealth(id: string, opts?: RequestOptions): Promise<ConnectionHealth>;
+    /** Begins an OAuth installation (authorization code + PKCE); redirect the user to `authorizationUrl`. */
+    startConnectionOAuth(id: string, request: OAuthStartRequest, opts?: RequestOptions): Promise<OAuthStartResult>;
+    /** Completes an OAuth installation with the `state` and `code` from the redirect. */
+    completeConnectionOAuth(request: OAuthCallbackRequest, opts?: RequestOptions): Promise<OAuthInstallResult>;
+    /** Installs with the OAuth client-credentials grant (machine-to-machine). */
+    installClientCredentials(id: string, request: ClientCredentialsInstallRequest, opts?: RequestOptions): Promise<OAuthInstallResult>;
+    /** Installs with the RFC 7523 JWT-bearer grant (e.g. a Google service account). */
+    installJwtBearer(id: string, request: JwtBearerInstallRequest, opts?: RequestOptions): Promise<OAuthInstallResult>;
+    /** Searches audit events (newest first); with `afterSeq`, tails the events after that sequence number (oldest first). */
+    searchAudit(params?: AuditSearchParams, opts?: RequestOptions): Promise<AuditPage>;
+    /** One audit event. */
+    getAuditEvent(id: string, opts?: RequestOptions): Promise<AuditEvent>;
+    /** Exports audit events; resolves to the raw body (ndjson by default, csv or json). */
+    exportAudit(params?: AuditExportParams, opts?: RequestOptions): Promise<string>;
+    /** Verifies the integrity of the audit hash chain. */
+    verifyAudit(request?: VerifyAuditRequest, opts?: RequestOptions): Promise<AuditVerification>;
+    /** Full approval record (control plane): steps, decisions, comments, history and `canDecide`. */
+    getApprovalDetails(id: string, opts?: RequestOptions): Promise<Approval>;
+    /** Approves or rejects; `snapshotHash` must be the hash of the request snapshot the reviewer saw. */
+    decideApproval(id: string, request: DecideApprovalRequest, opts?: RequestOptions): Promise<ApprovalDecisionResult>;
+    /** Security alerts. */
+    listAlerts(params?: ListAlertsParams, opts?: RequestOptions): Promise<AlertPage>;
+    /** One alert with its investigation context. */
+    getAlert(id: string, opts?: RequestOptions): Promise<Alert>;
+    /** Acknowledges, assigns, annotates, resolves or dismisses an alert. */
+    updateAlert(id: string, request: UpdateAlertRequest, opts?: RequestOptions): Promise<Alert>;
+    /** Searches traces. */
+    searchTraces(params?: TraceSearchParams, opts?: RequestOptions): Promise<TraceSearchResult>;
+    /** One trace: platform and agent spans, correlated records, timeline and performance breakdown. */
+    getTrace(traceId: string, opts?: RequestOptions): Promise<Trace>;
+    /** Everything a principal (agent or user) did in a window, step by step. */
+    replaySession(principalId: string, params?: ReplayParams, opts?: RequestOptions): Promise<SessionReplay>;
+}
+
+/** Options of {@link buildSpan} (conformance §5.1). */
+interface BuildSpanOptions {
+    /** W3C traceparent of the enclosing span: its trace id is used and its span id becomes the parent. */
+    traceparent?: string;
+    /** Explicit parent span id (16 lowercase hex); wins over the traceparent's span id. */
+    parentSpanId?: string;
+    /** Span id to use (16 lowercase hex). Default: random. */
+    spanId?: string;
+    kind?: SpanKind;
+    status?: SpanStatus;
+    statusMessage?: string;
+    attributes?: Record<string, string | number | boolean | null>;
+    events?: SpanEvent[];
+}
+/**
+ * Builds an agent-side span (LLM call, planning step, tool selection) for {@link GebSecure.reportSpans}.
+ * With the `traceparent` of the current trace, the span joins the platform's spans for that trace.
+ *
+ * ```ts
+ * const start = Date.now();
+ * const answer = await llm.complete(prompt);
+ * await gs.reportSpans([buildSpan('llm.complete', start, Date.now(), { traceparent, attributes: { model: 'x' } })]);
+ * ```
+ */
+declare function buildSpan(name: string, start: number | Date, end: number | Date, options?: BuildSpanOptions): AgentSpan;
+/** The W3C traceparent that makes subsequent calls children of `span`. */
+declare function traceparentOf(span: Pick<AgentSpan, 'traceId' | 'spanId'>): string;
+
+/** Fields shared by every GebSecure SDK error (see sdks/conformance/README.md §4). */
+interface ErrorInit {
+    status?: number;
+    code: string;
+    detail?: string;
+    requestId?: string | null;
+    traceId?: string | null;
+    details?: Record<string, unknown> | null;
+    type?: string | null;
+    cause?: unknown;
+}
+/** Base class of every error raised by the SDK. */
+declare class GebSecureError extends Error {
+    /** HTTP status, or 0 for client-side errors (network, timeouts, approval waits). */
+    readonly status: number;
+    /** Machine-readable error code, e.g. `policy_denied`, `rate_limited`, `connection_error`. */
+    readonly code: string;
+    /** Human-readable detail from the server (or the SDK). */
+    readonly detail: string;
+    /** Server request id (`x-request-id`), when known. */
+    readonly requestId: string | null;
+    /** W3C trace id of the request, when known. */
+    readonly traceId: string | null;
+    /** Structured problem details (e.g. validation issues), when provided. */
+    readonly details: Record<string, unknown> | null;
+    /** Problem type URI, when provided. */
+    readonly type: string | null;
+    constructor(init: ErrorInit);
+}
+/** An error returned by the GebSecure API (RFC 9457 problem+json). Unknown codes use this class. */
+declare class ApiError extends GebSecureError {
+}
+/** 401 `unauthenticated`: missing, invalid, expired or revoked credentials. */
+declare class AuthenticationError extends ApiError {
+}
+/** 403 `forbidden`: the principal lacks a permission or scope. */
+declare class PermissionDeniedError extends ApiError {
+}
+/** 403 `policy_denied`: a policy denied the action. */
+declare class PolicyDeniedError extends ApiError {
+}
+/** 403 `approval_required`: the action requires human approval. */
+declare class ApprovalRequiredError extends ApiError {
+}
+/** 400 `bad_request` / 422 `validation_failed`. */
+declare class ValidationError extends ApiError {
+}
+/** 404 `not_found`. */
+declare class NotFoundError extends ApiError {
+}
+/** 409 `conflict` / 412 `precondition_failed`. */
+declare class ConflictError extends ApiError {
+}
+/** 502 `upstream_error`. */
+declare class UpstreamError extends ApiError {
+}
+/** 504 `timeout`, or a client-side per-attempt timeout (status 0). */
+declare class TimeoutError extends ApiError {
+}
+/** 503 `unavailable`. */
+declare class UnavailableError extends ApiError {
+}
+/** 500 `internal` and unknown 5xx. */
+declare class InternalError extends ApiError {
+}
+/** 429 `rate_limited` / `quota_exceeded`. */
+declare class RateLimitError extends ApiError {
+    /** Server-requested wait before retrying, in milliseconds (from `Retry-After`), if any. */
+    readonly retryAfterMs: number | null;
+    constructor(init: ErrorInit & {
+        retryAfterMs?: number | null;
+    });
+}
+/** The request could not be delivered (DNS, connection refused/reset, TLS). */
+declare class ConnectionError extends GebSecureError {
+    constructor(detail: string, cause?: unknown);
+}
+/** `waitForApproval` deadline passed while the approval was still pending. */
+declare class ApprovalTimeoutError extends GebSecureError {
+    readonly approvalId: string;
+    constructor(approvalId: string, timeoutMs: number);
+}
+/** `executeWithApproval`: the approval ended rejected, expired or cancelled (not `approved`/`consumed`). */
+declare class ApprovalNotGrantedError extends GebSecureError {
+    readonly approval: Approval;
+    constructor(approval: Approval);
+}
+/**
+ * `runSimulation({ failOnMismatch: true })`: the run failed or errored and the server answered 422 with
+ * the full run, available as `run` (conformance §4).
+ */
+declare class SimulationFailedError extends ApiError {
+    readonly run: SimulationRun;
+    constructor(run: SimulationRun, meta?: {
+        requestId?: string | null;
+        traceId?: string | null;
+    });
+}
+/** Invalid SDK configuration (e.g. an unsupported key or an assertion lifetime above 300 s). */
+declare class ConfigurationError extends GebSecureError {
+    constructor(detail: string);
+}
+/** Default error code for an HTTP status (conformance §4). */
+declare function codeForStatus(status: number): string;
+/** Builds the typed error for a non-2xx response. */
+declare function errorFromResponse(args: {
+    status: number;
+    body: unknown;
+    text: string;
+    requestId: string | null;
+    traceId: string | null;
+    retryAfterMs: number | null;
+}): ApiError;
+
+/** SDK version (kept in sync with package.json by the release workflow check). */
+declare const VERSION = "0.2.1";
+
+export { type Agent, type AgentCredential, type AgentCredentialList, type AgentPage, type AgentSpan, AgentStatus, type AgentStatusRequest, type Alert, type AlertPage, AlertStatus, ApiError, type Approval, type ApprovalDecisionResult, ApprovalNotGrantedError, type ApprovalPage, type ApprovalRef, ApprovalRequiredError, type ApprovalRequirement, ApprovalStatus, ApprovalTimeoutError, ApprovalVerdict, type AssertionSigner, type AuditChainError, type AuditEvent, type AuditExportParams, type AuditPage, type AuditSearchParams, type AuditVerification, type AuthContext, type AuthUser, AuthenticationError, type AuthorizeBatchEntry, type AuthorizeBatchRequest, type AuthorizeBatchResult, type AuthorizeRequest, type AuthorizeResult, type BatchError, type BuildSpanOptions, type CachedToken, type CancelExecutionResult, type ClientCredentialsInstallRequest, type ClientSecretOptions, type Clock, ConfigurationError, ConflictError, type Connection, type ConnectionCredential, ConnectionError, type ConnectionHealth, type ConnectionList, type Connector, type ConnectorAction, type ConnectorList, type ContentProvenance, ContentSource, type CreateConnectionRequest, type CreateCredentialRequest, type CreateDelegationRequest, type CreatePolicyRequest, type CreateSecretRequest, type CreatedSecret, type DecideApprovalRequest, Decision, type Delegation, type DelegationConstraints, type DelegationOptions, DelegationScope, type DeployPolicyRequest, DlpAction, DlpDirection, type DlpFinding, type DlpMatchedRule, type DlpScanRequest, type DlpScanResult, type EnvironmentRef, type ErrorInit, ExecuteMode, type ExecuteRequest, type ExecuteResult, type Execution, type ExecutionError, type ExecutionLog, type ExecutionPage, ExecutionStatus, type Explanation, type FetchLike, GebSecure, GebSecureError, type GebSecureOptions, type GuardResult, type InjectionFinding, InjectionLevel, type InjectionModelResult, type InjectionReport, type InspectDlpReport, type InspectRequest, type InspectResult, InternalError, type IssuedCredential, type JwtAlgorithm, type JwtBearerInstallRequest, type LimitState, type ListAgentsParams, type ListAlertsParams, type ListApprovalsParams, type ListConnectionsParams, type ListExecutionsParams, type ListPoliciesParams, type ListSecretsParams, type LoginRequest, type LoginResult, type Me, type MePrincipal, NotFoundError, type OAuthCallbackRequest, type OAuthInstallResult, type OAuthStartRequest, type OAuthStartResult, OAuthTokenProvider, type OnBehalfOf, type OrgMembership, PermissionDeniedError, type Policy, PolicyDeniedError, type PolicyDeployResult, type PolicyDeployment, type PolicyDeploymentList, type PolicyDetail, type PolicyDiff, type PolicyDiffChange, type PolicyList, type PolicyOverride, type PolicyRollbackResult, type PolicyScope, type PolicySimulateRequest, type PolicySimulation, type PolicySimulationCase, type PolicySimulationOutcome, type PolicySimulationResult, type PolicySimulationSummary, type PolicyTest, type PolicyTestCase, type PolicyTestEnvironment, type PolicyTestList, type PolicyTestPrincipal, type PolicyTestRequest, type PolicyTestRisk, type PolicyTestRun, type PolicyValidation, type PolicyVersion, type PolicyVersionResult, type PreviousCredential, type PrincipalRef, type PrivateKeyJwtOptions, type Problem, RateLimitError, type RegisterAgentRequest, type RegisteredAgent, type RelationshipTuple, type ReplacePolicyTestsRequest, type ReplayParams, type ReportSpansRequest, type ReportSpansResult, type RequestOptions, type RetryOptions, type RevokeSecretRequest, type RevokeSecretResult, type Risk, RiskLevel, RiskRecommendation, type RiskSignal, type RiskThresholds, RiskTier, type RollbackPolicyRequest, type RotateCredentialRequest, type RotateSecretRequest, type RotatedCredential, type RotatedSecret, type ScenarioContent, type ScenarioExecution, type ScenarioHistory, type ScenarioPrincipal, type ScenarioRequest, type ScenarioTaint, type Secret, type SecretAccessPolicy, type SecretGenerateOptions, type SecretList, type SecretRotationPolicy, SecretType, type SecretVersionInfo, type SessionReplay, type SessionTokens, type SimulationExpectation, SimulationFailedError, type SimulationFixed, type SimulationRegression, type SimulationResult, type SimulationRun, type SimulationRunRequest, type SimulationScenario, SimulationStatus, type SimulationSummary, type SpanEvent, SpanKind, SpanStatus, type SyntheticDelegation, type SyntheticPrincipal, TimeoutError, type TokenProvider, type TokenResponse, type Trace, type TraceEntry, type TraceSearchParams, type TraceSearchResult, type TraceSpan, type TraceSummary, UnavailableError, type UpdateAgentRequest, type UpdateAlertRequest, type UpdateConnectionRequest, type UpdatePolicyRequest, type UpdateSecretRequest, UpstreamError, VERSION, ValidationError, type VerifyAuditRequest, type WaitOptions, apiKey, backoffDelay, buildSpan, clientSecret, codeForStatus, createClientAssertion, delegation, errorFromResponse, importSigningKey, inferAlgorithm, parseRetryAfter, privateKeyJwt, staticToken, systemClock, traceparentOf, unauthenticated };