@vertesia/common 1.5.0-dev.20260725.083715Z → 1.5.0-dev.20260806.125520Z

package/lib/api-schemas/audit-trail.d.ts

@@ -0,0 +1,465 @@
+import { z } from 'zod';
+export declare const AuditMeterSchema: z.ZodObject<{
+    category: z.ZodString;
+    type: z.ZodString;
+    quantity: z.ZodNumber;
+}, z.core.$strict>;
+export declare const KnownAuditActionSchema: z.ZodEnum<{
+    attach: "attach";
+    bulk_change_type: "bulk_change_type";
+    bulk_create: "bulk_create";
+    bulk_delete: "bulk_delete";
+    bulk_update: "bulk_update";
+    create: "create";
+    credentials_fill: "credentials_fill";
+    credentials_totp_generation: "credentials_totp_generation";
+    delete: "delete";
+    detach: "detach";
+    document_processed: "document_processed";
+    embedding: "embedding";
+    image_generation: "image_generation";
+    inference: "inference";
+    publish: "publish";
+    unpublish: "unpublish";
+    update: "update";
+}>;
+export declare const EventCategorySchema: z.ZodEnum<{
+    billing: "billing";
+    content: "content";
+    external: "external";
+    security: "security";
+    system: "system";
+    workflow: "workflow";
+}>;
+export declare const AuditAggregationDimensionMapSchema: z.ZodObject<{
+    time: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    action: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    resource_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    event_category: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    provider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    project_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    'details.pipeline': z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    'details.verdict': z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    'details.workflow_type': z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    'details.rule_id': z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export declare const AuditAggregationDistinctFieldSchema: z.ZodEnum<{
+    request_id: "request_id";
+    resource_id: "resource_id";
+}>;
+export declare const AuditAggregationOperationSchema: z.ZodEnum<{
+    average_meter: "average_meter";
+    count: "count";
+    count_distinct: "count_distinct";
+    sum_meter: "sum_meter";
+}>;
+export declare const AuditAggregationResolutionSchema: z.ZodEnum<{
+    day: "day";
+    hour: "hour";
+    month: "month";
+    week: "week";
+}>;
+export declare const AuditAggregationDimensionSchema: z.ZodEnum<{
+    action: "action";
+    "details.pipeline": "details.pipeline";
+    "details.rule_id": "details.rule_id";
+    "details.verdict": "details.verdict";
+    "details.workflow_type": "details.workflow_type";
+    event_category: "event_category";
+    model: "model";
+    project_id: "project_id";
+    provider: "provider";
+    resource_type: "resource_type";
+    time: "time";
+}>;
+export declare const AuditAggregationDetailFieldSchema: z.ZodEnum<{
+    pipeline: "pipeline";
+    rule_id: "rule_id";
+    verdict: "verdict";
+    workflow_type: "workflow_type";
+}>;
+export declare const AuditActionSchema: z.ZodUnion<readonly [z.ZodEnum<{
+    attach: "attach";
+    bulk_change_type: "bulk_change_type";
+    bulk_create: "bulk_create";
+    bulk_delete: "bulk_delete";
+    bulk_update: "bulk_update";
+    create: "create";
+    credentials_fill: "credentials_fill";
+    credentials_totp_generation: "credentials_totp_generation";
+    delete: "delete";
+    detach: "detach";
+    document_processed: "document_processed";
+    embedding: "embedding";
+    image_generation: "image_generation";
+    inference: "inference";
+    publish: "publish";
+    unpublish: "unpublish";
+    update: "update";
+}>, z.ZodString]>;
+export declare const AuditAggregationRowSchema: z.ZodObject<{
+    dimensions: z.ZodObject<{
+        time: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        action: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        resource_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        event_category: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        provider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        project_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        'details.pipeline': z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        'details.verdict': z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        'details.workflow_type': z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        'details.rule_id': z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>;
+    metrics: z.ZodObject<{}, z.core.$catchall<z.ZodNumber>>;
+}, z.core.$strict>;
+export declare const AuditAggregationMetricSchema: z.ZodObject<{
+    id: z.ZodString;
+    operation: z.ZodEnum<{
+        average_meter: "average_meter";
+        count: "count";
+        count_distinct: "count_distinct";
+        sum_meter: "sum_meter";
+    }>;
+    field: z.ZodOptional<z.ZodEnum<{
+        request_id: "request_id";
+        resource_id: "resource_id";
+    }>>;
+    meterCategory: z.ZodOptional<z.ZodString>;
+    meterType: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const AuditAggregationGroupSchema: z.ZodObject<{
+    dimension: z.ZodEnum<{
+        action: "action";
+        "details.pipeline": "details.pipeline";
+        "details.rule_id": "details.rule_id";
+        "details.verdict": "details.verdict";
+        "details.workflow_type": "details.workflow_type";
+        event_category: "event_category";
+        model: "model";
+        project_id: "project_id";
+        provider: "provider";
+        resource_type: "resource_type";
+        time: "time";
+    }>;
+    resolution: z.ZodOptional<z.ZodEnum<{
+        day: "day";
+        hour: "hour";
+        month: "month";
+        week: "week";
+    }>>;
+}, z.core.$strict>;
+export declare const AuditAggregationDetailFilterSchema: z.ZodObject<{
+    field: z.ZodEnum<{
+        pipeline: "pipeline";
+        rule_id: "rule_id";
+        verdict: "verdict";
+        workflow_type: "workflow_type";
+    }>;
+    values: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const AuditTrailEventSchema: z.ZodObject<{
+    event_type: z.ZodLiteral<"audit">;
+    event_id: z.ZodOptional<z.ZodString>;
+    event_category: z.ZodOptional<z.ZodEnum<{
+        billing: "billing";
+        content: "content";
+        external: "external";
+        security: "security";
+        system: "system";
+        workflow: "workflow";
+    }>>;
+    source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    root_event_id: z.ZodOptional<z.ZodString>;
+    caused_by_event_id: z.ZodOptional<z.ZodString>;
+    hop_count: z.ZodOptional<z.ZodNumber>;
+    audit_trail: z.ZodOptional<z.ZodBoolean>;
+    replay_of: z.ZodOptional<z.ZodString>;
+    replay_root_event_id: z.ZodOptional<z.ZodString>;
+    replayed_by: z.ZodOptional<z.ZodString>;
+    action: z.ZodUnion<readonly [z.ZodEnum<{
+        attach: "attach";
+        bulk_change_type: "bulk_change_type";
+        bulk_create: "bulk_create";
+        bulk_delete: "bulk_delete";
+        bulk_update: "bulk_update";
+        create: "create";
+        credentials_fill: "credentials_fill";
+        credentials_totp_generation: "credentials_totp_generation";
+        delete: "delete";
+        detach: "detach";
+        document_processed: "document_processed";
+        embedding: "embedding";
+        image_generation: "image_generation";
+        inference: "inference";
+        publish: "publish";
+        unpublish: "unpublish";
+        update: "update";
+    }>, z.ZodString]>;
+    resource_type: z.ZodString;
+    resource_id: z.ZodString;
+    timestamp: z.ZodString;
+    request_id: z.ZodString;
+    status: z.ZodNumber;
+    success: z.ZodBoolean;
+    principal_id: z.ZodNullable<z.ZodString>;
+    principal_type: z.ZodNullable<z.ZodString>;
+    effective_principal_id: z.ZodNullable<z.ZodString>;
+    roles: z.ZodArray<z.ZodString>;
+    account_id: z.ZodNullable<z.ZodString>;
+    project_id: z.ZodNullable<z.ZodString>;
+    tenant_id: z.ZodNullable<z.ZodString>;
+    account_name: z.ZodNullable<z.ZodString>;
+    project_name: z.ZodNullable<z.ZodString>;
+    provider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    meters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        type: z.ZodString;
+        quantity: z.ZodNumber;
+    }, z.core.$strict>>>;
+    details: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+}, z.core.$strict>;
+export declare const AuditAggregationResponseSchema: z.ZodObject<{
+    rows: z.ZodArray<z.ZodObject<{
+        dimensions: z.ZodObject<{
+            time: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            action: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            resource_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            event_category: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            provider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            project_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            'details.pipeline': z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            'details.verdict': z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            'details.workflow_type': z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            'details.rule_id': z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>;
+        metrics: z.ZodObject<{}, z.core.$catchall<z.ZodNumber>>;
+    }, z.core.$strict>>;
+    from: z.ZodString;
+    to: z.ZodString;
+}, z.core.$strict>;
+export declare const AuditAggregationFilterSchema: z.ZodObject<{
+    actions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+        attach: "attach";
+        bulk_change_type: "bulk_change_type";
+        bulk_create: "bulk_create";
+        bulk_delete: "bulk_delete";
+        bulk_update: "bulk_update";
+        create: "create";
+        credentials_fill: "credentials_fill";
+        credentials_totp_generation: "credentials_totp_generation";
+        delete: "delete";
+        detach: "detach";
+        document_processed: "document_processed";
+        embedding: "embedding";
+        image_generation: "image_generation";
+        inference: "inference";
+        publish: "publish";
+        unpublish: "unpublish";
+        update: "update";
+    }>, z.ZodString]>>>;
+    resourceTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    eventCategories: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        billing: "billing";
+        content: "content";
+        external: "external";
+        security: "security";
+        system: "system";
+        workflow: "workflow";
+    }>>>;
+    providers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    success: z.ZodOptional<z.ZodBoolean>;
+    details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field: z.ZodEnum<{
+            pipeline: "pipeline";
+            rule_id: "rule_id";
+            verdict: "verdict";
+            workflow_type: "workflow_type";
+        }>;
+        values: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const AuditTrailResponseSchema: z.ZodObject<{
+    events: z.ZodArray<z.ZodObject<{
+        event_type: z.ZodLiteral<"audit">;
+        event_id: z.ZodOptional<z.ZodString>;
+        event_category: z.ZodOptional<z.ZodEnum<{
+            billing: "billing";
+            content: "content";
+            external: "external";
+            security: "security";
+            system: "system";
+            workflow: "workflow";
+        }>>;
+        source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        root_event_id: z.ZodOptional<z.ZodString>;
+        caused_by_event_id: z.ZodOptional<z.ZodString>;
+        hop_count: z.ZodOptional<z.ZodNumber>;
+        audit_trail: z.ZodOptional<z.ZodBoolean>;
+        replay_of: z.ZodOptional<z.ZodString>;
+        replay_root_event_id: z.ZodOptional<z.ZodString>;
+        replayed_by: z.ZodOptional<z.ZodString>;
+        action: z.ZodUnion<readonly [z.ZodEnum<{
+            attach: "attach";
+            bulk_change_type: "bulk_change_type";
+            bulk_create: "bulk_create";
+            bulk_delete: "bulk_delete";
+            bulk_update: "bulk_update";
+            create: "create";
+            credentials_fill: "credentials_fill";
+            credentials_totp_generation: "credentials_totp_generation";
+            delete: "delete";
+            detach: "detach";
+            document_processed: "document_processed";
+            embedding: "embedding";
+            image_generation: "image_generation";
+            inference: "inference";
+            publish: "publish";
+            unpublish: "unpublish";
+            update: "update";
+        }>, z.ZodString]>;
+        resource_type: z.ZodString;
+        resource_id: z.ZodString;
+        timestamp: z.ZodString;
+        request_id: z.ZodString;
+        status: z.ZodNumber;
+        success: z.ZodBoolean;
+        principal_id: z.ZodNullable<z.ZodString>;
+        principal_type: z.ZodNullable<z.ZodString>;
+        effective_principal_id: z.ZodNullable<z.ZodString>;
+        roles: z.ZodArray<z.ZodString>;
+        account_id: z.ZodNullable<z.ZodString>;
+        project_id: z.ZodNullable<z.ZodString>;
+        tenant_id: z.ZodNullable<z.ZodString>;
+        account_name: z.ZodNullable<z.ZodString>;
+        project_name: z.ZodNullable<z.ZodString>;
+        provider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        meters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            category: z.ZodString;
+            type: z.ZodString;
+            quantity: z.ZodNumber;
+        }, z.core.$strict>>>;
+        details: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    }, z.core.$strict>>;
+    hasNext: z.ZodBoolean;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+}, z.core.$strict>;
+export declare const AuditAggregationQuerySchema: z.ZodObject<{
+    projectId: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodString>;
+    filter: z.ZodOptional<z.ZodObject<{
+        actions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+            attach: "attach";
+            bulk_change_type: "bulk_change_type";
+            bulk_create: "bulk_create";
+            bulk_delete: "bulk_delete";
+            bulk_update: "bulk_update";
+            create: "create";
+            credentials_fill: "credentials_fill";
+            credentials_totp_generation: "credentials_totp_generation";
+            delete: "delete";
+            detach: "detach";
+            document_processed: "document_processed";
+            embedding: "embedding";
+            image_generation: "image_generation";
+            inference: "inference";
+            publish: "publish";
+            unpublish: "unpublish";
+            update: "update";
+        }>, z.ZodString]>>>;
+        resourceTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        eventCategories: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            billing: "billing";
+            content: "content";
+            external: "external";
+            security: "security";
+            system: "system";
+            workflow: "workflow";
+        }>>>;
+        providers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        success: z.ZodOptional<z.ZodBoolean>;
+        details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodEnum<{
+                pipeline: "pipeline";
+                rule_id: "rule_id";
+                verdict: "verdict";
+                workflow_type: "workflow_type";
+            }>;
+            values: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    groupBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        dimension: z.ZodEnum<{
+            action: "action";
+            "details.pipeline": "details.pipeline";
+            "details.rule_id": "details.rule_id";
+            "details.verdict": "details.verdict";
+            "details.workflow_type": "details.workflow_type";
+            event_category: "event_category";
+            model: "model";
+            project_id: "project_id";
+            provider: "provider";
+            resource_type: "resource_type";
+            time: "time";
+        }>;
+        resolution: z.ZodOptional<z.ZodEnum<{
+            day: "day";
+            hour: "hour";
+            month: "month";
+            week: "week";
+        }>>;
+    }, z.core.$strict>>>;
+    metrics: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        operation: z.ZodEnum<{
+            average_meter: "average_meter";
+            count: "count";
+            count_distinct: "count_distinct";
+            sum_meter: "sum_meter";
+        }>;
+        field: z.ZodOptional<z.ZodEnum<{
+            request_id: "request_id";
+            resource_id: "resource_id";
+        }>>;
+        meterCategory: z.ZodOptional<z.ZodString>;
+        meterType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const AuditTrailQuerySchema: z.ZodObject<{
+    actions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+        attach: "attach";
+        bulk_change_type: "bulk_change_type";
+        bulk_create: "bulk_create";
+        bulk_delete: "bulk_delete";
+        bulk_update: "bulk_update";
+        create: "create";
+        credentials_fill: "credentials_fill";
+        credentials_totp_generation: "credentials_totp_generation";
+        delete: "delete";
+        detach: "detach";
+        document_processed: "document_processed";
+        embedding: "embedding";
+        image_generation: "image_generation";
+        inference: "inference";
+        publish: "publish";
+        unpublish: "unpublish";
+        update: "update";
+    }>, z.ZodString]>>>;
+    resourceTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    resourceId: z.ZodOptional<z.ZodString>;
+    principalId: z.ZodOptional<z.ZodString>;
+    principalType: z.ZodOptional<z.ZodString>;
+    effectivePrincipalId: z.ZodOptional<z.ZodString>;
+    hasEffectivePrincipal: z.ZodOptional<z.ZodBoolean>;
+    projectId: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+//# sourceMappingURL=audit-trail.d.ts.map

package/lib/api-schemas/audit-trail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-trail.d.ts","sourceRoot":"","sources":["../../src/api-schemas/audit-trail.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,gBAAgB;;;;kBAUvB,CAAC;AAMP,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;EAAyD,CAAC;AAE7F,eAAO,MAAM,mBAAmB;;;;;;;EAEE,CAAC;AAEnC,eAAO,MAAM,kCAAkC;;;;;;;;;;;;kBAcE,CAAC;AAElD,eAAO,MAAM,mCAAmC;;;EAEE,CAAC;AAEnD,eAAO,MAAM,+BAA+B;;;;;EAEE,CAAC;AAE/C,eAAO,MAAM,gCAAgC;;;;;EAEE,CAAC;AAEhD,eAAO,MAAM,+BAA+B;;;;;;;;;;;;EAEE,CAAC;AAE/C,eAAO,MAAM,iCAAiC;;;;;EAEE,CAAC;AAEjD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;iBAA4E,CAAC;AAE3G,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;kBAKE,CAAC;AAEzC,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;kBAWE,CAAC;AAE5C,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;kBAOE,CAAC;AAE3C,eAAO,MAAM,kCAAkC;;;;;;;;kBAKE,CAAC;AAElD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2CE,CAAC;AAErC,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;kBAME,CAAC;AAE9C,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBASE,CAAC;AAE5C,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAOE,CAAC;AAExC,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoBlC,CAAC;AAGP,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuCE,CAAC"}

package/lib/api-schemas/audit-trail.js

@@ -0,0 +1,218 @@
+import { z } from 'zod';
+import { AUDIT_ACTIONS, AUDIT_AGGREGATION_DIMENSIONS } from '../audit-trail.js';
+import { NumberValueMapSchema } from './interaction.js';
+// The audit trail: the events `GET /audit-trail` pages through and the aggregation `POST
+// /audit-trail/aggregate` computes over them.
+//
+// `//` rather than `/** */` throughout: a JSDoc block immediately preceding an exported declaration
+// is picked up by the OpenAPI scanner and published as that component's `description`, which would
+// double up with the `description` stated in `.meta()`.
+export const AuditMeterSchema = z
+    .strictObject({
+    category: z.string(),
+    type: z.string(),
+    quantity: z.number(),
+})
+    .meta({
+    id: 'AuditMeter',
+    description: 'Generic metering entry attached to audit events. Used for cost attribution, usage tracking, and billing.\n\nExamples:   { category: "tokens", type: "input", quantity: 1234 }   { category: "tokens", type: "output", quantity: 567 }   { category: "compute", type: "duration_ms", quantity: 2100 }   { category: "processing", type: "pages", quantity: 12 }',
+});
+// The two action/dimension vocabularies read their members off the `as const` arrays in
+// `../audit-trail.js` rather than restating them: those arrays are what the readers and the
+// aggregation validator iterate, so a member added there reaches the document with nothing here
+// changing. Everything else in this file is spelled out.
+export const KnownAuditActionSchema = z.enum(AUDIT_ACTIONS).meta({ id: 'KnownAuditAction' });
+export const EventCategorySchema = z
+    .enum(['content', 'workflow', 'security', 'billing', 'system', 'external'])
+    .meta({ id: 'EventCategory' });
+export const AuditAggregationDimensionMapSchema = z
+    .strictObject({
+    time: z.string().nullable().optional(),
+    action: z.string().nullable().optional(),
+    resource_type: z.string().nullable().optional(),
+    event_category: z.string().nullable().optional(),
+    provider: z.string().nullable().optional(),
+    project_id: z.string().nullable().optional(),
+    'details.pipeline': z.string().nullable().optional(),
+    'details.verdict': z.string().nullable().optional(),
+    'details.workflow_type': z.string().nullable().optional(),
+    'details.rule_id': z.string().nullable().optional(),
+    model: z.string().nullable().optional(),
+})
+    .meta({ id: 'AuditAggregationDimensionMap' });
+export const AuditAggregationDistinctFieldSchema = z
+    .enum(['resource_id', 'request_id'])
+    .meta({ id: 'AuditAggregationDistinctField' });
+export const AuditAggregationOperationSchema = z
+    .enum(['count', 'count_distinct', 'sum_meter', 'average_meter'])
+    .meta({ id: 'AuditAggregationOperation' });
+export const AuditAggregationResolutionSchema = z
+    .enum(['hour', 'day', 'week', 'month'])
+    .meta({ id: 'AuditAggregationResolution' });
+export const AuditAggregationDimensionSchema = z
+    .enum(AUDIT_AGGREGATION_DIMENSIONS)
+    .meta({ id: 'AuditAggregationDimension' });
+export const AuditAggregationDetailFieldSchema = z
+    .enum(['pipeline', 'verdict', 'workflow_type', 'rule_id'])
+    .meta({ id: 'AuditAggregationDetailField' });
+export const AuditActionSchema = z.union([KnownAuditActionSchema, z.string()]).meta({ id: 'AuditAction' });
+export const AuditAggregationRowSchema = z
+    .strictObject({
+    dimensions: AuditAggregationDimensionMapSchema,
+    metrics: NumberValueMapSchema,
+})
+    .meta({ id: 'AuditAggregationRow' });
+export const AuditAggregationMetricSchema = z
+    .strictObject({
+    id: z.string().meta({
+        description: 'Stable key used in response rows. Must contain only letters, numbers, underscores, or hyphens.',
+    }),
+    operation: AuditAggregationOperationSchema,
+    field: AuditAggregationDistinctFieldSchema.meta({ description: 'Required for count_distinct.' }).optional(),
+    meterCategory: z.string().meta({ description: 'Required for meter operations.' }).optional(),
+    meterType: z.string().meta({ description: 'Required for meter operations.' }).optional(),
+})
+    .meta({ id: 'AuditAggregationMetric' });
+export const AuditAggregationGroupSchema = z
+    .strictObject({
+    dimension: AuditAggregationDimensionSchema,
+    resolution: AuditAggregationResolutionSchema.meta({
+        description: 'Required for the time dimension; defaults to day.',
+    }).optional(),
+})
+    .meta({ id: 'AuditAggregationGroup' });
+export const AuditAggregationDetailFilterSchema = z
+    .strictObject({
+    field: AuditAggregationDetailFieldSchema,
+    values: z.array(z.string()),
+})
+    .meta({ id: 'AuditAggregationDetailFilter' });
+export const AuditTrailEventSchema = z
+    .strictObject({
+    event_type: z.literal('audit'),
+    event_id: z.string().optional(),
+    event_category: EventCategorySchema.optional(),
+    source: z.string().nullable().optional(),
+    root_event_id: z.string().optional(),
+    caused_by_event_id: z.string().optional(),
+    hop_count: z.number().optional(),
+    audit_trail: z.boolean().optional(),
+    replay_of: z.string().optional(),
+    replay_root_event_id: z.string().optional(),
+    replayed_by: z.string().optional(),
+    action: AuditActionSchema,
+    resource_type: z.string(),
+    resource_id: z.string(),
+    timestamp: z.string(),
+    request_id: z.string(),
+    status: z.number(),
+    success: z.boolean(),
+    principal_id: z.string().nullable(),
+    principal_type: z.string().nullable(),
+    effective_principal_id: z.string().nullable(),
+    roles: z.array(z.string()),
+    account_id: z.string().nullable(),
+    project_id: z.string().nullable(),
+    tenant_id: z.string().nullable(),
+    account_name: z.string().nullable(),
+    project_name: z.string().nullable(),
+    provider: z
+        .string()
+        .nullable()
+        .meta({ description: 'Provider type for billable/provider-backed events, e.g. vertexai, bedrock.' })
+        .optional(),
+    meters: z
+        .array(AuditMeterSchema)
+        .meta({ description: 'Generic metering data for cost attribution and usage tracking' })
+        .optional(),
+    details: z
+        .looseObject({})
+        .meta({ description: 'Event-specific metadata — shape varies by action/resource_type' })
+        .optional(),
+})
+    .meta({ id: 'AuditTrailEvent' });
+export const AuditAggregationResponseSchema = z
+    .strictObject({
+    rows: z.array(AuditAggregationRowSchema),
+    from: z.string(),
+    to: z.string(),
+})
+    .meta({ id: 'AuditAggregationResponse' });
+export const AuditAggregationFilterSchema = z
+    .strictObject({
+    actions: z.array(AuditActionSchema).optional(),
+    resourceTypes: z.array(z.string()).optional(),
+    eventCategories: z.array(EventCategorySchema).optional(),
+    providers: z.array(z.string()).optional(),
+    success: z.boolean().optional(),
+    details: z.array(AuditAggregationDetailFilterSchema).optional(),
+})
+    .meta({ id: 'AuditAggregationFilter' });
+export const AuditTrailResponseSchema = z
+    .strictObject({
+    events: z.array(AuditTrailEventSchema),
+    hasNext: z.boolean().meta({ description: 'Whether there are more events after this page' }),
+    limit: z.number(),
+    offset: z.number(),
+})
+    .meta({ id: 'AuditTrailResponse' });
+export const AuditAggregationQuerySchema = z
+    .strictObject({
+    projectId: z
+        .string()
+        .meta({ description: 'Optional account-admin project filter. Ignored for project-scoped principals.' })
+        .optional(),
+    from: z
+        .string()
+        .meta({ description: 'Start time; defaults to 30 days before to. The server caps the range at 366 days.' })
+        .optional(),
+    to: z.string().meta({ description: 'End time; defaults to the current time.' }).optional(),
+    filter: AuditAggregationFilterSchema.optional(),
+    groupBy: z.array(AuditAggregationGroupSchema).optional(),
+    metrics: z.array(AuditAggregationMetricSchema),
+    limit: z.number().meta({ description: 'Maximum groups returned (default 50, max 200).' }).optional(),
+})
+    .meta({
+    id: 'AuditAggregationQuery',
+    description: 'Safe audit aggregation query. The server always applies the authenticated account scope and, for project-scoped principals, replaces projectId with the authenticated project.',
+});
+// Query contracts are registry components even though the scanner expands them into parameters.
+export const AuditTrailQuerySchema = z
+    .strictObject({
+    actions: z.array(AuditActionSchema).meta({ description: 'Filter by action types' }).optional(),
+    resourceTypes: z.array(z.string()).meta({ description: 'Filter by resource types' }).optional(),
+    resourceId: z.string().meta({ description: 'Filter by resource ID' }).optional(),
+    principalId: z
+        .string()
+        .meta({ description: 'Filter by exact actor principal ref (matches principal_id column).' })
+        .optional(),
+    principalType: z
+        .string()
+        .meta({ description: 'Filter by top-level actor category (matches principal_type column).' })
+        .optional(),
+    effectivePrincipalId: z
+        .string()
+        .meta({
+        description: 'Filter by delegated/direct effective principal ref (matches effective_principal_id column).',
+    })
+        .optional(),
+    hasEffectivePrincipal: z
+        .boolean()
+        .meta({ description: 'Filter by whether an event has an effective principal ref.' })
+        .optional(),
+    projectId: z
+        .string()
+        .meta({
+        description: 'Filter by project ID. Honoured only for account-scoped principals; a project-scoped principal always reads its own project.',
+    })
+        .optional(),
+    from: z.string().meta({ description: 'Start time (ISO string)' }).optional(),
+    to: z.string().meta({ description: 'End time (ISO string)' }).optional(),
+    limit: z
+        .number()
+        .meta({ description: 'Pagination: number of items to return (default 50, max 200)' })
+        .optional(),
+    offset: z.number().meta({ description: 'Pagination: offset' }).optional(),
+})
+    .meta({ id: 'AuditTrailQuery' });
+//# sourceMappingURL=audit-trail.js.map