@opengeni/contracts 3.1.0-canary.2 → 3.1.2

package/src/memory-slack-delivery.ts

@@ -1,183 +1,212 @@
+import { defineSchema } from "./define-schema";
 import { z } from "zod";
 
-export const MemorySlackImportance = z.enum(["major", "normal", "minor"]);
+export const MemorySlackImportance = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["major", "normal", "minor"]),
+);
 export type MemorySlackImportance = z.infer<typeof MemorySlackImportance>;
 
-export const MemorySlackRequestedMode = z.enum(["auto", "review", "never"]);
+export const MemorySlackRequestedMode = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["auto", "review", "never"]),
+);
 export type MemorySlackRequestedMode = z.infer<typeof MemorySlackRequestedMode>;
 
-export const MemorySlackPublicationDistribution = z
-  .object({
-    importance: MemorySlackImportance,
-    audience: z.literal("workspace"),
-    slackMode: MemorySlackRequestedMode,
-    shareSummary: z.string().trim().min(1).max(4_096),
-  })
-  .strict();
+export const MemorySlackPublicationDistribution = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      importance: MemorySlackImportance,
+      audience: z.literal("workspace"),
+      slackMode: MemorySlackRequestedMode,
+      shareSummary: z.string().trim().min(1).max(4_096),
+    })
+    .strict(),
+);
 export type MemorySlackPublicationDistribution = z.infer<typeof MemorySlackPublicationDistribution>;
 
-export const MemorySlackPublicationConfiguration = z.object({
-  id: z.string().uuid(),
-  workspaceId: z.string().uuid(),
-  revision: z.number().int().positive(),
-  enabled: z.boolean(),
-  connectionId: z.string().uuid().nullable(),
-  slackTeamId: z.string().min(1).max(64).nullable(),
-  slackChannelId: z.string().min(1).max(64).nullable(),
-  slackChannelName: z.string().min(1).max(256).nullable(),
-  autoImportances: z.array(MemorySlackImportance).max(3),
-  reviewImportances: z.array(MemorySlackImportance).max(3),
-  createdBySubjectId: z.string().min(1).max(1_024),
-  createdAt: z.string(),
-});
-export type MemorySlackPublicationConfiguration = z.infer<
-  typeof MemorySlackPublicationConfiguration
->;
-
-export const UpdateMemorySlackPublicationConfigurationRequest = z
-  .object({
-    expectedRevision: z.number().int().nonnegative(),
+export const MemorySlackPublicationConfiguration = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    id: z.string().uuid(),
+    workspaceId: z.string().uuid(),
+    revision: z.number().int().positive(),
     enabled: z.boolean(),
     connectionId: z.string().uuid().nullable(),
-    slackChannelId: z.string().trim().min(1).max(64).nullable(),
-    slackChannelName: z.string().trim().min(1).max(256).nullable(),
+    slackTeamId: z.string().min(1).max(64).nullable(),
+    slackChannelId: z.string().min(1).max(64).nullable(),
+    slackChannelName: z.string().min(1).max(256).nullable(),
     autoImportances: z.array(MemorySlackImportance).max(3),
     reviewImportances: z.array(MemorySlackImportance).max(3),
-  })
-  .strict()
-  .superRefine((value, context) => {
-    const overlap = value.autoImportances.filter((importance) =>
-      value.reviewImportances.includes(importance),
-    );
-    if (overlap.length > 0) {
-      context.addIssue({
-        code: "custom",
-        message: "auto and review importance policies must not overlap",
-        path: ["reviewImportances"],
-      });
-    }
-    if (value.enabled && (!value.connectionId || !value.slackChannelId)) {
-      context.addIssue({
-        code: "custom",
-        message: "an enabled Slack publication configuration requires a connection and channel",
-      });
-    }
-  });
+    createdBySubjectId: z.string().min(1).max(1_024),
+    createdAt: z.string(),
+  }),
+);
+export type MemorySlackPublicationConfiguration = z.infer<
+  typeof MemorySlackPublicationConfiguration
+>;
+
+export const UpdateMemorySlackPublicationConfigurationRequest = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      expectedRevision: z.number().int().nonnegative(),
+      enabled: z.boolean(),
+      connectionId: z.string().uuid().nullable(),
+      slackChannelId: z.string().trim().min(1).max(64).nullable(),
+      slackChannelName: z.string().trim().min(1).max(256).nullable(),
+      autoImportances: z.array(MemorySlackImportance).max(3),
+      reviewImportances: z.array(MemorySlackImportance).max(3),
+    })
+    .strict()
+    .superRefine((value, context) => {
+      const overlap = value.autoImportances.filter((importance) =>
+        value.reviewImportances.includes(importance),
+      );
+      if (overlap.length > 0) {
+        context.addIssue({
+          code: "custom",
+          message: "auto and review importance policies must not overlap",
+          path: ["reviewImportances"],
+        });
+      }
+      if (value.enabled && (!value.connectionId || !value.slackChannelId)) {
+        context.addIssue({
+          code: "custom",
+          message: "an enabled Slack publication configuration requires a connection and channel",
+        });
+      }
+    }),
+);
 export type UpdateMemorySlackPublicationConfigurationRequest = z.infer<
   typeof UpdateMemorySlackPublicationConfigurationRequest
 >;
 
-export const MemorySlackPublicationConfigurationResponse = z.object({
-  current: MemorySlackPublicationConfiguration.nullable(),
-  history: z.array(MemorySlackPublicationConfiguration).max(100),
-});
+export const MemorySlackPublicationConfigurationResponse = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    current: MemorySlackPublicationConfiguration.nullable(),
+    history: z.array(MemorySlackPublicationConfiguration).max(100),
+  }),
+);
 export type MemorySlackPublicationConfigurationResponse = z.infer<
   typeof MemorySlackPublicationConfigurationResponse
 >;
 
-export const MemorySlackPublicationState = z.enum([
-  "review_pending",
-  "queued",
-  "delivering",
-  "retry_wait",
-  "delivered",
-  "rejected",
-  "failed",
-  "cancelled",
-]);
+export const MemorySlackPublicationState = /* @__PURE__ */ defineSchema(() =>
+  z.enum([
+    "review_pending",
+    "queued",
+    "delivering",
+    "retry_wait",
+    "delivered",
+    "rejected",
+    "failed",
+    "cancelled",
+  ]),
+);
 export type MemorySlackPublicationState = z.infer<typeof MemorySlackPublicationState>;
 
-export const MemorySlackPublicationReceiptKind = z.enum([
-  "enqueued",
-  "review_approved",
-  "review_rejected",
-  "delivery_claimed",
-  "retry_scheduled",
-  "delivered",
-  "failed",
-  "cancelled",
-  "manual_retry",
-]);
+export const MemorySlackPublicationReceiptKind = /* @__PURE__ */ defineSchema(() =>
+  z.enum([
+    "enqueued",
+    "review_approved",
+    "review_rejected",
+    "delivery_claimed",
+    "retry_scheduled",
+    "delivered",
+    "failed",
+    "cancelled",
+    "manual_retry",
+  ]),
+);
 export type MemorySlackPublicationReceiptKind = z.infer<typeof MemorySlackPublicationReceiptKind>;
 
-export const MemorySlackPublicationReceipt = z.object({
-  id: z.string().uuid(),
-  publicationId: z.string().uuid(),
-  sequence: z.number().int().positive(),
-  kind: MemorySlackPublicationReceiptKind,
-  state: MemorySlackPublicationState,
-  attemptNumber: z.number().int().nonnegative(),
-  actorKind: z.enum(["human", "agent", "service"]),
-  actorSubjectId: z.string().min(1).max(1_024),
-  operationId: z.string().uuid(),
-  errorCode: z.string().min(1).max(128).nullable(),
-  retryAt: z.string().nullable(),
-  slackChannelId: z.string().min(1).max(64).nullable(),
-  slackMessageTimestamp: z.string().min(1).max(64).nullable(),
-  createdAt: z.string(),
-});
+export const MemorySlackPublicationReceipt = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    id: z.string().uuid(),
+    publicationId: z.string().uuid(),
+    sequence: z.number().int().positive(),
+    kind: MemorySlackPublicationReceiptKind,
+    state: MemorySlackPublicationState,
+    attemptNumber: z.number().int().nonnegative(),
+    actorKind: z.enum(["human", "agent", "service"]),
+    actorSubjectId: z.string().min(1).max(1_024),
+    operationId: z.string().uuid(),
+    errorCode: z.string().min(1).max(128).nullable(),
+    retryAt: z.string().nullable(),
+    slackChannelId: z.string().min(1).max(64).nullable(),
+    slackMessageTimestamp: z.string().min(1).max(64).nullable(),
+    createdAt: z.string(),
+  }),
+);
 export type MemorySlackPublicationReceipt = z.infer<typeof MemorySlackPublicationReceipt>;
 
-export const MemorySlackPublication = z.object({
-  id: z.string().uuid(),
-  workspaceId: z.string().uuid(),
-  configurationRevision: z.number().int().positive(),
-  connectionId: z.string().uuid(),
-  slackTeamId: z.string().min(1).max(64),
-  slackChannelId: z.string().min(1).max(64),
-  sourceType: z.enum(["workspace_memory", "durable_learning"]),
-  sourceId: z.string().min(1).max(1_024),
-  sourceVersion: z.string().min(1).max(512).nullable(),
-  importance: MemorySlackImportance,
-  deliveryMode: z.enum(["auto", "review"]),
-  state: MemorySlackPublicationState,
-  summary: z.string().max(512),
-  sourceLabel: z.string().max(128),
-  authoritativePath: z.string().max(2_048).nullable(),
-  initiatorKind: z.enum(["human", "agent", "service"]),
-  initiatorSubjectId: z.string().min(1).max(1_024),
-  initiatingHumanSubjectId: z.string().min(1).max(1_024).nullable(),
-  attemptCount: z.number().int().nonnegative(),
-  retryAt: z.string().nullable(),
-  lastErrorCode: z.string().min(1).max(128).nullable(),
-  slackMessageTimestamp: z.string().min(1).max(64).nullable(),
-  deliveredAt: z.string().nullable(),
-  terminalAt: z.string().nullable(),
-  createdAt: z.string(),
-  updatedAt: z.string(),
-  receipts: z.array(MemorySlackPublicationReceipt).max(100),
-});
+export const MemorySlackPublication = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    id: z.string().uuid(),
+    workspaceId: z.string().uuid(),
+    configurationRevision: z.number().int().positive(),
+    connectionId: z.string().uuid(),
+    slackTeamId: z.string().min(1).max(64),
+    slackChannelId: z.string().min(1).max(64),
+    sourceType: z.enum(["workspace_memory", "durable_learning"]),
+    sourceId: z.string().min(1).max(1_024),
+    sourceVersion: z.string().min(1).max(512).nullable(),
+    importance: MemorySlackImportance,
+    deliveryMode: z.enum(["auto", "review"]),
+    state: MemorySlackPublicationState,
+    summary: z.string().max(512),
+    sourceLabel: z.string().max(128),
+    authoritativePath: z.string().max(2_048).nullable(),
+    initiatorKind: z.enum(["human", "agent", "service"]),
+    initiatorSubjectId: z.string().min(1).max(1_024),
+    initiatingHumanSubjectId: z.string().min(1).max(1_024).nullable(),
+    attemptCount: z.number().int().nonnegative(),
+    retryAt: z.string().nullable(),
+    lastErrorCode: z.string().min(1).max(128).nullable(),
+    slackMessageTimestamp: z.string().min(1).max(64).nullable(),
+    deliveredAt: z.string().nullable(),
+    terminalAt: z.string().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    receipts: z.array(MemorySlackPublicationReceipt).max(100),
+  }),
+);
 export type MemorySlackPublication = z.infer<typeof MemorySlackPublication>;
 
-export const MemorySlackPublicationHistoryResponse = z.object({
-  publications: z.array(MemorySlackPublication).max(100),
-  nextCursor: z.string().uuid().nullable(),
-});
+export const MemorySlackPublicationHistoryResponse = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    publications: z.array(MemorySlackPublication).max(100),
+    nextCursor: z.string().uuid().nullable(),
+  }),
+);
 export type MemorySlackPublicationHistoryResponse = z.infer<
   typeof MemorySlackPublicationHistoryResponse
 >;
 
-export const MemorySlackPublicationActionRequest = z
-  .object({
-    action: z.enum(["approve", "reject", "retry"]),
-    expectedState: MemorySlackPublicationState,
-  })
-  .strict();
+export const MemorySlackPublicationActionRequest = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      action: z.enum(["approve", "reject", "retry"]),
+      expectedState: MemorySlackPublicationState,
+    })
+    .strict(),
+);
 export type MemorySlackPublicationActionRequest = z.infer<
   typeof MemorySlackPublicationActionRequest
 >;
 
-export const SlackPublicationChannel = z.object({
-  id: z.string().min(1).max(64),
-  name: z.string().min(1).max(256).nullable(),
-  isPrivate: z.boolean(),
-});
+export const SlackPublicationChannel = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    id: z.string().min(1).max(64),
+    name: z.string().min(1).max(256).nullable(),
+    isPrivate: z.boolean(),
+  }),
+);
 export type SlackPublicationChannel = z.infer<typeof SlackPublicationChannel>;
 
-export const SlackPublicationChannelListResponse = z.object({
-  channels: z.array(SlackPublicationChannel).max(200),
-  nextCursor: z.string().max(1_024).nullable(),
-});
+export const SlackPublicationChannelListResponse = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    channels: z.array(SlackPublicationChannel).max(200),
+    nextCursor: z.string().max(1_024).nullable(),
+  }),
+);
 export type SlackPublicationChannelListResponse = z.infer<
   typeof SlackPublicationChannelListResponse
 >;