@vibesdotdev/security 0.0.0-stage → 1.0.0-rc.4

package/dist/kinds/policy.kind.d.ts

@@ -0,0 +1,42 @@
+import type { SecurityPolicyService } from '../schemas/contracts/policy.ts';
+export type { SecurityPolicyService } from '../schemas/contracts/policy.ts';
+import { type SecurityPolicyDescriptor, type PolicyOutcome, type PolicyEvaluationContext } from '../schemas/policy.ts';
+export { PolicyRuleSchema, type PolicyRule, SecurityPolicyDescriptorSchema, type SecurityPolicyDescriptor, PolicyOutcomeSchema, type PolicyOutcome, PolicyEvaluationContextSchema, type PolicyEvaluationContext } from '../schemas/policy.ts';
+declare class DefaultSecurityPolicyService implements SecurityPolicyService {
+    readonly descriptor: SecurityPolicyDescriptor;
+    constructor(descriptor: SecurityPolicyDescriptor);
+    evaluate(_context: PolicyEvaluationContext): Promise<PolicyOutcome>;
+}
+declare function resolvePolicy(candidates: SecurityPolicyDescriptor[]): SecurityPolicyDescriptor | undefined;
+export declare const securityPolicyKind: {
+    readonly id: "security/policy";
+    readonly descriptorSchema: import("zod/v4").ZodObject<{
+        id: import("zod/v4").ZodString;
+        kind: import("zod/v4").ZodLiteral<"security/policy">;
+        name: import("zod/v4").ZodString;
+        description: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        enabled: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+        tags: import("zod/v4").ZodOptional<import("zod/v4").ZodArray<import("zod/v4").ZodString>>;
+        hardware: import("zod/v4").ZodOptional<import("zod/v4").ZodArray<import("zod/v4").ZodEnum<{
+            consumer: "consumer";
+            cloud: "cloud";
+        }>>>;
+        rules: import("zod/v4").ZodArray<import("zod/v4").ZodObject<{
+            pattern: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+            action: import("zod/v4").ZodEnum<{
+                allow: "allow";
+                deny: "deny";
+                review: "review";
+            }>;
+            target: import("zod/v4").ZodEnum<{
+                metadata: "metadata";
+                content: "content";
+                header: "header";
+            }>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+    readonly defaultImplementation: typeof DefaultSecurityPolicyService;
+    readonly resolve: typeof resolvePolicy;
+    readonly contexts: readonly [];
+};
+//# sourceMappingURL=policy.kind.d.ts.map

package/dist/kinds/policy.kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.kind.d.ts","sourceRoot":"","sources":["../../src/kinds/policy.kind.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAC5E,YAAY,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAC5E,OAAO,EAAkC,KAAK,wBAAwB,EAAE,KAAK,aAAa,EAAE,KAAK,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AACvJ,OAAO,EAAE,gBAAgB,EAAE,KAAK,UAAU,EAAE,8BAA8B,EAAE,KAAK,wBAAwB,EAAE,mBAAmB,EAAE,KAAK,aAAa,EAAE,6BAA6B,EAAE,KAAK,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAG9O,cAAM,4BAA6B,YAAW,qBAAqB;IAClE,QAAQ,CAAC,UAAU,EAAE,wBAAwB,CAAC;gBAElC,UAAU,EAAE,wBAAwB;IAI1C,QAAQ,CAAC,QAAQ,EAAE,uBAAuB,GAAG,OAAO,CAAC,aAAa,CAAC;CAGzE;AAED,iBAAS,aAAa,CACrB,UAAU,EAAE,wBAAwB,EAAE,GACpC,wBAAwB,GAAG,SAAS,CAGtC;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAM+D,CAAC"}

package/dist/kinds/policy.kind.js

@@ -0,0 +1,23 @@
+import { SecurityPolicyDescriptorSchema } from "../schemas/policy.js";
+export { PolicyRuleSchema, SecurityPolicyDescriptorSchema, PolicyOutcomeSchema, PolicyEvaluationContextSchema } from "../schemas/policy.js";
+class DefaultSecurityPolicyService {
+    descriptor;
+    constructor(descriptor) {
+        this.descriptor = descriptor;
+    }
+    async evaluate(_context) {
+        return 'deny';
+    }
+}
+function resolvePolicy(candidates) {
+    const enabled = candidates.filter((d) => d.enabled !== false);
+    return enabled[0];
+}
+export const securityPolicyKind = {
+    id: 'security/policy',
+    descriptorSchema: SecurityPolicyDescriptorSchema,
+    defaultImplementation: DefaultSecurityPolicyService,
+    resolve: resolvePolicy,
+    contexts: [],
+};
+//# sourceMappingURL=policy.kind.js.map

package/dist/kinds/policy.kind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.kind.js","sourceRoot":"","sources":["../../src/kinds/policy.kind.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,8BAA8B,EAAmF,MAAM,sBAAsB,CAAC;AACvJ,OAAO,EAAE,gBAAgB,EAAmB,8BAA8B,EAAiC,mBAAmB,EAAsB,6BAA6B,EAAgC,MAAM,sBAAsB,CAAC;AAG9O,MAAM,4BAA4B;IACxB,UAAU,CAA2B;IAE9C,YAAY,UAAoC;QAC/C,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IAC9B,CAAC;IAED,KAAK,CAAC,QAAQ,CAAC,QAAiC;QAC/C,OAAO,MAAM,CAAC;IACf,CAAC;CACD;AAED,SAAS,aAAa,CACrB,UAAsC;IAEtC,MAAM,OAAO,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,KAAK,CAAC,CAAC;IAC9D,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC;AACnB,CAAC;AAED,MAAM,CAAC,MAAM,kBAAkB,GAAG;IACjC,EAAE,EAAE,iBAAiB;IACrB,gBAAgB,EAAE,8BAA8B;IAChD,qBAAqB,EAAE,4BAA4B;IACnD,OAAO,EAAE,aAAa;IACtB,QAAQ,EAAE,EAAE;CACiF,CAAC"}

package/dist/kinds/redactor.kind.d.ts

@@ -0,0 +1,30 @@
+import type { RedactionRuleInput } from '../schemas/RedactionRule.ts';
+import { type SecurityRedactorService } from '../schemas/contracts/redactor.ts';
+export type { SecurityRedactorService } from '../schemas/contracts/redactor.ts';
+import { type SecurityRedactorResult, type SecurityRedactorDescriptor } from '../schemas/redactor.ts';
+export { RedactionMatchSchema, type RedactionMatch, SecurityRedactorResultSchema, type SecurityRedactorResult, SecurityRedactorDescriptorSchema, type SecurityRedactorDescriptor, type RedactionRule } from '../schemas/redactor.ts';
+declare class DefaultSecurityRedactorService implements SecurityRedactorService {
+    readonly descriptor: SecurityRedactorDescriptor;
+    constructor(descriptor: SecurityRedactorDescriptor);
+    redact(content: string, rules?: RedactionRuleInput[]): Promise<SecurityRedactorResult>;
+}
+declare function resolveRedactor(candidates: SecurityRedactorDescriptor[]): SecurityRedactorDescriptor | undefined;
+export declare const securityRedactorKind: {
+    readonly id: "security/redactor";
+    readonly descriptorSchema: import("zod/v4").ZodObject<{
+        id: import("zod/v4").ZodString;
+        kind: import("zod/v4").ZodLiteral<"security/redactor">;
+        name: import("zod/v4").ZodString;
+        description: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        enabled: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+        tags: import("zod/v4").ZodOptional<import("zod/v4").ZodArray<import("zod/v4").ZodString>>;
+        hardware: import("zod/v4").ZodOptional<import("zod/v4").ZodArray<import("zod/v4").ZodEnum<{
+            consumer: "consumer";
+            cloud: "cloud";
+        }>>>;
+    }, import("zod/v4/core").$strip>;
+    readonly defaultImplementation: typeof DefaultSecurityRedactorService;
+    readonly resolve: typeof resolveRedactor;
+    readonly contexts: readonly [];
+};
+//# sourceMappingURL=redactor.kind.d.ts.map

package/dist/kinds/redactor.kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redactor.kind.d.ts","sourceRoot":"","sources":["../../src/kinds/redactor.kind.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAmC,KAAK,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AACjH,YAAY,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AAChF,OAAO,EAAE,KAAK,sBAAsB,EAAoC,KAAK,0BAA0B,EAAE,MAAM,wBAAwB,CAAC;AACxI,OAAO,EAAE,oBAAoB,EAAE,KAAK,cAAc,EAAE,4BAA4B,EAAE,KAAK,sBAAsB,EAAE,gCAAgC,EAAE,KAAK,0BAA0B,EAAE,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAGrO,cAAM,8BAA+B,YAAW,uBAAuB;IACtE,QAAQ,CAAC,UAAU,EAAE,0BAA0B,CAAC;gBAEpC,UAAU,EAAE,0BAA0B;IAI5C,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,kBAAkB,EAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;CAI5F;AAED,iBAAS,eAAe,CACvB,UAAU,EAAE,0BAA0B,EAAE,GACtC,0BAA0B,GAAG,SAAS,CAGxC;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;CAMiE,CAAC"}

package/dist/kinds/redactor.kind.js

@@ -0,0 +1,25 @@
+import { SecurityRedactorArgumentsSchema } from "../schemas/contracts/redactor.js";
+import { SecurityRedactorDescriptorSchema } from "../schemas/redactor.js";
+export { RedactionMatchSchema, SecurityRedactorResultSchema, SecurityRedactorDescriptorSchema } from "../schemas/redactor.js";
+class DefaultSecurityRedactorService {
+    descriptor;
+    constructor(descriptor) {
+        this.descriptor = descriptor;
+    }
+    async redact(content, rules) {
+        const [validatedContent] = SecurityRedactorArgumentsSchema.parse([content, rules]);
+        return { redacted: validatedContent, matches: [], redactorAvailable: false };
+    }
+}
+function resolveRedactor(candidates) {
+    const enabled = candidates.filter((d) => d.enabled !== false);
+    return enabled.find(descriptor => !descriptor.tags?.includes('builtin')) ?? enabled[0];
+}
+export const securityRedactorKind = {
+    id: 'security/redactor',
+    descriptorSchema: SecurityRedactorDescriptorSchema,
+    defaultImplementation: DefaultSecurityRedactorService,
+    resolve: resolveRedactor,
+    contexts: [],
+};
+//# sourceMappingURL=redactor.kind.js.map

package/dist/kinds/redactor.kind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redactor.kind.js","sourceRoot":"","sources":["../../src/kinds/redactor.kind.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,+BAA+B,EAAgC,MAAM,kCAAkC,CAAC;AAEjH,OAAO,EAA+B,gCAAgC,EAAmC,MAAM,wBAAwB,CAAC;AACxI,OAAO,EAAE,oBAAoB,EAAuB,4BAA4B,EAA+B,gCAAgC,EAAuD,MAAM,wBAAwB,CAAC;AAGrO,MAAM,8BAA8B;IAC1B,UAAU,CAA6B;IAEhD,YAAY,UAAsC;QACjD,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IAC9B,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,OAAe,EAAE,KAA4B;QACzD,MAAM,CAAC,gBAAgB,CAAC,GAAG,+BAA+B,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC;QACnF,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,OAAO,EAAE,EAAE,EAAE,iBAAiB,EAAE,KAAK,EAAE,CAAC;IAC9E,CAAC;CACD;AAED,SAAS,eAAe,CACvB,UAAwC;IAExC,MAAM,OAAO,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,KAAK,CAAC,CAAC;IAC9D,OAAO,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;AACxF,CAAC;AAED,MAAM,CAAC,MAAM,oBAAoB,GAAG;IACnC,EAAE,EAAE,mBAAmB;IACvB,gBAAgB,EAAE,gCAAgC;IAClD,qBAAqB,EAAE,8BAA8B;IACrD,OAAO,EAAE,eAAe;IACxB,QAAQ,EAAE,EAAE;CACqF,CAAC"}

package/dist/kinds/scanner.kind.d.ts

@@ -0,0 +1,35 @@
+import type { SecurityScannerOptionsInput } from '../schemas/contracts/scanner.ts';
+import type { SecurityScannerService } from '../schemas/contracts/scanner.ts';
+export type { SecurityScannerService } from '../schemas/contracts/scanner.ts';
+import { type SecurityScannerResult, type SecurityScannerDescriptor } from '../schemas/scanner.ts';
+export { SecurityScannerOptionsSchema, type SecurityScannerOptions, ThreatMatchSchema, type ThreatMatch, SecurityScannerResultSchema, type SecurityScannerResult, SecurityScannerDescriptorSchema, type SecurityScannerDescriptor } from '../schemas/scanner.ts';
+declare class DefaultSecurityScannerService implements SecurityScannerService {
+    readonly descriptor: SecurityScannerDescriptor;
+    constructor(descriptor: SecurityScannerDescriptor);
+    scan(_content: string, _options?: SecurityScannerOptionsInput): Promise<SecurityScannerResult>;
+}
+declare function resolveScanner(candidates: SecurityScannerDescriptor[]): SecurityScannerDescriptor | undefined;
+export declare const securityScannerKind: {
+    readonly id: "security/scanner";
+    readonly descriptorSchema: import("zod/v4").ZodObject<{
+        id: import("zod/v4").ZodString;
+        kind: import("zod/v4").ZodLiteral<"security/scanner">;
+        name: import("zod/v4").ZodString;
+        description: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        enabled: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+        tags: import("zod/v4").ZodOptional<import("zod/v4").ZodArray<import("zod/v4").ZodString>>;
+        hardware: import("zod/v4").ZodOptional<import("zod/v4").ZodArray<import("zod/v4").ZodEnum<{
+            consumer: "consumer";
+            cloud: "cloud";
+        }>>>;
+        options: import("zod/v4").ZodOptional<import("zod/v4").ZodObject<{
+            detectSecrets: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+            detectPII: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+            detectPromptInjection: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+    readonly defaultImplementation: typeof DefaultSecurityScannerService;
+    readonly resolve: typeof resolveScanner;
+    readonly contexts: readonly [];
+};
+//# sourceMappingURL=scanner.kind.d.ts.map

package/dist/kinds/scanner.kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanner.kind.d.ts","sourceRoot":"","sources":["../../src/kinds/scanner.kind.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAC;AACnF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAC9E,YAAY,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAC9E,OAAO,EAAE,KAAK,qBAAqB,EAAmC,KAAK,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AACpI,OAAO,EAAE,4BAA4B,EAAE,KAAK,sBAAsB,EAAE,iBAAiB,EAAE,KAAK,WAAW,EAAE,2BAA2B,EAAE,KAAK,qBAAqB,EAAE,+BAA+B,EAAE,KAAK,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAGjQ,cAAM,6BAA8B,YAAW,sBAAsB;IACpE,QAAQ,CAAC,UAAU,EAAE,yBAAyB,CAAC;gBAEnC,UAAU,EAAE,yBAAyB;IAI3C,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,2BAA2B,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAKpG;AAED,iBAAS,cAAc,CACtB,UAAU,EAAE,yBAAyB,EAAE,GACrC,yBAAyB,GAAG,SAAS,CAGvC;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;CAMgE,CAAC"}

package/dist/kinds/scanner.kind.js

@@ -0,0 +1,26 @@
+import { SecurityContentSchema, SecurityScannerOverridesSchema } from "../schemas/contracts/scanner.js";
+import { SecurityScannerDescriptorSchema } from "../schemas/scanner.js";
+export { SecurityScannerOptionsSchema, ThreatMatchSchema, SecurityScannerResultSchema, SecurityScannerDescriptorSchema } from "../schemas/scanner.js";
+class DefaultSecurityScannerService {
+    descriptor;
+    constructor(descriptor) {
+        this.descriptor = descriptor;
+    }
+    async scan(_content, _options) {
+        SecurityContentSchema.parse(_content);
+        SecurityScannerOverridesSchema.optional().parse(_options);
+        return { threats: [], scanAvailable: false };
+    }
+}
+function resolveScanner(candidates) {
+    const enabled = candidates.filter((d) => d.enabled !== false);
+    return enabled[0];
+}
+export const securityScannerKind = {
+    id: 'security/scanner',
+    descriptorSchema: SecurityScannerDescriptorSchema,
+    defaultImplementation: DefaultSecurityScannerService,
+    resolve: resolveScanner,
+    contexts: [],
+};
+//# sourceMappingURL=scanner.kind.js.map

package/dist/kinds/scanner.kind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanner.kind.js","sourceRoot":"","sources":["../../src/kinds/scanner.kind.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,8BAA8B,EAAE,MAAM,iCAAiC,CAAC;AAIxG,OAAO,EAA8B,+BAA+B,EAAkC,MAAM,uBAAuB,CAAC;AACpI,OAAO,EAAE,4BAA4B,EAA+B,iBAAiB,EAAoB,2BAA2B,EAA8B,+BAA+B,EAAkC,MAAM,uBAAuB,CAAC;AAGjQ,MAAM,6BAA6B;IACzB,UAAU,CAA4B;IAE/C,YAAY,UAAqC;QAChD,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IAC9B,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,QAAgB,EAAE,QAAsC;QAClE,qBAAqB,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QACtC,8BAA8B,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAC1D,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC;IAC9C,CAAC;CACD;AAED,SAAS,cAAc,CACtB,UAAuC;IAEvC,MAAM,OAAO,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,KAAK,CAAC,CAAC;IAC9D,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC;AACnB,CAAC;AAED,MAAM,CAAC,MAAM,mBAAmB,GAAG;IAClC,EAAE,EAAE,kBAAkB;IACtB,gBAAgB,EAAE,+BAA+B;IACjD,qBAAqB,EAAE,6BAA6B;IACpD,OAAO,EAAE,cAAc;IACvB,QAAQ,EAAE,EAAE;CACmF,CAAC"}

package/dist/schemas/AuditEvent.d.ts

@@ -0,0 +1,30 @@
+import * as z from 'zod/v4';
+export declare const AuditEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    timestamp: z.ZodString;
+    actor: z.ZodString;
+    action: z.ZodString;
+    resource: z.ZodString;
+    outcome: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        review: "review";
+    }>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type AuditEvent = z.infer<typeof AuditEventSchema>;
+export declare const AuditQueryOptionsSchema: z.ZodObject<{
+    actor: z.ZodOptional<z.ZodString>;
+    action: z.ZodOptional<z.ZodString>;
+    resource: z.ZodOptional<z.ZodString>;
+    outcome: z.ZodOptional<z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        review: "review";
+    }>>;
+    from: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type AuditQueryOptions = z.infer<typeof AuditQueryOptionsSchema>;
+//# sourceMappingURL=AuditEvent.d.ts.map

package/dist/schemas/AuditEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuditEvent.d.ts","sourceRoot":"","sources":["../../src/schemas/AuditEvent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,eAAO,MAAM,gBAAgB;;;;;;;;;;;;iBAQ3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;iBAKlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/schemas/AuditEvent.js

@@ -0,0 +1,17 @@
+import * as z from 'zod/v4';
+export const AuditEventSchema = z.object({
+    id: z.string(),
+    timestamp: z.string().datetime(),
+    actor: z.string(),
+    action: z.string(),
+    resource: z.string(),
+    outcome: z.enum(['allow', 'deny', 'review']),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+export const AuditQueryOptionsSchema = z.object({
+    actor: z.string().optional(), action: z.string().optional(), resource: z.string().optional(),
+    outcome: AuditEventSchema.shape.outcome.optional(),
+    from: z.string().datetime().optional(), to: z.string().datetime().optional(),
+    limit: z.number().int().nonnegative().optional()
+});
+//# sourceMappingURL=AuditEvent.js.map

package/dist/schemas/AuditEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuditEvent.js","sourceRoot":"","sources":["../../src/schemas/AuditEvent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IACrC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;IACjB,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IACpB,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC5C,QAAQ,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE;CACzD,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC5F,OAAO,EAAE,gBAAgB,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,EAAE;IAClD,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IAC5E,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE;CACnD,CAAC,CAAC"}

package/dist/schemas/RedactionRule.d.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod/v4';
+export declare const RedactionRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    pattern: z.ZodString;
+    replacement: z.ZodString;
+    target: z.ZodEnum<{
+        metadata: "metadata";
+        content: "content";
+        header: "header";
+    }>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type RedactionRule = z.infer<typeof RedactionRuleSchema>;
+export type RedactionRuleInput = z.input<typeof RedactionRuleSchema>;
+//# sourceMappingURL=RedactionRule.d.ts.map

package/dist/schemas/RedactionRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedactionRule.d.ts","sourceRoot":"","sources":["../../src/schemas/RedactionRule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,eAAO,MAAM,mBAAmB;;;;;;;;;;;iBAO9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/schemas/RedactionRule.js

@@ -0,0 +1,10 @@
+import * as z from 'zod/v4';
+export const RedactionRuleSchema = z.object({
+    id: z.string().max(256),
+    name: z.string().max(256),
+    pattern: z.string().max(4096),
+    replacement: z.string().max(4096),
+    target: z.enum(['content', 'header', 'metadata']),
+    enabled: z.boolean().default(true),
+});
+//# sourceMappingURL=RedactionRule.js.map

package/dist/schemas/RedactionRule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedactionRule.js","sourceRoot":"","sources":["../../src/schemas/RedactionRule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC;IACvB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC;IACzB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC;IAC7B,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC;IACjC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;IACjD,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;CACrC,CAAC,CAAC"}

package/dist/schemas/SecurityPolicy.d.ts

@@ -0,0 +1,21 @@
+import * as z from 'zod/v4';
+export declare const SecurityPolicySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    rules: z.ZodArray<z.ZodObject<{
+        pattern: z.ZodOptional<z.ZodString>;
+        action: z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            review: "review";
+        }>;
+        target: z.ZodEnum<{
+            metadata: "metadata";
+            content: "content";
+            header: "header";
+        }>;
+    }, z.core.$strip>>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SecurityPolicy = z.infer<typeof SecurityPolicySchema>;
+//# sourceMappingURL=SecurityPolicy.d.ts.map

package/dist/schemas/SecurityPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecurityPolicy.d.ts","sourceRoot":"","sources":["../../src/schemas/SecurityPolicy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;iBAK/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/schemas/SecurityPolicy.js

@@ -0,0 +1,9 @@
+import { PolicyRuleSchema } from "./contracts/policy.js";
+import * as z from 'zod/v4';
+export const SecurityPolicySchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    rules: z.array(PolicyRuleSchema),
+    enabled: z.boolean().default(true),
+});
+//# sourceMappingURL=SecurityPolicy.js.map

package/dist/schemas/SecurityPolicy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecurityPolicy.js","sourceRoot":"","sources":["../../src/schemas/SecurityPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC;IAChC,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;CAClC,CAAC,CAAC"}

package/dist/schemas/ThreatReport.d.ts

@@ -0,0 +1,25 @@
+import * as z from 'zod/v4';
+export declare const ThreatReportSchema: z.ZodObject<{
+    id: z.ZodString;
+    timestamp: z.ZodString;
+    severity: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        critical: "critical";
+    }>;
+    kind: z.ZodEnum<{
+        prompt_injection: "prompt_injection";
+        secret_leak: "secret_leak";
+        pii: "pii";
+        suspicious_payload: "suspicious_payload";
+    }>;
+    description: z.ZodString;
+    matches: z.ZodArray<z.ZodObject<{
+        pattern: z.ZodString;
+        index: z.ZodNumber;
+        length: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ThreatReport = z.infer<typeof ThreatReportSchema>;
+//# sourceMappingURL=ThreatReport.d.ts.map

package/dist/schemas/ThreatReport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreatReport.d.ts","sourceRoot":"","sources":["../../src/schemas/ThreatReport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;iBAa7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/schemas/ThreatReport.js

@@ -0,0 +1,14 @@
+import * as z from 'zod/v4';
+export const ThreatReportSchema = z.object({
+    id: z.string(),
+    timestamp: z.string().datetime(),
+    severity: z.enum(['low', 'medium', 'high', 'critical']),
+    kind: z.enum(['prompt_injection', 'secret_leak', 'pii', 'suspicious_payload']),
+    description: z.string(),
+    matches: z.array(z.object({
+        pattern: z.string(),
+        index: z.number(),
+        length: z.number(),
+    })),
+});
+//# sourceMappingURL=ThreatReport.js.map

package/dist/schemas/ThreatReport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreatReport.js","sourceRoot":"","sources":["../../src/schemas/ThreatReport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;IACvD,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,kBAAkB,EAAE,aAAa,EAAE,KAAK,EAAE,oBAAoB,CAAC,CAAC;IAC9E,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,OAAO,EAAE,CAAC,CAAC,KAAK,CACf,CAAC,CAAC,MAAM,CAAC;QACR,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;QACnB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;QACjB,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;KAClB,CAAC,CACF;CACD,CAAC,CAAC"}

package/dist/schemas/contracts/auditor.d.ts

@@ -0,0 +1,68 @@
+import * as z from 'zod/v4';
+export declare const SecurityAuditorDescriptorSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"security/auditor">;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    hardware: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        consumer: "consumer";
+        cloud: "cloud";
+    }>>>;
+}, z.core.$strip>;
+export type SecurityAuditorDescriptor = z.output<typeof SecurityAuditorDescriptorSchema>;
+export declare const SecurityAuditorServiceSchema: z.ZodObject<{
+    descriptor: z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"security/auditor">;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        hardware: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            consumer: "consumer";
+            cloud: "cloud";
+        }>>>;
+    }, z.core.$strip>;
+    emit: z.ZodFunction<z.ZodTuple<readonly [z.ZodObject<{
+        id: z.ZodString;
+        timestamp: z.ZodString;
+        actor: z.ZodString;
+        action: z.ZodString;
+        resource: z.ZodString;
+        outcome: z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            review: "review";
+        }>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>], null>, z.ZodPromise<z.ZodVoid>>;
+    query: z.ZodFunction<z.ZodTuple<readonly [z.ZodOptional<z.ZodObject<{
+        actor: z.ZodOptional<z.ZodString>;
+        action: z.ZodOptional<z.ZodString>;
+        resource: z.ZodOptional<z.ZodString>;
+        outcome: z.ZodOptional<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            review: "review";
+        }>>;
+        from: z.ZodOptional<z.ZodString>;
+        to: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>], null>, z.ZodPromise<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        timestamp: z.ZodString;
+        actor: z.ZodString;
+        action: z.ZodString;
+        resource: z.ZodString;
+        outcome: z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            review: "review";
+        }>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+export type SecurityAuditorService = z.infer<typeof SecurityAuditorServiceSchema>;
+//# sourceMappingURL=auditor.d.ts.map

package/dist/schemas/contracts/auditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auditor.d.ts","sourceRoot":"","sources":["../../../src/schemas/contracts/auditor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,eAAO,MAAM,+BAA+B;;;;;;;;;;;iBAQ1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAEzF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA4P,CAAC;AACtS,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC"}

package/dist/schemas/contracts/auditor.js

@@ -0,0 +1,13 @@
+import * as z from 'zod/v4';
+export const SecurityAuditorDescriptorSchema = z.object({
+    id: z.string(),
+    kind: z.literal('security/auditor'),
+    name: z.string(),
+    description: z.string().optional(),
+    enabled: z.boolean().optional(),
+    tags: z.array(z.string()).optional(),
+    hardware: z.array(z.enum(['consumer', 'cloud'])).optional(),
+});
+import { AuditEventSchema, AuditQueryOptionsSchema } from "../AuditEvent.js";
+export const SecurityAuditorServiceSchema = z.object({ descriptor: SecurityAuditorDescriptorSchema, emit: z.function({ input: [AuditEventSchema], output: z.promise(z.void()) }), query: z.function({ input: [AuditQueryOptionsSchema.optional()], output: z.promise(z.array(AuditEventSchema)) }) });
+//# sourceMappingURL=auditor.js.map

package/dist/schemas/contracts/auditor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auditor.js","sourceRoot":"","sources":["../../../src/schemas/contracts/auditor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAAC,CAAC,MAAM,CAAC;IACpD,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,kBAAkB,CAAC;IACnC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAClC,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IAC/B,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IACpC,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;CAC9D,CAAC,CAAC;AAEH,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAC7E,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,+BAA+B,EAAE,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,EAAE,KAAK,EAAE,CAAC,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,QAAQ,CAAC,EAAE,KAAK,EAAE,CAAC,uBAAuB,CAAC,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC"}

package/dist/schemas/contracts/card.d.ts

@@ -0,0 +1,106 @@
+import * as z from 'zod/v4';
+import { PolicyOutcomeSchema } from './policy.ts';
+export declare const SECURITY_TOOL_IDS: readonly ["security.check-policy", "security.redact-output", "security.report-event", "security.scan-input"];
+export declare const SecurityToolIdSchema: z.ZodEnum<{
+    "security.scan-input": "security.scan-input";
+    "security.redact-output": "security.redact-output";
+    "security.check-policy": "security.check-policy";
+    "security.report-event": "security.report-event";
+}>;
+export type SecurityToolId = z.infer<typeof SecurityToolIdSchema>;
+export type PolicyDecision = z.infer<typeof PolicyOutcomeSchema>;
+export declare const SecurityToolCardToneSchema: z.ZodEnum<{
+    success: "success";
+    default: "default";
+    danger: "danger";
+    warning: "warning";
+    muted: "muted";
+}>;
+export type SecurityToolCardTone = z.infer<typeof SecurityToolCardToneSchema>;
+export declare const SecurityToolThreatSchema: z.ZodObject<{
+    severity: z.ZodString;
+    kind: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strip>;
+export type SecurityToolThreat = z.infer<typeof SecurityToolThreatSchema>;
+export declare const SecurityToolCardRowSchema: z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodString;
+    tone: z.ZodEnum<{
+        success: "success";
+        default: "default";
+        danger: "danger";
+        warning: "warning";
+        muted: "muted";
+    }>;
+}, z.core.$strip>;
+export type SecurityToolCardRow = z.infer<typeof SecurityToolCardRowSchema>;
+export declare const SecurityToolCardModelSchema: z.ZodObject<{
+    toolId: z.ZodString;
+    title: z.ZodString;
+    icon: z.ZodString;
+    policyName: z.ZodNullable<z.ZodString>;
+    decision: z.ZodNullable<z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        review: "review";
+    }>>;
+    decisionLabel: z.ZodNullable<z.ZodString>;
+    eventType: z.ZodNullable<z.ZodString>;
+    recorded: z.ZodNullable<z.ZodBoolean>;
+    eventId: z.ZodNullable<z.ZodString>;
+    actor: z.ZodNullable<z.ZodString>;
+    resource: z.ZodNullable<z.ZodString>;
+    reason: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodString>;
+    available: z.ZodNullable<z.ZodBoolean>;
+    availabilityLabel: z.ZodNullable<z.ZodString>;
+    threats: z.ZodArray<z.ZodObject<{
+        severity: z.ZodString;
+        kind: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+    matchCount: z.ZodNullable<z.ZodNumber>;
+    redactedPreview: z.ZodNullable<z.ZodString>;
+    defaultOpen: z.ZodBoolean;
+}, z.core.$strip>;
+export type SecurityToolCardModel = z.infer<typeof SecurityToolCardModelSchema>;
+export declare const StringField: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+export declare const CardArgsSchema: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+    policyId: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    event: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        id: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        action: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        actor: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        resource: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        outcome: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            review: "review";
+        }>>>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>>>;
+export declare const CardOutputSchema: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+    policyId: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    outcome: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        review: "review";
+    }>>>;
+    recorded: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+    eventId: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    reason: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    error: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    engineAvailable: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+    scannerAvailable: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+    redactorAvailable: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+    threats: z.ZodPipe<z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodUnknown>>>, z.ZodTransform<{
+        severity: string;
+        kind: string;
+        description: string;
+    }[], unknown[] | undefined>>;
+    matches: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodUnknown>>>;
+    redacted: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+}, z.core.$loose>>>;
+export type ParsedCardOutput = z.infer<typeof CardOutputSchema>;
+//# sourceMappingURL=card.d.ts.map

package/dist/schemas/contracts/card.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"card.d.ts","sourceRoot":"","sources":["../../../src/schemas/contracts/card.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,eAAO,MAAM,iBAAiB,8GAKpB,CAAC;AACX,eAAO,MAAM,oBAAoB;;;;;EAA4B,CAAC;AAC9D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACjE,eAAO,MAAM,0BAA0B;;;;;;EAA+D,CAAC;AACvG,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,eAAO,MAAM,wBAAwB;;;;iBAAgF,CAAC;AACtH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,eAAO,MAAM,yBAAyB;;;;;;;;;;iBAAuF,CAAC;AAC9H,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOtC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,WAAW,wCAAuC,CAAC;AAiChE,eAAO,MAAM,cAAc;;;;;;;;;;;;;mBAGiB,CAAC;AAC7C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;mBAae,CAAC;AAC7C,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}