@prave/shared 1.4.6 → 1.4.8

package/dist/schemas/skill-test.schema.js

@@ -1,25 +0,0 @@
-import { z } from 'zod';
-/**
- * Managed Skill-Tester input. Prave provides the Anthropic API key
- * server-side and meters usage in credits — one credit per request.
- * Model is fixed to Haiku 4.5 for predictable cost; advanced users can
- * later override via a per-plan whitelist.
- */
-export const skillTestInputSchema = z.object({
-    prompt: z.string().min(1).max(12_000),
-    max_tokens: z.number().int().min(1).max(8192).optional(),
-    temperature: z.number().min(0).max(1).optional(),
-});
-export const skillTestResultSchema = z.object({
-    id: z.string().uuid(),
-    skill_id: z.string().uuid(),
-    model: z.string(),
-    input_prompt: z.string(),
-    output: z.string(),
-    latency_ms: z.number().int().nonnegative(),
-    input_tokens: z.number().int().nullable(),
-    output_tokens: z.number().int().nullable(),
-    status: z.enum(['pending', 'success', 'error']),
-    error_message: z.string().nullable(),
-    created_at: z.string().datetime(),
-});

package/dist/schemas/skill-version.schema.d.ts

@@ -1,69 +0,0 @@
-import { z } from 'zod';
-/**
- * A snapshot of a Skill's `content` at one point in time. Written
- * automatically by the API whenever the content changes, plus explicitly
- * on revert. Monotonic per-skill `version` integer, starting at 1.
- */
-export declare const skillVersionSchema: z.ZodObject<{
-    id: z.ZodString;
-    skill_id: z.ZodString;
-    version: z.ZodNumber;
-    content: z.ZodString;
-    commit_message: z.ZodNullable<z.ZodString>;
-    created_by: z.ZodNullable<z.ZodString>;
-    created_at: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    skill_id: string;
-    content: string;
-    created_at: string;
-    commit_message: string | null;
-    version: number;
-    created_by: string | null;
-}, {
-    id: string;
-    skill_id: string;
-    content: string;
-    created_at: string;
-    commit_message: string | null;
-    version: number;
-    created_by: string | null;
-}>;
-export type SkillVersion = z.infer<typeof skillVersionSchema>;
-/** Compact list row — omits the full `content` blob so timelines stay cheap. */
-export declare const skillVersionSummarySchema: z.ZodObject<Omit<{
-    id: z.ZodString;
-    skill_id: z.ZodString;
-    version: z.ZodNumber;
-    content: z.ZodString;
-    commit_message: z.ZodNullable<z.ZodString>;
-    created_by: z.ZodNullable<z.ZodString>;
-    created_at: z.ZodString;
-}, "content">, "strip", z.ZodTypeAny, {
-    id: string;
-    skill_id: string;
-    created_at: string;
-    commit_message: string | null;
-    version: number;
-    created_by: string | null;
-}, {
-    id: string;
-    skill_id: string;
-    created_at: string;
-    commit_message: string | null;
-    version: number;
-    created_by: string | null;
-}>;
-export type SkillVersionSummary = z.infer<typeof skillVersionSummarySchema>;
-export declare const revertSkillInputSchema: z.ZodObject<{
-    version: z.ZodNumber;
-    commit_message: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    version: number;
-    commit_message?: string | undefined;
-}, {
-    version: number;
-    commit_message?: string | undefined;
-}>;
-export type RevertSkillInput = z.infer<typeof revertSkillInputSchema>;
-//# sourceMappingURL=skill-version.schema.d.ts.map

package/dist/schemas/skill-version.schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skill-version.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/skill-version.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;EAQ7B,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,gFAAgF;AAChF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;EAA6C,CAAA;AACnF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E,eAAO,MAAM,sBAAsB;;;;;;;;;EAGjC,CAAA;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

package/dist/schemas/skill-version.schema.js

@@ -1,21 +0,0 @@
-import { z } from 'zod';
-/**
- * A snapshot of a Skill's `content` at one point in time. Written
- * automatically by the API whenever the content changes, plus explicitly
- * on revert. Monotonic per-skill `version` integer, starting at 1.
- */
-export const skillVersionSchema = z.object({
-    id: z.string().uuid(),
-    skill_id: z.string().uuid(),
-    version: z.number().int().positive(),
-    content: z.string(),
-    commit_message: z.string().nullable(),
-    created_by: z.string().uuid().nullable(),
-    created_at: z.string().datetime(),
-});
-/** Compact list row — omits the full `content` blob so timelines stay cheap. */
-export const skillVersionSummarySchema = skillVersionSchema.omit({ content: true });
-export const revertSkillInputSchema = z.object({
-    version: z.number().int().positive(),
-    commit_message: z.string().max(200).optional(),
-});

package/dist/schemas/vault.schema.d.ts

@@ -1,54 +0,0 @@
-import { z } from 'zod';
-/**
- * Vault — user-supplied secrets bound to a Run.
- *
- * Values are AES-256-GCM-encrypted at rest (same master key as
- * `runs.env_encrypted` and `user_api_keys`). The plaintext only ever
- * surfaces to the worker via the `/api/v1/sdk/vault/:key` route, which
- * authenticates with the short-lived `PRAVE_SDK_TOKEN` JWT minted per
- * execution.
- *
- * Dashboard UI sets values; SDK reads them. There is intentionally no
- * read endpoint that returns plaintext to the dashboard — once set, a
- * value can only be overwritten, never read back through the web app.
- */
-export declare const vaultKeySchema: z.ZodString;
-export type VaultKey = z.infer<typeof vaultKeySchema>;
-export declare const vaultSecretSchema: z.ZodObject<{
-    key: z.ZodString;
-    label: z.ZodNullable<z.ZodString>;
-    link: z.ZodNullable<z.ZodString>;
-    size_bytes: z.ZodNumber;
-    created_at: z.ZodString;
-    updated_at: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    size_bytes: number;
-    created_at: string;
-    updated_at: string;
-    label: string | null;
-    key: string;
-    link: string | null;
-}, {
-    size_bytes: number;
-    created_at: string;
-    updated_at: string;
-    label: string | null;
-    key: string;
-    link: string | null;
-}>;
-export type VaultSecret = z.infer<typeof vaultSecretSchema>;
-export declare const vaultPutInputSchema: z.ZodObject<{
-    value: z.ZodString;
-    label: z.ZodOptional<z.ZodString>;
-    link: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    value: string;
-    label?: string | undefined;
-    link?: string | undefined;
-}, {
-    value: string;
-    label?: string | undefined;
-    link?: string | undefined;
-}>;
-export type VaultPutInput = z.infer<typeof vaultPutInputSchema>;
-//# sourceMappingURL=vault.schema.d.ts.map

package/dist/schemas/vault.schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vault.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/vault.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;;;;;;GAYG;AAMH,eAAO,MAAM,cAAc,aAOxB,CAAA;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAErD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;EAO5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAK3D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAI9B,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/schemas/vault.schema.js

@@ -1,39 +0,0 @@
-import { z } from 'zod';
-/**
- * Vault — user-supplied secrets bound to a Run.
- *
- * Values are AES-256-GCM-encrypted at rest (same master key as
- * `runs.env_encrypted` and `user_api_keys`). The plaintext only ever
- * surfaces to the worker via the `/api/v1/sdk/vault/:key` route, which
- * authenticates with the short-lived `PRAVE_SDK_TOKEN` JWT minted per
- * execution.
- *
- * Dashboard UI sets values; SDK reads them. There is intentionally no
- * read endpoint that returns plaintext to the dashboard — once set, a
- * value can only be overwritten, never read back through the web app.
- */
-// POSIX-ish key — same shape as env var names so skill code can stash
-// secrets under the same identifier (`prave.vault.get('TIKTOK_CLIENT_ID')`)
-// or, where a skill expects an env var directly, the SDK's loader can
-// project them into the bwrap env without renaming.
-export const vaultKeySchema = z
-    .string()
-    .min(1)
-    .max(128)
-    .regex(/^[A-Za-z_][A-Za-z0-9_]*$/, 'Use POSIX-style names: letters, digits, underscore; cannot start with a digit.');
-export const vaultSecretSchema = z.object({
-    key: vaultKeySchema,
-    label: z.string().max(120).nullable(),
-    link: z.string().url().max(2_048).nullable(),
-    size_bytes: z.number().int().nonnegative(),
-    created_at: z.string().datetime(),
-    updated_at: z.string().datetime(),
-});
-// Body for PUT /api/v1/runs/:slug/vault/:key. Caller passes the full
-// new value; we encrypt + replace. Empty string is allowed (some
-// providers expect a literal "" header).
-export const vaultPutInputSchema = z.object({
-    value: z.string().max(65_536),
-    label: z.string().max(120).optional(),
-    link: z.string().url().max(2_048).optional(),
-});

package/dist/schemas/webhook-endpoint.schema.d.ts

@@ -1,161 +0,0 @@
-import { z } from 'zod';
-/**
- * Webhook endpoint declarations — each one mints a stable HTTPS URL on
- * `in.prave.app/w/<runs.webhook_token>/<endpoint_id>` that buffers
- * inbound traffic into `webhook_events` (or, when trigger_mode is
- * 'immediate', also enqueues a fresh run execution).
- *
- * Two flavours of inbound traffic share this surface:
- *   • short-lived OAuth callbacks (`?code=…&state=…`) — almost always
- *     'immediate' so the code is exchanged before its ~10-minute window
- *     closes;
- *   • long-tail webhooks (Slack interactivity, TikTok post.published,
- *     etc.) — 'buffer', drained by `prave.webhooks.drain()` on the
- *     next cron run.
- *
- * HMAC verification is optional and only meaningful for buffered
- * webhooks where the provider signs the body. OAuth callbacks rarely
- * sign — providers rely on the redirect_uri being preregistered.
- */
-export declare const webhookEndpointIdSchema: z.ZodString;
-export type WebhookEndpointId = z.infer<typeof webhookEndpointIdSchema>;
-export declare const webhookTriggerModeSchema: z.ZodEnum<["buffer", "immediate"]>;
-export type WebhookTriggerMode = z.infer<typeof webhookTriggerModeSchema>;
-export declare const webhookHmacAlgorithmSchema: z.ZodEnum<["sha256", "sha1", "sha512"]>;
-export type WebhookHmacAlgorithm = z.infer<typeof webhookHmacAlgorithmSchema>;
-export declare const webhookEndpointSchema: z.ZodObject<{
-    id: z.ZodString;
-    endpoint_id: z.ZodString;
-    label: z.ZodNullable<z.ZodString>;
-    url: z.ZodString;
-    hmac_header: z.ZodNullable<z.ZodString>;
-    hmac_algorithm: z.ZodNullable<z.ZodEnum<["sha256", "sha1", "sha512"]>>;
-    signing_secret_preview: z.ZodNullable<z.ZodString>;
-    trigger_mode: z.ZodEnum<["buffer", "immediate"]>;
-    response_status: z.ZodNumber;
-    response_body: z.ZodNullable<z.ZodString>;
-    response_content_type: z.ZodNullable<z.ZodString>;
-    events_30d: z.ZodOptional<z.ZodNumber>;
-    last_received_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    created_at: z.ZodString;
-    updated_at: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    created_at: string;
-    updated_at: string;
-    url: string;
-    label: string | null;
-    endpoint_id: string;
-    hmac_header: string | null;
-    hmac_algorithm: "sha256" | "sha1" | "sha512" | null;
-    signing_secret_preview: string | null;
-    trigger_mode: "buffer" | "immediate";
-    response_status: number;
-    response_body: string | null;
-    response_content_type: string | null;
-    events_30d?: number | undefined;
-    last_received_at?: string | null | undefined;
-}, {
-    id: string;
-    created_at: string;
-    updated_at: string;
-    url: string;
-    label: string | null;
-    endpoint_id: string;
-    hmac_header: string | null;
-    hmac_algorithm: "sha256" | "sha1" | "sha512" | null;
-    signing_secret_preview: string | null;
-    trigger_mode: "buffer" | "immediate";
-    response_status: number;
-    response_body: string | null;
-    response_content_type: string | null;
-    events_30d?: number | undefined;
-    last_received_at?: string | null | undefined;
-}>;
-export type WebhookEndpoint = z.infer<typeof webhookEndpointSchema>;
-export declare const webhookEndpointCreateInputSchema: z.ZodObject<{
-    endpoint_id: z.ZodString;
-    label: z.ZodOptional<z.ZodString>;
-    trigger_mode: z.ZodDefault<z.ZodEnum<["buffer", "immediate"]>>;
-    hmac_header: z.ZodOptional<z.ZodString>;
-    hmac_algorithm: z.ZodOptional<z.ZodEnum<["sha256", "sha1", "sha512"]>>;
-    signing_secret: z.ZodOptional<z.ZodString>;
-    response_status: z.ZodOptional<z.ZodNumber>;
-    response_body: z.ZodOptional<z.ZodString>;
-    response_content_type: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    endpoint_id: string;
-    trigger_mode: "buffer" | "immediate";
-    label?: string | undefined;
-    hmac_header?: string | undefined;
-    hmac_algorithm?: "sha256" | "sha1" | "sha512" | undefined;
-    response_status?: number | undefined;
-    response_body?: string | undefined;
-    response_content_type?: string | undefined;
-    signing_secret?: string | undefined;
-}, {
-    endpoint_id: string;
-    label?: string | undefined;
-    hmac_header?: string | undefined;
-    hmac_algorithm?: "sha256" | "sha1" | "sha512" | undefined;
-    trigger_mode?: "buffer" | "immediate" | undefined;
-    response_status?: number | undefined;
-    response_body?: string | undefined;
-    response_content_type?: string | undefined;
-    signing_secret?: string | undefined;
-}>;
-export type WebhookEndpointCreateInput = z.infer<typeof webhookEndpointCreateInputSchema>;
-export declare const webhookEndpointPatchInputSchema: z.ZodObject<Omit<{
-    endpoint_id: z.ZodOptional<z.ZodString>;
-    label: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    trigger_mode: z.ZodOptional<z.ZodDefault<z.ZodEnum<["buffer", "immediate"]>>>;
-    hmac_header: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    hmac_algorithm: z.ZodOptional<z.ZodOptional<z.ZodEnum<["sha256", "sha1", "sha512"]>>>;
-    signing_secret: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    response_status: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
-    response_body: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    response_content_type: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-}, "endpoint_id">, "strip", z.ZodTypeAny, {
-    label?: string | undefined;
-    hmac_header?: string | undefined;
-    hmac_algorithm?: "sha256" | "sha1" | "sha512" | undefined;
-    trigger_mode?: "buffer" | "immediate" | undefined;
-    response_status?: number | undefined;
-    response_body?: string | undefined;
-    response_content_type?: string | undefined;
-    signing_secret?: string | undefined;
-}, {
-    label?: string | undefined;
-    hmac_header?: string | undefined;
-    hmac_algorithm?: "sha256" | "sha1" | "sha512" | undefined;
-    trigger_mode?: "buffer" | "immediate" | undefined;
-    response_status?: number | undefined;
-    response_body?: string | undefined;
-    response_content_type?: string | undefined;
-    signing_secret?: string | undefined;
-}>;
-export type WebhookEndpointPatchInput = z.infer<typeof webhookEndpointPatchInputSchema>;
-export declare const webhookEventForSdkSchema: z.ZodObject<{
-    id: z.ZodString;
-    received_at: z.ZodString;
-    method: z.ZodString;
-    headers: z.ZodRecord<z.ZodString, z.ZodString>;
-    body: z.ZodNullable<z.ZodString>;
-    body_base64: z.ZodNullable<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    body: string | null;
-    received_at: string;
-    method: string;
-    headers: Record<string, string>;
-    body_base64: string | null;
-}, {
-    id: string;
-    body: string | null;
-    received_at: string;
-    method: string;
-    headers: Record<string, string>;
-    body_base64: string | null;
-}>;
-export type WebhookEventForSdk = z.infer<typeof webhookEventForSdkSchema>;
-//# sourceMappingURL=webhook-endpoint.schema.d.ts.map

package/dist/schemas/webhook-endpoint.schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"webhook-endpoint.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/webhook-endpoint.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;;;;;;;;;;;GAiBG;AAKH,eAAO,MAAM,uBAAuB,aAOjC,CAAA;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE,eAAO,MAAM,wBAAwB,oCAAkC,CAAA;AACvE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE,eAAO,MAAM,0BAA0B,yCAAuC,CAAA;AAC9E,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBhC,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU3C,CAAA;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAEzF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAC4B,CAAA;AACxE,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAKvF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;EAOnC,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA"}

package/dist/schemas/webhook-endpoint.schema.js

@@ -1,74 +0,0 @@
-import { z } from 'zod';
-/**
- * Webhook endpoint declarations — each one mints a stable HTTPS URL on
- * `in.prave.app/w/<runs.webhook_token>/<endpoint_id>` that buffers
- * inbound traffic into `webhook_events` (or, when trigger_mode is
- * 'immediate', also enqueues a fresh run execution).
- *
- * Two flavours of inbound traffic share this surface:
- *   • short-lived OAuth callbacks (`?code=…&state=…`) — almost always
- *     'immediate' so the code is exchanged before its ~10-minute window
- *     closes;
- *   • long-tail webhooks (Slack interactivity, TikTok post.published,
- *     etc.) — 'buffer', drained by `prave.webhooks.drain()` on the
- *     next cron run.
- *
- * HMAC verification is optional and only meaningful for buffered
- * webhooks where the provider signs the body. OAuth callbacks rarely
- * sign — providers rely on the redirect_uri being preregistered.
- */
-// URL-path-segment shaped — short and lowercase. Skill-builders use
-// it both in their `prave.webhooks.drain('<endpoint_id>')` calls and as
-// the literal path segment in the public URL.
-export const webhookEndpointIdSchema = z
-    .string()
-    .min(1)
-    .max(64)
-    .regex(/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/, 'Lowercase letters, digits and dashes — must start and end with an alphanumeric.');
-export const webhookTriggerModeSchema = z.enum(['buffer', 'immediate']);
-export const webhookHmacAlgorithmSchema = z.enum(['sha256', 'sha1', 'sha512']);
-export const webhookEndpointSchema = z.object({
-    id: z.string().uuid(),
-    endpoint_id: webhookEndpointIdSchema,
-    label: z.string().nullable(),
-    // Public URL the user pastes into their provider's developer console.
-    url: z.string().url(),
-    // HMAC config — `null` everywhere means no verification.
-    hmac_header: z.string().max(80).nullable(),
-    hmac_algorithm: webhookHmacAlgorithmSchema.nullable(),
-    // Last 4 chars of the signing secret, to confirm "yes I have one set".
-    signing_secret_preview: z.string().nullable(),
-    trigger_mode: webhookTriggerModeSchema,
-    // Static-response config (Slack slash command wants "200 ok" right back).
-    response_status: z.number().int().min(100).max(599),
-    response_body: z.string().nullable(),
-    response_content_type: z.string().nullable(),
-    // Stats surfaced in the UI card.
-    events_30d: z.number().int().nonnegative().optional(),
-    last_received_at: z.string().datetime().nullable().optional(),
-    created_at: z.string().datetime(),
-    updated_at: z.string().datetime(),
-});
-export const webhookEndpointCreateInputSchema = z.object({
-    endpoint_id: webhookEndpointIdSchema,
-    label: z.string().max(120).optional(),
-    trigger_mode: webhookTriggerModeSchema.default('buffer'),
-    hmac_header: z.string().max(80).optional(),
-    hmac_algorithm: webhookHmacAlgorithmSchema.optional(),
-    signing_secret: z.string().min(8).max(512).optional(),
-    response_status: z.number().int().min(100).max(599).optional(),
-    response_body: z.string().max(8_192).optional(),
-    response_content_type: z.string().max(120).optional(),
-});
-export const webhookEndpointPatchInputSchema = webhookEndpointCreateInputSchema.partial().omit({ endpoint_id: true });
-// Shape returned to the SDK by GET /api/v1/sdk/webhooks/:endpointId.
-// `body` is a UTF-8 best-effort decode; binary uploads return
-// `body_base64` instead. Headers are forwarded as the captured object.
-export const webhookEventForSdkSchema = z.object({
-    id: z.string().uuid(),
-    received_at: z.string().datetime(),
-    method: z.string(),
-    headers: z.record(z.string(), z.string()),
-    body: z.string().nullable(),
-    body_base64: z.string().nullable(),
-});