@mindburn/helm-ai-kernel 0.5.1

package/dist/generated/helm/kernel/v1/helm.d.ts

@@ -0,0 +1,269 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { type CallOptions, type ChannelCredentials, Client, type ClientOptions, type ClientUnaryCall, type handleUnaryCall, type Metadata, type ServiceError, type UntypedServiceImplementation } from "@grpc/grpc-js";
+export declare const protobufPackage = "helm.kernel.v1";
+/**
+ * HELM Kernel Protocol Buffer Service Definitions
+ *
+ * Canonical IDL for the core HELM types that cross language boundaries.
+ * These are the wire-format definitions for Receipt, DecisionRecord,
+ * AuthorizedExecutionIntent, PDP, and EffectBoundary.
+ *
+ * Stability: v1 additive-only.
+ */
+export declare enum Verdict {
+    VERDICT_UNSPECIFIED = 0,
+    VERDICT_ALLOW = 1,
+    VERDICT_DENY = 2,
+    VERDICT_ESCALATE = 3,
+    UNRECOGNIZED = -1
+}
+export declare function verdictFromJSON(object: any): Verdict;
+export declare function verdictToJSON(object: Verdict): string;
+export declare enum ReasonCode {
+    REASON_CODE_UNSPECIFIED = 0,
+    REASON_CODE_POLICY_VIOLATION = 1,
+    REASON_CODE_NO_POLICY_DEFINED = 2,
+    REASON_CODE_PRG_EVALUATION_ERROR = 3,
+    REASON_CODE_MISSING_REQUIREMENT = 4,
+    REASON_CODE_PDP_DENY = 5,
+    REASON_CODE_PDP_ERROR = 6,
+    REASON_CODE_BUDGET_EXCEEDED = 7,
+    REASON_CODE_BUDGET_ERROR = 8,
+    REASON_CODE_ENVELOPE_INVALID = 9,
+    REASON_CODE_SCHEMA_VIOLATION = 10,
+    REASON_CODE_TEMPORAL_INTERVENTION = 11,
+    REASON_CODE_TEMPORAL_THROTTLE = 12,
+    REASON_CODE_SANDBOX_VIOLATION = 13,
+    REASON_CODE_PROVENANCE_FAILURE = 14,
+    REASON_CODE_VERIFICATION_FAILURE = 15,
+    REASON_CODE_TENANT_ISOLATION = 16,
+    REASON_CODE_JURISDICTION_VIOLATION = 17,
+    UNRECOGNIZED = -1
+}
+export declare function reasonCodeFromJSON(object: any): ReasonCode;
+export declare function reasonCodeToJSON(object: ReasonCode): string;
+export interface Effect {
+    effectType: string;
+    effectId: string;
+    /** JSON-encoded parameters */
+    params: Uint8Array;
+    budgetId: string;
+}
+export interface DecisionRecord {
+    id: string;
+    timestamp: Date | undefined;
+    verdict: Verdict;
+    reason: string;
+    reasonCode: ReasonCode;
+    effectDigest: string;
+    requirementSetHash: string;
+    signature: string;
+    signerKeyId: string;
+    policyRef: string;
+    policyDecisionHash: string;
+    inputContext: Uint8Array;
+}
+export interface AuthorizedExecutionIntent {
+    intentId: string;
+    decisionId: string;
+    effectId: string;
+    issuedAt: Date | undefined;
+    expiresAt: Date | undefined;
+    signature: string;
+    signerKeyId: string;
+    principal: string;
+}
+export interface Receipt {
+    receiptVersion: string;
+    receiptId: string;
+    decisionId: string;
+    effectId: string;
+    verdict: Verdict;
+    principal: string;
+    tool: string;
+    action: string;
+    timestamp: Date | undefined;
+    lamport: number;
+    proofgraphNode: string;
+    signature: string;
+    signerKeyId: string;
+    payloadHash: string;
+    reasonCode: ReasonCode;
+    metadata: {
+        [key: string]: string;
+    };
+}
+export interface Receipt_MetadataEntry {
+    key: string;
+    value: string;
+}
+export interface PDPRequest {
+    effect: Effect | undefined;
+    subject: SubjectDescriptor | undefined;
+    context: ContextDescriptor | undefined;
+}
+export interface SubjectDescriptor {
+    principal: string;
+    tenant: string;
+    roles: string[];
+}
+export interface ContextDescriptor {
+    jurisdiction: string;
+    environment: string;
+    timeWindowStart: Date | undefined;
+    timeWindowEnd: Date | undefined;
+}
+export interface PDPResponse {
+    allow: boolean;
+    reasonCode: ReasonCode;
+    policyRef: string;
+    decisionHash: string;
+    obligations: Obligation[];
+}
+export interface Obligation {
+    id: string;
+    type: string;
+    description: string;
+    deadline: Date | undefined;
+}
+export interface EffectRequest {
+    effect: Effect | undefined;
+    principal: string;
+    context: {
+        [key: string]: string;
+    };
+}
+export interface EffectRequest_ContextEntry {
+    key: string;
+    value: string;
+}
+export interface EffectResponse {
+    verdict: Verdict;
+    reasonCode: ReasonCode;
+    reason: string;
+    receipt: Receipt | undefined;
+    intent: AuthorizedExecutionIntent | undefined;
+}
+export interface ExecutionResult {
+    intentId: string;
+    success: boolean;
+    output: Uint8Array;
+    errorMessage: string;
+    completedAt: Date | undefined;
+}
+export interface CompletionReceipt {
+    receipt: Receipt | undefined;
+    proofgraphNode: string;
+}
+export declare const Effect: MessageFns<Effect>;
+export declare const DecisionRecord: MessageFns<DecisionRecord>;
+export declare const AuthorizedExecutionIntent: MessageFns<AuthorizedExecutionIntent>;
+export declare const Receipt: MessageFns<Receipt>;
+export declare const Receipt_MetadataEntry: MessageFns<Receipt_MetadataEntry>;
+export declare const PDPRequest: MessageFns<PDPRequest>;
+export declare const SubjectDescriptor: MessageFns<SubjectDescriptor>;
+export declare const ContextDescriptor: MessageFns<ContextDescriptor>;
+export declare const PDPResponse: MessageFns<PDPResponse>;
+export declare const Obligation: MessageFns<Obligation>;
+export declare const EffectRequest: MessageFns<EffectRequest>;
+export declare const EffectRequest_ContextEntry: MessageFns<EffectRequest_ContextEntry>;
+export declare const EffectResponse: MessageFns<EffectResponse>;
+export declare const ExecutionResult: MessageFns<ExecutionResult>;
+export declare const CompletionReceipt: MessageFns<CompletionReceipt>;
+export type PolicyDecisionPointServiceService = typeof PolicyDecisionPointServiceService;
+export declare const PolicyDecisionPointServiceService: {
+    readonly evaluate: {
+        readonly path: "/helm.kernel.v1.PolicyDecisionPointService/Evaluate";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: PDPRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => PDPRequest;
+        readonly responseSerialize: (value: PDPResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => PDPResponse;
+    };
+};
+export interface PolicyDecisionPointServiceServer extends UntypedServiceImplementation {
+    evaluate: handleUnaryCall<PDPRequest, PDPResponse>;
+}
+export interface PolicyDecisionPointServiceClient extends Client {
+    evaluate(request: PDPRequest, callback: (error: ServiceError | null, response: PDPResponse) => void): ClientUnaryCall;
+    evaluate(request: PDPRequest, metadata: Metadata, callback: (error: ServiceError | null, response: PDPResponse) => void): ClientUnaryCall;
+    evaluate(request: PDPRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: PDPResponse) => void): ClientUnaryCall;
+}
+export declare const PolicyDecisionPointServiceClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): PolicyDecisionPointServiceClient;
+    service: typeof PolicyDecisionPointServiceService;
+    serviceName: string;
+};
+export type EffectBoundaryServiceService = typeof EffectBoundaryServiceService;
+export declare const EffectBoundaryServiceService: {
+    /**
+     * Submit submits an effect for governance evaluation.
+     * Returns a verdict, receipt, and (if ALLOW) an authorized execution intent.
+     */
+    readonly submit: {
+        readonly path: "/helm.kernel.v1.EffectBoundaryService/Submit";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: EffectRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => EffectRequest;
+        readonly responseSerialize: (value: EffectResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => EffectResponse;
+    };
+    /** Complete reports the execution result and receives a completion receipt. */
+    readonly complete: {
+        readonly path: "/helm.kernel.v1.EffectBoundaryService/Complete";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ExecutionResult) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ExecutionResult;
+        readonly responseSerialize: (value: CompletionReceipt) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => CompletionReceipt;
+    };
+};
+export interface EffectBoundaryServiceServer extends UntypedServiceImplementation {
+    /**
+     * Submit submits an effect for governance evaluation.
+     * Returns a verdict, receipt, and (if ALLOW) an authorized execution intent.
+     */
+    submit: handleUnaryCall<EffectRequest, EffectResponse>;
+    /** Complete reports the execution result and receives a completion receipt. */
+    complete: handleUnaryCall<ExecutionResult, CompletionReceipt>;
+}
+export interface EffectBoundaryServiceClient extends Client {
+    /**
+     * Submit submits an effect for governance evaluation.
+     * Returns a verdict, receipt, and (if ALLOW) an authorized execution intent.
+     */
+    submit(request: EffectRequest, callback: (error: ServiceError | null, response: EffectResponse) => void): ClientUnaryCall;
+    submit(request: EffectRequest, metadata: Metadata, callback: (error: ServiceError | null, response: EffectResponse) => void): ClientUnaryCall;
+    submit(request: EffectRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: EffectResponse) => void): ClientUnaryCall;
+    /** Complete reports the execution result and receives a completion receipt. */
+    complete(request: ExecutionResult, callback: (error: ServiceError | null, response: CompletionReceipt) => void): ClientUnaryCall;
+    complete(request: ExecutionResult, metadata: Metadata, callback: (error: ServiceError | null, response: CompletionReceipt) => void): ClientUnaryCall;
+    complete(request: ExecutionResult, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: CompletionReceipt) => void): ClientUnaryCall;
+}
+export declare const EffectBoundaryServiceClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): EffectBoundaryServiceClient;
+    service: typeof EffectBoundaryServiceService;
+    serviceName: string;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};