@oxy.so/contracts 4.10.0 → 4.11.0

package/dist/types/inference/inbox.d.ts

@@ -66,23 +66,24 @@ export declare const inboxComposeRequestSchema: z.ZodDiscriminatedUnion<"operati
 export declare const inboxDailyBriefRequestSchema: z.ZodEffects<z.ZodObject<{
     startAt: z.ZodEffects<z.ZodString, string, string>;
     endAt: z.ZodEffects<z.ZodString, string, string>;
-    stream: z.ZodOptional<z.ZodBoolean>;
+    /** BCP 47 tag of the language the brief is written in; English when absent. */
+    locale: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     startAt: string;
     endAt: string;
-    stream?: boolean | undefined;
+    locale?: string | undefined;
 }, {
     startAt: string;
     endAt: string;
-    stream?: boolean | undefined;
+    locale?: string | undefined;
 }>, {
     startAt: string;
     endAt: string;
-    stream?: boolean | undefined;
+    locale?: string | undefined;
 }, {
     startAt: string;
     endAt: string;
-    stream?: boolean | undefined;
+    locale?: string | undefined;
 }>;
 export declare const inboxNaturalSearchRequestSchema: z.ZodObject<{
     query: z.ZodString;
@@ -179,6 +180,127 @@ export declare const inboxNaturalSearchResponseSchema: z.ZodObject<{
     };
     interpretation: string;
 }>;
+/** Where the brief puts a message: it asks something of the owner, it is today's news, or it is still unread from before. */
+export declare const INBOX_DAILY_BRIEF_SECTIONS: readonly ["needs_you", "today", "earlier"];
+/**
+ * The Daily Brief as data, so a client draws it rather than printing a wall of
+ * text: a short summary, then the messages it mentions — each with the
+ * server's own copy of its sender, subject, time and unread state, so a client
+ * can show and open it, and a one-line note of why it matters.
+ */
+export declare const inboxDailyBriefResponseSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    requestId: z.ZodString;
+    generationId: z.ZodOptional<z.ZodString>;
+    summary: z.ZodString;
+    counts: z.ZodObject<{
+        received: z.ZodNumber;
+        unread: z.ZodNumber;
+        starred: z.ZodNumber;
+        earlierUnread: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        received: number;
+        starred: number;
+        unread: number;
+        earlierUnread: number;
+    }, {
+        received: number;
+        starred: number;
+        unread: number;
+        earlierUnread: number;
+    }>;
+    items: z.ZodArray<z.ZodObject<{
+        messageId: z.ZodString;
+        section: z.ZodEnum<["needs_you", "today", "earlier"]>;
+        note: z.ZodString;
+        from: z.ZodObject<{
+            name: z.ZodNullable<z.ZodString>;
+            address: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            name: string | null;
+            address: string;
+        }, {
+            name: string | null;
+            address: string;
+        }>;
+        subject: z.ZodString;
+        receivedAt: z.ZodString;
+        unread: z.ZodBoolean;
+        hasAttachments: z.ZodBoolean;
+    }, "strict", z.ZodTypeAny, {
+        subject: string;
+        messageId: string;
+        from: {
+            name: string | null;
+            address: string;
+        };
+        receivedAt: string;
+        unread: boolean;
+        section: "needs_you" | "today" | "earlier";
+        note: string;
+        hasAttachments: boolean;
+    }, {
+        subject: string;
+        messageId: string;
+        from: {
+            name: string | null;
+            address: string;
+        };
+        receivedAt: string;
+        unread: boolean;
+        section: "needs_you" | "today" | "earlier";
+        note: string;
+        hasAttachments: boolean;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: 1;
+    requestId: string;
+    summary: string;
+    counts: {
+        received: number;
+        starred: number;
+        unread: number;
+        earlierUnread: number;
+    };
+    items: {
+        subject: string;
+        messageId: string;
+        from: {
+            name: string | null;
+            address: string;
+        };
+        receivedAt: string;
+        unread: boolean;
+        section: "needs_you" | "today" | "earlier";
+        note: string;
+        hasAttachments: boolean;
+    }[];
+    generationId?: string | undefined;
+}, {
+    schemaVersion: 1;
+    requestId: string;
+    summary: string;
+    counts: {
+        received: number;
+        starred: number;
+        unread: number;
+        earlierUnread: number;
+    };
+    items: {
+        subject: string;
+        messageId: string;
+        from: {
+            name: string | null;
+            address: string;
+        };
+        receivedAt: string;
+        unread: boolean;
+        section: "needs_you" | "today" | "earlier";
+        note: string;
+        hasAttachments: boolean;
+    }[];
+    generationId?: string | undefined;
+}>;
 export declare const inboxSmartRepliesResponseSchema: z.ZodObject<{
     replies: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
@@ -367,6 +489,8 @@ export declare const inboxInferenceStreamEventSchema: z.ZodDiscriminatedUnion<"t
 }>]>;
 export type InboxComposeRequest = z.infer<typeof inboxComposeRequestSchema>;
 export type InboxDailyBriefRequest = z.infer<typeof inboxDailyBriefRequestSchema>;
+export type InboxDailyBriefResponse = z.infer<typeof inboxDailyBriefResponseSchema>;
+export type InboxDailyBriefSection = (typeof INBOX_DAILY_BRIEF_SECTIONS)[number];
 export type InboxInferenceTextResponse = z.infer<typeof inboxInferenceTextResponseSchema>;
 export type InboxNaturalSearchResponse = z.infer<typeof inboxNaturalSearchResponseSchema>;
 export type InboxSmartRepliesResponse = z.infer<typeof inboxSmartRepliesResponseSchema>;

package/dist/types/inference/realtime.d.ts

@@ -83,7 +83,7 @@
  *
  * Decided in: OxyHQ/Kaana#90.
  */
-import { z } from "zod";
+import { z } from 'zod';
 /**
  * The most base64 characters one audio frame may carry: 49 152 bytes of audio,
  * about one second of 24 kHz mono PCM16. Bounded so no frame is large enough to

package/dist/types/inference/scopedExecution.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 /** Explicit extension negotiation; never replaces the legacy 3.5 handshake. */
 export declare const SCOPED_EXECUTION_CONTRACT_VERSION: "3.6.0";
 /** Scoped only; normal envelope v2 and metadata 3.5 remain unchanged. */

package/dist/types/moderationReputation.d.ts

@@ -273,7 +273,7 @@ export declare const reverseModerationEffectSchema: z.ZodType<ReverseModerationE
  * are reported so the figure is explainable without re-running the engine.
  */
 export interface ModerationEffect {
-    /** The effect's own id (its Mongo `_id` as a string). */
+    /** The effect's own id, as a string. */
     id: string;
     incidentId: string;
     caseId: string;

package/dist/types/oxyRecordTypes.d.ts

@@ -7,8 +7,8 @@
  * is rejected as `invalid_envelope`.
  *
  * `oxySignedRecordTypeSchema` is that runtime gate (the API's `verifyEnvelope`
- * re-narrows with it; the Mongoose `SignedRecord.type` enum and the Postgres
- * CHECK on `signed_records.type` are both derived from `.options`);
+ * re-narrows with it; the Postgres CHECK on `signed_records.type` is derived
+ * from `.options`);
  * `OxySignedRecordType` is the matching compile-time union the SDK
  * identity/civic mixins type against.
  *

package/dist/types/products/access.d.ts

@@ -485,3 +485,408 @@ export type ProductAccessGrant = z.infer<typeof productAccessGrantSchema>;
 export type SubjectProductAccess = z.infer<typeof subjectProductAccessSchema>;
 export type ProductDefinition = z.infer<typeof productDefinitionSchema>;
 export type SubjectProductAccessQuery = z.infer<typeof subjectProductAccessQuerySchema>;
+/** Active grant periods for metering adapters; no financial/provider identity. */
+export declare const subjectProductGrantSnapshotSchema: z.ZodEffects<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    access: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        subjectAccountId: z.ZodBranded<z.ZodString, "OxyAccountId">;
+        productId: z.ZodString;
+        evaluatedAt: z.ZodString;
+        capabilities: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            grantIds: z.ZodArray<z.ZodString, "many">;
+        }, "strict", z.ZodTypeAny, {
+            key: string;
+            grantIds: string[];
+        }, {
+            key: string;
+            grantIds: string[];
+        }>, "many">;
+        quotas: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            unit: z.ZodString;
+            included: z.ZodNumber;
+            combination: z.ZodEnum<["maximum", "sum", "exclusive"]>;
+            grantIds: z.ZodArray<z.ZodString, "many">;
+        }, "strict", z.ZodTypeAny, {
+            key: string;
+            unit: string;
+            included: number;
+            combination: "maximum" | "sum" | "exclusive";
+            grantIds: string[];
+        }, {
+            key: string;
+            unit: string;
+            included: number;
+            combination: "maximum" | "sum" | "exclusive";
+            grantIds: string[];
+        }>, "many">;
+        conflicts: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            reason: z.ZodEnum<["combination_mismatch", "unit_mismatch", "exclusive_overlap", "unsafe_total"]>;
+            grantIds: z.ZodArray<z.ZodString, "many">;
+        }, "strict", z.ZodTypeAny, {
+            key: string;
+            reason: "combination_mismatch" | "unit_mismatch" | "exclusive_overlap" | "unsafe_total";
+            grantIds: string[];
+        }, {
+            key: string;
+            reason: "combination_mismatch" | "unit_mismatch" | "exclusive_overlap" | "unsafe_total";
+            grantIds: string[];
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        schemaVersion: 1;
+        subjectAccountId: string & z.BRAND<"OxyAccountId">;
+        capabilities: {
+            key: string;
+            grantIds: string[];
+        }[];
+        evaluatedAt: string;
+        productId: string;
+        quotas: {
+            key: string;
+            unit: string;
+            included: number;
+            combination: "maximum" | "sum" | "exclusive";
+            grantIds: string[];
+        }[];
+        conflicts: {
+            key: string;
+            reason: "combination_mismatch" | "unit_mismatch" | "exclusive_overlap" | "unsafe_total";
+            grantIds: string[];
+        }[];
+    }, {
+        schemaVersion: 1;
+        subjectAccountId: string;
+        capabilities: {
+            key: string;
+            grantIds: string[];
+        }[];
+        evaluatedAt: string;
+        productId: string;
+        quotas: {
+            key: string;
+            unit: string;
+            included: number;
+            combination: "maximum" | "sum" | "exclusive";
+            grantIds: string[];
+        }[];
+        conflicts: {
+            key: string;
+            reason: "combination_mismatch" | "unit_mismatch" | "exclusive_overlap" | "unsafe_total";
+            grantIds: string[];
+        }[];
+    }>;
+    grants: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        sourceSegmentId: z.ZodString;
+        beneficiaryAccountId: z.ZodBranded<z.ZodString, "OxyAccountId">;
+        offerId: z.ZodString;
+        offerVersion: z.ZodNumber;
+        origin: z.ZodEnum<["individual", "bundle"]>;
+        benefit: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"capability">;
+            productId: z.ZodString;
+            key: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            kind: "capability";
+            key: string;
+            productId: string;
+        }, {
+            kind: "capability";
+            key: string;
+            productId: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"quota">;
+            productId: z.ZodString;
+            key: z.ZodString;
+            unit: z.ZodString;
+            included: z.ZodNumber;
+            combination: z.ZodEnum<["maximum", "sum", "exclusive"]>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "quota";
+            key: string;
+            unit: string;
+            included: number;
+            productId: string;
+            combination: "maximum" | "sum" | "exclusive";
+        }, {
+            kind: "quota";
+            key: string;
+            unit: string;
+            included: number;
+            productId: string;
+            combination: "maximum" | "sum" | "exclusive";
+        }>]>;
+        period: z.ZodEffects<z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            start: string;
+            end: string;
+        }, {
+            start: string;
+            end: string;
+        }>, {
+            start: string;
+            end: string;
+        }, {
+            start: string;
+            end: string;
+        }>;
+        revokedAt: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        schemaVersion: 1;
+        id: string;
+        revokedAt: string | null;
+        beneficiaryAccountId: string & z.BRAND<"OxyAccountId">;
+        period: {
+            start: string;
+            end: string;
+        };
+        offerId: string;
+        offerVersion: number;
+        origin: "bundle" | "individual";
+        sourceSegmentId: string;
+        benefit: {
+            kind: "capability";
+            key: string;
+            productId: string;
+        } | {
+            kind: "quota";
+            key: string;
+            unit: string;
+            included: number;
+            productId: string;
+            combination: "maximum" | "sum" | "exclusive";
+        };
+    }, {
+        schemaVersion: 1;
+        id: string;
+        revokedAt: string | null;
+        beneficiaryAccountId: string;
+        period: {
+            start: string;
+            end: string;
+        };
+        offerId: string;
+        offerVersion: number;
+        origin: "bundle" | "individual";
+        sourceSegmentId: string;
+        benefit: {
+            kind: "capability";
+            key: string;
+            productId: string;
+        } | {
+            kind: "quota";
+            key: string;
+            unit: string;
+            included: number;
+            productId: string;
+            combination: "maximum" | "sum" | "exclusive";
+        };
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: 1;
+    access: {
+        schemaVersion: 1;
+        subjectAccountId: string & z.BRAND<"OxyAccountId">;
+        capabilities: {
+            key: string;
+            grantIds: string[];
+        }[];
+        evaluatedAt: string;
+        productId: string;
+        quotas: {
+            key: string;
+            unit: string;
+            included: number;
+            combination: "maximum" | "sum" | "exclusive";
+            grantIds: string[];
+        }[];
+        conflicts: {
+            key: string;
+            reason: "combination_mismatch" | "unit_mismatch" | "exclusive_overlap" | "unsafe_total";
+            grantIds: string[];
+        }[];
+    };
+    grants: {
+        schemaVersion: 1;
+        id: string;
+        revokedAt: string | null;
+        beneficiaryAccountId: string & z.BRAND<"OxyAccountId">;
+        period: {
+            start: string;
+            end: string;
+        };
+        offerId: string;
+        offerVersion: number;
+        origin: "bundle" | "individual";
+        sourceSegmentId: string;
+        benefit: {
+            kind: "capability";
+            key: string;
+            productId: string;
+        } | {
+            kind: "quota";
+            key: string;
+            unit: string;
+            included: number;
+            productId: string;
+            combination: "maximum" | "sum" | "exclusive";
+        };
+    }[];
+}, {
+    schemaVersion: 1;
+    access: {
+        schemaVersion: 1;
+        subjectAccountId: string;
+        capabilities: {
+            key: string;
+            grantIds: string[];
+        }[];
+        evaluatedAt: string;
+        productId: string;
+        quotas: {
+            key: string;
+            unit: string;
+            included: number;
+            combination: "maximum" | "sum" | "exclusive";
+            grantIds: string[];
+        }[];
+        conflicts: {
+            key: string;
+            reason: "combination_mismatch" | "unit_mismatch" | "exclusive_overlap" | "unsafe_total";
+            grantIds: string[];
+        }[];
+    };
+    grants: {
+        schemaVersion: 1;
+        id: string;
+        revokedAt: string | null;
+        beneficiaryAccountId: string;
+        period: {
+            start: string;
+            end: string;
+        };
+        offerId: string;
+        offerVersion: number;
+        origin: "bundle" | "individual";
+        sourceSegmentId: string;
+        benefit: {
+            kind: "capability";
+            key: string;
+            productId: string;
+        } | {
+            kind: "quota";
+            key: string;
+            unit: string;
+            included: number;
+            productId: string;
+            combination: "maximum" | "sum" | "exclusive";
+        };
+    }[];
+}>, {
+    schemaVersion: 1;
+    access: {
+        schemaVersion: 1;
+        subjectAccountId: string & z.BRAND<"OxyAccountId">;
+        capabilities: {
+            key: string;
+            grantIds: string[];
+        }[];
+        evaluatedAt: string;
+        productId: string;
+        quotas: {
+            key: string;
+            unit: string;
+            included: number;
+            combination: "maximum" | "sum" | "exclusive";
+            grantIds: string[];
+        }[];
+        conflicts: {
+            key: string;
+            reason: "combination_mismatch" | "unit_mismatch" | "exclusive_overlap" | "unsafe_total";
+            grantIds: string[];
+        }[];
+    };
+    grants: {
+        schemaVersion: 1;
+        id: string;
+        revokedAt: string | null;
+        beneficiaryAccountId: string & z.BRAND<"OxyAccountId">;
+        period: {
+            start: string;
+            end: string;
+        };
+        offerId: string;
+        offerVersion: number;
+        origin: "bundle" | "individual";
+        sourceSegmentId: string;
+        benefit: {
+            kind: "capability";
+            key: string;
+            productId: string;
+        } | {
+            kind: "quota";
+            key: string;
+            unit: string;
+            included: number;
+            productId: string;
+            combination: "maximum" | "sum" | "exclusive";
+        };
+    }[];
+}, {
+    schemaVersion: 1;
+    access: {
+        schemaVersion: 1;
+        subjectAccountId: string;
+        capabilities: {
+            key: string;
+            grantIds: string[];
+        }[];
+        evaluatedAt: string;
+        productId: string;
+        quotas: {
+            key: string;
+            unit: string;
+            included: number;
+            combination: "maximum" | "sum" | "exclusive";
+            grantIds: string[];
+        }[];
+        conflicts: {
+            key: string;
+            reason: "combination_mismatch" | "unit_mismatch" | "exclusive_overlap" | "unsafe_total";
+            grantIds: string[];
+        }[];
+    };
+    grants: {
+        schemaVersion: 1;
+        id: string;
+        revokedAt: string | null;
+        beneficiaryAccountId: string;
+        period: {
+            start: string;
+            end: string;
+        };
+        offerId: string;
+        offerVersion: number;
+        origin: "bundle" | "individual";
+        sourceSegmentId: string;
+        benefit: {
+            kind: "capability";
+            key: string;
+            productId: string;
+        } | {
+            kind: "quota";
+            key: string;
+            unit: string;
+            included: number;
+            productId: string;
+            combination: "maximum" | "sum" | "exclusive";
+        };
+    }[];
+}>;
+export type SubjectProductGrantSnapshot = z.infer<typeof subjectProductGrantSnapshotSchema>;

package/dist/types/products/billing.d.ts

@@ -530,12 +530,15 @@ export declare const subscriptionCreditGrantsResponseSchema: z.ZodObject<{
 }>;
 export declare const cancelProductSubscriptionSchema: z.ZodObject<{
     sourceId: z.ZodString;
+    actionId: z.ZodOptional<z.ZodString>;
     expectedSubjectAccountId: z.ZodOptional<z.ZodBranded<z.ZodString, "OxyAccountId">>;
 }, "strict", z.ZodTypeAny, {
     sourceId: string;
+    actionId?: string | undefined;
     expectedSubjectAccountId?: (string & z.BRAND<"OxyAccountId">) | undefined;
 }, {
     sourceId: string;
+    actionId?: string | undefined;
     expectedSubjectAccountId?: string | undefined;
 }>;
 export type ProductSubscriptionSummary = z.infer<typeof productSubscriptionSummarySchema>;

package/dist/types/products/checkout.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+export declare const personalPlanCheckoutRequestSchema: z.ZodObject<{
+    expectedSubjectAccountId: z.ZodBranded<z.ZodString, "OxyAccountId">;
+    offerId: z.ZodString;
+    offerVersion: z.ZodNumber;
+    idempotencyKey: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    idempotencyKey: string;
+    offerId: string;
+    offerVersion: number;
+    expectedSubjectAccountId: string & z.BRAND<"OxyAccountId">;
+}, {
+    idempotencyKey: string;
+    offerId: string;
+    offerVersion: number;
+    expectedSubjectAccountId: string;
+}>;
+/** No grant or subscription is created by checkout completion in the browser. */
+export declare const personalPlanCheckoutResultSchema: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
+    state: z.ZodLiteral<"unconfigured">;
+    reason: z.ZodEnum<["provider_unconfigured", "offer_unconfigured", "price_unconfigured"]>;
+}, "strict", z.ZodTypeAny, {
+    reason: "provider_unconfigured" | "offer_unconfigured" | "price_unconfigured";
+    state: "unconfigured";
+}, {
+    reason: "provider_unconfigured" | "offer_unconfigured" | "price_unconfigured";
+    state: "unconfigured";
+}>, z.ZodObject<{
+    state: z.ZodLiteral<"pending">;
+    intentId: z.ZodString;
+    checkoutUrl: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    state: "pending";
+    intentId: string;
+    checkoutUrl?: string | undefined;
+}, {
+    state: "pending";
+    intentId: string;
+    checkoutUrl?: string | undefined;
+}>, z.ZodObject<{
+    state: z.ZodLiteral<"closed">;
+    intentId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    state: "closed";
+    intentId: string;
+}, {
+    state: "closed";
+    intentId: string;
+}>, z.ZodObject<{
+    state: z.ZodLiteral<"fulfilled">;
+    intentId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    state: "fulfilled";
+    intentId: string;
+}, {
+    state: "fulfilled";
+    intentId: string;
+}>]>;
+export type PersonalPlanCheckoutRequest = z.infer<typeof personalPlanCheckoutRequestSchema>;
+export type PersonalPlanCheckoutResult = z.infer<typeof personalPlanCheckoutResultSchema>;