@amalgm/automations 0.1.0

package/dist/src/http.js

@@ -0,0 +1,154 @@
+import { AutomationError } from './errors.js';
+import { parseCreateAutomation, parseCreateScheduleTrigger, parseCreateWebhookTrigger, parseCreateWorkflow, parseListAutomations, parseListRuns, parsePageQuery, parseUpdateAutomation, parseUpdateScheduleTrigger, parseUpdateWebhookTrigger, parseUpdateWorkflow, } from './schema.js';
+export function createAutomationApi(options) {
+    return async (request) => {
+        try {
+            const principal = await options.authenticate(request);
+            const sdk = options.service.for(principal);
+            const url = new URL(request.url);
+            const parts = url.pathname.split('/').filter(Boolean).map(decodeURIComponent);
+            if (parts[0] !== 'v1' || parts[1] !== 'automations')
+                return response(404, { error: 'Not found' });
+            const method = request.method.toUpperCase();
+            const query = pageQuery(url);
+            if (parts.length === 2 && method === 'POST')
+                return response(201, await sdk.automations.create(parseCreateAutomation(await body(request))));
+            if (parts.length === 2 && method === 'GET') {
+                return response(200, await sdk.automations.list(parseListAutomations({
+                    ...query,
+                    ...(url.searchParams.has('targetId') ? { targetId: url.searchParams.get('targetId') || '' } : {}),
+                    ...(url.searchParams.has('enabled') ? { enabled: booleanQuery(url, 'enabled') } : {}),
+                })));
+            }
+            const automationId = parts[2];
+            if (!automationId)
+                return response(404, { error: 'Not found' });
+            if (parts.length === 3 && method === 'GET')
+                return nullable(await sdk.automations.get(automationId));
+            if (parts.length === 3 && method === 'PATCH')
+                return response(200, await sdk.automations.update(automationId, parseUpdateAutomation(await body(request))));
+            if (parts.length === 3 && method === 'DELETE') {
+                await sdk.automations.delete(automationId);
+                return new Response(null, { status: 204 });
+            }
+            if (parts[3] === 'triggers' && parts.length === 4 && method === 'GET') {
+                return response(200, await sdk.triggers.list(automationId));
+            }
+            if (parts[3] === 'triggers' && parts[4] && parts[4] !== 'schedules' && parts[4] !== 'webhooks') {
+                return response(404, { error: 'Not found' });
+            }
+            const triggerKind = parts[4];
+            if (parts[3] === 'triggers' && triggerKind === 'schedules') {
+                if (parts.length === 5 && method === 'POST')
+                    return response(201, await sdk.triggers.schedule.create(automationId, parseCreateScheduleTrigger(await body(request))));
+                if (parts.length === 5 && method === 'GET')
+                    return response(200, await sdk.triggers.schedule.list(automationId, parsePageQuery(query)));
+                const triggerId = parts[5];
+                if (!triggerId)
+                    return response(404, { error: 'Not found' });
+                if (parts.length === 6 && method === 'GET')
+                    return nullable(await sdk.triggers.schedule.get(automationId, triggerId));
+                if (parts.length === 6 && method === 'PATCH')
+                    return response(200, await sdk.triggers.schedule.update(automationId, triggerId, parseUpdateScheduleTrigger(await body(request))));
+                if (parts.length === 6 && method === 'DELETE') {
+                    await sdk.triggers.schedule.delete(automationId, triggerId);
+                    return new Response(null, { status: 204 });
+                }
+            }
+            if (parts[3] === 'triggers' && triggerKind === 'webhooks') {
+                if (parts.length === 5 && method === 'POST')
+                    return response(201, await sdk.triggers.webhook.create(automationId, parseCreateWebhookTrigger(await body(request))));
+                if (parts.length === 5 && method === 'GET')
+                    return response(200, await sdk.triggers.webhook.list(automationId, parsePageQuery(query)));
+                const triggerId = parts[5];
+                if (!triggerId)
+                    return response(404, { error: 'Not found' });
+                if (parts.length === 6 && method === 'GET')
+                    return nullable(await sdk.triggers.webhook.get(automationId, triggerId));
+                if (parts.length === 6 && method === 'PATCH')
+                    return response(200, await sdk.triggers.webhook.update(automationId, triggerId, parseUpdateWebhookTrigger(await body(request))));
+                if (parts.length === 6 && method === 'DELETE') {
+                    await sdk.triggers.webhook.delete(automationId, triggerId);
+                    return new Response(null, { status: 204 });
+                }
+            }
+            if (parts[3] === 'workflow' && parts.length === 4) {
+                if (method === 'POST')
+                    return response(201, await sdk.workflow.create(automationId, parseCreateWorkflow(await body(request))));
+                if (method === 'GET')
+                    return nullable(await sdk.workflow.get(automationId));
+                if (method === 'PATCH')
+                    return response(200, await sdk.workflow.update(automationId, parseUpdateWorkflow(await body(request))));
+                if (method === 'DELETE') {
+                    await sdk.workflow.delete(automationId);
+                    return new Response(null, { status: 204 });
+                }
+            }
+            if (parts[3] === 'runs') {
+                if (parts.length === 4 && method === 'GET') {
+                    return response(200, await sdk.runs.list(automationId, parseListRuns({
+                        ...query,
+                        ...(url.searchParams.has('status') ? { status: url.searchParams.get('status') } : {}),
+                    })));
+                }
+                if (parts.length === 5 && method === 'GET')
+                    return nullable(await sdk.runs.get(automationId, parts[4]));
+            }
+            return response(405, { error: 'Method not allowed' });
+        }
+        catch (error) {
+            if (error instanceof AutomationError)
+                return response(status(error), { error: error.message, code: error.code });
+            return response(500, { error: 'Automations service failed' });
+        }
+    };
+}
+async function body(request) {
+    const value = await request.json().catch(() => {
+        throw new AutomationError('validation', 'Request body must be JSON');
+    });
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new AutomationError('validation', 'Request body must be an object');
+    }
+    return value;
+}
+function pageQuery(url) {
+    return {
+        ...(url.searchParams.has('limit') ? { limit: numberQuery(url, 'limit') } : {}),
+        ...(url.searchParams.has('offset') ? { offset: numberQuery(url, 'offset') } : {}),
+    };
+}
+function numberQuery(url, name) {
+    const value = Number(url.searchParams.get(name));
+    if (!Number.isInteger(value))
+        throw new AutomationError('validation', `${name} must be an integer`);
+    return value;
+}
+function booleanQuery(url, name) {
+    const value = url.searchParams.get(name);
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    throw new AutomationError('validation', `${name} must be true or false`);
+}
+function nullable(value) {
+    return value === null ? response(404, { error: 'Not found', code: 'not_found' }) : response(200, value);
+}
+function response(status, body) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' },
+    });
+}
+function status(error) {
+    if (error.code === 'validation')
+        return 400;
+    if (error.code === 'forbidden')
+        return 403;
+    if (error.code === 'conflict')
+        return 409;
+    if (error.code === 'internal')
+        return 500;
+    return 404;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,14 @@
+export { createAutomationClient, type AutomationAuthorization } from './client.js';
+export { AutomationCrudService, type AutomationCrudRepository } from './crud.js';
+export { AutomationError, ConflictError, ForbiddenError, NotFoundError, ValidationError, type AutomationErrorCode, } from './errors.js';
+export { createAutomationApi, type AuthenticateAutomationRequest, type AutomationApi } from './http.js';
+export { runAutomationCli } from './cli.js';
+export { createAutomationMcpServer } from './mcp.js';
+export { SupabaseAutomationCrudRepository, type SupabaseRpcClient } from './supabase-crud.js';
+export type { Automation, AutomationCrud, AutomationCrudService as AutomationCrudServiceContract, AutomationPrincipal, AutomationRun, AutomationScope, CreateAutomation, CreateScheduleTrigger, CreateWebhookTrigger, CreateWorkflow, Json, ListAutomations, ListRuns, Page, PageQuery, RunStatus, ScheduleTrigger, Trigger, UpdateAutomation, UpdateScheduleTrigger, UpdateWebhookTrigger, UpdateWorkflow, WebhookTrigger, Workflow, } from './contract.js';
+export { Automations, EventRejectedError } from './automations.js';
+export { nextCronAt, validateCron } from './schedule.js';
+export { eventReference, eventReferences, matchesEvent, normalizeHeaders, verifyEventSecret, } from './webhook.js';
+export { SupabaseStore } from './supabase-store.js';
+export type { SupabaseRpcClient as SupabaseStoreRpcClient } from './supabase-store.js';
+export type { AutomationDefinition, AutomationLog, AutomationRun as AutomationRunRecord, AutomationStore, AutomationTarget, AutomationTransport, CronTrigger, DueCronTrigger, EventTrigger, PreparedAutomation, PreparedTrigger, RunInput, RunUpdate, StoredEventTrigger, Trigger as StoreTrigger, WorkflowDefinition, } from './types.js';

package/dist/src/index.js

@@ -0,0 +1,18 @@
+// The automation product has two composable halves:
+//  - the configuration service (contract/crud/http/mcp/cli) — Supabase owns
+//    everything except execution;
+//  - the delivery rail (automations/webhook/schedule/store) — the receipt,
+//    lease, and retry laws that decide when a run happens.
+// Colliding names keep the contract's spelling; the rail's store-level
+// records are exported under Store-scoped aliases.
+export { createAutomationClient } from './client.js';
+export { AutomationCrudService } from './crud.js';
+export { AutomationError, ConflictError, ForbiddenError, NotFoundError, ValidationError, } from './errors.js';
+export { createAutomationApi } from './http.js';
+export { runAutomationCli } from './cli.js';
+export { createAutomationMcpServer } from './mcp.js';
+export { SupabaseAutomationCrudRepository } from './supabase-crud.js';
+export { Automations, EventRejectedError } from './automations.js';
+export { nextCronAt, validateCron } from './schedule.js';
+export { eventReference, eventReferences, matchesEvent, normalizeHeaders, verifyEventSecret, } from './webhook.js';
+export { SupabaseStore } from './supabase-store.js';

package/dist/src/mcp-main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/mcp-main.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createAutomationClient } from './client.js';
+import { createAutomationMcpServer } from './mcp.js';
+const baseUrl = process.env.AMALGM_AUTOMATIONS_API_URL;
+const authorization = process.env.AMALGM_AUTOMATIONS_AUTHORIZATION;
+if (!baseUrl || !authorization) {
+    process.stderr.write('AMALGM_AUTOMATIONS_API_URL and AMALGM_AUTOMATIONS_AUTHORIZATION are required.\n');
+    process.exitCode = 1;
+}
+else {
+    const server = createAutomationMcpServer(createAutomationClient({
+        baseUrl,
+        authorization: () => authorization,
+    }));
+    await server.connect(new StdioServerTransport());
+}

package/dist/src/mcp.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { AutomationCrud } from './contract.js';
+export declare function createAutomationMcpServer(sdk: AutomationCrud): McpServer;

package/dist/src/mcp.js

@@ -0,0 +1,88 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod/v3';
+import { createAutomationSchema, createScheduleTriggerSchema, createWebhookTriggerSchema, createWorkflowSchema, identifierSchema, listAutomationsSchema, listRunsSchema, pageQuerySchema, updateAutomationSchema, updateScheduleTriggerSchema, updateWebhookTriggerSchema, updateWorkflowSchema, } from './schema.js';
+const resultSchema = { result: z.unknown() };
+const automationIdInput = { automation_id: identifierSchema };
+const triggerIdInput = { ...automationIdInput, trigger_id: identifierSchema };
+const runIdInput = { ...automationIdInput, run_id: identifierSchema };
+export function createAutomationMcpServer(sdk) {
+    const server = new McpServer({ name: 'amalgm-automations-mcp-server', version: '0.1.0' });
+    register(server, 'amalgm_automations_create', 'Create automation', 'Create an automation configuration without triggers or workflow.', { input: createAutomationSchema }, write(false), ({ input }) => sdk.automations.create(input));
+    register(server, 'amalgm_automations_list', 'List automations', 'List the caller\'s automations with optional target and enabled filters.', { query: listAutomationsSchema.optional() }, read(), ({ query }) => sdk.automations.list(query));
+    register(server, 'amalgm_automations_get', 'Get automation', 'Get one automation by id.', automationIdInput, read(), ({ automation_id }) => sdk.automations.get(automation_id));
+    register(server, 'amalgm_automations_update', 'Update automation', 'Update automation metadata, target, or enabled state.', { automation_id: identifierSchema, patch: updateAutomationSchema }, write(true), ({ automation_id, patch }) => sdk.automations.update(automation_id, patch));
+    register(server, 'amalgm_automations_delete', 'Delete automation', 'Delete an automation and its current triggers and workflow. Historical runs remain.', automationIdInput, destructive(), async ({ automation_id }) => {
+        await sdk.automations.delete(automation_id);
+        return { deleted: automation_id };
+    });
+    register(server, 'amalgm_automation_triggers_list', 'List automation triggers', 'List all schedule and webhook triggers belonging to one automation.', automationIdInput, read(), ({ automation_id }) => sdk.triggers.list(automation_id));
+    register(server, 'amalgm_schedule_triggers_create', 'Create schedule trigger', 'Create a cron schedule trigger for one automation.', { automation_id: identifierSchema, input: createScheduleTriggerSchema }, write(false), ({ automation_id, input }) => sdk.triggers.schedule.create(automation_id, input));
+    register(server, 'amalgm_schedule_triggers_list', 'List schedule triggers', 'List schedule triggers for one automation.', { automation_id: identifierSchema, query: pageQuerySchema.optional() }, read(), ({ automation_id, query }) => sdk.triggers.schedule.list(automation_id, query));
+    register(server, 'amalgm_schedule_triggers_get', 'Get schedule trigger', 'Get one schedule trigger by automation and trigger id.', triggerIdInput, read(), ({ automation_id, trigger_id }) => sdk.triggers.schedule.get(automation_id, trigger_id));
+    register(server, 'amalgm_schedule_triggers_update', 'Update schedule trigger', 'Update a cron schedule trigger without changing its type.', { automation_id: identifierSchema, trigger_id: identifierSchema, patch: updateScheduleTriggerSchema }, write(true), ({ automation_id, trigger_id, patch }) => sdk.triggers.schedule.update(automation_id, trigger_id, patch));
+    register(server, 'amalgm_schedule_triggers_delete', 'Delete schedule trigger', 'Delete one schedule trigger. The automation and its workflow remain.', triggerIdInput, destructive(), async ({ automation_id, trigger_id }) => {
+        await sdk.triggers.schedule.delete(automation_id, trigger_id);
+        return { deleted: trigger_id };
+    });
+    register(server, 'amalgm_webhook_triggers_create', 'Create webhook trigger', 'Create a webhook trigger. The secret is accepted only on writes and never returned.', { automation_id: identifierSchema, input: createWebhookTriggerSchema }, write(false), ({ automation_id, input }) => sdk.triggers.webhook.create(automation_id, input));
+    register(server, 'amalgm_webhook_triggers_list', 'List webhook triggers', 'List webhook triggers for one automation. Secrets are never returned.', { automation_id: identifierSchema, query: pageQuerySchema.optional() }, read(), ({ automation_id, query }) => sdk.triggers.webhook.list(automation_id, query));
+    register(server, 'amalgm_webhook_triggers_get', 'Get webhook trigger', 'Get one webhook trigger by automation and trigger id. The secret is never returned.', triggerIdInput, read(), ({ automation_id, trigger_id }) => sdk.triggers.webhook.get(automation_id, trigger_id));
+    register(server, 'amalgm_webhook_triggers_update', 'Update webhook trigger', 'Update webhook matching, secret, or enabled state without changing its type.', { automation_id: identifierSchema, trigger_id: identifierSchema, patch: updateWebhookTriggerSchema }, write(true), ({ automation_id, trigger_id, patch }) => sdk.triggers.webhook.update(automation_id, trigger_id, patch));
+    register(server, 'amalgm_webhook_triggers_delete', 'Delete webhook trigger', 'Delete one webhook trigger. The automation and its workflow remain.', triggerIdInput, destructive(), async ({ automation_id, trigger_id }) => {
+        await sdk.triggers.webhook.delete(automation_id, trigger_id);
+        return { deleted: trigger_id };
+    });
+    register(server, 'amalgm_workflow_create', 'Create automation workflow', 'Create the one workflow script owned by an automation.', { automation_id: identifierSchema, input: createWorkflowSchema }, write(false), ({ automation_id, input }) => sdk.workflow.create(automation_id, input));
+    register(server, 'amalgm_workflow_get', 'Get automation workflow', 'Get the workflow script owned by an automation.', automationIdInput, read(), ({ automation_id }) => sdk.workflow.get(automation_id));
+    register(server, 'amalgm_workflow_update', 'Update automation workflow', 'Update the workflow script or its configuration.', { automation_id: identifierSchema, patch: updateWorkflowSchema }, write(true), ({ automation_id, patch }) => sdk.workflow.update(automation_id, patch));
+    register(server, 'amalgm_workflow_delete', 'Delete automation workflow', 'Delete the workflow script. The automation and its triggers remain.', automationIdInput, destructive(), async ({ automation_id }) => {
+        await sdk.workflow.delete(automation_id);
+        return { deleted: automation_id };
+    });
+    register(server, 'amalgm_automation_runs_list', 'List automation runs', 'List historical runs for one automation. This tool never changes run state.', { automation_id: identifierSchema, query: listRunsSchema.optional() }, read(), ({ automation_id, query }) => sdk.runs.list(automation_id, query));
+    register(server, 'amalgm_automation_runs_get', 'Get automation run', 'Get one historical run for an automation. This tool never changes run state.', runIdInput, read(), ({ automation_id, run_id }) => sdk.runs.get(automation_id, run_id));
+    return server;
+}
+function register(server, name, title, description, inputSchema, annotations, handler) {
+    registerUnchecked(server, name, title, description, inputSchema, annotations, async (input) => {
+        return handler(input);
+    });
+}
+function registerUnchecked(server, name, title, description, inputSchema, annotations, handler) {
+    server.registerTool(name, {
+        title,
+        description,
+        inputSchema,
+        outputSchema: resultSchema,
+        annotations,
+    }, async (input) => {
+        try {
+            const result = await handler(input);
+            return toolSuccess(result);
+        }
+        catch (error) {
+            return toolFailure(error);
+        }
+    });
+}
+function toolSuccess(result) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result) }],
+        structuredContent: { result },
+    };
+}
+function toolFailure(error) {
+    return {
+        isError: true,
+        content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
+    };
+}
+function read() {
+    return { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+}
+function write(idempotentHint) {
+    return { readOnlyHint: false, destructiveHint: false, idempotentHint, openWorldHint: false };
+}
+function destructive() {
+    return { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+}

package/dist/src/schedule.d.ts

@@ -0,0 +1,2 @@
+export declare function nextCronAt(cron: string, timezone: string, after: Date | string): string;
+export declare function validateCron(cron: string, timezone: string): void;

package/dist/src/schedule.js

@@ -0,0 +1,10 @@
+import { CronExpressionParser } from 'cron-parser';
+export function nextCronAt(cron, timezone, after) {
+    return CronExpressionParser.parse(cron, {
+        currentDate: after,
+        tz: timezone,
+    }).next().toDate().toISOString();
+}
+export function validateCron(cron, timezone) {
+    nextCronAt(cron, timezone, new Date(0));
+}

package/dist/src/schema.d.ts

@@ -0,0 +1,236 @@
+import { z } from 'zod/v3';
+import type { CreateAutomation, CreateScheduleTrigger, CreateWebhookTrigger, CreateWorkflow, Json, ListAutomations, ListRuns, PageQuery, UpdateAutomation, UpdateScheduleTrigger, UpdateWebhookTrigger, UpdateWorkflow } from './contract.js';
+export declare const identifierSchema: z.ZodString;
+export declare const pageQuerySchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, {
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export declare const createAutomationSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    targetId: z.ZodString;
+    name: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    description: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    id?: string | undefined;
+    targetId: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    enabled?: boolean | undefined;
+}, {
+    id?: string | undefined;
+    targetId: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    enabled?: boolean | undefined;
+}>;
+export declare const updateAutomationSchema: z.ZodEffects<z.ZodObject<{
+    targetId: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    targetId?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    enabled?: boolean | undefined;
+}, {
+    targetId?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    enabled?: boolean | undefined;
+}>, {
+    targetId?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    enabled?: boolean | undefined;
+}, {
+    targetId?: string | undefined;
+    name?: string | null | undefined;
+    description?: string | null | undefined;
+    enabled?: boolean | undefined;
+}>;
+export declare const listAutomationsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+} & {
+    targetId: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    limit?: number | undefined;
+    offset?: number | undefined;
+    targetId?: string | undefined;
+    enabled?: boolean | undefined;
+}, {
+    limit?: number | undefined;
+    offset?: number | undefined;
+    targetId?: string | undefined;
+    enabled?: boolean | undefined;
+}>;
+export declare const createScheduleTriggerSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    cron: z.ZodEffects<z.ZodString, string, string>;
+    timezone: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    id?: string | undefined;
+    cron: string;
+    timezone?: string | undefined;
+    enabled?: boolean | undefined;
+}, {
+    id?: string | undefined;
+    cron: string;
+    timezone?: string | undefined;
+    enabled?: boolean | undefined;
+}>;
+export declare const updateScheduleTriggerSchema: z.ZodEffects<z.ZodObject<{
+    cron: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    timezone: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    cron?: string | undefined;
+    timezone?: string | undefined;
+    enabled?: boolean | undefined;
+}, {
+    cron?: string | undefined;
+    timezone?: string | undefined;
+    enabled?: boolean | undefined;
+}>, {
+    cron?: string | undefined;
+    timezone?: string | undefined;
+    enabled?: boolean | undefined;
+}, {
+    cron?: string | undefined;
+    timezone?: string | undefined;
+    enabled?: boolean | undefined;
+}>;
+export declare const createWebhookTriggerSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    event: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    secret: z.ZodString;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    id?: string | undefined;
+    source?: string | undefined;
+    event?: string | undefined;
+    secret: string;
+    enabled?: boolean | undefined;
+}, {
+    id?: string | undefined;
+    source?: string | undefined;
+    event?: string | undefined;
+    secret: string;
+    enabled?: boolean | undefined;
+}>;
+export declare const updateWebhookTriggerSchema: z.ZodEffects<z.ZodObject<{
+    source: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    event: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    secret: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    source?: string | undefined;
+    event?: string | undefined;
+    secret?: string | undefined;
+    enabled?: boolean | undefined;
+}, {
+    source?: string | undefined;
+    event?: string | undefined;
+    secret?: string | undefined;
+    enabled?: boolean | undefined;
+}>, {
+    source?: string | undefined;
+    event?: string | undefined;
+    secret?: string | undefined;
+    enabled?: boolean | undefined;
+}, {
+    source?: string | undefined;
+    event?: string | undefined;
+    secret?: string | undefined;
+    enabled?: boolean | undefined;
+}>;
+export declare const createWorkflowSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    script: z.ZodEffects<z.ZodString, string, string>;
+    compiled: z.ZodOptional<z.ZodType<Json, z.ZodTypeDef, Json>>;
+    allowlist: z.ZodOptional<z.ZodType<Json, z.ZodTypeDef, Json>>;
+    limits: z.ZodOptional<z.ZodType<Json, z.ZodTypeDef, Json>>;
+}, "strict", z.ZodTypeAny, {
+    id?: string | undefined;
+    name?: string | undefined;
+    script: string;
+    compiled?: Json | undefined;
+    allowlist?: Json | undefined;
+    limits?: Json | undefined;
+}, {
+    id?: string | undefined;
+    name?: string | undefined;
+    script: string;
+    compiled?: Json | undefined;
+    allowlist?: Json | undefined;
+    limits?: Json | undefined;
+}>;
+export declare const updateWorkflowSchema: z.ZodEffects<z.ZodObject<{
+    name: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+    script: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    compiled: z.ZodOptional<z.ZodNullable<z.ZodType<Json, z.ZodTypeDef, Json>>>;
+    allowlist: z.ZodOptional<z.ZodNullable<z.ZodType<Json, z.ZodTypeDef, Json>>>;
+    limits: z.ZodOptional<z.ZodNullable<z.ZodType<Json, z.ZodTypeDef, Json>>>;
+}, "strict", z.ZodTypeAny, {
+    name?: string | null | undefined;
+    script?: string | undefined;
+    compiled?: Json | undefined;
+    allowlist?: Json | undefined;
+    limits?: Json | undefined;
+}, {
+    name?: string | null | undefined;
+    script?: string | undefined;
+    compiled?: Json | undefined;
+    allowlist?: Json | undefined;
+    limits?: Json | undefined;
+}>, {
+    name?: string | null | undefined;
+    script?: string | undefined;
+    compiled?: Json | undefined;
+    allowlist?: Json | undefined;
+    limits?: Json | undefined;
+}, {
+    name?: string | null | undefined;
+    script?: string | undefined;
+    compiled?: Json | undefined;
+    allowlist?: Json | undefined;
+    limits?: Json | undefined;
+}>;
+export declare const listRunsSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+} & {
+    status: z.ZodOptional<z.ZodEnum<["pending", "sent", "running", "completed", "failed"]>>;
+}, "strict", z.ZodTypeAny, {
+    limit?: number | undefined;
+    offset?: number | undefined;
+    status?: "completed" | "failed" | "pending" | "running" | "sent" | undefined;
+}, {
+    limit?: number | undefined;
+    offset?: number | undefined;
+    status?: "completed" | "failed" | "pending" | "running" | "sent" | undefined;
+}>;
+export declare function parseCreateAutomation(value: unknown): CreateAutomation;
+export declare function parseUpdateAutomation(value: unknown): UpdateAutomation;
+export declare function parseListAutomations(value: unknown): ListAutomations;
+export declare function parseCreateScheduleTrigger(value: unknown): CreateScheduleTrigger;
+export declare function parseUpdateScheduleTrigger(value: unknown): UpdateScheduleTrigger;
+export declare function parseCreateWebhookTrigger(value: unknown): CreateWebhookTrigger;
+export declare function parseUpdateWebhookTrigger(value: unknown): UpdateWebhookTrigger;
+export declare function parseCreateWorkflow(value: unknown): CreateWorkflow;
+export declare function parseUpdateWorkflow(value: unknown): UpdateWorkflow;
+export declare function parsePageQuery(value: unknown): PageQuery;
+export declare function parseListRuns(value: unknown): ListRuns;
+export declare function parse<T>(schema: z.ZodType<T>, value: unknown): T;