@objectstack/spec 0.3.0 → 0.3.1

package/dist/system/driver.zod.d.ts

@@ -1096,11 +1096,11 @@ export declare const DriverInterfaceSchema: z.ZodObject<{
         id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
         data: z.ZodRecord<z.ZodString, z.ZodAny>;
     }, "strip", z.ZodTypeAny, {
-        id: string | number;
         data: Record<string, any>;
-    }, {
         id: string | number;
+    }, {
         data: Record<string, any>;
+        id: string | number;
     }>, "many">, z.ZodOptional<z.ZodObject<{
         /**
          * Transaction handle/identifier.
@@ -1336,8 +1336,8 @@ export declare const DriverInterfaceSchema: z.ZodObject<{
         skipCache?: boolean | undefined;
     } | undefined, ...args: unknown[]) => Promise<Record<string, any>[]>;
     bulkUpdate: (args_0: string, args_1: {
-        id: string | number;
         data: Record<string, any>;
+        id: string | number;
     }[], args_2: {
         timeout?: number | undefined;
         transaction?: any;
@@ -1532,8 +1532,8 @@ export declare const DriverInterfaceSchema: z.ZodObject<{
         skipCache?: boolean | undefined;
     } | undefined, ...args: unknown[]) => Promise<Record<string, any>[]>;
     bulkUpdate: (args_0: string, args_1: {
-        id: string | number;
         data: Record<string, any>;
+        id: string | number;
     }[], args_2: {
         timeout?: number | undefined;
         transaction?: any;

package/dist/system/events.zod.d.ts

@@ -0,0 +1,177 @@
+import { z } from 'zod';
+/**
+ * Event Metadata Schema
+ * Metadata associated with every event
+ */
+export declare const EventMetadataSchema: z.ZodObject<{
+    source: z.ZodString;
+    timestamp: z.ZodString;
+    userId: z.ZodOptional<z.ZodString>;
+    tenantId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    source: string;
+    timestamp: string;
+    userId?: string | undefined;
+    tenantId?: string | undefined;
+}, {
+    source: string;
+    timestamp: string;
+    userId?: string | undefined;
+    tenantId?: string | undefined;
+}>;
+/**
+ * Event Schema
+ * Base schema for all events in the system
+ */
+export declare const EventSchema: z.ZodObject<{
+    name: z.ZodString;
+    payload: z.ZodAny;
+    metadata: z.ZodObject<{
+        source: z.ZodString;
+        timestamp: z.ZodString;
+        userId: z.ZodOptional<z.ZodString>;
+        tenantId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        timestamp: string;
+        userId?: string | undefined;
+        tenantId?: string | undefined;
+    }, {
+        source: string;
+        timestamp: string;
+        userId?: string | undefined;
+        tenantId?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    metadata: {
+        source: string;
+        timestamp: string;
+        userId?: string | undefined;
+        tenantId?: string | undefined;
+    };
+    payload?: any;
+}, {
+    name: string;
+    metadata: {
+        source: string;
+        timestamp: string;
+        userId?: string | undefined;
+        tenantId?: string | undefined;
+    };
+    payload?: any;
+}>;
+export type Event = z.infer<typeof EventSchema>;
+/**
+ * Event Handler Schema
+ * Defines how to handle a specific event
+ */
+export declare const EventHandlerSchema: z.ZodObject<{
+    eventName: z.ZodString;
+    handler: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
+        name: z.ZodString;
+        payload: z.ZodAny;
+        metadata: z.ZodObject<{
+            source: z.ZodString;
+            timestamp: z.ZodString;
+            userId: z.ZodOptional<z.ZodString>;
+            tenantId: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            source: string;
+            timestamp: string;
+            userId?: string | undefined;
+            tenantId?: string | undefined;
+        }, {
+            source: string;
+            timestamp: string;
+            userId?: string | undefined;
+            tenantId?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        metadata: {
+            source: string;
+            timestamp: string;
+            userId?: string | undefined;
+            tenantId?: string | undefined;
+        };
+        payload?: any;
+    }, {
+        name: string;
+        metadata: {
+            source: string;
+            timestamp: string;
+            userId?: string | undefined;
+            tenantId?: string | undefined;
+        };
+        payload?: any;
+    }>], z.ZodUnknown>, z.ZodPromise<z.ZodVoid>>;
+    priority: z.ZodDefault<z.ZodNumber>;
+    async: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    async: boolean;
+    priority: number;
+    eventName: string;
+    handler: (args_0: {
+        name: string;
+        metadata: {
+            source: string;
+            timestamp: string;
+            userId?: string | undefined;
+            tenantId?: string | undefined;
+        };
+        payload?: any;
+    }, ...args: unknown[]) => Promise<void>;
+}, {
+    eventName: string;
+    handler: (args_0: {
+        name: string;
+        metadata: {
+            source: string;
+            timestamp: string;
+            userId?: string | undefined;
+            tenantId?: string | undefined;
+        };
+        payload?: any;
+    }, ...args: unknown[]) => Promise<void>;
+    async?: boolean | undefined;
+    priority?: number | undefined;
+}>;
+export type EventHandler = z.infer<typeof EventHandlerSchema>;
+/**
+ * Event Route Schema
+ * Routes events from one pattern to multiple targets with optional transformation
+ */
+export declare const EventRouteSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodArray<z.ZodString, "many">;
+    transform: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    to: string[];
+    from: string;
+    transform?: ((...args: unknown[]) => unknown) | undefined;
+}, {
+    to: string[];
+    from: string;
+    transform?: ((...args: unknown[]) => unknown) | undefined;
+}>;
+export type EventRoute = z.infer<typeof EventRouteSchema>;
+/**
+ * Event Persistence Schema
+ * Configuration for persisting events to storage
+ */
+export declare const EventPersistenceSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    retention: z.ZodNumber;
+    filter: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    retention: number;
+    filter?: ((...args: unknown[]) => unknown) | undefined;
+}, {
+    retention: number;
+    filter?: ((...args: unknown[]) => unknown) | undefined;
+    enabled?: boolean | undefined;
+}>;
+export type EventPersistence = z.infer<typeof EventPersistenceSchema>;
+//# sourceMappingURL=events.zod.d.ts.map

package/dist/system/events.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.zod.d.ts","sourceRoot":"","sources":["../../src/system/events.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;EAK9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAItB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEhD;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAI3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;EAIjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/system/events.zod.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventPersistenceSchema = exports.EventRouteSchema = exports.EventHandlerSchema = exports.EventSchema = exports.EventMetadataSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Event Metadata Schema
+ * Metadata associated with every event
+ */
+exports.EventMetadataSchema = zod_1.z.object({
+    source: zod_1.z.string().describe('Event source (e.g., plugin name, system component)'),
+    timestamp: zod_1.z.string().datetime().describe('ISO 8601 datetime when event was created'),
+    userId: zod_1.z.string().optional().describe('User who triggered the event'),
+    tenantId: zod_1.z.string().optional().describe('Tenant identifier for multi-tenant systems'),
+});
+/**
+ * Event Schema
+ * Base schema for all events in the system
+ */
+exports.EventSchema = zod_1.z.object({
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_.]*$/).describe('Event name (snake_case with dots, e.g., user.created)'),
+    payload: zod_1.z.any().describe('Event payload schema'),
+    metadata: exports.EventMetadataSchema.describe('Event metadata'),
+});
+/**
+ * Event Handler Schema
+ * Defines how to handle a specific event
+ */
+exports.EventHandlerSchema = zod_1.z.object({
+    eventName: zod_1.z.string().describe('Name of event to handle (supports wildcards like user.*)'),
+    handler: zod_1.z.function().args(exports.EventSchema).returns(zod_1.z.promise(zod_1.z.void())).describe('Handler function'),
+    priority: zod_1.z.number().int().default(0).describe('Execution priority (lower numbers execute first)'),
+    async: zod_1.z.boolean().default(true).describe('Execute in background (true) or block (false)'),
+});
+/**
+ * Event Route Schema
+ * Routes events from one pattern to multiple targets with optional transformation
+ */
+exports.EventRouteSchema = zod_1.z.object({
+    from: zod_1.z.string().describe('Source event pattern (supports wildcards, e.g., user.* or *.created)'),
+    to: zod_1.z.array(zod_1.z.string()).describe('Target event names to route to'),
+    transform: zod_1.z.function().optional().describe('Optional function to transform payload'),
+});
+/**
+ * Event Persistence Schema
+ * Configuration for persisting events to storage
+ */
+exports.EventPersistenceSchema = zod_1.z.object({
+    enabled: zod_1.z.boolean().default(false).describe('Enable event persistence'),
+    retention: zod_1.z.number().int().positive().describe('Days to retain persisted events'),
+    filter: zod_1.z.function().optional().describe('Optional filter function to select which events to persist'),
+});

package/dist/system/identity.zod.d.ts

@@ -121,12 +121,12 @@ export declare const AccountSchema: z.ZodObject<{
      */
     updatedAt: z.ZodDate;
 }, "strip", z.ZodTypeAny, {
-    type: "email" | "oauth" | "oidc" | "credentials" | "saml" | "ldap";
+    type: "email" | "credentials" | "oauth" | "oidc" | "saml" | "ldap";
+    provider: string;
     id: string;
     userId: string;
     createdAt: Date;
     updatedAt: Date;
-    provider: string;
     providerAccountId: string;
     scope?: string | undefined;
     refreshToken?: string | undefined;
@@ -136,12 +136,12 @@ export declare const AccountSchema: z.ZodObject<{
     idToken?: string | undefined;
     sessionState?: string | undefined;
 }, {
-    type: "email" | "oauth" | "oidc" | "credentials" | "saml" | "ldap";
+    type: "email" | "credentials" | "oauth" | "oidc" | "saml" | "ldap";
+    provider: string;
     id: string;
     userId: string;
     createdAt: Date;
     updatedAt: Date;
-    provider: string;
     providerAccountId: string;
     scope?: string | undefined;
     refreshToken?: string | undefined;

package/dist/system/index.d.ts

@@ -17,12 +17,17 @@ export * from './organization.zod';
 export * from './policy.zod';
 export * from './role.zod';
 export * from './territory.zod';
+export * from './tenant.zod';
+export * from './audit.zod';
 export * from './license.zod';
 export * from './webhook.zod';
 export * from './translation.zod';
 export * from './driver.zod';
 export * from './discovery.zod';
 export * from './plugin.zod';
+export * from './realtime.zod';
+export * from './events.zod';
+export * from './job.zod';
 export * from './constants';
 export * from './types';
 //# sourceMappingURL=index.d.ts.map

package/dist/system/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/system/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/system/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC"}

package/dist/system/index.js

@@ -33,11 +33,16 @@ __exportStar(require("./organization.zod"), exports);
 __exportStar(require("./policy.zod"), exports);
 __exportStar(require("./role.zod"), exports);
 __exportStar(require("./territory.zod"), exports);
+__exportStar(require("./tenant.zod"), exports);
+__exportStar(require("./audit.zod"), exports);
 __exportStar(require("./license.zod"), exports);
 __exportStar(require("./webhook.zod"), exports);
 __exportStar(require("./translation.zod"), exports);
 __exportStar(require("./driver.zod"), exports);
 __exportStar(require("./discovery.zod"), exports);
 __exportStar(require("./plugin.zod"), exports);
+__exportStar(require("./realtime.zod"), exports);
+__exportStar(require("./events.zod"), exports);
+__exportStar(require("./job.zod"), exports);
 __exportStar(require("./constants"), exports);
 __exportStar(require("./types"), exports);

package/dist/system/job.zod.d.ts

@@ -0,0 +1,237 @@
+import { z } from 'zod';
+/**
+ * Cron Schedule Schema
+ * Schedule jobs using cron expressions
+ */
+export declare const CronScheduleSchema: z.ZodObject<{
+    type: z.ZodLiteral<"cron">;
+    expression: z.ZodString;
+    timezone: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    type: "cron";
+    expression: string;
+    timezone: string;
+}, {
+    type: "cron";
+    expression: string;
+    timezone?: string | undefined;
+}>;
+/**
+ * Interval Schedule Schema
+ * Schedule jobs at fixed intervals
+ */
+export declare const IntervalScheduleSchema: z.ZodObject<{
+    type: z.ZodLiteral<"interval">;
+    intervalMs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "interval";
+    intervalMs: number;
+}, {
+    type: "interval";
+    intervalMs: number;
+}>;
+/**
+ * Once Schedule Schema
+ * Schedule a job to run once at a specific time
+ */
+export declare const OnceScheduleSchema: z.ZodObject<{
+    type: z.ZodLiteral<"once">;
+    at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "once";
+}, {
+    at: string;
+    type: "once";
+}>;
+/**
+ * Schedule Schema
+ * Discriminated union of all schedule types
+ */
+export declare const ScheduleSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"cron">;
+    expression: z.ZodString;
+    timezone: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    type: "cron";
+    expression: string;
+    timezone: string;
+}, {
+    type: "cron";
+    expression: string;
+    timezone?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"interval">;
+    intervalMs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "interval";
+    intervalMs: number;
+}, {
+    type: "interval";
+    intervalMs: number;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"once">;
+    at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    at: string;
+    type: "once";
+}, {
+    at: string;
+    type: "once";
+}>]>;
+export type Schedule = z.infer<typeof ScheduleSchema>;
+export type CronSchedule = z.infer<typeof CronScheduleSchema>;
+export type IntervalSchedule = z.infer<typeof IntervalScheduleSchema>;
+export type OnceSchedule = z.infer<typeof OnceScheduleSchema>;
+/**
+ * Retry Policy Schema
+ * Configuration for job retry behavior with exponential backoff
+ */
+export declare const RetryPolicySchema: z.ZodObject<{
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    backoffMs: z.ZodDefault<z.ZodNumber>;
+    backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    maxRetries: number;
+    backoffMs: number;
+    backoffMultiplier: number;
+}, {
+    maxRetries?: number | undefined;
+    backoffMs?: number | undefined;
+    backoffMultiplier?: number | undefined;
+}>;
+export type RetryPolicy = z.infer<typeof RetryPolicySchema>;
+/**
+ * Job Schema
+ * Defines a scheduled job
+ */
+export declare const JobSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    schedule: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+        timezone: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    }, {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"interval">;
+        intervalMs: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type: "interval";
+        intervalMs: number;
+    }, {
+        type: "interval";
+        intervalMs: number;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"once">;
+        at: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        at: string;
+        type: "once";
+    }, {
+        at: string;
+        type: "once";
+    }>]>;
+    handler: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodPromise<z.ZodVoid>>;
+    retryPolicy: z.ZodOptional<z.ZodObject<{
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+        backoffMs: z.ZodDefault<z.ZodNumber>;
+        backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxRetries: number;
+        backoffMs: number;
+        backoffMultiplier: number;
+    }, {
+        maxRetries?: number | undefined;
+        backoffMs?: number | undefined;
+        backoffMultiplier?: number | undefined;
+    }>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    schedule: {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    } | {
+        type: "interval";
+        intervalMs: number;
+    } | {
+        at: string;
+        type: "once";
+    };
+    id: string;
+    enabled: boolean;
+    handler: (...args: unknown[]) => Promise<void>;
+    timeout?: number | undefined;
+    retryPolicy?: {
+        maxRetries: number;
+        backoffMs: number;
+        backoffMultiplier: number;
+    } | undefined;
+}, {
+    name: string;
+    schedule: {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    } | {
+        type: "interval";
+        intervalMs: number;
+    } | {
+        at: string;
+        type: "once";
+    };
+    id: string;
+    handler: (...args: unknown[]) => Promise<void>;
+    timeout?: number | undefined;
+    enabled?: boolean | undefined;
+    retryPolicy?: {
+        maxRetries?: number | undefined;
+        backoffMs?: number | undefined;
+        backoffMultiplier?: number | undefined;
+    } | undefined;
+}>;
+export type Job = z.infer<typeof JobSchema>;
+/**
+ * Job Execution Status Enum
+ * Status of job execution
+ */
+export declare const JobExecutionStatus: z.ZodEnum<["running", "success", "failed", "timeout"]>;
+export type JobExecutionStatus = z.infer<typeof JobExecutionStatus>;
+/**
+ * Job Execution Schema
+ * Logs for job execution
+ */
+export declare const JobExecutionSchema: z.ZodObject<{
+    jobId: z.ZodString;
+    startedAt: z.ZodString;
+    completedAt: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<["running", "success", "failed", "timeout"]>;
+    error: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status: "timeout" | "success" | "running" | "failed";
+    jobId: string;
+    startedAt: string;
+    error?: string | undefined;
+    duration?: number | undefined;
+    completedAt?: string | undefined;
+}, {
+    status: "timeout" | "success" | "running" | "failed";
+    jobId: string;
+    startedAt: string;
+    error?: string | undefined;
+    duration?: number | undefined;
+    completedAt?: string | undefined;
+}>;
+export type JobExecution = z.infer<typeof JobExecutionSchema>;
+//# sourceMappingURL=job.zod.d.ts.map

package/dist/system/job.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job.zod.d.ts","sourceRoot":"","sources":["../../src/system/job.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAI7B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;EAGjC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;EAG7B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIzB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;EAI5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;;GAGG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQpB,CAAC;AAEH,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAE5C;;;GAGG;AACH,eAAO,MAAM,kBAAkB,wDAK7B,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;EAO7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/system/job.zod.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobExecutionSchema = exports.JobExecutionStatus = exports.JobSchema = exports.RetryPolicySchema = exports.ScheduleSchema = exports.OnceScheduleSchema = exports.IntervalScheduleSchema = exports.CronScheduleSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Cron Schedule Schema
+ * Schedule jobs using cron expressions
+ */
+exports.CronScheduleSchema = zod_1.z.object({
+    type: zod_1.z.literal('cron'),
+    expression: zod_1.z.string().describe('Cron expression (e.g., "0 0 * * *" for daily at midnight)'),
+    timezone: zod_1.z.string().optional().default('UTC').describe('Timezone for cron execution (e.g., "America/New_York")'),
+});
+/**
+ * Interval Schedule Schema
+ * Schedule jobs at fixed intervals
+ */
+exports.IntervalScheduleSchema = zod_1.z.object({
+    type: zod_1.z.literal('interval'),
+    intervalMs: zod_1.z.number().int().positive().describe('Interval in milliseconds'),
+});
+/**
+ * Once Schedule Schema
+ * Schedule a job to run once at a specific time
+ */
+exports.OnceScheduleSchema = zod_1.z.object({
+    type: zod_1.z.literal('once'),
+    at: zod_1.z.string().datetime().describe('ISO 8601 datetime when to execute'),
+});
+/**
+ * Schedule Schema
+ * Discriminated union of all schedule types
+ */
+exports.ScheduleSchema = zod_1.z.discriminatedUnion('type', [
+    exports.CronScheduleSchema,
+    exports.IntervalScheduleSchema,
+    exports.OnceScheduleSchema,
+]);
+/**
+ * Retry Policy Schema
+ * Configuration for job retry behavior with exponential backoff
+ */
+exports.RetryPolicySchema = zod_1.z.object({
+    maxRetries: zod_1.z.number().int().min(0).default(3).describe('Maximum number of retry attempts'),
+    backoffMs: zod_1.z.number().int().positive().default(1000).describe('Initial backoff delay in milliseconds'),
+    backoffMultiplier: zod_1.z.number().positive().default(2).describe('Multiplier for exponential backoff'),
+});
+/**
+ * Job Schema
+ * Defines a scheduled job
+ */
+exports.JobSchema = zod_1.z.object({
+    id: zod_1.z.string().describe('Unique job identifier'),
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Job name (snake_case)'),
+    schedule: exports.ScheduleSchema.describe('Job schedule configuration'),
+    handler: zod_1.z.function().returns(zod_1.z.promise(zod_1.z.void())).describe('Job handler function'),
+    retryPolicy: exports.RetryPolicySchema.optional().describe('Retry policy configuration'),
+    timeout: zod_1.z.number().int().positive().optional().describe('Timeout in milliseconds'),
+    enabled: zod_1.z.boolean().default(true).describe('Whether the job is enabled'),
+});
+/**
+ * Job Execution Status Enum
+ * Status of job execution
+ */
+exports.JobExecutionStatus = zod_1.z.enum([
+    'running',
+    'success',
+    'failed',
+    'timeout',
+]);
+/**
+ * Job Execution Schema
+ * Logs for job execution
+ */
+exports.JobExecutionSchema = zod_1.z.object({
+    jobId: zod_1.z.string().describe('Job identifier'),
+    startedAt: zod_1.z.string().datetime().describe('ISO 8601 datetime when execution started'),
+    completedAt: zod_1.z.string().datetime().optional().describe('ISO 8601 datetime when execution completed'),
+    status: exports.JobExecutionStatus.describe('Execution status'),
+    error: zod_1.z.string().optional().describe('Error message if failed'),
+    duration: zod_1.z.number().int().optional().describe('Execution duration in milliseconds'),
+});