@openagentid/arsenal-sdk API

export declare const VERSION: "0.1.0";

export declare const isClientError: (code: number) => boolean;

export declare const isServerError: (code: number) => boolean;

export declare const isProxyError: (code: number) => boolean;

export declare const isConsentError: (code: number) => boolean;

export declare const isFingerprintError: (code: number) => boolean;

export declare const isPermanentError: (code: number) => boolean;

export declare const sanitizeResourceId: (id: string) => string;

export declare const sanitizeScope: (scope: string) => string;

export declare const sanitizeFieldName: (field: string) => string;

export declare const ErrorCode: { readonly AuthenticationFailed: 1001; readonly TokenExpired: 1002; readonly TokenSignatureInvalid: 1003; readonly PopVerificationFailed: 1004; readonly IdentityInvalid: 1005; readonly SessionExpired: 1006; readonly InsufficientPermissions: 2001; readonly ScopeExceeded: 2002; readonly PolicyDenied: 2003; readonly DelegationInvalid: 2004; readonly RateLimitExceeded: 2005; readonly BudgetExhausted: 2006; readonly TimeConstraintViolation: 3001; readonly EnvironmentBindingViolation: 3002; readonly NetworkConstraintViolation: 3003; readonly DeviceBindingViolation: 3004; readonly OriginBindingViolation: 3005; readonly SecretNotFound: 4001; readonly SecretVersionNotFound: 4002; readonly SecretRevoked: 4003; readonly SecretRotationInProgress: 4004; readonly SecretUnwrapLimitExceeded: 4005; readonly CryptoOperationFailed: 4006; readonly ValidationFailed: 5001; readonly MalformedRequest: 5002; readonly InvalidTokenFormat: 5003; readonly InvalidScopeFormat: 5004; readonly InvalidConstraint: 5005; readonly InternalError: 6001; readonly StorageError: 6002; readonly ConfigurationError: 6003; readonly CryptoSubsystemError: 6004; readonly AuditError: 6005; readonly SerializationFailed: 6006; readonly TokenRevoked: 7001; readonly AgentDeactivated: 7002; readonly TenantSuspended: 7003; readonly RevocationStatusUnknown: 7004; readonly ProxyDestinationViolation: 8001; readonly ProxyRequestFailed: 8002; readonly ProxyTimeout: 8003; readonly SsrfBlocked: 8004; readonly TemplateVariableNotFound: 8005; readonly TemplateVariableAccessDenied: 8006; readonly InvalidTemplateVariable: 8007; readonly OAuthReauthRequired: 8008; readonly ConsentRequired: 9001; readonly ConsentDenied: 9002; readonly ConsentExpired: 9003; readonly ConsentRevoked: 9004; readonly FingerprintMismatch: 10001; readonly FingerprintStateNotFound: 10002; readonly DctScopeAmplification: 11001; readonly DctDepthExceeded: 11002; };

export type ErrorCodeValue = (typeof ErrorCode)[keyof typeof ErrorCode];

/**
 * Additional structured context attached to an ArsenalError. All fields are
 * sanitized — never include raw secrets or internal paths.
 */
export interface ErrorContext {
    operation?: string;
    resource?: string;
    constraint?: string;
    timestamp?: string; // ISO 8601
}

export declare class ArsenalError {
  name: "ArsenalError";
  code: number;
  correlationId: string | undefined;
  context: ErrorContext | undefined;
  constructor(code: number, message: string, options?: { correlationId?: string; context?: ErrorContext; cause?: unknown; }): ArsenalError;
  toString(): string;
  toJSON(): { code: number; message: string; correlation_id?: string; context?: ErrorContext; };
  withCorrelationId(id: string): ArsenalError;
  withContext(context: ErrorContext): ArsenalError;
  authenticationFailed(): ArsenalError;
  tokenExpired(): ArsenalError;
  tokenSignatureInvalid(): ArsenalError;
  tokenRevoked(): ArsenalError;
  scopeExceeded(): ArsenalError;
  insufficientPermissions(requiredScope: string): ArsenalError;
  policyDenied(policyId: string): ArsenalError;
  rateLimitExceeded(retryAfterSecs?: number): ArsenalError;
  secretNotFound(): ArsenalError;
  validationFailed(field: string, reason: string): ArsenalError;
  internal(): ArsenalError;
  sessionExpired(): ArsenalError;
  proxyDestinationViolation(domain: string): ArsenalError;
  ssrfBlocked(): ArsenalError;
  templateVariableNotFound(variable: string): ArsenalError;
  invalidTemplateVariable(name: string): ArsenalError;
  consentRequired(): ArsenalError;
  consentDenied(): ArsenalError;
  fingerprintMismatch(): ArsenalError;
  configurationError(component: string): ArsenalError;
  cryptoOperationFailed(): ArsenalError;
}

export declare class TenantId {
  parse(id: string): TenantId;
  generate(): TenantId;
  asString(): string;
  toString(): string;
  toJSON(): string;
  equals(other: TenantId): boolean;
}

export declare class PrincipalId {
  parse(id: string): PrincipalId;
  generate(): PrincipalId;
  system(): PrincipalId;
  isSystem(): boolean;
  asString(): string;
  toString(): string;
  toJSON(): string;
}

export declare class AgentId {
  fromUuid(uuid: string): AgentId;
  generate(): AgentId;
  asUuid(): string;
  toString(): string;
  toJSON(): string;
  equals(other: AgentId): boolean;
}

export declare class DeviceId {
  parse(id: string): DeviceId;
  asString(): string;
  toString(): string;
  toJSON(): string;
}

export declare class KeyFingerprint {
  fromBytes(bytes: Uint8Array): KeyFingerprint;
  fromPublicKey(publicKey: Uint8Array): Promise<KeyFingerprint>;
  fromHex(hex: string): KeyFingerprint;
  asBytes(): Uint8Array;
  toHex(): string;
  toString(): string;
  constantTimeEquals(other: KeyFingerprint): boolean;
  toJSON(): string;
}

/**
 * Agent identity — the public cryptographic identity of an agent.
 *
 * Contains only public key material — the private key is never stored.
 */
export interface AgentIdentityData {
    id: AgentId;
    publicKeyFingerprint: KeyFingerprint;
    tenantId: TenantId;
    name: string;
    createdAt: string; // ISO 8601
    expiresAt: string | null;
    isActive: boolean;
    tags: readonly string[];
}

export declare class AgentIdentity {
  create(tenantId: TenantId, name: string, publicKeyFingerprint: KeyFingerprint): AgentIdentity;
  id(): AgentId;
  publicKeyFingerprint(): KeyFingerprint;
  tenantId(): TenantId;
  name(): string;
  isActive(): boolean;
  tags(): readonly string[];
  isValid(now?: Date): boolean;
  deactivate(): AgentIdentity;
  withExpiresAt(expiresAt: Date): AgentIdentity;
  withTag(tag: string): AgentIdentity;
  toJSON(): { id: string; public_key_fingerprint: string; tenant_id: string; name: string; created_at: string; expires_at: string | null; is_active: boolean; tags: readonly string[]; };
}

export declare const permissionImplies: (a: PermissionValue, b: PermissionValue) => boolean;

export declare const parsePermission: (s: string) => PermissionValue;

export declare class Scope {
  parse(scope: string): Scope;
  wildcard(): Scope;
  readOnly(service: string): Scope;
  fullAccess(service: string): Scope;
  service(): string;
  resource(): string;
  action(): string;
  isWildcard(): boolean;
  implies(other: Scope): boolean;
  asString(): string;
  toString(): string;
  toJSON(): string;
  equals(other: Scope): boolean;
}

export declare class ScopeSet {
  empty(): ScopeSet;
  single(scope: Scope): ScopeSet;
  fromStrings(scopes: readonly string[]): ScopeSet;
  fromScopes(scopes: readonly Scope[]): ScopeSet;
  add(scope: Scope): ScopeSet;
  remove(scope: Scope): ScopeSet;
  contains(scope: Scope): boolean;
  allows(requested: Scope): boolean;
  isSupersetOf(other: ScopeSet): boolean;
  intersection(other: ScopeSet): ScopeSet;
  union(other: ScopeSet): ScopeSet;
  length(): number;
  isEmpty(): boolean;
  toArray(): readonly Scope[];
  toStrings(): readonly string[];
  [Symbol.iterator](): Iterator<Scope>;
  toJSON(): readonly string[];
}

export declare const Permission: { readonly Read: "read"; readonly Create: "create"; readonly Update: "update"; readonly Delete: "delete"; readonly Admin: "admin"; };

export type PermissionValue = (typeof Permission)[keyof typeof Permission];

export declare const noConstraints: () => Constraints;

export declare const withPop: () => Constraints;

export declare const withDevice: (base: Constraints, deviceId: string) => Constraints;

export declare const withOrigins: (base: Constraints, origins: readonly string[]) => Constraints;

export declare const withTimeWindow: (base: Constraints, notBefore: Date, notAfter: Date) => Constraints;

export declare const contextNow: () => ConstraintContext;

export declare const validateConstraints: (constraints: Constraints, ctx: ConstraintContext) => void;

export declare const ipInCidrRange: (ip: string, cidr: string) => boolean;

export declare const BindingType: { readonly Required: "required"; readonly Preferred: "preferred"; };

export type BindingTypeValue = (typeof BindingType)[keyof typeof BindingType];

export interface DeviceBinding {
    device_id: string;
    binding_type: BindingTypeValue;
}

export interface SessionBinding {
    session_id: string;
    session_key_hash?: Uint8Array; // 32 bytes when set
}

export interface OriginBinding {
    allowed_origins: ReadonlySet<string>;
}

export interface NetworkConstraints {
    allowed_ips?: ReadonlySet<string>;
    denied_ips?: ReadonlySet<string>;
    allowed_cidrs?: readonly string[];
    allowed_asns?: ReadonlySet<number>;
}

export interface TimeConstraints {
    not_before?: string; // ISO 8601
    not_after?: string; // ISO 8601
    allowed_hours?: readonly number[];
    allowed_days?: readonly number[];
}

export interface EnvironmentConstraint {
    required_environment?: string;
    required_tags?: ReadonlySet<string>;
    forbidden_tags?: ReadonlySet<string>;
}

export interface Constraints {
    device_binding?: DeviceBinding;
    session_binding?: SessionBinding;
    origin_binding?: OriginBinding;
    network_constraints?: NetworkConstraints;
    time_constraints?: TimeConstraints;
    environment_constraints?: EnvironmentConstraint;
    require_pop: boolean;
}

export interface ConstraintContext {
    current_time: Date;
    device_id?: string;
    session_id?: string;
    session_key_hash?: Uint8Array;
    origin?: string;
    client_ip?: string;
    environment?: string;
    tags: ReadonlySet<string>;
}

export declare const defaultRateLimits: () => RateLimits;

export declare const unlimitedRateLimits: () => RateLimits;

export declare const strictRateLimits: () => RateLimits;

export declare const mergeRateLimits: (a: RateLimits, b: RateLimits) => RateLimits;

export declare const defaultUsageBudget: () => UsageBudget;

export declare const unlimitedUsageBudget: () => UsageBudget;

export declare const minimalUsageBudget: () => UsageBudget;

export declare const mergeUsageBudget: (a: UsageBudget, b: UsageBudget) => UsageBudget;

export interface RateLimits {
    requests_per_second?: number;
    requests_per_minute?: number;
    requests_per_hour?: number;
    max_concurrent?: number;
    max_request_size?: number;
    max_response_size?: number;
}

export interface UsageBudget {
    max_requests?: number;
    max_bytes?: number;
    max_cost_units?: number;
    max_secret_unwraps?: number;
    max_delegation_depth?: number;
}

/** Current usage snapshot. */
export interface UsageStats {
    request_count: number;
    bytes_transferred: number;
    cost_units: number;
    secret_unwraps: number;
    elapsed_ms: number;
}

/** Remaining budget (undefined entries are unlimited). */
export interface RemainingBudget {
    requests?: number;
    bytes?: number;
    cost_units?: number;
    secret_unwraps?: number;
}

export declare class UsageTracker {
  constructor(budget: UsageBudget): UsageTracker;
  recordRequest(): void;
  recordBytes(bytes: number): void;
  recordCost(units: number): void;
  recordSecretUnwrap(): void;
  getStats(): UsageStats;
  remaining(): RemainingBudget;
}

export declare class TokenBucketLimiter {
  constructor(maxTokens: number, refillAmount: number, refillIntervalMs: number): TokenBucketLimiter;
  perSecond(rate: number): TokenBucketLimiter;
  perMinute(rate: number): TokenBucketLimiter;
  perHour(rate: number): TokenBucketLimiter;
  tryAcquire(): void;
  available(): number;
}

export declare class CompositeRateLimiter {
  constructor(limits: RateLimits): CompositeRateLimiter;
  acquire(): () => void;
}

export declare const createSecretMetadata: (tenantId: string, name: string, secretType: SecretTypeValue) => SecretMetadata;

export declare const latestSecretRef: (id: string) => SecretRef;

export declare const specificSecretRef: (id: string, version: number) => SecretRef;

export declare class SecretId {
  generate(): SecretId;
  fromString(id: string): SecretId;
  asString(): string;
  toString(): string;
  toJSON(): string;
}

export declare class SecretVersion {
  initial(): SecretVersion;
  fromNumber(n: number): SecretVersion;
  asNumber(): number;
  next(): SecretVersion;
  isInitial(): boolean;
  toString(): string;
  toJSON(): number;
}

export declare const SecretType: { readonly ApiKey: "api_key"; readonly OAuthClientCredentials: "o_auth_client_credentials"; readonly OAuthAccessToken: "o_auth_access_token"; readonly OAuthRefreshToken: "o_auth_refresh_token"; readonly DatabaseCredentials: "database_credentials"; readonly SshKey: "ssh_key"; readonly TlsCertificate: "tls_certificate"; readonly SigningKey: "signing_key"; readonly EncryptionKey: "encryption_key"; readonly Generic: "generic"; };

export type SecretTypeValue = (typeof SecretType)[keyof typeof SecretType];

export declare const SecretVersionState: { readonly Active: "active"; readonly Previous: "previous"; readonly Disabled: "disabled"; readonly PendingDeletion: "pending_deletion"; };

export type SecretVersionStateValue = (typeof SecretVersionState)[keyof typeof SecretVersionState];

export interface SecretVersionInfo {
    version: number;
    created_at: string;
    created_by?: string;
    state: SecretVersionStateValue;
}

export interface SecretMetadata {
    id: string;
    tenant_id: string;
    name: string;
    description?: string;
    secret_type: SecretTypeValue;
    current_version: number;
    versions: readonly SecretVersionInfo[];
    created_at: string;
    updated_at: string;
    expires_at?: string;
    last_rotated_at?: string;
    next_rotation_at?: string;
    is_active: boolean;
    labels: Readonly<Record<string, string>>;
    service?: string;
}

/** Reference to a secret — used when the value shouldn't be inlined. */
export interface SecretRef {
    id: string;
    version?: number;
}

export declare class SecretValue {
  fromBytes(bytes: Uint8Array): SecretValue;
  fromString(s: string): SecretValue;
  asBytes(): Uint8Array;
  asString(): string;
  length(): number;
  isEmpty(): boolean;
  zeroize(): void;
}

export declare const buildTokenClaims: (opts: TokenClaimsBuildOptions) => TokenClaims;

export declare const SignatureAlgorithm: { readonly Ed25519: "ED25519"; readonly Es256: "ES256"; readonly Es384: "ES384"; };

export type SignatureAlgorithmValue = (typeof SignatureAlgorithm)[keyof typeof SignatureAlgorithm];

export interface TokenSignature {
    bytes: Uint8Array;
    algorithm: SignatureAlgorithmValue;
    key_id?: string;
}

export interface ProofOfPossession {
    /** Hex-encoded BLAKE3 public key fingerprint. */
    key_fingerprint: string;
    /** Algorithm label, e.g. "Ed25519". */
    alg: string;
}

export interface TokenTrace {
    issuance_id: string;
    parent_token_id?: string;
    policy_id?: string;
    delegation_depth: number;
}

export interface TokenClaims {
    jti: string; // Token ID (UUID v7)
    sub: string; // Subject (agent ID UUID)
    iss: string; // Issuer
    aud: string; // Audience
    iat: string; // Issued-at ISO timestamp
    nbf: string; // Not-before ISO timestamp
    exp: string; // Expiration ISO timestamp
    tenant_id: string;
    scope: readonly string[];
    constraints?: Constraints;
    limits?: RateLimits;
    budget?: UsageBudget;
    trace?: TokenTrace;
    cnf?: ProofOfPossession;
    delegated_variables?: readonly string[];
    max_delegation_depth?: number;
}

/** Options for building a fresh set of claims. */
export interface TokenClaimsBuildOptions {
    subject: string;
    issuer: string;
    audience: string;
    tenant_id: string;
    scopes: ScopeSet;
    ttl_seconds?: number;
    constraints?: Constraints;
    limits?: RateLimits;
    budget?: UsageBudget;
    parent_token_id?: string;
    cnf?: ProofOfPossession;
    delegated_variables?: readonly string[];
    max_delegation_depth?: number;
}

export declare class AgentCapabilityToken {
  fromClaims(claims: TokenClaims): AgentCapabilityToken;
  fromClaimsAndSignature(claims: TokenClaims, signature: TokenSignature): AgentCapabilityToken;
  id(): string;
  subject(): string;
  audience(): string;
  scopes(): ScopeSet;
  isExpired(now?: Date): boolean;
  isNotYetValid(now?: Date): boolean;
  isTimeValid(now?: Date): boolean;
  remainingTtlMs(now?: Date): number;
  isSigned(): boolean;
  validateStructure(now?: Date): void;
  toCbor(): Uint8Array;
  claimsToCbor(): Uint8Array;
  toBase64Url(): string;
  fromCbor(bytes: Uint8Array): AgentCapabilityToken;
  fromBase64Url(s: string): AgentCapabilityToken;
}

export declare const consentStatusAllowsOperation: (status: ConsentStatusValue) => boolean;

export declare const consentRecordIsValid: (record: ConsentRecord, now?: Date) => boolean;

export declare const consentRecordCoversVariable: (record: ConsentRecord, variable: string) => boolean;

export declare const consentRecordCoversDomain: (record: ConsentRecord, domain: string) => boolean;

export declare const revokeConsentRecord: (record: ConsentRecord, at?: Date) => ConsentRecord;

export declare const consentRecordSigningBytes: (record: ConsentRecord) => Uint8Array;

export declare const createConsentRequest: (opts: { agent_did: string; human_root_did: string; variables: readonly string[]; destination_domains: readonly string[]; scopes: readonly string[]; ttl_seconds?: number; }) => ConsentRequest;

export declare const consentRequestIsExpired: (req: ConsentRequest, now?: Date) => boolean;

export declare const ConsentStatus: { readonly PreApproved: "pre_approved"; readonly Approved: "approved"; readonly Pending: "pending"; readonly Denied: "denied"; readonly Revoked: "revoked"; readonly NotRequired: "not_required"; };

export type ConsentStatusValue = (typeof ConsentStatus)[keyof typeof ConsentStatus];

export declare const ConsentPolicy: { readonly PerVariable: "per_variable"; readonly PerProvider: "per_provider"; readonly PerAgent: "per_agent"; };

export type ConsentPolicyValue = (typeof ConsentPolicy)[keyof typeof ConsentPolicy];

export interface ConsentRecord {
    consent_id: string;
    tenant_id: string;
    agent_did: string;
    human_root_did: string;
    variables: readonly string[];
    destination_domains: readonly string[];
    scopes: readonly string[];
    granted_by: string;
    granted_at: string;
    expires_at: string;
    /** Ed25519 signature bytes over the signing payload. */
    signature: Uint8Array;
    revocable: boolean;
    revoked: boolean;
    revoked_at?: string;
}

export interface ConsentRequest {
    request_id: string;
    agent_did: string;
    human_root_did: string;
    variables: readonly string[];
    destination_domains: readonly string[];
    scopes: readonly string[];
    created_at: string;
    expires_at: string;
}

export declare const createDestinationBinding: (allowedDomains: readonly string[], opts?: Partial<Omit<DestinationBinding, "allowed_domains">>) => DestinationBinding;

export declare const validateDestinationBinding: (binding: DestinationBinding) => void;

export declare const isDomainAllowed: (binding: DestinationBinding, domain: string) => boolean;

export declare const isMethodAllowed: (binding: DestinationBinding, method: string) => boolean;

export declare const isPortAllowed: (binding: DestinationBinding, port: number) => boolean;

export declare const isPathAllowed: (binding: DestinationBinding, path: string) => boolean;

export declare const createTemplateVariable: (name: string) => TemplateVariable;

export declare const validateVariableName: (name: string) => void;

export declare const inferVariablePrefix: (name: string) => VariablePrefixValue;

export declare const parseTemplateVariables: (input: string) => readonly TemplateVariable[];

export declare const validateProxyRequest: (req: ProxyRequest) => void;

export declare const effectiveTimeoutMs: (req: ProxyRequest) => number;

export declare const extractProxyRequestVariables: (req: ProxyRequest) => readonly TemplateVariable[];

export declare const VariablePrefix: { readonly OAuth2: "OAUTH2"; readonly OAuth1: "OAUTH1"; readonly ApiKey: "API_KEY"; readonly Basic: "BASIC"; readonly Bearer: "BEARER"; readonly Cert: "CERT"; readonly Custom: "CUSTOM"; };

export type VariablePrefixValue = (typeof VariablePrefix)[keyof typeof VariablePrefix];

/** Destination binding restricting which endpoints a credential can reach. */
export interface DestinationBinding {
    allowed_domains: readonly string[];
    allowed_paths?: readonly string[];
    allowed_methods?: readonly string[];
    allowed_ports?: readonly number[];
    require_tls: boolean;
    allow_subdomains: boolean;
}

/** Parsed template variable reference. */
export interface TemplateVariable {
    name: string;
    prefix: VariablePrefixValue;
}

/** Proxy request envelope sent to the broker. */
export interface ProxyRequest {
    method: string;
    url: string;
    headers?: Readonly<Record<string, string>>;
    body?: Uint8Array;
    capability_token: string;
    timeout_ms?: number;
}

/** Response from a proxy request. */
export interface ProxyResponse {
    status: number;
    headers: Readonly<Record<string, string>>;
    body: Uint8Array;
    proxy_metadata: ProxyMetadata;
}

/** Metadata about proxy processing (never includes resolved values). */
export interface ProxyMetadata {
    variables_resolved: readonly string[];
    destination_verified: boolean;
    fingerprint_verified: boolean;
    consent_status: ConsentStatusValue;
    latency_ms: number;
    request_id: string;
}

export declare class VariableResolutionTable {
  register(variableName: string, secretRef: { id: string; version?: number; }): void;
  unregister(variableName: string): boolean;
  resolve(variableName: string): { id: string; version?: number; } | undefined;
  variableNames(): readonly string[];
  size(): number;
  isEmpty(): boolean;
}

export declare const createPolicyRule: (id: string, effect: PolicyEffectValue, conditions?: readonly PolicyCondition[]) => PolicyRule;

export declare const createPolicyDocument: (tenantId: string, name: string) => PolicyDocument;

export declare const addPolicyRule: (doc: PolicyDocument, rule: PolicyRule) => PolicyDocument;

export declare const createPolicyRequest: (agentId: string, tenantId: string, requestedScope: string) => PolicyRequest;

export declare const decisionIsAllowed: (d: PolicyDecision) => boolean;

export declare const decisionIsDenied: (d: PolicyDecision) => boolean;

export declare const MAX_CONDITION_DEPTH: 16;

export declare class PolicyId {
  parse(id: string): PolicyId;
  generate(): PolicyId;
  asString(): string;
  toString(): string;
  toJSON(): string;
}

export declare const PolicyEffect: { readonly Allow: "allow"; readonly Deny: "deny"; };

export type PolicyEffectValue = (typeof PolicyEffect)[keyof typeof PolicyEffect];

export declare const ConditionOperator: { readonly Equals: "equals"; readonly NotEquals: "not_equals"; readonly Contains: "contains"; readonly StartsWith: "starts_with"; readonly EndsWith: "ends_with"; readonly Matches: "matches"; readonly In: "in"; readonly NotIn: "not_in"; };

export type ConditionOperatorValue = (typeof ConditionOperator)[keyof typeof ConditionOperator];

export type PolicyCondition = {
    type: "agent_id";
    operator: ConditionOperatorValue;
    value: string;
} | {
    type: "tenant_id";
    operator: ConditionOperatorValue;
    value: string;
} | {
    type: "scope";
    operator: ConditionOperatorValue;
    value: string;
} | {
    type: "environment";
    operator: ConditionOperatorValue;
    value: string;
} | {
    type: "time_of_day";
    allowed_hours: readonly number[];
} | {
    type: "day_of_week";
    allowed_days: readonly number[];
} | {
    type: "ip_address";
    allowed_cidrs: readonly string[];
} | {
    type: "attribute";
    key: string;
    operator: ConditionOperatorValue;
    value: string;
} | {
    type: "and";
    conditions: readonly PolicyCondition[];
} | {
    type: "or";
    conditions: readonly PolicyCondition[];
} | {
    type: "not";
    condition: PolicyCondition;
};

export interface PolicyRule {
    id: string;
    description?: string;
    effect: PolicyEffectValue;
    conditions: readonly PolicyCondition[];
    scopes?: ScopeSet;
    constraints?: Constraints;
    rate_limits?: RateLimits;
    budget?: UsageBudget;
}

export interface PolicySignature {
    bytes: Uint8Array;
    algorithm: string;
    key_id: string;
    signed_at: string;
}

export interface PolicyDocument {
    id: string;
    version: number;
    tenant_id: string;
    name: string;
    description?: string;
    rules: readonly PolicyRule[];
    default_effect: PolicyEffectValue;
    is_active: boolean;
    priority: number;
    created_at: string;
    updated_at: string;
    signature?: PolicySignature;
    labels: Readonly<Record<string, string>>;
}

export interface PolicyRequest {
    agent_id: string;
    tenant_id: string;
    requested_scope: string;
    timestamp: Date;
    environment?: string;
    client_ip?: string;
    attributes: Readonly<Record<string, string>>;
}

export interface PolicyDecision {
    effect: PolicyEffectValue;
    matched_rule?: string;
    reason?: string;
}

export declare const denyDelegation: () => DelegationConstraints;

export declare const allowDelegation: (depth: number) => DelegationConstraints;

export declare const canDelegateTo: (constraints: DelegationConstraints, agentId: string) => boolean;

export declare const validateDelegationDepth: (depth: number) => void;

export declare const MAX_DELEGATION_DEPTH: 5;

export declare const MAX_CHAIN_LENGTH: 10;

export interface DelegationConstraints {
    allow_delegation: boolean;
    max_depth: number;
    delegatable_scopes?: ScopeSet;
    allowed_delegates: readonly string[];
    allow_any_delegate: boolean;
    /** Minimum TTL reduction (seconds) between parent and child token. */
    min_ttl_reduction: number;
    require_approval: boolean;
}

export declare const sessionStateCanUseTools: (state: SessionStateValue) => boolean;

export declare const sessionStateCanRequestCapabilities: (state: SessionStateValue) => boolean;

export declare const sessionStateIsTerminal: (state: SessionStateValue) => boolean;

export declare const sessionStateIsActive: (state: SessionStateValue) => boolean;

export declare const validSessionStateTransitions: (state: SessionStateValue) => readonly SessionStateValue[];

export declare const canTransitionTo: (from: SessionStateValue, to: SessionStateValue) => boolean;

export declare class SessionId {
  generate(): SessionId;
  fromString(s: string): SessionId;
  asString(): string;
  toString(): string;
  toJSON(): string;
}

export declare const SessionState: { readonly AgentBootstrapped: "agent_bootstrapped"; readonly SessionStarted: "session_started"; readonly CapabilitiesGranted: "capabilities_granted"; readonly ToolUse: "tool_use"; readonly Renewal: "renewal"; readonly Escalation: "escalation"; readonly SessionEnded: "session_ended"; };

export type SessionStateValue = (typeof SessionState)[keyof typeof SessionState];

export declare const SessionEndReason: { readonly Completed: "completed"; readonly Logout: "logout"; readonly Timeout: "timeout"; readonly TokenExpired: "token_expired"; readonly Revoked: "revoked"; readonly SecurityViolation: "security_violation"; readonly PolicyViolation: "policy_violation"; readonly SystemShutdown: "system_shutdown"; };

export type SessionEndReasonValue = (typeof SessionEndReason)[keyof typeof SessionEndReason] | {
    error: string;
};

export declare const createAuditEvent: (opts: { kind: AuditEventKindValue; tenant_id: string; severity?: AuditSeverityValue; outcome?: AuditOutcomeValue; description?: string; metadata?: Record<string, unknown>; agent_id?: string; session_id?: string; token_id?: string; client_ip?: string; user_agent?: string; request_id?: string; }) => AuditEvent;

export declare const hashAuditEvent: (event: AuditEvent) => Promise<Uint8Array>;

export declare const AuditSeverity: { readonly Info: "info"; readonly Warning: "warning"; readonly Error: "error"; readonly Critical: "critical"; };

export type AuditSeverityValue = (typeof AuditSeverity)[keyof typeof AuditSeverity];

export declare const AuditOutcome: { readonly Success: "success"; readonly Failure: "failure"; readonly Partial: "partial"; readonly Pending: "pending"; };

export type AuditOutcomeValue = (typeof AuditOutcome)[keyof typeof AuditOutcome];

export declare const AuditEventKind: { readonly AgentAuthenticated: "agent_authenticated"; readonly AuthenticationFailed: "authentication_failed"; readonly SessionStarted: "session_started"; readonly SessionEnded: "session_ended"; readonly CapabilityRequested: "capability_requested"; readonly CapabilityGranted: "capability_granted"; readonly CapabilityDenied: "capability_denied"; readonly TokenRevoked: "token_revoked"; readonly SecretRead: "secret_read"; readonly SecretRotated: "secret_rotated"; readonly ProxyRequest: "proxy_request"; readonly ProxyDenied: "proxy_denied"; readonly ConsentRequested: "consent_requested"; readonly ConsentApproved: "consent_approved"; readonly ConsentDenied: "consent_denied"; readonly ConsentRevoked: "consent_revoked"; readonly PolicyEvaluated: "policy_evaluated"; readonly PolicyViolation: "policy_violation"; readonly ConfigChanged: "config_changed"; readonly KeyRotated: "key_rotated"; };