@automate.ax/integration-contracts 0.148.0 → 0.150.1

package/dist/calcom/events.js

@@ -287,7 +287,40 @@ const CALCOM_PAYLOAD_SCHEMAS = {
         }),
     }),
 };
-export const CALCOM_TRIGGER_CONFIG_SCHEMA = z.object({});
+export const CALCOM_USER_WEBHOOK_SCOPE_SCHEMA = z.object({
+    type: z.literal("user"),
+});
+export const CALCOM_TEAM_WEBHOOK_SCOPE_SCHEMA = z.object({
+    eventTypeId: z.number().int().positive(),
+    teamId: z.number().int().positive(),
+    type: z.literal("team"),
+});
+export const CALCOM_ORGANIZATION_WEBHOOK_SCOPE_SCHEMA = z.object({
+    organizationId: z.number().int().positive(),
+    type: z.literal("organization"),
+});
+export const CALCOM_WEBHOOK_SCOPE_SCHEMA = z.discriminatedUnion("type", [
+    CALCOM_USER_WEBHOOK_SCOPE_SCHEMA,
+    CALCOM_TEAM_WEBHOOK_SCOPE_SCHEMA,
+    CALCOM_ORGANIZATION_WEBHOOK_SCOPE_SCHEMA,
+]);
+export const CALCOM_USER_TRIGGER_CONFIG_SCHEMA = z.object({
+    scope: CALCOM_USER_WEBHOOK_SCOPE_SCHEMA.optional(),
+});
+export const CALCOM_TEAM_TRIGGER_CONFIG_SCHEMA = z.object({
+    scope: z
+        .discriminatedUnion("type", [
+        CALCOM_USER_WEBHOOK_SCOPE_SCHEMA,
+        CALCOM_TEAM_WEBHOOK_SCOPE_SCHEMA,
+    ])
+        .optional(),
+});
+export const CALCOM_ORGANIZATION_TRIGGER_CONFIG_SCHEMA = z.object({
+    scope: CALCOM_ORGANIZATION_WEBHOOK_SCOPE_SCHEMA,
+});
+export const CALCOM_BROAD_TRIGGER_CONFIG_SCHEMA = z.object({
+    scope: CALCOM_WEBHOOK_SCOPE_SCHEMA.optional(),
+});
 export const CALCOM_EVENT_SCHEMA = z.custom((value) => {
     if (typeof value !== "object" ||
         value === null ||
@@ -368,47 +401,48 @@ export const CALCOM_EVENT_TYPE_MAP = {
     WRONG_ASSIGNMENT_REPORT: "calcom.wrongAssignmentReported",
 };
 export const calcomTriggerContracts = {
-    "calcom.afterGuestsCalVideoNoShow": contract("AFTER_GUESTS_CAL_VIDEO_NO_SHOW"),
-    "calcom.afterHostsCalVideoNoShow": contract("AFTER_HOSTS_CAL_VIDEO_NO_SHOW"),
-    "calcom.booking.cancelled": contract("BOOKING_CANCELLED"),
-    "calcom.booking.created": contract("BOOKING_CREATED"),
-    "calcom.booking.locationUpdated": contract("BOOKING_LOCATION_UPDATED"),
-    "calcom.booking.noShowUpdated": contract("BOOKING_NO_SHOW_UPDATED"),
-    "calcom.booking.paid": contract("BOOKING_PAID"),
-    "calcom.booking.paymentInitiated": contract("BOOKING_PAYMENT_INITIATED"),
-    "calcom.booking.reassigned": contract("BOOKING_REASSIGNED"),
-    "calcom.booking.rejected": contract("BOOKING_REJECTED"),
-    "calcom.booking.requested": contract("BOOKING_REQUESTED"),
-    "calcom.booking.rescheduled": contract("BOOKING_RESCHEDULED"),
-    "calcom.calendarEntryRejected": contract("CALENDAR_ENTRY_REJECTED"),
-    "calcom.delegationCredential.error": contract("DELEGATION_CREDENTIAL_ERROR"),
-    "calcom.delegationCredential.rotationRequired": contract("DELEGATION_CREDENTIAL_ROTATION_REQUIRED"),
-    "calcom.delegationCredential.secretRotated": contract("DELEGATION_CREDENTIAL_SECRET_ROTATED"),
-    "calcom.delegationCredential.secretRotationFailed": contract("DELEGATION_CREDENTIAL_SECRET_ROTATION_FAILED"),
+    "calcom.afterGuestsCalVideoNoShow": contract("AFTER_GUESTS_CAL_VIDEO_NO_SHOW", CALCOM_USER_TRIGGER_CONFIG_SCHEMA),
+    "calcom.afterHostsCalVideoNoShow": contract("AFTER_HOSTS_CAL_VIDEO_NO_SHOW", CALCOM_USER_TRIGGER_CONFIG_SCHEMA),
+    "calcom.booking.cancelled": contract("BOOKING_CANCELLED", CALCOM_TEAM_TRIGGER_CONFIG_SCHEMA),
+    "calcom.booking.created": contract("BOOKING_CREATED", CALCOM_TEAM_TRIGGER_CONFIG_SCHEMA),
+    "calcom.booking.locationUpdated": contract("BOOKING_LOCATION_UPDATED", CALCOM_TEAM_TRIGGER_CONFIG_SCHEMA),
+    "calcom.booking.noShowUpdated": contract("BOOKING_NO_SHOW_UPDATED", CALCOM_TEAM_TRIGGER_CONFIG_SCHEMA),
+    "calcom.booking.paid": contract("BOOKING_PAID", CALCOM_TEAM_TRIGGER_CONFIG_SCHEMA),
+    "calcom.booking.paymentInitiated": contract("BOOKING_PAYMENT_INITIATED", CALCOM_TEAM_TRIGGER_CONFIG_SCHEMA),
+    "calcom.booking.reassigned": contract("BOOKING_REASSIGNED", CALCOM_TEAM_TRIGGER_CONFIG_SCHEMA),
+    "calcom.booking.rejected": contract("BOOKING_REJECTED", CALCOM_TEAM_TRIGGER_CONFIG_SCHEMA),
+    "calcom.booking.requested": contract("BOOKING_REQUESTED", CALCOM_TEAM_TRIGGER_CONFIG_SCHEMA),
+    "calcom.booking.rescheduled": contract("BOOKING_RESCHEDULED", CALCOM_TEAM_TRIGGER_CONFIG_SCHEMA),
+    "calcom.calendarEntryRejected": contract("CALENDAR_ENTRY_REJECTED", CALCOM_USER_TRIGGER_CONFIG_SCHEMA),
+    "calcom.delegationCredential.error": contract("DELEGATION_CREDENTIAL_ERROR", CALCOM_ORGANIZATION_TRIGGER_CONFIG_SCHEMA),
+    "calcom.delegationCredential.rotationRequired": contract("DELEGATION_CREDENTIAL_ROTATION_REQUIRED", CALCOM_ORGANIZATION_TRIGGER_CONFIG_SCHEMA),
+    "calcom.delegationCredential.secretRotated": contract("DELEGATION_CREDENTIAL_SECRET_ROTATED", CALCOM_ORGANIZATION_TRIGGER_CONFIG_SCHEMA),
+    "calcom.delegationCredential.secretRotationFailed": contract("DELEGATION_CREDENTIAL_SECRET_ROTATION_FAILED", CALCOM_ORGANIZATION_TRIGGER_CONFIG_SCHEMA),
     "calcom.event": {
-        configSchema: CALCOM_TRIGGER_CONFIG_SCHEMA,
+        configSchema: CALCOM_BROAD_TRIGGER_CONFIG_SCHEMA,
         eventSchema: CALCOM_EVENT_SCHEMA,
     },
-    "calcom.form.submitted": contract("FORM_SUBMITTED"),
-    "calcom.form.submittedWithoutEvent": contract("FORM_SUBMITTED_NO_EVENT"),
-    "calcom.instantMeeting.accepted": contract("INSTANT_MEETING_ACCEPTED"),
-    "calcom.instantMeeting.created": contract("INSTANT_MEETING"),
-    "calcom.meeting.ended": contract("MEETING_ENDED"),
-    "calcom.meeting.started": contract("MEETING_STARTED"),
-    "calcom.outOfOffice.created": contract("OOO_CREATED"),
-    "calcom.recording.ready": contract("RECORDING_READY"),
-    "calcom.recording.transcriptionGenerated": contract("RECORDING_TRANSCRIPTION_GENERATED"),
-    "calcom.routingForm.fallbackHit": contract("ROUTING_FORM_FALLBACK_HIT"),
-    "calcom.wrongAssignmentReported": contract("WRONG_ASSIGNMENT_REPORT"),
+    "calcom.form.submitted": contract("FORM_SUBMITTED", CALCOM_USER_TRIGGER_CONFIG_SCHEMA),
+    "calcom.form.submittedWithoutEvent": contract("FORM_SUBMITTED_NO_EVENT", CALCOM_USER_TRIGGER_CONFIG_SCHEMA),
+    "calcom.instantMeeting.accepted": contract("INSTANT_MEETING_ACCEPTED", CALCOM_USER_TRIGGER_CONFIG_SCHEMA),
+    "calcom.instantMeeting.created": contract("INSTANT_MEETING", CALCOM_USER_TRIGGER_CONFIG_SCHEMA),
+    "calcom.meeting.ended": contract("MEETING_ENDED", CALCOM_USER_TRIGGER_CONFIG_SCHEMA),
+    "calcom.meeting.started": contract("MEETING_STARTED", CALCOM_USER_TRIGGER_CONFIG_SCHEMA),
+    "calcom.outOfOffice.created": contract("OOO_CREATED", CALCOM_USER_TRIGGER_CONFIG_SCHEMA),
+    "calcom.recording.ready": contract("RECORDING_READY", CALCOM_USER_TRIGGER_CONFIG_SCHEMA),
+    "calcom.recording.transcriptionGenerated": contract("RECORDING_TRANSCRIPTION_GENERATED", CALCOM_USER_TRIGGER_CONFIG_SCHEMA),
+    "calcom.routingForm.fallbackHit": contract("ROUTING_FORM_FALLBACK_HIT", CALCOM_USER_TRIGGER_CONFIG_SCHEMA),
+    "calcom.wrongAssignmentReported": contract("WRONG_ASSIGNMENT_REPORT", CALCOM_USER_TRIGGER_CONFIG_SCHEMA),
 };
 /**
  * Builds one trigger contract for an exact Cal.com provider event.
  *
  * @param type Exact Cal.com provider event type.
+ * @param configSchema Trigger configuration schema.
  */
-function contract(type) {
+function contract(type, configSchema) {
     return {
-        configSchema: CALCOM_TRIGGER_CONFIG_SCHEMA,
+        configSchema,
         eventSchema: calcomSemanticEventSchema(type),
     };
 }

package/dist/kit/schemas.js

@@ -4,6 +4,13 @@ import * as z from "zod";
 import { KIT_OPENAPI_DATA } from "./openapi-operations.generated";
 /** Runtime Kit contract narrowed once from the opaque generated payload. */
 const operationData = KIT_OPENAPI_DATA;
+for (const operation of Object.values(operationData.operations)) {
+    if (typeof operation !== "object" || operation === null)
+        continue;
+    const record = operation;
+    normalizeObservedKitNulls(record.outputSchema);
+    normalizeObservedKitNulls(record.outputWireSchema);
+}
 const OPERATIONS = operationData.operations;
 const VALIDATOR = new Validator({
     $defs: operationData.definitions,
@@ -41,3 +48,53 @@ export function kitOperationOutputSchema(key) {
 }
 /** Provider-native component schemas used for schema-guided key mapping. */
 export const KIT_WIRE_DEFINITIONS = operationData.wireDefinitions;
+/**
+ * Accepts nullable fields observed in successful Kit responses but omitted from
+ * the provider's OpenAPI nullability metadata.
+ *
+ * @param value Generated operation metadata.
+ */
+function normalizeObservedKitNulls(value) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            normalizeObservedKitNulls(item);
+        return;
+    }
+    if (typeof value !== "object" || value === null)
+        return;
+    const record = value;
+    const properties = record.properties;
+    if (typeof properties === "object" && properties !== null) {
+        const propertyRecord = properties;
+        for (const name of [
+            "bio",
+            "byline",
+            "endCursor",
+            "end_cursor",
+            "startCursor",
+            "start_cursor",
+        ]) {
+            const property = propertyRecord[name];
+            if (typeof property !== "object" ||
+                property === null ||
+                isNullableSchema(property)) {
+                continue;
+            }
+            propertyRecord[name] = { anyOf: [property, { type: "null" }] };
+        }
+    }
+    for (const child of Object.values(record))
+        normalizeObservedKitNulls(child);
+}
+/**
+ * Returns whether one JSON Schema fragment already accepts null.
+ *
+ * @param value JSON Schema fragment.
+ */
+function isNullableSchema(value) {
+    const anyOf = value.anyOf;
+    return (Array.isArray(anyOf) &&
+        anyOf.some((branch) => typeof branch === "object" &&
+            branch !== null &&
+            branch.type === "null"));
+}

package/dist/kit/types.d.ts

@@ -28,6 +28,12 @@ type Simplify<TValue> = {
 type EncodableValue<TValue> = unknown extends TValue ? Encodable : TValue extends undefined | null | boolean | number | string ? TValue : TValue extends readonly (infer TItem)[] ? EncodableValue<TItem>[] : TValue extends object ? keyof TValue extends never ? Record<string, Encodable> : {
     [TKey in keyof TValue]: EncodableValue<TValue[TKey]>;
 } : never;
+/** Fields whose live Kit nullability is missing from its OpenAPI document. */
+type ObservedNullableField = "bio" | "byline" | "endCursor" | "startCursor";
+/** Adds nulls returned by Kit but omitted from its generated OpenAPI types. */
+type NormalizeObservedKitNulls<TValue> = TValue extends readonly (infer TItem)[] ? NormalizeObservedKitNulls<TItem>[] : TValue extends object ? {
+    [TKey in keyof TValue]: NormalizeObservedKitNulls<TValue[TKey]> | (TKey extends ObservedNullableField ? null : never);
+} : TValue;
 /** Flattens one generated operation's path, query, and body fields. */
 type RawKitOperationInput<TKey extends KitOperationKey> = Simplify<Parameters<Operation<TKey>, "path"> & Parameters<Operation<TKey>, "query"> & JsonBody<Operation<TKey>>>;
 /** Preserves operation unions and rejects fields on truly empty inputs. */
@@ -37,5 +43,5 @@ type PublicInput<TValue> = TValue extends unknown ? keyof TValue extends never ?
 /** Flattened camelCase input for one frozen Kit V4 operation. */
 export type KitOperationInput<TKey extends KitOperationKey> = PublicInput<RawKitOperationInput<TKey>>;
 /** CamelCase successful response for one frozen Kit V4 operation. */
-export type KitOperationOutput<TKey extends KitOperationKey> = EncodableValue<SuccessResponse<Operation<TKey>>>;
+export type KitOperationOutput<TKey extends KitOperationKey> = EncodableValue<NormalizeObservedKitNulls<SuccessResponse<Operation<TKey>>>>;
 export {};

package/dist/krisp/api.d.ts

@@ -0,0 +1,61 @@
+import type { Encodable } from "@automate.ax/codec";
+import * as z from "zod";
+/** Options for one authenticated Krisp REST request. */
+export interface KrispRequestOptions<TSchema extends z.ZodType> {
+    /** Public camelCase JSON body. */
+    body?: Encodable;
+    /** HTTP verb. Defaults to `GET`. */
+    method?: "GET" | "POST";
+    /** Public camelCase query parameters. */
+    query?: Record<string, boolean | number | readonly string[] | string | undefined>;
+    /** Schema for the normalized provider response. */
+    responseSchema: TSchema;
+}
+/** Structured Krisp REST failure. */
+export declare class KrispApiError extends Error {
+    /** Normalized provider error payload, when valid JSON was returned. */
+    readonly body?: Encodable;
+    /** Retry delay in seconds, when Krisp returned one. */
+    readonly retryAfter?: number;
+    /** HTTP status returned by Krisp. */
+    readonly status: number;
+    /**
+     * Creates a structured Krisp API error.
+     *
+     * @param options - Provider status, body, and retry metadata.
+     * @param options.body - Normalized provider error body.
+     * @param options.retryAfter - Retry delay in seconds.
+     * @param options.status - HTTP status.
+     */
+    constructor(options: {
+        body?: Encodable;
+        retryAfter?: number;
+        status: number;
+    });
+}
+/**
+ * Creates an authenticated Krisp Meeting Assistant REST client.
+ *
+ * @param secret - Resolved Krisp API-key secret.
+ */
+export declare function getKrispApi(secret: Record<string, unknown>): {
+    /**
+     * Runs one Krisp request and returns its normalized response.
+     *
+     * @param path - API path relative to the v1 root.
+     * @param options - Method, parameters, and response schema.
+     */
+    request<TSchema extends z.ZodType>(path: string, options: KrispRequestOptions<TSchema>): Promise<z.output<TSchema>>;
+};
+/**
+ * Converts public camelCase JSON to Krisp wire keys.
+ *
+ * @param value - Public value to normalize.
+ */
+export declare function toKrisp(value: Encodable): Encodable;
+/**
+ * Converts Krisp wire JSON to public camelCase keys.
+ *
+ * @param value - Provider value to normalize.
+ */
+export declare function fromKrisp(value: unknown): unknown;

package/dist/krisp/api.js

@@ -0,0 +1,170 @@
+import { encodableSchema } from "@automate.ax/codec";
+import * as z from "zod";
+const KRISP_API_BASE_URL = "https://meeting-api.krisp.ai/v1/";
+const KRISP_API_ORIGIN = new URL(KRISP_API_BASE_URL).origin;
+const KRISP_SECRET_SCHEMA = z.object({ apiKey: z.string().min(1) });
+/** Structured Krisp REST failure. */
+export class KrispApiError extends Error {
+    /** Normalized provider error payload, when valid JSON was returned. */
+    body;
+    /** Retry delay in seconds, when Krisp returned one. */
+    retryAfter;
+    /** HTTP status returned by Krisp. */
+    status;
+    /**
+     * Creates a structured Krisp API error.
+     *
+     * @param options - Provider status, body, and retry metadata.
+     * @param options.body - Normalized provider error body.
+     * @param options.retryAfter - Retry delay in seconds.
+     * @param options.status - HTTP status.
+     */
+    constructor(options) {
+        super(getErrorMessage(options.body) ??
+            `Krisp API request failed with status ${options.status}.`);
+        this.name = "KrispApiError";
+        this.body = options.body;
+        this.retryAfter = options.retryAfter;
+        this.status = options.status;
+    }
+}
+/**
+ * Creates an authenticated Krisp Meeting Assistant REST client.
+ *
+ * @param secret - Resolved Krisp API-key secret.
+ */
+export function getKrispApi(secret) {
+    const { apiKey } = KRISP_SECRET_SCHEMA.parse(secret);
+    return {
+        /**
+         * Runs one Krisp request and returns its normalized response.
+         *
+         * @param path - API path relative to the v1 root.
+         * @param options - Method, parameters, and response schema.
+         */
+        async request(path, options) {
+            const url = new URL(path.replace(/^\//, ""), KRISP_API_BASE_URL);
+            if (url.origin !== KRISP_API_ORIGIN) {
+                throw new Error("Krisp API paths must use the Krisp API origin.");
+            }
+            for (const [name, value] of Object.entries(options.query ?? {})) {
+                if (value === undefined)
+                    continue;
+                url.searchParams.set(toSnakeCase(name), Array.isArray(value) ? value.join(",") : String(value));
+            }
+            const response = await fetch(url, {
+                body: options.body === undefined
+                    ? undefined
+                    : JSON.stringify(toKrisp(options.body)),
+                headers: {
+                    Accept: "application/json",
+                    Authorization: `Bearer ${apiKey}`,
+                    ...(options.body === undefined
+                        ? {}
+                        : { "Content-Type": "application/json" }),
+                },
+                method: options.method ?? "GET",
+            });
+            const normalized = fromKrisp(parseJson(await response.text()));
+            if (!response.ok) {
+                const body = encodableSchema.safeParse(normalized);
+                throw new KrispApiError({
+                    ...(body.success && { body: body.data }),
+                    retryAfter: parseFiniteNumber(response.headers.get("Retry-After")),
+                    status: response.status,
+                });
+            }
+            return options.responseSchema.parse(normalized);
+        },
+    };
+}
+/**
+ * Converts public camelCase JSON to Krisp wire keys.
+ *
+ * @param value - Public value to normalize.
+ */
+export function toKrisp(value) {
+    if (value instanceof Date)
+        return value.toISOString();
+    if (Array.isArray(value))
+        return value.map(toKrisp);
+    if (!isPlainObject(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        toSnakeCase(key),
+        toKrisp(item),
+    ]));
+}
+/**
+ * Converts Krisp wire JSON to public camelCase keys.
+ *
+ * @param value - Provider value to normalize.
+ */
+export function fromKrisp(value) {
+    if (Array.isArray(value))
+        return value.map(fromKrisp);
+    if (!isPlainObject(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        toCamelCase(key),
+        fromKrisp(item),
+    ]));
+}
+/**
+ * Checks whether a value is a key-value object.
+ *
+ * @param value - Candidate value.
+ */
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Parses a JSON response body without obscuring the HTTP status on failure.
+ *
+ * @param value - Raw response text.
+ */
+function parseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Parses an optional finite numeric header.
+ *
+ * @param value - Raw header value.
+ */
+function parseFiniteNumber(value) {
+    if (value === null)
+        return undefined;
+    const number = Number(value);
+    return Number.isFinite(number) ? number : undefined;
+}
+/**
+ * Extracts Krisp's human-readable error string.
+ *
+ * @param body - Normalized provider error body.
+ */
+function getErrorMessage(body) {
+    return isPlainObject(body) && typeof body.error === "string"
+        ? body.error
+        : undefined;
+}
+/**
+ * Converts one public camelCase key to Krisp snake_case.
+ *
+ * @param value - Public key.
+ */
+function toSnakeCase(value) {
+    return value.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+/**
+ * Converts one Krisp snake_case key to public camelCase.
+ *
+ * @param value - Provider key.
+ */
+function toCamelCase(value) {
+    return value.replace(/_([a-z0-9])/g, (_, letter) => letter.toUpperCase());
+}

package/dist/krisp/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./api.js";
+export * from "./schemas.js";

package/dist/krisp/index.js

@@ -0,0 +1,2 @@
+export * from "./api.js";
+export * from "./schemas.js";

package/dist/krisp/schemas.d.ts

@@ -0,0 +1,145 @@
+import * as z from "zod";
+import type { Encodable } from "@automate.ax/codec";
+/** Krisp profile represented by a personal API key. */
+export declare const KRISP_PROFILE_SCHEMA: z.ZodObject<{
+    avatar: z.ZodPrefault<z.ZodNullable<z.ZodURL>>;
+    email: z.ZodEmail;
+    firstName: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+    id: z.ZodNumber;
+    lastName: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+    teamId: z.ZodNumber;
+    workspaceId: z.ZodNumber;
+}, z.core.$strip>;
+/** Calendar attendee or diarized speaker attached to a Krisp meeting. */
+export declare const KRISP_PARTICIPANT_SCHEMA: z.ZodObject<{
+    email: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+    firstName: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+    lastName: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+    photo: z.ZodPrefault<z.ZodNullable<z.ZodURL>>;
+    status: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/** Meeting metadata returned by Krisp list and detail endpoints. */
+export declare const KRISP_MEETING_SCHEMA: z.ZodObject<{
+    duration: z.ZodNullable<z.ZodNumber>;
+    id: z.ZodString;
+    ownership: z.ZodEnum<{
+        shared: "shared";
+        owned: "owned";
+    }>;
+    participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        email: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+        firstName: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+        lastName: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+        photo: z.ZodPrefault<z.ZodNullable<z.ZodURL>>;
+        status: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+    source: z.ZodNullable<z.ZodString>;
+    startedAt: z.ZodNullable<z.ZodISODateTime>;
+    status: z.ZodString;
+    tags: z.ZodArray<z.ZodString>;
+    title: z.ZodString;
+}, z.core.$strip>;
+/** One diarized transcript segment. Times are seconds from recording start. */
+export declare const KRISP_TRANSCRIPT_SEGMENT_SCHEMA: z.ZodObject<{
+    end: z.ZodNumber;
+    speaker: z.ZodNumber;
+    start: z.ZodNumber;
+    text: z.ZodString;
+}, z.core.$strip>;
+declare const KRISP_NOTE_ASSIGNEE_SCHEMA: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+export interface KrispNoteBlock {
+    [key: string]: Encodable;
+    assignee?: z.output<typeof KRISP_NOTE_ASSIGNEE_SCHEMA> | null;
+    children?: KrispNoteBlock[];
+    completed?: boolean | null;
+    dueDate?: string | null;
+    text?: string;
+    type: string;
+}
+/** Recursive block returned by Krisp's fixed and custom meeting-note sections. */
+export declare const KRISP_NOTE_BLOCK_SCHEMA: z.ZodType<KrispNoteBlock>;
+/** Complete Krisp meeting detail with optional heavy transcript and note data. */
+export declare const KRISP_MEETING_DETAIL_SCHEMA: z.ZodObject<{
+    duration: z.ZodNullable<z.ZodNumber>;
+    id: z.ZodString;
+    ownership: z.ZodEnum<{
+        shared: "shared";
+        owned: "owned";
+    }>;
+    participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        email: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+        firstName: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+        lastName: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+        photo: z.ZodPrefault<z.ZodNullable<z.ZodURL>>;
+        status: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+    source: z.ZodNullable<z.ZodString>;
+    startedAt: z.ZodNullable<z.ZodISODateTime>;
+    status: z.ZodString;
+    tags: z.ZodArray<z.ZodString>;
+    title: z.ZodString;
+    language: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+    meetingType: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+    notes: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        blocks: z.ZodArray<z.ZodType<KrispNoteBlock, unknown, z.core.$ZodTypeInternals<KrispNoteBlock, unknown>>>;
+    }, z.core.$strip>>>;
+    transcript: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        language: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+        segments: z.ZodPrefault<z.ZodArray<z.ZodObject<{
+            end: z.ZodNumber;
+            speaker: z.ZodNumber;
+            start: z.ZodNumber;
+            text: z.ZodString;
+        }, z.core.$strip>>>;
+        speakers: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            email: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+            firstName: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+            lastName: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+            photo: z.ZodPrefault<z.ZodNullable<z.ZodURL>>;
+            status: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** One action item extracted from a Krisp meeting. */
+export declare const KRISP_ACTION_ITEM_SCHEMA: z.ZodObject<{
+    assignee: z.ZodPrefault<z.ZodNullable<z.ZodObject<{
+        email: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+        firstName: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+        lastName: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+        photo: z.ZodPrefault<z.ZodNullable<z.ZodURL>>;
+        status: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+    completed: z.ZodPrefault<z.ZodNullable<z.ZodBoolean>>;
+    dueDate: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+    id: z.ZodString;
+    meetingId: z.ZodString;
+    meetingStartedAt: z.ZodPrefault<z.ZodNullable<z.ZodISODateTime>>;
+    meetingTitle: z.ZodString;
+    title: z.ZodString;
+}, z.core.$strip>;
+/** Tag used to organize Krisp meetings. */
+export declare const KRISP_TAG_SCHEMA: z.ZodObject<{
+    color: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    id: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strip>;
+/** Recording-import identity returned after Krisp issues an upload URL. */
+export declare const KRISP_IMPORT_SCHEMA: z.ZodObject<{
+    expiresAt: z.ZodISODateTime;
+    importId: z.ZodString;
+    url: z.ZodURL;
+}, z.core.$strip>;
+/** Current processing state for a Krisp recording import. */
+export declare const KRISP_IMPORT_STATUS_SCHEMA: z.ZodObject<{
+    error: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+    importId: z.ZodString;
+    meetingId: z.ZodPrefault<z.ZodNullable<z.ZodString>>;
+    status: z.ZodEnum<{
+        failed: "failed";
+        ready: "ready";
+        uploading: "uploading";
+        processing: "processing";
+    }>;
+}, z.core.$strip>;
+export {};