@lssm/lib.contracts-spec 17.3.2

package/dist/customer-support/reporting-operations.js

@@ -0,0 +1 @@
+import{defineCommand as r,defineQuery as i}from"../operations/index.js";import{supportOperationErrors as o}from"./operation-schemas.js";import{SupportReportDefinitionGetInputModel as a,SupportReportDefinitionLifecycleInputModel as n,SupportReportDefinitionListInputModel as c,SupportReportDefinitionListOutputModel as d,SupportReportDefinitionRevisionInputModel as m,SupportReportDefinitionRevisionModel as e}from"./reporting-definition-schemas.js";import{SupportReportingDocRef as f}from"./reporting-doc.js";import{SupportReportQueryInputModel as R,SupportReportQueryOutputModel as l}from"./reporting-query-schemas.js";import{SupportCaseCorrectionRecordInputModel as g,SupportCaseOutcomeRecordInputModel as y,SupportReportingMutationOutputModel as u}from"./reporting-record-schemas.js";const t=(s,p)=>({key:s,version:"1.0.0",title:p,description:`${p} with server-derived authority and immutable evidence.`,goal:p,context:"SupportOS reporting exposes revision-pinned privacy-safe aggregates and never accepts or returns raw support content.",domain:"customer-support",owners:["platform.support","platform.data"],tags:["support","reporting","analytics","privacy"],stability:"experimental",docId:[f]});export const SupportReportDefinitionCreateRevisionCommand=r({meta:t("support.reporting.definition.create-revision","Create support report definition revision"),io:{input:m,output:e,errors:o},policy:{auth:"user",pii:[]}});export const SupportReportDefinitionPublishCommand=r({meta:t("support.reporting.definition.publish","Publish support report definition"),io:{input:n,output:e,errors:o},policy:{auth:"user",pii:[]}});export const SupportReportDefinitionRetireCommand=r({meta:t("support.reporting.definition.retire","Retire support report definition"),io:{input:n,output:e,errors:o},policy:{auth:"user",pii:[]}});export const SupportReportDefinitionGetQuery=i({meta:t("support.reporting.definition.get","Get support report definition"),io:{input:a,output:e,errors:o},policy:{auth:"user",pii:[]}});export const SupportReportDefinitionListQuery=i({meta:t("support.reporting.definition.list","List support report definitions"),io:{input:c,output:d,errors:o},policy:{auth:"user",pii:[]}});export const SupportReportingQuery=i({meta:t("support.reporting.query","Query support report aggregates"),io:{input:R,output:l,errors:o},policy:{auth:"user",pii:[]}});export const SupportReportingCorrectionRecordCommand=r({meta:t("support.reporting.correction.record","Record support case correction evidence"),io:{input:g,output:u,errors:o},policy:{auth:"user",pii:[]}});export const SupportReportingOutcomeRecordCommand=r({meta:t("support.reporting.outcome.record","Record support case outcome evidence"),io:{input:y,output:u,errors:o},policy:{auth:"user",pii:[]}});export const supportReportingOperations=[SupportReportDefinitionCreateRevisionCommand,SupportReportDefinitionPublishCommand,SupportReportDefinitionRetireCommand,SupportReportDefinitionGetQuery,SupportReportDefinitionListQuery,SupportReportingQuery,SupportReportingCorrectionRecordCommand,SupportReportingOutcomeRecordCommand];

package/dist/customer-support/reporting-port.d.ts

@@ -0,0 +1,17 @@
+import type { SupportAuthorityScope } from './ports.js';
+import type { SupportCaseCorrectionRecord, SupportCaseOutcomeRecord, SupportReportDefinitionLifecycleMutation, SupportReportDefinitionList, SupportReportDefinitionListResult, SupportReportDefinitionRevision, SupportReportDefinitionRevisionMutation, SupportReportDefinitionView, SupportReportingMutationResult, SupportReportQuery, SupportReportResult } from './reporting.js';
+export interface SupportReportingAuthorityPort {
+    createDefinitionRevision(scope: SupportAuthorityScope, input: SupportReportDefinitionRevisionMutation): Promise<SupportReportDefinitionRevision>;
+    publishDefinition(scope: SupportAuthorityScope, input: SupportReportDefinitionLifecycleMutation): Promise<SupportReportDefinitionRevision>;
+    retireDefinition(scope: SupportAuthorityScope, input: SupportReportDefinitionLifecycleMutation): Promise<SupportReportDefinitionRevision>;
+    getDefinition(scope: SupportAuthorityScope, input: {
+        readonly definitionRef: string;
+        readonly revision?: number;
+        readonly view?: SupportReportDefinitionView;
+    }): Promise<SupportReportDefinitionRevision | undefined>;
+    listDefinitions(scope: SupportAuthorityScope, input: SupportReportDefinitionList): Promise<SupportReportDefinitionListResult>;
+    query(scope: SupportAuthorityScope, input: SupportReportQuery): Promise<SupportReportResult>;
+    recordCorrection(scope: SupportAuthorityScope, input: SupportCaseCorrectionRecord): Promise<SupportReportingMutationResult>;
+    recordOutcome(scope: SupportAuthorityScope, input: SupportCaseOutcomeRecord): Promise<SupportReportingMutationResult>;
+}
+export type SupportCaseReportingAuthorityPort = SupportReportingAuthorityPort;

package/dist/customer-support/reporting-query-schemas.d.ts

@@ -0,0 +1,259 @@
+import { SchemaModel } from '@lssm/lib.schema';
+declare const filterFields: {
+    dimension: {
+        type: import("@lssm/lib.schema").EnumType<["queue", "priority", "channel", "csat-score", "sla-target", "correction-kind", "outcome-kind"]>;
+        isOptional: boolean;
+    };
+    valueRefs: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+        isArray: true;
+    };
+};
+export declare const SupportReportFilterModel: SchemaModel<typeof filterFields>;
+declare const queryFields: {
+    definitionRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    expectedDefinitionRevision: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: boolean;
+    };
+    from: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    to: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    timezone: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    timezoneDataRevision: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    filters: {
+        type: SchemaModel<{
+            dimension: {
+                type: import("@lssm/lib.schema").EnumType<["queue", "priority", "channel", "csat-score", "sla-target", "correction-kind", "outcome-kind"]>;
+                isOptional: boolean;
+            };
+            valueRefs: {
+                type: import("@lssm/lib.schema").FieldType<string, string>;
+                isOptional: boolean;
+                isArray: true;
+            };
+        }>;
+        isOptional: boolean;
+        isArray: true;
+    };
+    projection: {
+        type: import("@lssm/lib.schema").EnumType<["redacted", "sensitive"]>;
+        isOptional: boolean;
+    };
+    limit: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: boolean;
+    };
+    cursor: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    watermark: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+};
+export declare const SupportReportQueryInputModel: SchemaModel<typeof queryFields>;
+declare const dimensionCellFields: {
+    dimension: {
+        type: import("@lssm/lib.schema").EnumType<["time-bucket", "queue", "priority", "channel", "csat-score", "sla-target", "correction-kind", "outcome-kind"]>;
+        isOptional: boolean;
+    };
+    valueRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+};
+export declare const SupportReportDimensionCellModel: SchemaModel<typeof dimensionCellFields>;
+declare const metricCellFields: {
+    metric: {
+        type: import("@lssm/lib.schema").EnumType<["case-created", "case-resolved", "case-reopened", "queue-arrival-count", "queue-backlog-count", "queue-backlog-age-average-ms", "sla-met", "sla-breached", "first-response-duration-average-ms", "resolution-duration-average-ms", "first-response-sla-attainment-rate", "resolution-sla-attainment-rate", "reopen-rate", "csat-response-count", "csat-score-average", "csat-score-count", "csat-response-rate", "correction-count", "outcome-count"]>;
+        isOptional: boolean;
+    };
+    state: {
+        type: import("@lssm/lib.schema").EnumType<["measured", "suppressed", "unavailable"]>;
+        isOptional: boolean;
+    };
+    value: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: boolean;
+    };
+    numerator: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: boolean;
+    };
+    denominator: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: boolean;
+    };
+};
+export declare const SupportReportMetricCellModel: SchemaModel<typeof metricCellFields>;
+declare const rowFields: {
+    rowRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    bucketStart: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    bucketEnd: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    dimensions: {
+        type: SchemaModel<{
+            dimension: {
+                type: import("@lssm/lib.schema").EnumType<["time-bucket", "queue", "priority", "channel", "csat-score", "sla-target", "correction-kind", "outcome-kind"]>;
+                isOptional: boolean;
+            };
+            valueRef: {
+                type: import("@lssm/lib.schema").FieldType<string, string>;
+                isOptional: boolean;
+            };
+        }>;
+        isOptional: boolean;
+        isArray: true;
+    };
+    metrics: {
+        type: SchemaModel<{
+            metric: {
+                type: import("@lssm/lib.schema").EnumType<["case-created", "case-resolved", "case-reopened", "queue-arrival-count", "queue-backlog-count", "queue-backlog-age-average-ms", "sla-met", "sla-breached", "first-response-duration-average-ms", "resolution-duration-average-ms", "first-response-sla-attainment-rate", "resolution-sla-attainment-rate", "reopen-rate", "csat-response-count", "csat-score-average", "csat-score-count", "csat-response-rate", "correction-count", "outcome-count"]>;
+                isOptional: boolean;
+            };
+            state: {
+                type: import("@lssm/lib.schema").EnumType<["measured", "suppressed", "unavailable"]>;
+                isOptional: boolean;
+            };
+            value: {
+                type: import("@lssm/lib.schema").FieldType<number, number>;
+                isOptional: boolean;
+            };
+            numerator: {
+                type: import("@lssm/lib.schema").FieldType<number, number>;
+                isOptional: boolean;
+            };
+            denominator: {
+                type: import("@lssm/lib.schema").FieldType<number, number>;
+                isOptional: boolean;
+            };
+        }>;
+        isOptional: boolean;
+        isArray: true;
+    };
+};
+export declare const SupportReportAggregateRowModel: SchemaModel<typeof rowFields>;
+declare const outputFields: {
+    definitionRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    definitionRevision: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: boolean;
+    };
+    projection: {
+        type: import("@lssm/lib.schema").EnumType<["redacted", "sensitive"]>;
+        isOptional: boolean;
+    };
+    rows: {
+        type: SchemaModel<{
+            rowRef: {
+                type: import("@lssm/lib.schema").FieldType<string, string>;
+                isOptional: boolean;
+            };
+            bucketStart: {
+                type: import("@lssm/lib.schema").FieldType<string, string>;
+                isOptional: boolean;
+            };
+            bucketEnd: {
+                type: import("@lssm/lib.schema").FieldType<string, string>;
+                isOptional: boolean;
+            };
+            dimensions: {
+                type: SchemaModel<{
+                    dimension: {
+                        type: import("@lssm/lib.schema").EnumType<["time-bucket", "queue", "priority", "channel", "csat-score", "sla-target", "correction-kind", "outcome-kind"]>;
+                        isOptional: boolean;
+                    };
+                    valueRef: {
+                        type: import("@lssm/lib.schema").FieldType<string, string>;
+                        isOptional: boolean;
+                    };
+                }>;
+                isOptional: boolean;
+                isArray: true;
+            };
+            metrics: {
+                type: SchemaModel<{
+                    metric: {
+                        type: import("@lssm/lib.schema").EnumType<["case-created", "case-resolved", "case-reopened", "queue-arrival-count", "queue-backlog-count", "queue-backlog-age-average-ms", "sla-met", "sla-breached", "first-response-duration-average-ms", "resolution-duration-average-ms", "first-response-sla-attainment-rate", "resolution-sla-attainment-rate", "reopen-rate", "csat-response-count", "csat-score-average", "csat-score-count", "csat-response-rate", "correction-count", "outcome-count"]>;
+                        isOptional: boolean;
+                    };
+                    state: {
+                        type: import("@lssm/lib.schema").EnumType<["measured", "suppressed", "unavailable"]>;
+                        isOptional: boolean;
+                    };
+                    value: {
+                        type: import("@lssm/lib.schema").FieldType<number, number>;
+                        isOptional: boolean;
+                    };
+                    numerator: {
+                        type: import("@lssm/lib.schema").FieldType<number, number>;
+                        isOptional: boolean;
+                    };
+                    denominator: {
+                        type: import("@lssm/lib.schema").FieldType<number, number>;
+                        isOptional: boolean;
+                    };
+                }>;
+                isOptional: boolean;
+                isArray: true;
+            };
+        }>;
+        isOptional: boolean;
+        isArray: true;
+    };
+    suppressionPolicy: {
+        type: SchemaModel<{
+            kind: {
+                type: import("@lssm/lib.schema").EnumType<["minimum-cohort"]>;
+                isOptional: boolean;
+            };
+            minimumCount: {
+                type: import("@lssm/lib.schema").FieldType<number, number>;
+                isOptional: boolean;
+            };
+        }>;
+        isOptional: boolean;
+    };
+    queryReceiptRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    watermark: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    nextCursor: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+};
+export declare const SupportReportQueryOutputModel: SchemaModel<typeof outputFields>;
+export {};

package/dist/customer-support/reporting-query-schemas.js

@@ -0,0 +1 @@
+import{SupportReportSuppressionPolicyModel as b}from"./reporting-definition-schemas.js";import{validateSupportReportQuery as S}from"./reporting-query-validation.js";import{decimal as f,id as n,integer as l,issue as r,ReportDimension as w,ReportFilterDimension as g,ReportingStrictSchema as s,ReportMetric as M,ReportMetricState as h,ReportProjection as R,text as o,validateRefArray as F,validIso as y,validRef as a,validRevision as O}from"./reporting-schema-primitives.js";const k={dimension:{type:g,isOptional:!1},valueRefs:{type:n().type,isOptional:!1,isArray:!0}};export const SupportReportFilterModel=new s({name:"SupportReportFilterV1",fields:k},(e,t)=>{F(e.valueRefs,"valueRefs",t);if(Array.isArray(e.valueRefs)&&e.valueRefs.length<1)r(t,"valueRefs","valueRefs must not be empty")});const A={definitionRef:n(),expectedDefinitionRevision:l(),from:o(),to:o(),timezone:o(),timezoneDataRevision:n(),filters:{type:SupportReportFilterModel,isOptional:!1,isArray:!0},projection:{type:R,isOptional:!1},limit:l(),cursor:o(!0),watermark:o(!0)};export const SupportReportQueryInputModel=new s({name:"SupportReportQueryInputV1",fields:A},S);const C={dimension:{type:w,isOptional:!1},valueRef:n()};export const SupportReportDimensionCellModel=new s({name:"SupportReportDimensionCellV1",fields:C},(e,t)=>{if(!a(e.valueRef))r(t,"valueRef","valueRef must be opaque and bounded")});const q={metric:{type:M,isOptional:!1},state:{type:h,isOptional:!1},value:{...f(),isOptional:!0},numerator:{...f(),isOptional:!0},denominator:{...f(),isOptional:!0}};export const SupportReportMetricCellModel=new s({name:"SupportReportMetricCellV1",fields:q},(e,t)=>{const i=new Set(["first-response-sla-attainment-rate","resolution-sla-attainment-rate","reopen-rate","csat-response-rate"]),p=[e.value,e.numerator,e.denominator];if(e.state==="measured"){if(typeof e.value!=="number"||!Number.isFinite(e.value)||e.value<0)r(t,"value","measured cells require a finite nonnegative value");if(e.numerator===void 0!==(e.denominator===void 0))r(t,"denominator","numerator and denominator must be provided together");if(e.numerator!==void 0&&(typeof e.numerator!=="number"||!Number.isFinite(e.numerator)||e.numerator<0||typeof e.denominator!=="number"||!Number.isFinite(e.denominator)||e.denominator<=0))r(t,"denominator","ratio evidence must be finite and nonnegative");if(i.has(String(e.metric))&&(e.numerator===void 0||e.denominator===void 0))r(t,"numerator","rate cells require explicit numerator and denominator evidence");if(!i.has(String(e.metric))&&e.numerator!==void 0)r(t,"numerator","non-rate cells cannot carry ratio evidence");if(i.has(String(e.metric))&&(typeof e.value!=="number"||e.value>1||Number(e.numerator)>Number(e.denominator)))r(t,"value","rate cells must be within zero and one");if(e.metric==="csat-score-average"&&(typeof e.value!=="number"||e.value<1||e.value>5))r(t,"value","CSAT averages must be between one and five")}else if(p.some((d)=>d!==void 0))r(t,"state","suppressed and unavailable cells cannot carry values")});const D={rowRef:n(),bucketStart:o(),bucketEnd:o(),dimensions:{type:SupportReportDimensionCellModel,isOptional:!1,isArray:!0},metrics:{type:SupportReportMetricCellModel,isOptional:!1,isArray:!0}};export const SupportReportAggregateRowModel=new s({name:"SupportReportAggregateRowV1",fields:D},(e,t)=>{if(!a(e.rowRef))r(t,"rowRef","rowRef must be opaque and bounded");if(!y(e.bucketStart)||!y(e.bucketEnd)||Date.parse(String(e.bucketStart))>=Date.parse(String(e.bucketEnd)))r(t,"bucketEnd","bucket bounds must be increasing canonical UTC timestamps");for(const[i,p,d]of[["dimensions","dimension",7],["metrics","metric",19]]){const u=Array.isArray(e[i])?e[i]:[];if(u.length<1||u.length>d)r(t,i,`${i} must be nonempty and bounded`);const c=u.map((m)=>typeof m==="object"&&m!==null?m[p]:void 0);if(new Set(c).size!==c.length)r(t,i,`${i} must be unique`)}});const v={definitionRef:n(),definitionRevision:l(),projection:{type:R,isOptional:!1},rows:{type:SupportReportAggregateRowModel,isOptional:!1,isArray:!0},suppressionPolicy:{type:b,isOptional:!1},queryReceiptRef:n(),watermark:o(),nextCursor:o(!0)};export const SupportReportQueryOutputModel=new s({name:"SupportReportQueryOutputV1",fields:v},(e,t)=>{for(const i of["definitionRef","queryReceiptRef"])if(!a(e[i]))r(t,i,`${i} must be bounded`);if(!O(e.definitionRevision))r(t,"definitionRevision","revision must be positive");if(!Array.isArray(e.rows)||e.rows.length>500)r(t,"rows","rows must be bounded");if(!a(e.watermark))r(t,"watermark","watermark must be opaque and bounded");if(e.nextCursor!==void 0&&!a(e.nextCursor))r(t,"nextCursor","nextCursor must be opaque and bounded")});

package/dist/customer-support/reporting-query-validation.d.ts

@@ -0,0 +1,3 @@
+export declare function validateSupportReportQuery(value: Record<string, unknown>, context: {
+    addIssue(input: object): void;
+}): void;

package/dist/customer-support/reporting-query-validation.js

@@ -0,0 +1 @@
+import{issue as n,validIso as s,validRef as t,validRevision as d}from"./reporting-schema-primitives.js";export function validateSupportReportQuery(i,e){if(!t(i.definitionRef))n(e,"definitionRef","definitionRef must be bounded");if(!d(i.expectedDefinitionRevision))n(e,"expectedDefinitionRevision","revision must be positive");for(const o of["from","to"])if(!s(i[o]))n(e,o,`${o} must be a canonical UTC timestamp`);if(s(i.from)&&s(i.to)){const o=Date.parse(i.to)-Date.parse(i.from);if(o<=0||o>31622400000)n(e,"to","range must be positive and no longer than 366 days")}if(typeof i.timezone!=="string"||i.timezone.length>100||!/^(UTC|[A-Za-z_]+(?:\/[A-Za-z0-9_+.-]+)+)$/.test(i.timezone))n(e,"timezone","timezone must be a bounded IANA zone");if(!t(i.timezoneDataRevision))n(e,"timezoneDataRevision","timezoneDataRevision must be bounded");const r=Array.isArray(i.filters)?i.filters:[];if(r.length>6)n(e,"filters","filters must contain at most six dimensions");const m=r.map((o)=>typeof o==="object"&&o!==null?o.dimension:void 0);if(new Set(m).size!==m.length)n(e,"filters","filter dimensions must be unique");if(!Number.isSafeInteger(i.limit)||Number(i.limit)<1||Number(i.limit)>500)n(e,"limit","limit must be 1 through 500");if(i.cursor!==void 0&&!t(i.cursor))n(e,"cursor","cursor must be opaque and bounded");if(i.watermark!==void 0&&!t(i.watermark))n(e,"watermark","watermark must be opaque and bounded");if(i.cursor===void 0!==(i.watermark===void 0))n(e,"watermark","cursor and watermark must be provided together")}

package/dist/customer-support/reporting-record-schemas.d.ts

@@ -0,0 +1,93 @@
+import { SchemaModel } from '@lssm/lib.schema';
+declare const correctionFields: {
+    correctionRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    caseRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    kind: {
+        type: import("@lssm/lib.schema").EnumType<["priority-corrected", "routing-corrected", "resolution-corrected", "duplicate-corrected", "ai-output-rejected"]>;
+        isOptional: boolean;
+    };
+    sourceEvidenceRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    expectedCaseRevision: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: boolean;
+    };
+    policyRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    evidenceRefs: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+        isArray: true;
+    };
+    idempotencyKey: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+};
+export declare const SupportCaseCorrectionRecordInputModel: SchemaModel<typeof correctionFields>;
+declare const outcomeFields: {
+    outcomeRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    caseRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    kind: {
+        type: import("@lssm/lib.schema").EnumType<["resolved", "reopened", "sla-met", "sla-breached", "csat-positive", "csat-negative", "policy-compliant", "policy-violated"]>;
+        isOptional: boolean;
+    };
+    sourceEvidenceRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    expectedCaseRevision: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: boolean;
+    };
+    policyRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    evidenceRefs: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+        isArray: true;
+    };
+    idempotencyKey: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+};
+export declare const SupportCaseOutcomeRecordInputModel: SchemaModel<typeof outcomeFields>;
+declare const mutationOutputFields: {
+    resourceRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    revision: {
+        type: import("@lssm/lib.schema").FieldType<number, number>;
+        isOptional: boolean;
+    };
+    receiptRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+    eventRef: {
+        type: import("@lssm/lib.schema").FieldType<string, string>;
+        isOptional: boolean;
+    };
+};
+export declare const SupportReportingMutationOutputModel: SchemaModel<typeof mutationOutputFields>;
+export {};

package/dist/customer-support/reporting-record-schemas.js

@@ -0,0 +1 @@
+import{CaseCorrectionKind as R,CaseOutcomeKind as u,id as i,ids as d,integer as c,issue as t,ReportingStrictSchema as s,validateRefArray as a,validRef as r,validRevision as f}from"./reporting-schema-primitives.js";const m={correctionRef:i(),caseRef:i(),kind:{type:R,isOptional:!1},sourceEvidenceRef:i(),expectedCaseRevision:c(),policyRef:i(),evidenceRefs:d(),idempotencyKey:i()};export const SupportCaseCorrectionRecordInputModel=new s({name:"SupportCaseCorrectionRecordInputV1",fields:m},p);const l={outcomeRef:i(),caseRef:i(),kind:{type:u,isOptional:!1},sourceEvidenceRef:i(),expectedCaseRevision:c(),policyRef:i(),evidenceRefs:d(),idempotencyKey:i()};export const SupportCaseOutcomeRecordInputModel=new s({name:"SupportCaseOutcomeRecordInputV1",fields:l},p);function p(e,o){if(e.outcomeRef!==void 0&&!["policy-compliant","policy-violated"].includes(String(e.kind)))t(o,"kind","canonical case, SLA, and CSAT outcomes are recorded automatically");for(const n of[e.correctionRef===void 0?"outcomeRef":"correctionRef","caseRef","sourceEvidenceRef","policyRef","idempotencyKey"])if(!r(e[n]))t(o,n,`${n} must be bounded`);if(!f(e.expectedCaseRevision))t(o,"expectedCaseRevision","case revision must be positive");a(e.evidenceRefs,"evidenceRefs",o,48);if(Array.isArray(e.evidenceRefs)&&e.evidenceRefs.length<1)t(o,"evidenceRefs","evidenceRefs must not be empty");if(Array.isArray(e.evidenceRefs)&&e.evidenceRefs.includes(e.sourceEvidenceRef))t(o,"evidenceRefs","sourceEvidenceRef must not be duplicated in evidenceRefs")}const v={resourceRef:i(),revision:c(),receiptRef:i(),eventRef:i()};export const SupportReportingMutationOutputModel=new s({name:"SupportReportingMutationOutputV1",fields:v},(e,o)=>{for(const n of["resourceRef","receiptRef","eventRef"])if(!r(e[n]))t(o,n,`${n} must be bounded`);if(!f(e.revision))t(o,"revision","revision must be positive")});

package/dist/customer-support/reporting-schema-primitives.d.ts

@@ -0,0 +1,49 @@
+import { EnumType, type SchemaModelFieldsAnyConfig } from '@lssm/lib.schema';
+import { StrictSemanticSchema } from './data-lifecycle-schema-primitives.js';
+export declare const ReportMetric: EnumType<["case-created", "case-resolved", "case-reopened", "queue-arrival-count", "queue-backlog-count", "queue-backlog-age-average-ms", "sla-met", "sla-breached", "first-response-duration-average-ms", "resolution-duration-average-ms", "first-response-sla-attainment-rate", "resolution-sla-attainment-rate", "reopen-rate", "csat-response-count", "csat-score-average", "csat-score-count", "csat-response-rate", "correction-count", "outcome-count"]>;
+export declare const ReportMetricState: EnumType<["measured", "suppressed", "unavailable"]>;
+export declare const ReportDimension: EnumType<["time-bucket", "queue", "priority", "channel", "csat-score", "sla-target", "correction-kind", "outcome-kind"]>;
+export declare const ReportFilterDimension: EnumType<["queue", "priority", "channel", "csat-score", "sla-target", "correction-kind", "outcome-kind"]>;
+export declare const ReportInterval: EnumType<["hour", "day", "week", "month"]>;
+export declare const ReportProjection: EnumType<["redacted", "sensitive"]>;
+export declare const ReportDefinitionStatus: EnumType<["draft", "published", "retired"]>;
+export declare const ReportDefinitionView: EnumType<["published", "head"]>;
+export declare const ReportSuppressionKind: EnumType<["minimum-cohort"]>;
+export declare const CaseCorrectionKind: EnumType<["priority-corrected", "routing-corrected", "resolution-corrected", "duplicate-corrected", "ai-output-rejected"]>;
+export declare const CaseOutcomeKind: EnumType<["resolved", "reopened", "sla-met", "sla-breached", "csat-positive", "csat-negative", "policy-compliant", "policy-violated"]>;
+export declare const id: (optional?: boolean) => {
+    type: import("@lssm/lib.schema").FieldType<string, string>;
+    isOptional: boolean;
+};
+export declare const text: (optional?: boolean) => {
+    type: import("@lssm/lib.schema").FieldType<string, string>;
+    isOptional: boolean;
+};
+export declare const integer: (optional?: boolean) => {
+    type: import("@lssm/lib.schema").FieldType<number, number>;
+    isOptional: boolean;
+};
+export declare const decimal: () => {
+    type: import("@lssm/lib.schema").FieldType<number, number>;
+    isOptional: boolean;
+};
+export declare const boolean: () => {
+    type: import("@lssm/lib.schema").FieldType<boolean, boolean>;
+    isOptional: boolean;
+};
+export declare const ids: () => {
+    type: import("@lssm/lib.schema").FieldType<string, string>;
+    isOptional: boolean;
+    isArray: true;
+};
+export declare const validRef: (value: unknown) => value is string;
+export declare const validIso: (value: unknown) => value is string;
+export declare const validRevision: (value: unknown, allowZero?: boolean) => boolean;
+export declare function issue(context: {
+    addIssue(input: object): void;
+}, path: string, message: string): void;
+export declare function validateRefArray(value: unknown, path: string, context: {
+    addIssue(input: object): void;
+}, maximum?: number): void;
+export declare class ReportingStrictSchema<F extends SchemaModelFieldsAnyConfig> extends StrictSemanticSchema<F> {
+}

package/dist/customer-support/reporting-schema-primitives.js

@@ -0,0 +1 @@
+import{EnumType as e,ScalarTypeEnum as n}from"@lssm/lib.schema";import{StrictSemanticSchema as s}from"./data-lifecycle-schema-primitives.js";import{SUPPORT_CASE_CORRECTION_KINDS as S,SUPPORT_CASE_OUTCOME_KINDS as R,SUPPORT_REPORT_DEFINITION_STATUSES as c,SUPPORT_REPORT_DEFINITION_VIEWS as a,SUPPORT_REPORT_DIMENSIONS as O,SUPPORT_REPORT_FILTER_DIMENSIONS as u,SUPPORT_REPORT_INTERVALS as P,SUPPORT_REPORT_METRIC_STATES as T,SUPPORT_REPORT_METRICS as _,SUPPORT_REPORT_PROJECTIONS as d,SUPPORT_REPORT_SUPPRESSION_KINDS as I}from"./reporting.js";export const ReportMetric=new e("SupportReportMetric",[..._]);export const ReportMetricState=new e("SupportReportMetricState",[...T]);export const ReportDimension=new e("SupportReportDimension",[...O]);export const ReportFilterDimension=new e("SupportReportFilterDimension",[...u]);export const ReportInterval=new e("SupportReportInterval",[...P]);export const ReportProjection=new e("SupportReportProjection",[...d]);export const ReportDefinitionStatus=new e("SupportReportDefinitionStatus",[...c]);export const ReportDefinitionView=new e("SupportReportDefinitionView",[...a]);export const ReportSuppressionKind=new e("SupportReportSuppressionKind",[...I]);export const CaseCorrectionKind=new e("SupportCaseCorrectionKind",[...S]);export const CaseOutcomeKind=new e("SupportCaseOutcomeKind",[...R]);export const id=(t=!1)=>({type:n.ID(),isOptional:t});export const text=(t=!1)=>({type:n.String_unsecure(),isOptional:t});export const integer=(t=!1)=>({type:n.Int_unsecure(),isOptional:t});export const decimal=()=>({type:n.Float_unsecure(),isOptional:!1});export const boolean=()=>({type:n.Boolean(),isOptional:!1});export const ids=()=>({type:n.ID(),isOptional:!1,isArray:!0});export const validRef=(t)=>typeof t==="string"&&/^[a-z0-9][a-z0-9._:/-]{1,199}$/i.test(t);export const validIso=(t)=>typeof t==="string"&&Number.isFinite(Date.parse(t))&&new Date(t).toISOString()===t;export const validRevision=(t,o=!1)=>Number.isSafeInteger(t)&&Number(t)>=(o?0:1);export function issue(t,o,r){t.addIssue({code:"custom",path:[o],message:r})}export function validateRefArray(t,o,r,i=50){if(!Array.isArray(t)||t.length>i||new Set(t).size!==t.length||t.some((p)=>!validRef(p)))issue(r,o,`${o} must contain unique bounded references`)}export class ReportingStrictSchema extends s{}

package/dist/customer-support/reporting-schemas.d.ts

@@ -0,0 +1,4 @@
+export * from './reporting-definition-schemas.js';
+export * from './reporting-event-schemas.js';
+export * from './reporting-query-schemas.js';
+export * from './reporting-record-schemas.js';

package/dist/customer-support/reporting-schemas.js

@@ -0,0 +1 @@
+export*from"./reporting-definition-schemas.js";export*from"./reporting-event-schemas.js";export*from"./reporting-query-schemas.js";export*from"./reporting-record-schemas.js";

package/dist/customer-support/reporting.d.ts

@@ -0,0 +1,148 @@
+export declare const SUPPORT_REPORT_METRICS: readonly ['case-created', 'case-resolved', 'case-reopened', 'queue-arrival-count', 'queue-backlog-count', 'queue-backlog-age-average-ms', 'sla-met', 'sla-breached', 'first-response-duration-average-ms', 'resolution-duration-average-ms', 'first-response-sla-attainment-rate', 'resolution-sla-attainment-rate', 'reopen-rate', 'csat-response-count', 'csat-score-average', 'csat-score-count', 'csat-response-rate', 'correction-count', 'outcome-count'];
+export declare const SUPPORT_REPORT_DIMENSIONS: readonly ['time-bucket', 'queue', 'priority', 'channel', 'csat-score', 'sla-target', 'correction-kind', 'outcome-kind'];
+export declare const SUPPORT_REPORT_FILTER_DIMENSIONS: readonly ['queue', 'priority', 'channel', 'csat-score', 'sla-target', 'correction-kind', 'outcome-kind'];
+export declare const SUPPORT_REPORT_INTERVALS: readonly ['hour', 'day', 'week', 'month'];
+export declare const SUPPORT_REPORT_PROJECTIONS: readonly ['redacted', 'sensitive'];
+export declare const SUPPORT_REPORT_DEFINITION_STATUSES: readonly ['draft', 'published', 'retired'];
+export declare const SUPPORT_REPORT_DEFINITION_VIEWS: readonly ['published', 'head'];
+export declare const SUPPORT_REPORT_SUPPRESSION_KINDS: readonly ['minimum-cohort'];
+export declare const SUPPORT_REPORT_METRIC_STATES: readonly ['measured', 'suppressed', 'unavailable'];
+export declare const SUPPORT_CASE_CORRECTION_KINDS: readonly ['priority-corrected', 'routing-corrected', 'resolution-corrected', 'duplicate-corrected', 'ai-output-rejected'];
+export declare const SUPPORT_CASE_OUTCOME_KINDS: readonly ['resolved', 'reopened', 'sla-met', 'sla-breached', 'csat-positive', 'csat-negative', 'policy-compliant', 'policy-violated'];
+export type SupportReportMetric = (typeof SUPPORT_REPORT_METRICS)[number];
+export type SupportReportDimension = (typeof SUPPORT_REPORT_DIMENSIONS)[number];
+export type SupportReportInterval = (typeof SUPPORT_REPORT_INTERVALS)[number];
+export type SupportReportProjection = (typeof SUPPORT_REPORT_PROJECTIONS)[number];
+export type SupportReportDefinitionStatus = (typeof SUPPORT_REPORT_DEFINITION_STATUSES)[number];
+export type SupportReportDefinitionView = (typeof SUPPORT_REPORT_DEFINITION_VIEWS)[number];
+export type SupportReportMetricState = (typeof SUPPORT_REPORT_METRIC_STATES)[number];
+export type SupportCaseCorrectionKind = (typeof SUPPORT_CASE_CORRECTION_KINDS)[number];
+export type SupportCaseOutcomeKind = (typeof SUPPORT_CASE_OUTCOME_KINDS)[number];
+export interface SupportReportSuppressionPolicy {
+    readonly kind: 'minimum-cohort';
+    readonly minimumCount: number;
+}
+export interface SupportReportDefinitionRevision {
+    readonly definitionRef: string;
+    readonly revision: number;
+    readonly status: SupportReportDefinitionStatus;
+    readonly titleKey: string;
+    readonly metrics: readonly SupportReportMetric[];
+    readonly dimensions: readonly SupportReportDimension[];
+    readonly interval: SupportReportInterval;
+    readonly defaultProjection: SupportReportProjection;
+    readonly maximumProjection: SupportReportProjection;
+    readonly suppressionPolicy: SupportReportSuppressionPolicy;
+    readonly policyRef: string;
+    readonly evidenceRefs: readonly string[];
+    readonly createdAt: string;
+    readonly publishedAt?: string;
+    readonly retiredAt?: string;
+    readonly receiptRef: string;
+}
+export interface SupportReportDefinitionRevisionMutation {
+    readonly definitionRef: string;
+    readonly expectedDefinitionRevision: number;
+    readonly titleKey: string;
+    readonly metrics: readonly SupportReportMetric[];
+    readonly dimensions: readonly SupportReportDimension[];
+    readonly interval: SupportReportInterval;
+    readonly defaultProjection: SupportReportProjection;
+    readonly maximumProjection: SupportReportProjection;
+    readonly suppressionPolicy: SupportReportSuppressionPolicy;
+    readonly policyRef: string;
+    readonly evidenceRefs: readonly string[];
+    readonly idempotencyKey: string;
+}
+export interface SupportReportQuery {
+    readonly definitionRef: string;
+    readonly expectedDefinitionRevision: number;
+    readonly from: string;
+    readonly to: string;
+    readonly timezone: string;
+    readonly timezoneDataRevision: string;
+    readonly filters: readonly SupportReportFilter[];
+    readonly projection: SupportReportProjection;
+    readonly limit: number;
+    readonly cursor?: string;
+    readonly watermark?: string;
+}
+export interface SupportReportFilter {
+    readonly dimension: Exclude<SupportReportDimension, 'time-bucket'>;
+    readonly valueRefs: readonly string[];
+}
+export interface SupportReportAggregateRow {
+    readonly rowRef: string;
+    readonly bucketStart: string;
+    readonly bucketEnd: string;
+    readonly dimensions: readonly SupportReportDimensionCell[];
+    readonly metrics: readonly SupportReportMetricCell[];
+}
+export interface SupportReportDimensionCell {
+    readonly dimension: SupportReportDimension;
+    readonly valueRef: string;
+}
+export interface SupportReportMetricCell {
+    readonly metric: SupportReportMetric;
+    readonly state: SupportReportMetricState;
+    readonly value?: number;
+    readonly numerator?: number;
+    readonly denominator?: number;
+}
+export interface SupportReportResult {
+    readonly definitionRef: string;
+    readonly definitionRevision: number;
+    readonly projection: SupportReportProjection;
+    readonly rows: readonly SupportReportAggregateRow[];
+    readonly suppressionPolicy: SupportReportSuppressionPolicy;
+    readonly queryReceiptRef: string;
+    readonly watermark: string;
+    readonly nextCursor?: string;
+}
+export interface SupportCaseCorrectionRecord {
+    readonly correctionRef: string;
+    readonly caseRef: string;
+    readonly kind: SupportCaseCorrectionKind;
+    readonly sourceEvidenceRef: string;
+    readonly expectedCaseRevision: number;
+    readonly policyRef: string;
+    readonly evidenceRefs: readonly string[];
+    readonly idempotencyKey: string;
+}
+export interface SupportCaseOutcomeRecord {
+    readonly outcomeRef: string;
+    readonly caseRef: string;
+    readonly kind: SupportCaseOutcomeKind;
+    readonly sourceEvidenceRef: string;
+    readonly expectedCaseRevision: number;
+    readonly policyRef: string;
+    readonly evidenceRefs: readonly string[];
+    readonly idempotencyKey: string;
+}
+export interface SupportReportDefinitionLifecycleMutation {
+    readonly definitionRef: string;
+    readonly expectedDefinitionRevision: number;
+    readonly policyRef: string;
+    readonly evidenceRefs: readonly string[];
+    readonly idempotencyKey: string;
+}
+export interface SupportReportDefinitionList {
+    readonly view?: SupportReportDefinitionView;
+    readonly status?: SupportReportDefinitionStatus;
+    readonly limit: number;
+    readonly cursor?: string;
+    readonly watermark?: string;
+}
+export interface SupportReportDefinitionListResult {
+    readonly items: readonly SupportReportDefinitionRevision[];
+    readonly nextCursor?: string;
+    readonly watermark: string;
+}
+export interface SupportReportingMutationResult {
+    readonly resourceRef: string;
+    readonly revision: number;
+    readonly receiptRef: string;
+    readonly eventRef: string;
+}
+export declare function isSupportReportProjectionAllowed(maximum: SupportReportProjection, requested: SupportReportProjection): boolean;
+export type { SupportCaseReportingAuthorityPort, SupportReportingAuthorityPort, } from './reporting-port.js';

package/dist/customer-support/reporting.js

@@ -0,0 +1 @@
+export const SUPPORT_REPORT_METRICS=["case-created","case-resolved","case-reopened","queue-arrival-count","queue-backlog-count","queue-backlog-age-average-ms","sla-met","sla-breached","first-response-duration-average-ms","resolution-duration-average-ms","first-response-sla-attainment-rate","resolution-sla-attainment-rate","reopen-rate","csat-response-count","csat-score-average","csat-score-count","csat-response-rate","correction-count","outcome-count"];export const SUPPORT_REPORT_DIMENSIONS=["time-bucket","queue","priority","channel","csat-score","sla-target","correction-kind","outcome-kind"];export const SUPPORT_REPORT_FILTER_DIMENSIONS=["queue","priority","channel","csat-score","sla-target","correction-kind","outcome-kind"];export const SUPPORT_REPORT_INTERVALS=["hour","day","week","month"];export const SUPPORT_REPORT_PROJECTIONS=["redacted","sensitive"];export const SUPPORT_REPORT_DEFINITION_STATUSES=["draft","published","retired"];export const SUPPORT_REPORT_DEFINITION_VIEWS=["published","head"];export const SUPPORT_REPORT_SUPPRESSION_KINDS=["minimum-cohort"];export const SUPPORT_REPORT_METRIC_STATES=["measured","suppressed","unavailable"];export const SUPPORT_CASE_CORRECTION_KINDS=["priority-corrected","routing-corrected","resolution-corrected","duplicate-corrected","ai-output-rejected"];export const SUPPORT_CASE_OUTCOME_KINDS=["resolved","reopened","sla-met","sla-breached","csat-positive","csat-negative","policy-compliant","policy-violated"];export function isSupportReportProjectionAllowed(e,r){return e==="sensitive"||r==="redacted"}