@automate.ax/integration-contracts 0.115.6 → 0.118.0

package/dist/millionverifier/events.js

@@ -0,0 +1,103 @@
+import * as z from "zod";
+const FILE_ID_WIRE_SCHEMA = z.union([z.string(), z.number()]).transform(String);
+export const MILLIONVERIFIER_NO_CREDIT_EVENT_SCHEMA = z.object({
+    reason: z.literal("noCredit"),
+});
+export const MILLIONVERIFIER_LOW_CREDIT_EVENT_SCHEMA = z.object({
+    credits: z.number().int().nonnegative(),
+    reason: z.literal("lowCredit"),
+});
+export const MILLIONVERIFIER_FILE_READY_EVENT_SCHEMA = z.object({
+    file: z.object({
+        catchAll: z.number().int().nonnegative(),
+        disposable: z.number().int().nonnegative(),
+        fileId: z.string(),
+        fileName: z.string(),
+        invalid: z.number().int().nonnegative(),
+        ok: z.number().int().nonnegative(),
+        totalRows: z.number().int().nonnegative(),
+        uniqueEmails: z.number().int().nonnegative(),
+        unknown: z.number().int().nonnegative(),
+    }),
+    reason: z.literal("fileReady"),
+});
+export const MILLIONVERIFIER_FILE_DELETION_SCHEDULED_EVENT_SCHEMA = z.object({
+    file: z.object({
+        deletesIn: z.string().min(1),
+        fileId: z.string(),
+        fileName: z.string(),
+    }),
+    reason: z.literal("fileDeletionScheduled"),
+});
+export const MILLIONVERIFIER_EVENT_SCHEMA = z.discriminatedUnion("reason", [
+    MILLIONVERIFIER_NO_CREDIT_EVENT_SCHEMA,
+    MILLIONVERIFIER_LOW_CREDIT_EVENT_SCHEMA,
+    MILLIONVERIFIER_FILE_READY_EVENT_SCHEMA,
+    MILLIONVERIFIER_FILE_DELETION_SCHEDULED_EVENT_SCHEMA,
+]);
+export const MILLIONVERIFIER_WEBHOOK_WIRE_SCHEMA = z.discriminatedUnion("reason", [
+    z.looseObject({ reason: z.literal("no_credit") }),
+    z.looseObject({
+        credits: z.number().int().nonnegative(),
+        reason: z.literal("low_credit"),
+    }),
+    z.looseObject({
+        file: z.looseObject({
+            catch_all: z.number().int().nonnegative(),
+            disposable: z.number().int().nonnegative(),
+            file_id: FILE_ID_WIRE_SCHEMA,
+            file_name: z.string(),
+            invalid: z.number().int().nonnegative(),
+            ok: z.number().int().nonnegative(),
+            total_rows: z.number().int().nonnegative(),
+            unique_emails: z.number().int().nonnegative(),
+            unknown: z.number().int().nonnegative(),
+        }),
+        reason: z.literal("file_ready"),
+    }),
+    z.looseObject({
+        file: z.looseObject({
+            file_delete: z.string().min(1),
+            file_id: FILE_ID_WIRE_SCHEMA,
+            file_name: z.string(),
+        }),
+        reason: z.literal("file_delete"),
+    }),
+]);
+/**
+ * Normalizes one documented MillionVerifier notification payload.
+ *
+ * @param value - Untrusted provider callback payload.
+ */
+export function normalizeMillionVerifierEvent(value) {
+    const event = MILLIONVERIFIER_WEBHOOK_WIRE_SCHEMA.parse(value);
+    if (event.reason === "no_credit")
+        return { reason: "noCredit" };
+    if (event.reason === "low_credit") {
+        return { credits: event.credits, reason: "lowCredit" };
+    }
+    if (event.reason === "file_delete") {
+        return {
+            file: {
+                deletesIn: event.file.file_delete,
+                fileId: event.file.file_id,
+                fileName: event.file.file_name,
+            },
+            reason: "fileDeletionScheduled",
+        };
+    }
+    return {
+        file: {
+            catchAll: event.file.catch_all,
+            disposable: event.file.disposable,
+            fileId: event.file.file_id,
+            fileName: event.file.file_name,
+            invalid: event.file.invalid,
+            ok: event.file.ok,
+            totalRows: event.file.total_rows,
+            uniqueEmails: event.file.unique_emails,
+            unknown: event.file.unknown,
+        },
+        reason: "fileReady",
+    };
+}

package/dist/millionverifier/index.d.ts

@@ -0,0 +1,77 @@
+export * from "./api.js";
+export * from "./events.js";
+export * from "./schemas.js";
+import * as z from "zod";
+export declare const MILLIONVERIFIER_TRIGGER_CONFIG_SCHEMA: z.ZodObject<{}, z.core.$strip>;
+export declare const millionVerifierTriggerContracts: {
+    readonly "millionverifier.event": {
+        configSchema: z.ZodObject<{}, z.core.$strip>;
+        eventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            reason: z.ZodLiteral<"noCredit">;
+        }, z.core.$strip>, z.ZodObject<{
+            credits: z.ZodNumber;
+            reason: z.ZodLiteral<"lowCredit">;
+        }, z.core.$strip>, z.ZodObject<{
+            file: z.ZodObject<{
+                catchAll: z.ZodNumber;
+                disposable: z.ZodNumber;
+                fileId: z.ZodString;
+                fileName: z.ZodString;
+                invalid: z.ZodNumber;
+                ok: z.ZodNumber;
+                totalRows: z.ZodNumber;
+                uniqueEmails: z.ZodNumber;
+                unknown: z.ZodNumber;
+            }, z.core.$strip>;
+            reason: z.ZodLiteral<"fileReady">;
+        }, z.core.$strip>, z.ZodObject<{
+            file: z.ZodObject<{
+                deletesIn: z.ZodString;
+                fileId: z.ZodString;
+                fileName: z.ZodString;
+            }, z.core.$strip>;
+            reason: z.ZodLiteral<"fileDeletionScheduled">;
+        }, z.core.$strip>], "reason">;
+    };
+    readonly "millionverifier.noCredit": {
+        configSchema: z.ZodObject<{}, z.core.$strip>;
+        eventSchema: z.ZodObject<{
+            reason: z.ZodLiteral<"noCredit">;
+        }, z.core.$strip>;
+    };
+    readonly "millionverifier.lowCredit": {
+        configSchema: z.ZodObject<{}, z.core.$strip>;
+        eventSchema: z.ZodObject<{
+            credits: z.ZodNumber;
+            reason: z.ZodLiteral<"lowCredit">;
+        }, z.core.$strip>;
+    };
+    readonly "millionverifier.fileReady": {
+        configSchema: z.ZodObject<{}, z.core.$strip>;
+        eventSchema: z.ZodObject<{
+            file: z.ZodObject<{
+                catchAll: z.ZodNumber;
+                disposable: z.ZodNumber;
+                fileId: z.ZodString;
+                fileName: z.ZodString;
+                invalid: z.ZodNumber;
+                ok: z.ZodNumber;
+                totalRows: z.ZodNumber;
+                uniqueEmails: z.ZodNumber;
+                unknown: z.ZodNumber;
+            }, z.core.$strip>;
+            reason: z.ZodLiteral<"fileReady">;
+        }, z.core.$strip>;
+    };
+    readonly "millionverifier.fileDeletionScheduled": {
+        configSchema: z.ZodObject<{}, z.core.$strip>;
+        eventSchema: z.ZodObject<{
+            file: z.ZodObject<{
+                deletesIn: z.ZodString;
+                fileId: z.ZodString;
+                fileName: z.ZodString;
+            }, z.core.$strip>;
+            reason: z.ZodLiteral<"fileDeletionScheduled">;
+        }, z.core.$strip>;
+    };
+};

package/dist/millionverifier/index.js

@@ -0,0 +1,17 @@
+export * from "./api.js";
+export * from "./events.js";
+export * from "./schemas.js";
+import * as z from "zod";
+import { MILLIONVERIFIER_EVENT_SCHEMA, MILLIONVERIFIER_FILE_DELETION_SCHEDULED_EVENT_SCHEMA, MILLIONVERIFIER_FILE_READY_EVENT_SCHEMA, MILLIONVERIFIER_LOW_CREDIT_EVENT_SCHEMA, MILLIONVERIFIER_NO_CREDIT_EVENT_SCHEMA, } from "./events.js";
+export const MILLIONVERIFIER_TRIGGER_CONFIG_SCHEMA = z.object({});
+const contract = (eventSchema) => ({
+    configSchema: MILLIONVERIFIER_TRIGGER_CONFIG_SCHEMA,
+    eventSchema,
+});
+export const millionVerifierTriggerContracts = {
+    "millionverifier.event": contract(MILLIONVERIFIER_EVENT_SCHEMA),
+    "millionverifier.noCredit": contract(MILLIONVERIFIER_NO_CREDIT_EVENT_SCHEMA),
+    "millionverifier.lowCredit": contract(MILLIONVERIFIER_LOW_CREDIT_EVENT_SCHEMA),
+    "millionverifier.fileReady": contract(MILLIONVERIFIER_FILE_READY_EVENT_SCHEMA),
+    "millionverifier.fileDeletionScheduled": contract(MILLIONVERIFIER_FILE_DELETION_SCHEDULED_EVENT_SCHEMA),
+};

package/dist/millionverifier/schemas.d.ts

@@ -0,0 +1,226 @@
+import * as z from "zod";
+export declare const MILLIONVERIFIER_FILE_ID_SCHEMA: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>;
+export declare const MILLIONVERIFIER_FILE_STATUS_SCHEMA: z.ZodEnum<{
+    error: "error";
+    paused: "paused";
+    canceled: "canceled";
+    finished: "finished";
+    inProgress: "inProgress";
+    inQueueToStart: "inQueueToStart";
+}>;
+export declare const MILLIONVERIFIER_FILE_SCHEMA: z.ZodObject<{
+    catchAll: z.ZodNumber;
+    createdAt: z.ZodString;
+    creditsRequired: z.ZodNumber;
+    disposable: z.ZodNumber;
+    error: z.ZodString;
+    estimatedTimeSeconds: z.ZodNumber;
+    fileId: z.ZodString;
+    fileName: z.ZodString;
+    invalid: z.ZodNumber;
+    ok: z.ZodNumber;
+    percent: z.ZodNumber;
+    reverify: z.ZodNumber;
+    status: z.ZodEnum<{
+        error: "error";
+        paused: "paused";
+        canceled: "canceled";
+        finished: "finished";
+        inProgress: "inProgress";
+        inQueueToStart: "inQueueToStart";
+    }>;
+    totalRows: z.ZodNumber;
+    uniqueEmails: z.ZodNumber;
+    unknown: z.ZodNumber;
+    unverified: z.ZodNumber;
+    updatedAt: z.ZodString;
+    verified: z.ZodNumber;
+}, z.core.$strip>;
+export declare const MILLIONVERIFIER_EMAIL_RESULT_SCHEMA: z.ZodEnum<{
+    unknown: "unknown";
+    error: "error";
+    invalid: "invalid";
+    ok: "ok";
+    catchAll: "catchAll";
+    disposable: "disposable";
+    unverified: "unverified";
+}>;
+export declare const MILLIONVERIFIER_EMAIL_VERIFICATION_SCHEMA: z.ZodObject<{
+    credits: z.ZodNumber;
+    didYouMean: z.ZodString;
+    email: z.ZodString;
+    error: z.ZodString;
+    executionTimeMilliseconds: z.ZodNumber;
+    free: z.ZodBoolean;
+    liveMode: z.ZodBoolean;
+    quality: z.ZodOptional<z.ZodEnum<{
+        good: "good";
+        bad: "bad";
+        risky: "risky";
+    }>>;
+    result: z.ZodEnum<{
+        unknown: "unknown";
+        error: "error";
+        invalid: "invalid";
+        ok: "ok";
+        catchAll: "catchAll";
+        disposable: "disposable";
+        unverified: "unverified";
+    }>;
+    resultCode: z.ZodNumber;
+    role: z.ZodBoolean;
+    subresult: z.ZodString;
+}, z.core.$strip>;
+export declare const MILLIONVERIFIER_CREDITS_SCHEMA: z.ZodObject<{
+    bulkCredits: z.ZodNumber;
+    credits: z.ZodNumber;
+    plan: z.ZodNumber;
+    renewingCredits: z.ZodNumber;
+}, z.core.$strip>;
+export declare const MILLIONVERIFIER_FILE_WIRE_SCHEMA: z.ZodPipe<z.ZodObject<{
+    catch_all: z.ZodNumber;
+    createdate: z.ZodString;
+    credit: z.ZodNumber;
+    disposable: z.ZodNumber;
+    error: z.ZodString;
+    estimated_time_sec: z.ZodNumber;
+    file_id: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>;
+    file_name: z.ZodString;
+    invalid: z.ZodNumber;
+    ok: z.ZodNumber;
+    percent: z.ZodNumber;
+    reverify: z.ZodNumber;
+    status: z.ZodEnum<{
+        error: "error";
+        in_progress: "in_progress";
+        paused: "paused";
+        canceled: "canceled";
+        finished: "finished";
+        in_queue_to_start: "in_queue_to_start";
+    }>;
+    total_rows: z.ZodNumber;
+    unique_emails: z.ZodNumber;
+    unknown: z.ZodNumber;
+    unverified: z.ZodNumber;
+    updated_at: z.ZodString;
+    verified: z.ZodNumber;
+}, z.core.$loose>, z.ZodTransform<{
+    catchAll: number;
+    createdAt: string;
+    creditsRequired: number;
+    disposable: number;
+    error: string;
+    estimatedTimeSeconds: number;
+    fileId: string;
+    fileName: string;
+    invalid: number;
+    ok: number;
+    percent: number;
+    reverify: number;
+    status: "error" | "paused" | "canceled" | "finished" | "inProgress" | "inQueueToStart";
+    totalRows: number;
+    uniqueEmails: number;
+    unknown: number;
+    unverified: number;
+    updatedAt: string;
+    verified: number;
+}, {
+    [x: string]: unknown;
+    catch_all: number;
+    createdate: string;
+    credit: number;
+    disposable: number;
+    error: string;
+    estimated_time_sec: number;
+    file_id: string;
+    file_name: string;
+    invalid: number;
+    ok: number;
+    percent: number;
+    reverify: number;
+    status: "error" | "in_progress" | "paused" | "canceled" | "finished" | "in_queue_to_start";
+    total_rows: number;
+    unique_emails: number;
+    unknown: number;
+    unverified: number;
+    updated_at: string;
+    verified: number;
+}>>;
+export declare const MILLIONVERIFIER_EMAIL_VERIFICATION_WIRE_SCHEMA: z.ZodPipe<z.ZodObject<{
+    credits: z.ZodNumber;
+    didyoumean: z.ZodString;
+    email: z.ZodString;
+    error: z.ZodString;
+    executiontime: z.ZodNumber;
+    free: z.ZodBoolean;
+    livemode: z.ZodBoolean;
+    quality: z.ZodOptional<z.ZodEnum<{
+        "": "";
+        good: "good";
+        bad: "bad";
+        risky: "risky";
+    }>>;
+    result: z.ZodEnum<{
+        "": "";
+        unknown: "unknown";
+        error: "error";
+        invalid: "invalid";
+        ok: "ok";
+        disposable: "disposable";
+        catch_all: "catch_all";
+        unverified: "unverified";
+    }>;
+    resultcode: z.ZodNumber;
+    role: z.ZodBoolean;
+    subresult: z.ZodString;
+}, z.core.$loose>, z.ZodTransform<{
+    credits: number;
+    didYouMean: string;
+    email: string;
+    error: string;
+    executionTimeMilliseconds: number;
+    free: boolean;
+    liveMode: boolean;
+    result: "unknown" | "error" | "invalid" | "ok" | "catchAll" | "disposable" | "unverified";
+    resultCode: number;
+    role: boolean;
+    subresult: string;
+    quality?: "good" | "bad" | "risky" | undefined;
+}, {
+    [x: string]: unknown;
+    credits: number;
+    didyoumean: string;
+    email: string;
+    error: string;
+    executiontime: number;
+    free: boolean;
+    livemode: boolean;
+    result: "" | "unknown" | "error" | "invalid" | "ok" | "disposable" | "catch_all" | "unverified";
+    resultcode: number;
+    role: boolean;
+    subresult: string;
+    quality?: "" | "good" | "bad" | "risky" | undefined;
+}>>;
+export declare const MILLIONVERIFIER_CREDITS_WIRE_SCHEMA: z.ZodPipe<z.ZodObject<{
+    bulk_credits: z.ZodNumber;
+    credits: z.ZodNumber;
+    plan: z.ZodNumber;
+    renewing_credits: z.ZodNumber;
+}, z.core.$loose>, z.ZodTransform<{
+    bulkCredits: number;
+    credits: number;
+    plan: number;
+    renewingCredits: number;
+}, {
+    [x: string]: unknown;
+    bulk_credits: number;
+    credits: number;
+    plan: number;
+    renewing_credits: number;
+}>>;
+/**
+ * Maps a public file status to MillionVerifier's query value.
+ *
+ * @param status - Public file status.
+ */
+export declare function toMillionVerifierFileStatus(status: z.output<typeof MILLIONVERIFIER_FILE_STATUS_SCHEMA>): "error" | "in_progress" | "paused" | "canceled" | "finished" | "in_queue_to_start";

package/dist/millionverifier/schemas.js

@@ -0,0 +1,188 @@
+import * as z from "zod";
+export const MILLIONVERIFIER_FILE_ID_SCHEMA = z
+    .union([z.string().regex(/^\d+$/), z.number().int().positive()])
+    .transform(String);
+export const MILLIONVERIFIER_FILE_STATUS_SCHEMA = z.enum([
+    "inProgress",
+    "error",
+    "finished",
+    "canceled",
+    "paused",
+    "inQueueToStart",
+]);
+export const MILLIONVERIFIER_FILE_SCHEMA = z.object({
+    catchAll: z.number().int().nonnegative(),
+    createdAt: z.string(),
+    creditsRequired: z.number().int().nonnegative(),
+    disposable: z.number().int().nonnegative(),
+    error: z.string(),
+    estimatedTimeSeconds: z.number().int().nonnegative(),
+    fileId: z.string(),
+    fileName: z.string(),
+    invalid: z.number().int().nonnegative(),
+    ok: z.number().int().nonnegative(),
+    percent: z.number().int().min(0).max(100),
+    reverify: z.number().int().nonnegative(),
+    status: MILLIONVERIFIER_FILE_STATUS_SCHEMA,
+    totalRows: z.number().int().nonnegative(),
+    uniqueEmails: z.number().int().nonnegative(),
+    unknown: z.number().int().nonnegative(),
+    unverified: z.number().int().nonnegative(),
+    updatedAt: z.string(),
+    verified: z.number().int().nonnegative(),
+});
+export const MILLIONVERIFIER_EMAIL_RESULT_SCHEMA = z.enum([
+    "unverified",
+    "ok",
+    "catchAll",
+    "unknown",
+    "error",
+    "disposable",
+    "invalid",
+]);
+export const MILLIONVERIFIER_EMAIL_VERIFICATION_SCHEMA = z.object({
+    credits: z.number().int().nonnegative(),
+    didYouMean: z.string(),
+    email: z.string(),
+    error: z.string(),
+    executionTimeMilliseconds: z.number().int().nonnegative(),
+    free: z.boolean(),
+    liveMode: z.boolean(),
+    quality: z.enum(["good", "bad", "risky"]).optional(),
+    result: MILLIONVERIFIER_EMAIL_RESULT_SCHEMA,
+    resultCode: z.number().int().min(0).max(6),
+    role: z.boolean(),
+    subresult: z.string(),
+});
+export const MILLIONVERIFIER_CREDITS_SCHEMA = z.object({
+    bulkCredits: z.number().int().nonnegative(),
+    credits: z.number().int().nonnegative(),
+    plan: z.number().int(),
+    renewingCredits: z.number().int().nonnegative(),
+});
+const PROVIDER_FILE_STATUS_SCHEMA = z.enum([
+    "in_progress",
+    "error",
+    "finished",
+    "canceled",
+    "paused",
+    "in_queue_to_start",
+]);
+export const MILLIONVERIFIER_FILE_WIRE_SCHEMA = z
+    .looseObject({
+    catch_all: z.number().int().nonnegative(),
+    createdate: z.string(),
+    credit: z.number().int().nonnegative(),
+    disposable: z.number().int().nonnegative(),
+    error: z.string(),
+    estimated_time_sec: z.number().int().nonnegative(),
+    file_id: z.union([z.string(), z.number()]).transform(String),
+    file_name: z.string(),
+    invalid: z.number().int().nonnegative(),
+    ok: z.number().int().nonnegative(),
+    percent: z.number().int().min(0).max(100),
+    reverify: z.number().int().nonnegative(),
+    status: PROVIDER_FILE_STATUS_SCHEMA,
+    total_rows: z.number().int().nonnegative(),
+    unique_emails: z.number().int().nonnegative(),
+    unknown: z.number().int().nonnegative(),
+    unverified: z.number().int().nonnegative(),
+    updated_at: z.string(),
+    verified: z.number().int().nonnegative(),
+})
+    .transform((file) => MILLIONVERIFIER_FILE_SCHEMA.parse({
+    catchAll: file.catch_all,
+    createdAt: file.createdate,
+    creditsRequired: file.credit,
+    disposable: file.disposable,
+    error: file.error,
+    estimatedTimeSeconds: file.estimated_time_sec,
+    fileId: file.file_id,
+    fileName: file.file_name,
+    invalid: file.invalid,
+    ok: file.ok,
+    percent: file.percent,
+    reverify: file.reverify,
+    status: fromProviderFileStatus(file.status),
+    totalRows: file.total_rows,
+    uniqueEmails: file.unique_emails,
+    unknown: file.unknown,
+    unverified: file.unverified,
+    updatedAt: file.updated_at,
+    verified: file.verified,
+}));
+export const MILLIONVERIFIER_EMAIL_VERIFICATION_WIRE_SCHEMA = z
+    .looseObject({
+    credits: z.number().int().nonnegative(),
+    didyoumean: z.string(),
+    email: z.string(),
+    error: z.string(),
+    executiontime: z.number().int().nonnegative(),
+    free: z.boolean(),
+    livemode: z.boolean(),
+    quality: z.enum(["", "good", "bad", "risky"]).optional(),
+    result: z.enum([
+        "",
+        "unverified",
+        "ok",
+        "catch_all",
+        "unknown",
+        "error",
+        "disposable",
+        "invalid",
+    ]),
+    resultcode: z.number().int().min(0).max(6),
+    role: z.boolean(),
+    subresult: z.string(),
+})
+    .transform((result) => MILLIONVERIFIER_EMAIL_VERIFICATION_SCHEMA.parse({
+    credits: result.credits,
+    didYouMean: result.didyoumean,
+    email: result.email,
+    error: result.error,
+    executionTimeMilliseconds: result.executiontime,
+    free: result.free,
+    liveMode: result.livemode,
+    quality: result.quality || undefined,
+    result: result.result === "catch_all" ? "catchAll" : result.result || "error",
+    resultCode: result.resultcode,
+    role: result.role,
+    subresult: result.subresult,
+}));
+export const MILLIONVERIFIER_CREDITS_WIRE_SCHEMA = z
+    .looseObject({
+    bulk_credits: z.number().int().nonnegative(),
+    credits: z.number().int().nonnegative(),
+    plan: z.number().int(),
+    renewing_credits: z.number().int().nonnegative(),
+})
+    .transform((credits) => MILLIONVERIFIER_CREDITS_SCHEMA.parse({
+    bulkCredits: credits.bulk_credits,
+    credits: credits.credits,
+    plan: credits.plan,
+    renewingCredits: credits.renewing_credits,
+}));
+/**
+ * Maps a provider file status to the public camelCase discriminator.
+ *
+ * @param status - Provider file status.
+ */
+function fromProviderFileStatus(status) {
+    if (status === "in_progress")
+        return "inProgress";
+    if (status === "in_queue_to_start")
+        return "inQueueToStart";
+    return status;
+}
+/**
+ * Maps a public file status to MillionVerifier's query value.
+ *
+ * @param status - Public file status.
+ */
+export function toMillionVerifierFileStatus(status) {
+    if (status === "inProgress")
+        return "in_progress";
+    if (status === "inQueueToStart")
+        return "in_queue_to_start";
+    return status;
+}

package/dist/tidycal/api.d.ts

@@ -0,0 +1,62 @@
+import type { Encodable } from "@automate.ax/codec";
+import * as z from "zod";
+/** Resolved TidyCal account accepted by the shared API client. */
+export interface TidyCalResolvedAccount {
+    connectionMethodId: string;
+    secret: Record<string, unknown>;
+    serviceId: "tidycal";
+}
+/** Options for one authenticated TidyCal REST request. */
+export interface TidyCalRequestOptions<TSchema extends z.ZodType> {
+    /** Public camelCase JSON body. */
+    body?: Encodable;
+    /** HTTP verb. Defaults to `GET`. */
+    method?: "DELETE" | "GET" | "PATCH" | "POST";
+    /** Public camelCase query parameters. */
+    query?: Record<string, boolean | number | string | undefined>;
+    /** Schema for the normalized provider response. */
+    responseSchema: TSchema;
+}
+/** Structured TidyCal REST error. */
+export declare class TidyCalApiError extends Error {
+    /** Normalized provider error payload, when it was valid JSON. */
+    readonly body?: Encodable;
+    /** Retry delay in seconds, when TidyCal returned one. */
+    readonly retryAfter?: number;
+    /** HTTP status returned by TidyCal. */
+    readonly status: number;
+    /**
+     * Creates a structured error from one TidyCal response.
+     *
+     * @param options - Response status, provider body, and retry metadata.
+     * @param options.body - Normalized provider error payload.
+     * @param options.retryAfter - Retry delay in seconds.
+     * @param options.status - HTTP response status.
+     */
+    constructor(options: {
+        body?: Encodable;
+        retryAfter?: number;
+        status: number;
+    });
+}
+/**
+ * Creates an authenticated TidyCal REST client.
+ *
+ * @param account - Resolved OAuth or personal-access-token account.
+ * @throws When the connection method or secret shape is unsupported.
+ */
+export declare function getTidyCalApi(account: TidyCalResolvedAccount): {
+    request: <TSchema extends z.ZodType>(path: string, options: TidyCalRequestOptions<TSchema>) => Promise<z.output<TSchema>>;
+};
+/**
+ * Converts public camelCase JSON to TidyCal wire keys.
+ *
+ * @param value - Codec-safe public value.
+ */
+export declare function toTidyCal(value: Encodable): Encodable;
+/**
+ * Converts TidyCal wire JSON to public camelCase keys.
+ *
+ * @param value - Untrusted provider JSON value.
+ */
+export declare function fromTidyCal(value: unknown): unknown;