@contractspec/lib.contracts 1.44.0

package/dist/integrations/secrets/scaleway-secret-manager.d.ts

@@ -0,0 +1,38 @@
+import { SecretFetchOptions, SecretProvider, SecretReference, SecretRotationResult, SecretValue, SecretWritePayload } from "./provider.js";
+
+//#region src/integrations/secrets/scaleway-secret-manager.d.ts
+interface ScalewaySecretManagerProviderOptions {
+  /**
+   * Scaleway API token (SCW secret key). If omitted, uses env vars.
+   * Header: X-Auth-Token
+   */
+  token?: string;
+  /** Default region when not present in reference (e.g. fr-par). */
+  defaultRegion?: string;
+  /** Default project id used when creating secrets by name. */
+  defaultProjectId?: string;
+  /** Override API base url (defaults to https://api.scaleway.com). */
+  baseUrl?: string;
+  /** Inject fetch for tests. */
+  fetch?: typeof fetch;
+}
+declare class ScalewaySecretManagerProvider implements SecretProvider {
+  readonly id = "scaleway-secret-manager";
+  private readonly token;
+  private readonly defaultRegion?;
+  private readonly defaultProjectId?;
+  private readonly baseUrl;
+  private readonly fetchFn;
+  constructor(options?: ScalewaySecretManagerProviderOptions);
+  canHandle(reference: SecretReference): boolean;
+  getSecret(reference: SecretReference, options?: SecretFetchOptions): Promise<SecretValue>;
+  setSecret(reference: SecretReference, payload: SecretWritePayload): Promise<SecretRotationResult>;
+  rotateSecret(reference: SecretReference, payload: SecretWritePayload): Promise<SecretRotationResult>;
+  deleteSecret(reference: SecretReference): Promise<void>;
+  private parseReference;
+  private createSecret;
+  private createSecretVersion;
+  private buildReference;
+}
+//#endregion
+export { ScalewaySecretManagerProvider };

package/dist/integrations/secrets/scaleway-secret-manager.js

@@ -0,0 +1,247 @@
+import { SecretProviderError, normalizeSecretPayload, parseSecretUri } from "./provider.js";
+import { Buffer } from "node:buffer";
+
+//#region src/integrations/secrets/scaleway-secret-manager.ts
+const UUID_V4_LIKE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var ScalewaySecretManagerProvider = class {
+	id = "scaleway-secret-manager";
+	token;
+	defaultRegion;
+	defaultProjectId;
+	baseUrl;
+	fetchFn;
+	constructor(options = {}) {
+		this.token = options.token ?? process.env.SCW_SECRET_KEY ?? process.env.SCALEWAY_SECRET_KEY ?? "";
+		this.defaultRegion = options.defaultRegion ?? process.env.SCW_DEFAULT_REGION ?? process.env.SCW_REGION;
+		this.defaultProjectId = options.defaultProjectId ?? process.env.SCW_DEFAULT_PROJECT_ID ?? process.env.SCW_PROJECT_ID;
+		this.baseUrl = options.baseUrl ?? "https://api.scaleway.com";
+		this.fetchFn = options.fetch ?? fetch;
+	}
+	canHandle(reference) {
+		try {
+			const parsed = parseSecretUri(reference);
+			return parsed.provider === "scw" && (parsed.path === "secret-manager" || parsed.path.startsWith("secret-manager/"));
+		} catch {
+			return false;
+		}
+	}
+	async getSecret(reference, options) {
+		const location = this.parseReference(reference);
+		if (!this.token) throw new SecretProviderError({
+			message: "Scaleway secret manager token is missing (set SCW_SECRET_KEY / SCALEWAY_SECRET_KEY).",
+			provider: this.id,
+			reference,
+			code: "FORBIDDEN"
+		});
+		if (!UUID_V4_LIKE.test(location.secretIdOrName)) throw new SecretProviderError({
+			message: "Scaleway getSecret requires a secretId (uuid) reference, not a secret name.",
+			provider: this.id,
+			reference,
+			code: "INVALID"
+		});
+		const revision = options?.version ?? location.revision ?? "latest";
+		const url = `${this.baseUrl}/secret-manager/v1beta1/regions/${encodeURIComponent(location.region)}/secrets/${encodeURIComponent(location.secretIdOrName)}/versions/${encodeURIComponent(revision)}/access`;
+		const response = await this.fetchFn(url, {
+			method: "GET",
+			headers: { "X-Auth-Token": this.token }
+		});
+		if (!response.ok) throw await toScalewayError({
+			response,
+			provider: this.id,
+			reference,
+			operation: "getSecret"
+		});
+		const dataB64 = extractScalewayData(await response.json());
+		return {
+			data: Buffer.from(dataB64, "base64"),
+			version: revision,
+			metadata: {
+				region: location.region,
+				secretId: location.secretIdOrName
+			},
+			retrievedAt: /* @__PURE__ */ new Date()
+		};
+	}
+	async setSecret(reference, payload) {
+		const location = this.parseReference(reference);
+		if (!this.token) throw new SecretProviderError({
+			message: "Scaleway secret manager token is missing (set SCW_SECRET_KEY / SCALEWAY_SECRET_KEY).",
+			provider: this.id,
+			reference,
+			code: "FORBIDDEN"
+		});
+		const bytes = normalizeSecretPayload(payload);
+		const encoded = Buffer.from(bytes).toString("base64");
+		const secretId = UUID_V4_LIKE.test(location.secretIdOrName) ? location.secretIdOrName : await this.createSecret({
+			region: location.region,
+			name: location.secretIdOrName,
+			reference
+		});
+		const version = await this.createSecretVersion({
+			region: location.region,
+			secretId,
+			dataB64: encoded,
+			reference
+		});
+		return {
+			reference: this.buildReference(location.region, secretId, { version }),
+			version
+		};
+	}
+	async rotateSecret(reference, payload) {
+		return this.setSecret(reference, payload);
+	}
+	async deleteSecret(reference) {
+		const location = this.parseReference(reference);
+		if (!this.token) throw new SecretProviderError({
+			message: "Scaleway secret manager token is missing (set SCW_SECRET_KEY / SCALEWAY_SECRET_KEY).",
+			provider: this.id,
+			reference,
+			code: "FORBIDDEN"
+		});
+		if (!UUID_V4_LIKE.test(location.secretIdOrName)) throw new SecretProviderError({
+			message: "Scaleway deleteSecret requires a secretId (uuid) reference, not a secret name.",
+			provider: this.id,
+			reference,
+			code: "INVALID"
+		});
+		const url = `${this.baseUrl}/secret-manager/v1beta1/regions/${encodeURIComponent(location.region)}/secrets/${encodeURIComponent(location.secretIdOrName)}`;
+		const response = await this.fetchFn(url, {
+			method: "DELETE",
+			headers: { "X-Auth-Token": this.token }
+		});
+		if (!response.ok) throw await toScalewayError({
+			response,
+			provider: this.id,
+			reference,
+			operation: "deleteSecret"
+		});
+	}
+	parseReference(reference) {
+		const parsed = parseSecretUri(reference);
+		if (parsed.provider !== "scw") throw new SecretProviderError({
+			message: `Unsupported secret provider: ${parsed.provider}`,
+			provider: this.id,
+			reference,
+			code: "INVALID"
+		});
+		const segments = parsed.path.split("/").filter(Boolean);
+		if (segments.length < 2 || segments[0] !== "secret-manager") throw new SecretProviderError({
+			message: "Expected secret reference format scw://secret-manager/{region}/{secretIdOrName}[?version=...]",
+			provider: this.id,
+			reference,
+			code: "INVALID"
+		});
+		const region = segments[1] ?? this.defaultRegion;
+		if (!region) throw new SecretProviderError({
+			message: "Scaleway region must be provided either in reference (scw://secret-manager/{region}/...) or via SCW_DEFAULT_REGION/SCW_REGION.",
+			provider: this.id,
+			reference,
+			code: "INVALID"
+		});
+		const secretIdOrName = segments.slice(2).join("/");
+		if (!secretIdOrName) throw new SecretProviderError({
+			message: `Unable to resolve secret id/name from reference "${parsed.path}"`,
+			provider: this.id,
+			reference,
+			code: "INVALID"
+		});
+		return {
+			region,
+			secretIdOrName,
+			revision: parsed.extras?.version
+		};
+	}
+	async createSecret(params) {
+		const projectId = this.defaultProjectId;
+		if (!projectId) throw new SecretProviderError({
+			message: "Scaleway project id is required to create secrets by name (set SCW_DEFAULT_PROJECT_ID/SCW_PROJECT_ID).",
+			provider: this.id,
+			reference: params.reference,
+			code: "INVALID"
+		});
+		const url = `${this.baseUrl}/secret-manager/v1beta1/regions/${encodeURIComponent(params.region)}/secrets`;
+		const response = await this.fetchFn(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				"X-Auth-Token": this.token
+			},
+			body: JSON.stringify({
+				name: params.name,
+				project_id: projectId
+			})
+		});
+		if (!response.ok) throw await toScalewayError({
+			response,
+			provider: this.id,
+			reference: params.reference,
+			operation: "createSecret"
+		});
+		return extractScalewaySecretId(await response.json());
+	}
+	async createSecretVersion(params) {
+		const url = `${this.baseUrl}/secret-manager/v1beta1/regions/${encodeURIComponent(params.region)}/secrets/${encodeURIComponent(params.secretId)}/versions`;
+		const response = await this.fetchFn(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				"X-Auth-Token": this.token
+			},
+			body: JSON.stringify({ data: params.dataB64 })
+		});
+		if (!response.ok) throw await toScalewayError({
+			response,
+			provider: this.id,
+			reference: params.reference,
+			operation: "createSecretVersion"
+		});
+		return extractScalewayRevision(await response.json()) ?? "latest";
+	}
+	buildReference(region, secretId, extras) {
+		const base = `scw://secret-manager/${region}/${secretId}`;
+		const query = extras ? Object.entries(extras).filter(([, value]) => Boolean(value)).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&") : "";
+		return query ? `${base}?${query}` : base;
+	}
+};
+function extractScalewayData(payload) {
+	if (!payload || typeof payload !== "object") throw new Error("Invalid scaleway secret payload");
+	const record = payload;
+	if (typeof record.data === "string" && record.data) return record.data;
+	throw new Error("Scaleway secret payload is missing data");
+}
+function extractScalewaySecretId(payload) {
+	if (!payload || typeof payload !== "object") throw new Error("Invalid scaleway createSecret payload");
+	const record = payload;
+	if (typeof record.id === "string" && record.id) return record.id;
+	throw new Error("Scaleway createSecret response is missing id");
+}
+function extractScalewayRevision(payload) {
+	if (!payload || typeof payload !== "object") return;
+	const record = payload;
+	if (typeof record.revision === "number") return String(record.revision);
+	if (typeof record.revision === "string" && record.revision) return record.revision;
+	if (typeof record.id === "string" && record.id) return record.id;
+}
+async function toScalewayError(params) {
+	const { response, provider, reference, operation } = params;
+	const code = response.status === 404 ? "NOT_FOUND" : response.status === 401 || response.status === 403 ? "FORBIDDEN" : response.status >= 400 && response.status < 500 ? "INVALID" : "UNKNOWN";
+	const bodyText = await safeReadBody(response);
+	return new SecretProviderError({
+		message: bodyText ? `Scaleway Secret Manager ${operation} failed (${response.status}): ${bodyText}` : `Scaleway Secret Manager ${operation} failed (${response.status})`,
+		provider,
+		reference,
+		code
+	});
+}
+async function safeReadBody(response) {
+	try {
+		const trimmed = (await response.text()).trim();
+		return trimmed.length ? trimmed : void 0;
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+export { ScalewaySecretManagerProvider };

package/dist/integrations/secrets-types.d.ts

@@ -0,0 +1,17 @@
+//#region src/integrations/secrets-types.d.ts
+/**
+ * Secret Provider types for integrations
+ * These are core type definitions that don't require runtime dependencies.
+ */
+interface SecretValue {
+  data: Uint8Array;
+  version?: string;
+  metadata?: Record<string, string>;
+}
+interface SecretProvider {
+  id: string;
+  canHandle(reference: string): boolean;
+  getSecret(reference: string): Promise<SecretValue>;
+}
+//#endregion
+export { SecretProvider, SecretValue };

package/dist/integrations/spec.d.ts

@@ -0,0 +1,75 @@
+import { OwnerShipMeta } from "../ownership.js";
+import { CapabilityRef, CapabilityRequirement } from "../capabilities/capabilities.js";
+import "../capabilities/index.js";
+
+//#region src/integrations/spec.d.ts
+type IntegrationCategory = 'payments' | 'email' | 'calendar' | 'sms' | 'ai-llm' | 'ai-voice' | 'speech-to-text' | 'vector-db' | 'storage' | 'accounting' | 'crm' | 'helpdesk' | 'open-banking' | 'custom';
+type IntegrationOwnershipMode = 'managed' | 'byok';
+interface IntegrationMeta extends OwnerShipMeta {
+  category: IntegrationCategory;
+}
+interface IntegrationCapabilityMapping {
+  /** Which CapabilitySpec this integration provides. */
+  provides: CapabilityRef[];
+  /** Optional: which capabilities it requires (e.g., storage for caching). */
+  requires?: CapabilityRequirement[];
+}
+interface IntegrationConfigSchema {
+  /** JSON Schema or SchemaModel defining required config fields. */
+  schema: unknown;
+  /** Example configuration (for docs/UI). */
+  example?: Record<string, unknown>;
+}
+interface IntegrationSecretSchema {
+  /** JSON Schema or SchemaModel describing secret fields. */
+  schema: unknown;
+  /** Redacted example for documentation/UI. */
+  example?: Record<string, string>;
+}
+interface IntegrationByokSetup {
+  /** Human-readable instructions for tenants configuring BYOK accounts. */
+  setupInstructions?: string;
+  /** Required scopes/permissions for BYOK accounts. */
+  requiredScopes?: string[];
+}
+interface IntegrationHealthCheck {
+  /** Endpoint or method to validate connection health. */
+  method?: 'ping' | 'list' | 'custom';
+  /** Timeout in ms for health check. */
+  timeoutMs?: number;
+}
+interface IntegrationSpec {
+  meta: IntegrationMeta;
+  /** Supported ownership modes for this provider. */
+  supportedModes: IntegrationOwnershipMode[];
+  /** Which capabilities this integration provides/requires. */
+  capabilities: IntegrationCapabilityMapping;
+  /** Configuration schema (API keys, endpoints, etc.). */
+  configSchema: IntegrationConfigSchema;
+  /** Secret schema (API/key material stored via secretRef). */
+  secretSchema: IntegrationSecretSchema;
+  /** Optional health check configuration. */
+  healthCheck?: IntegrationHealthCheck;
+  /** Documentation URL. */
+  docsUrl?: string;
+  /** Rate limits or usage constraints. */
+  constraints?: {
+    rateLimit?: {
+      rpm?: number;
+      rph?: number;
+    };
+    quotas?: Record<string, number>;
+  };
+  /** Provider-specific metadata for BYOK setup flows. */
+  byokSetup?: IntegrationByokSetup;
+}
+declare class IntegrationSpecRegistry {
+  private readonly items;
+  register(spec: IntegrationSpec): this;
+  list(): IntegrationSpec[];
+  get(key: string, version?: number): IntegrationSpec | undefined;
+  getByCategory(category: IntegrationCategory): IntegrationSpec[];
+}
+declare function makeIntegrationSpecKey(meta: IntegrationMeta): string;
+//#endregion
+export { IntegrationByokSetup, IntegrationCapabilityMapping, IntegrationCategory, IntegrationConfigSchema, IntegrationHealthCheck, IntegrationMeta, IntegrationOwnershipMode, IntegrationSecretSchema, IntegrationSpec, IntegrationSpecRegistry, makeIntegrationSpecKey };

package/dist/integrations/spec.js

@@ -0,0 +1,39 @@
+//#region src/integrations/spec.ts
+const integrationKey = (meta) => `${meta.key}.v${meta.version}`;
+var IntegrationSpecRegistry = class {
+	items = /* @__PURE__ */ new Map();
+	register(spec) {
+		const key = integrationKey(spec.meta);
+		if (this.items.has(key)) throw new Error(`Duplicate IntegrationSpec ${key}`);
+		this.items.set(key, spec);
+		return this;
+	}
+	list() {
+		return [...this.items.values()];
+	}
+	get(key, version) {
+		if (version != null) return this.items.get(integrationKey({
+			key,
+			version
+		}));
+		let latest;
+		let maxVersion = -Infinity;
+		for (const spec of this.items.values()) {
+			if (spec.meta.key !== key) continue;
+			if (spec.meta.version > maxVersion) {
+				maxVersion = spec.meta.version;
+				latest = spec;
+			}
+		}
+		return latest;
+	}
+	getByCategory(category) {
+		return this.list().filter((spec) => spec.meta.category === category);
+	}
+};
+function makeIntegrationSpecKey(meta) {
+	return integrationKey(meta);
+}
+
+//#endregion
+export { IntegrationSpecRegistry, makeIntegrationSpecKey };

package/dist/jobs/define-job.d.ts

@@ -0,0 +1,18 @@
+import { Job, JobQueue } from "./queue.js";
+import { ZodSchema } from "zod";
+
+//#region src/jobs/define-job.d.ts
+interface DefinedJob<TPayload> {
+  type: string;
+  schema: ZodSchema<TPayload>;
+  handler: (payload: TPayload, job: Job<TPayload>) => Promise<void>;
+}
+/**
+ * Register a `DefinedJob` on a queue with payload validation.
+ *
+ * - Parses and validates payload via the job's Zod schema
+ * - Invokes the defined handler with the validated payload
+ */
+declare function registerDefinedJob<TPayload>(queue: JobQueue, job: DefinedJob<TPayload>): void;
+//#endregion
+export { DefinedJob, registerDefinedJob };

package/dist/jobs/define-job.js

@@ -0,0 +1,16 @@
+//#region src/jobs/define-job.ts
+/**
+* Register a `DefinedJob` on a queue with payload validation.
+*
+* - Parses and validates payload via the job's Zod schema
+* - Invokes the defined handler with the validated payload
+*/
+function registerDefinedJob(queue, job) {
+	queue.register(job.type, async (queuedJob) => {
+		const parsed = job.schema.parse(queuedJob.payload);
+		await job.handler(parsed, queuedJob);
+	});
+}
+
+//#endregion
+export { registerDefinedJob };

package/dist/jobs/gcp-cloud-tasks.d.ts

@@ -0,0 +1,41 @@
+import { EnqueueOptions, Job, JobHandler, JobQueue } from "./queue.js";
+
+//#region src/jobs/gcp-cloud-tasks.d.ts
+interface CloudTasksClientLike {
+  createTask(request: {
+    parent: string;
+    task: {
+      httpRequest: {
+        httpMethod: number | string;
+        url: string;
+        body: Buffer;
+        headers?: Record<string, string>;
+        oidcToken?: {
+          serviceAccountEmail: string;
+        };
+      };
+      scheduleTime?: {
+        seconds: number;
+      };
+    };
+  }): Promise<unknown>;
+}
+interface GcpCloudTasksQueueOptions {
+  client: CloudTasksClientLike;
+  projectId: string;
+  location: string;
+  queue: string;
+  resolveUrl(jobType: string): string;
+  serviceAccountEmail?: string;
+}
+declare class GcpCloudTasksQueue implements JobQueue {
+  private readonly options;
+  private readonly handlers;
+  constructor(options: GcpCloudTasksQueueOptions);
+  enqueue<TPayload>(jobType: string, payload: TPayload, options?: EnqueueOptions): Promise<Job<TPayload>>;
+  register<TPayload, TResult = void>(jobType: string, handler: JobHandler<TPayload, TResult>): void;
+  start(): void;
+  stop(): Promise<void>;
+}
+//#endregion
+export { GcpCloudTasksQueue, GcpCloudTasksQueueOptions };

package/dist/jobs/gcp-cloud-tasks.js

@@ -0,0 +1,53 @@
+import { DEFAULT_RETRY_POLICY } from "./queue.js";
+import { randomUUID } from "node:crypto";
+
+//#region src/jobs/gcp-cloud-tasks.ts
+var GcpCloudTasksQueue = class {
+	handlers = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+	}
+	async enqueue(jobType, payload, options = {}) {
+		const enqueueTime = options.delaySeconds != null ? { seconds: Math.floor(Date.now() / 1e3) + options.delaySeconds } : void 0;
+		const body = Buffer.from(JSON.stringify({
+			id: randomUUID(),
+			type: jobType,
+			payload
+		}), "utf-8");
+		await this.options.client.createTask({
+			parent: `projects/${this.options.projectId}/locations/${this.options.location}/queues/${this.options.queue}`,
+			task: {
+				httpRequest: {
+					httpMethod: "POST",
+					url: this.options.resolveUrl(jobType),
+					body,
+					headers: { "Content-Type": "application/json" },
+					oidcToken: this.options.serviceAccountEmail ? { serviceAccountEmail: this.options.serviceAccountEmail } : void 0
+				},
+				scheduleTime: enqueueTime
+			}
+		});
+		return {
+			id: randomUUID(),
+			type: jobType,
+			version: 1,
+			payload,
+			status: "pending",
+			priority: options.priority ?? 0,
+			attempts: 0,
+			maxRetries: options.maxRetries ?? DEFAULT_RETRY_POLICY.maxRetries,
+			createdAt: /* @__PURE__ */ new Date(),
+			updatedAt: /* @__PURE__ */ new Date()
+		};
+	}
+	register(jobType, handler) {
+		this.handlers.set(jobType, handler);
+	}
+	start() {}
+	async stop() {
+		this.handlers.clear();
+	}
+};
+
+//#endregion
+export { GcpCloudTasksQueue };

package/dist/jobs/gcp-pubsub.d.ts

@@ -0,0 +1,25 @@
+import { EnqueueOptions, Job, JobHandler, JobQueue } from "./queue.js";
+
+//#region src/jobs/gcp-pubsub.d.ts
+interface PubSubClientLike {
+  topic(name: string): {
+    publishMessage(message: {
+      data: Buffer;
+    }): Promise<string>;
+  };
+}
+interface GcpPubSubQueueOptions {
+  client: PubSubClientLike;
+  topicName: string;
+}
+declare class GcpPubSubQueue implements JobQueue {
+  private readonly options;
+  private readonly handlers;
+  constructor(options: GcpPubSubQueueOptions);
+  enqueue<TPayload>(jobType: string, payload: TPayload, options?: EnqueueOptions): Promise<Job<TPayload>>;
+  register<TPayload, TResult = void>(jobType: string, handler: JobHandler<TPayload, TResult>): void;
+  start(): void;
+  stop(): Promise<void>;
+}
+//#endregion
+export { GcpPubSubQueue, GcpPubSubQueueOptions };

package/dist/jobs/gcp-pubsub.js

@@ -0,0 +1,39 @@
+import { DEFAULT_RETRY_POLICY } from "./queue.js";
+import { randomUUID } from "node:crypto";
+
+//#region src/jobs/gcp-pubsub.ts
+var GcpPubSubQueue = class {
+	handlers = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+	}
+	async enqueue(jobType, payload, options = {}) {
+		await this.options.client.topic(this.options.topicName).publishMessage({ data: Buffer.from(JSON.stringify({
+			id: randomUUID(),
+			type: jobType,
+			payload
+		}), "utf-8") });
+		return {
+			id: randomUUID(),
+			type: jobType,
+			version: 1,
+			payload,
+			status: "pending",
+			priority: options.priority ?? 0,
+			attempts: 0,
+			maxRetries: options.maxRetries ?? DEFAULT_RETRY_POLICY.maxRetries,
+			createdAt: /* @__PURE__ */ new Date(),
+			updatedAt: /* @__PURE__ */ new Date()
+		};
+	}
+	register(jobType, handler) {
+		this.handlers.set(jobType, handler);
+	}
+	start() {}
+	async stop() {
+		this.handlers.clear();
+	}
+};
+
+//#endregion
+export { GcpPubSubQueue };

package/dist/jobs/handlers/gmail-sync-handler.d.ts

@@ -0,0 +1,9 @@
+import { EmailThreadListQuery } from "../../integrations/providers/email.js";
+import { JobHandler } from "../queue.js";
+import { GmailIngestionAdapter } from "../../knowledge/ingestion/gmail-adapter.js";
+
+//#region src/jobs/handlers/gmail-sync-handler.d.ts
+type GmailSyncJobPayload = EmailThreadListQuery;
+declare function createGmailSyncHandler(adapter: GmailIngestionAdapter): JobHandler<GmailSyncJobPayload>;
+//#endregion
+export { GmailSyncJobPayload, createGmailSyncHandler };

package/dist/jobs/handlers/gmail-sync-handler.js

@@ -0,0 +1,9 @@
+//#region src/jobs/handlers/gmail-sync-handler.ts
+function createGmailSyncHandler(adapter) {
+	return async (job) => {
+		await adapter.syncThreads(job.payload);
+	};
+}
+
+//#endregion
+export { createGmailSyncHandler };

package/dist/jobs/handlers/index.d.ts

@@ -0,0 +1,9 @@
+import { JobQueue } from "../queue.js";
+import { GmailSyncJobPayload, createGmailSyncHandler } from "./gmail-sync-handler.js";
+import { PING_JOB_TYPE, PingPayload, PingPayloadSchema, pingJob } from "./ping-handler.js";
+import { StorageDocumentJobPayload, createStorageDocumentHandler } from "./storage-document-handler.js";
+
+//#region src/jobs/handlers/index.d.ts
+declare function registerAllJobs(queue: JobQueue): void;
+//#endregion
+export { GmailSyncJobPayload, PING_JOB_TYPE, PingPayload, PingPayloadSchema, StorageDocumentJobPayload, createGmailSyncHandler, createStorageDocumentHandler, pingJob, registerAllJobs };

package/dist/jobs/handlers/index.js

@@ -0,0 +1,12 @@
+import { registerDefinedJob } from "../define-job.js";
+import { createGmailSyncHandler } from "./gmail-sync-handler.js";
+import { PING_JOB_TYPE, PingPayloadSchema, pingJob } from "./ping-handler.js";
+import { createStorageDocumentHandler } from "./storage-document-handler.js";
+
+//#region src/jobs/handlers/index.ts
+function registerAllJobs(queue) {
+	registerDefinedJob(queue, pingJob);
+}
+
+//#endregion
+export { PING_JOB_TYPE, PingPayloadSchema, createGmailSyncHandler, createStorageDocumentHandler, pingJob, registerAllJobs };

package/dist/jobs/handlers/ping-handler.d.ts

@@ -0,0 +1,10 @@
+import { DefinedJob } from "../define-job.js";
+import * as z$1 from "zod";
+
+//#region src/jobs/handlers/ping-handler.d.ts
+declare const PING_JOB_TYPE: "core.ping";
+declare const PingPayloadSchema: z$1.ZodObject<{}, z$1.core.$strip>;
+type PingPayload = z$1.infer<typeof PingPayloadSchema>;
+declare const pingJob: DefinedJob<PingPayload>;
+//#endregion
+export { PING_JOB_TYPE, PingPayload, PingPayloadSchema, pingJob };