@zapier/zapier-sdk 0.77.0 → 0.77.2

package/dist/plugins/triggers/watchTriggerInbox/index.js

@@ -1,402 +0,0 @@
-import { definePlugin } from "kitcore";
-import { WatchTriggerInboxSchema, } from "../drainTriggerInbox/schemas";
-import { requireOnMessage, resolveConcurrencyAndLease, runDrainPass, isNonRetryableDrainError, } from "../drainTriggerInbox";
-import { resolveTriggerInboxId } from "../utils";
-import { triggerInboxResolver } from "../../../resolvers";
-import { triggersDefaults } from "../shared";
-import { isAbortError, combineAbortSignals } from "../../../utils/abort-utils";
-import { sleep, calculateErrorBackoffMs, BASE_ERROR_BACKOFF_MS, } from "../../../utils/retry-utils";
-import { isPermanentHttpError } from "../../../api";
-import { ZapierError } from "../../../types/errors";
-import { readInboxEvents } from "./sse";
-// First entry is the floor, not 0: a server that closes the stream immediately
-// (instant EOF, empty body) must not be able to reconnect with no delay, or it
-// busy-loops. Repeated instant closes escalate through the later entries (up to
-// 5 s); only a clean end after a healthy, long-lived connection resets to the
-// floor — see SSE_HEALTHY_CONNECTION_MS.
-const SSE_RECONNECT_BACKOFF_MS = [500, 1000, 2000, 5000];
-const DEFAULT_SAFETY_DRAIN_INTERVAL_MS = 300000; // 5 minutes
-// A clean stream end only resets the reconnect backoff to the floor if the
-// connection stayed open at least this long. A connection that lived longer
-// than our longest reconnect backoff is "healthy", so resetting gives fast
-// recovery from routine server-side cycling (e.g. JWT expiry); a stream that
-// closes sooner is treated as unstable and escalates like any other.
-const SSE_HEALTHY_CONNECTION_MS = 5000;
-// Consecutive transient drain failures escalate the backoff via
-// calculateErrorBackoffMs, whose error term saturates at errorCount 4 (capped at
-// 2x the base interval). Past that the delay no longer grows, so we cap the
-// counter that feeds the backoff there, holding the steady-state ~3.5 s retry
-// cadence. (The separate, intentionally uncapped errorAttempts counter in
-// drainRunner is what the diagnostics report; its unbounded growth is harmless
-// since it only feeds a log string, never the backoff math.)
-const ERROR_BACKOFF_CAP = 4;
-/**
- * Coalescing wake latch between the drain producers (SSE connect, SSE frames,
- * the safety timer, abort) and the single drain consumer. A `request()` that
- * lands while the consumer is mid-drain is not lost: `pending` stays set, so
- * the consumer's next `waitForRequest()` returns immediately and runs one more
- * drain. Mirrors `createWaiter` in drainTriggerInbox/pipeline.ts.
- *
- * Exported for unit testing the coalescing / no-lost-wakeup semantics.
- */
-export function createDrainLatch() {
-    let pending = false;
-    const make = () => {
-        let resolve;
-        const promise = new Promise((r) => {
-            resolve = r;
-        });
-        return { promise, resolve };
-    };
-    let current = make();
-    return {
-        request() {
-            pending = true;
-            const prev = current;
-            current = make();
-            prev.resolve();
-        },
-        async waitForRequest() {
-            if (pending) {
-                pending = false;
-                return;
-            }
-            await current.promise;
-            pending = false;
-        },
-    };
-}
-/**
- * Sole caller of `runDrainPass`, so drains are serial and never overlap. Waits
- * for a request, drains the inbox to empty, repeats. The first pass carries
- * `firstFetch: true` (preserving the initialization_failure check).
- *
- * Transient infrastructure failures (5xx, 429, network blips on lease / ack /
- * release) are retried indefinitely with bounded backoff until they succeed or
- * the watch is aborted — a watch is a "consume until aborted" loop, so a blip (or
- * even a multi-minute outage) must not kill it, mirroring the SSE loop's
- * resilience. The backoff escalates with consecutive failures and resets on the
- * first success. Once retries saturate the backoff, a single warning prints to
- * stderr (re-armed on the next success), mirroring the SSE loop's degraded-state
- * notice; per-retry diagnostics print only under `debug`. A fail-fast handler
- * error, an `initialization_failure`, or a permanent HTTP error is fatal
- * immediately. Returns how the watch ended so the caller can resolve or re-throw.
- */
-async function drainRunner({ drainOptions, drainRequest, signal, inboxId, debug, }) {
-    let firstFetch = true;
-    let consecutiveErrors = 0;
-    // Uncapped, unlike consecutiveErrors: reports the true consecutive-failure count
-    // in diagnostics so a long outage doesn't freeze the logged attempt at the
-    // backoff cap. Reset on a successful pass.
-    let errorAttempts = 0;
-    // Mirrors the SSE loop's `degraded`: warn once when retries saturate the
-    // backoff, re-armed (silently) on the first successful pass.
-    let drainDegraded = false;
-    while (!signal.aborted) {
-        await drainRequest.waitForRequest();
-        if (signal.aborted)
-            return { kind: "aborted" };
-        let abortedFromCallback = false;
-        try {
-            ({ abortedFromCallback } = await runDrainPass({
-                ...drainOptions,
-                firstFetch,
-            }));
-        }
-        catch (error) {
-            // Abort is intent, not failure — surface it as a clean stop, uncounted.
-            // `signal.aborted` alone is the predicate: every abort of THIS watch has
-            // set it by the time the catch runs, so an abort-shaped error arriving
-            // without it can only be someone else's (e.g. the user's onMessage leaking
-            // its own aborted fetch) — that's a fail-fast handler error and must
-            // reject below, not resolve the watch as a clean stop.
-            if (signal.aborted)
-                return { kind: "aborted" };
-            // Fatal, never retried: fail-fast handler errors and initialization_failure
-            // are tagged non-retryable; permanent HTTP (4xx — auth / permission /
-            // not-found) won't fix itself; and a non-object thrown value can only be a
-            // user onMessage fail-fast throw (the API client only throws Error objects),
-            // which is the user's own failure. Everything else (5xx, 429, network blip)
-            // is transient and retried below.
-            const isNonObjectThrow = typeof error !== "object" || error === null;
-            if (isNonObjectThrow ||
-                isNonRetryableDrainError(error) ||
-                isPermanentHttpError(error)) {
-                return { kind: "error", error };
-            }
-            // Transient: retry indefinitely (a watch runs until aborted). The counter
-            // only escalates the backoff and is capped where the backoff saturates, so
-            // a long outage can't grow it unbounded; a successful pass resets it below.
-            consecutiveErrors = Math.min(consecutiveErrors + 1, ERROR_BACKOFF_CAP);
-            errorAttempts += 1;
-            const delay = calculateErrorBackoffMs(BASE_ERROR_BACKOFF_MS, consecutiveErrors);
-            const statusCode = errorStatusCode(error);
-            const httpPart = statusCode !== undefined ? ` (HTTP ${statusCode})` : "";
-            // Once retries saturate the backoff the watch is making no forward
-            // progress, so surface it once on stderr even without `debug` (re-armed on
-            // recovery), mirroring how the SSE loop warns when real-time wake-ups pause.
-            if (!drainDegraded && consecutiveErrors >= ERROR_BACKOFF_CAP) {
-                console.warn(`[zapier-sdk] Draining inbox ${inboxId}${httpPart} is failing ` +
-                    `repeatedly: ${errorMessage(error)}. Continuing to retry with backoff.`);
-                drainDegraded = true;
-            }
-            if (debug) {
-                console.error(`[zapier-sdk] Retrying drain for inbox ${inboxId} ` +
-                    `(attempt ${errorAttempts}, retry in ${delay}ms)${httpPart}: ${errorMessage(error)}`);
-            }
-            await sleep(delay, signal);
-            if (signal.aborted)
-                return { kind: "aborted" };
-            // Re-arm the latch so the loop drains again even without an external
-            // wake-up (SSE frame / safety timer). firstFetch stays set so a retry of
-            // the first pass still runs the initialization_failure check.
-            drainRequest.request();
-            continue;
-        }
-        firstFetch = false;
-        consecutiveErrors = 0;
-        errorAttempts = 0;
-        drainDegraded = false;
-        if (abortedFromCallback)
-            return { kind: "abortedFromCallback" };
-    }
-    return { kind: "aborted" };
-}
-/** statusCode off any ZapierError (ZapierApiError, ZapierApprovalError, …). */
-function errorStatusCode(err) {
-    return err instanceof ZapierError ? err.statusCode : undefined;
-}
-function errorMessage(err) {
-    return err instanceof Error ? err.message : String(err);
-}
-/**
- * Holds one persistent SSE connection open and requests a drain on connect
- * (catch-up) and on every frame, keeping the socket open across drains so no
- * notification window is missed. Reconnects with backoff on clean end or
- * transient error. A 4xx is permanent for now (auth/permission/bad request);
- * rather than hammer the endpoint or abandon SSE, it waits a full safety
- * interval before retrying so a transient misconfiguration still self-heals,
- * while the independent safety timer keeps draining. (429 never lands here —
- * api.fetch retries it upstream as ZapierRateLimitError, treated as transient.)
- *
- * Failures are printed to stderr (never stdout, so `--json` NDJSON stays clean):
- * permanent degradation warns once on entering the degraded state (silent on
- * the per-safety-interval retries, warning again only after a reconnect then
- * re-failure); transient reconnects are dim diagnostics printed only under
- * `debug`. Clean stream ends (e.g. routine JWT-expiry cycling) print nothing,
- * so a reconnect notice always means an error broke the stream.
- */
-async function sseLoop({ api, inboxId, drainRequest, safetyDrainMs, signal, debug, }) {
-    let attempt = 0;
-    // Whether we've already warned about the current permanent-failure spell.
-    // Warn once on entering it; stay silent on retries; re-arm on a successful
-    // reconnect (onOpen) — the only way out, since a permanent 4xx throws before
-    // onOpen fires. Without this a standing 4xx prints the same warning every
-    // safety interval forever.
-    let degraded = false;
-    while (!signal.aborted) {
-        let connected = false;
-        let connectedAt = 0;
-        let transientError;
-        try {
-            for await (const _event of readInboxEvents({
-                api,
-                inboxId,
-                signal,
-                // SSE is edge-triggered with no replay, so draining on connect is the
-                // only way to pick up messages that arrived before this connection —
-                // including the window left by a prior disconnect.
-                onOpen: () => {
-                    connected = true;
-                    connectedAt = Date.now();
-                    degraded = false;
-                    drainRequest.request();
-                },
-            })) {
-                drainRequest.request();
-            }
-            // Clean stream end. Reset to the floor only if the connection stayed open
-            // long enough to count as healthy (e.g. routine JWT-expiry cycling), so a
-            // server that accepts the connection and immediately closes it escalates
-            // through the backoff below instead of reconnecting at a fixed 500 ms.
-            if (connected && Date.now() - connectedAt >= SSE_HEALTHY_CONNECTION_MS) {
-                attempt = 0;
-            }
-        }
-        catch (err) {
-            if (signal.aborted || isAbortError(err))
-                return;
-            if (isPermanentHttpError(err)) {
-                if (!degraded) {
-                    const statusCode = errorStatusCode(err);
-                    const errorMsg = errorMessage(err);
-                    const httpPart = statusCode !== undefined ? ` (HTTP ${statusCode})` : "";
-                    console.warn(`[zapier-sdk] Real-time wake-ups for inbox ${inboxId}${httpPart} ` +
-                        `paused: ${errorMsg}. Falling back to the periodic safety drain.`);
-                    degraded = true;
-                }
-                attempt = 0;
-                if (signal.aborted)
-                    return;
-                await sleep(safetyDrainMs, signal);
-                continue;
-            }
-            // A connection that opened then dropped proves the endpoint is reachable,
-            // so reset to the floor; a failed connect grows the backoff instead.
-            if (connected)
-                attempt = 0;
-            transientError = err;
-        }
-        if (signal.aborted)
-            return;
-        const delay = SSE_RECONNECT_BACKOFF_MS[Math.min(attempt, SSE_RECONNECT_BACKOFF_MS.length - 1)];
-        attempt = Math.min(attempt + 1, SSE_RECONNECT_BACKOFF_MS.length - 1);
-        if (transientError !== undefined && debug) {
-            const statusCode = errorStatusCode(transientError);
-            const errorMsg = errorMessage(transientError);
-            const httpPart = statusCode !== undefined ? ` (HTTP ${statusCode})` : "";
-            console.error(`[zapier-sdk] Reconnecting real-time wake-ups for inbox ${inboxId} ` +
-                `(attempt ${attempt}, retry in ${delay}ms)${httpPart}: ${errorMsg}`);
-        }
-        await sleep(delay, signal);
-    }
-}
-/**
- * Requests a drain every `safetyDrainMs`, independent of SSE state. Guarantees
- * forward progress when SSE frames are missed, the connection drops undetected,
- * or SSE is degraded. The timer is ref'd (like the prior poll loop) so the
- * watch keeps the process alive until aborted — that is what makes this a real
- * backstop even when SSE is parked on a permanent failure with no open socket.
- */
-async function safetyTimerLoop({ safetyDrainMs, drainRequest, signal, }) {
-    while (!signal.aborted) {
-        await sleep(safetyDrainMs, signal);
-        if (signal.aborted)
-            return;
-        drainRequest.request();
-    }
-}
-/**
- * `watchTriggerInbox` is the continuous-consumption variant of
- * `drainTriggerInbox`. Same options surface, same callback shape;
- * the difference is that after draining the inbox, it subscribes to
- * a Server-Sent Events stream to wake on new-message notifications
- * rather than polling. A periodic safety drain fires every
- * `maxDrainIntervalSeconds` seconds (default: 300) to guarantee
- * forward progress if SSE events are missed or the connection drops
- * undetected. Resolves cleanly on `signal` abort or when a callback
- * throws `ZapierAbortDrainSignal`. Transient drain failures (5xx, 429,
- * network blips) are retried indefinitely with bounded backoff until they
- * succeed or the watch is aborted; it rejects only on a fail-fast handler
- * error, an `initialization_failure`, or a permanent HTTP error.
- */
-export const watchTriggerInboxPlugin = definePlugin((sdk) => {
-    async function watchTriggerInbox(options) {
-        const onMessage = requireOnMessage(options.onMessage);
-        const { concurrency, leaseLimit } = resolveConcurrencyAndLease(options);
-        const inboxId = await resolveTriggerInboxId({
-            api: sdk.context.api,
-            inbox: options.inbox,
-        });
-        if (options.signal?.aborted)
-            return;
-        const safetyDrainMs = options.maxDrainIntervalSeconds !== undefined
-            ? options.maxDrainIntervalSeconds * 1000
-            : DEFAULT_SAFETY_DRAIN_INTERVAL_MS;
-        // Internal stop lets the drain runner's terminal states (a handler's
-        // ZapierAbortDrainSignal, a fatal error) tear down the background SSE and
-        // safety loops. Combined with the caller's signal so either stops all.
-        const stop = new AbortController();
-        const combined = combineAbortSignals({
-            handles: [
-                ...(options.signal
-                    ? [{ signal: options.signal, dispose: () => { } }]
-                    : []),
-                { signal: stop.signal, dispose: () => { } },
-            ],
-        });
-        const signal = combined?.signal ?? stop.signal;
-        const drainRequest = createDrainLatch();
-        // Abort wakes the idle drain runner so it observes the abort and exits;
-        // the latch otherwise only resolves on a drain request.
-        signal.addEventListener("abort", () => drainRequest.request(), {
-            once: true,
-        });
-        // Real-time health is printed to stderr by the SSE loop (warnings always,
-        // reconnect diagnostics only under `debug`), so every consumer surfaces it
-        // without wiring anything — the watcher never routes this through onEvent.
-        const debug = sdk.context.options.debug === true;
-        const drainOptions = {
-            sdk,
-            inboxId,
-            onMessage,
-            concurrency,
-            leaseLimit,
-            leaseSeconds: options.leaseSeconds,
-            maxMessages: undefined,
-            releaseOnError: options.releaseOnError ?? false,
-            continueOnError: options.continueOnError ?? false,
-            onError: options.onError,
-            signal,
-        };
-        // Unconditional initial drain (firstFetch: true): handle anything already
-        // in the inbox even if SSE never connects (e.g. a permanent 4xx). SSE and
-        // the safety timer then layer on additional catch-up drains.
-        drainRequest.request();
-        const runnerDone = drainRunner({
-            drainOptions,
-            drainRequest,
-            signal,
-            inboxId,
-            debug,
-        });
-        const sseDone = sseLoop({
-            api: sdk.context.api,
-            inboxId,
-            drainRequest,
-            safetyDrainMs,
-            signal,
-            debug,
-        }).catch(() => { });
-        const safetyDone = safetyTimerLoop({
-            safetyDrainMs,
-            drainRequest,
-            signal,
-        }).catch(() => { });
-        let end;
-        try {
-            end = await runnerDone;
-        }
-        finally {
-            // Stop the producers and wait for them to unwind so no fetch or timer
-            // outlives this call, then release the combined-signal listeners.
-            stop.abort();
-            await Promise.all([sseDone, safetyDone]);
-            combined?.dispose();
-        }
-        if (end.kind === "error")
-            throw end.error;
-    }
-    return {
-        watchTriggerInbox,
-        context: {
-            meta: {
-                watchTriggerInbox: {
-                    ...triggersDefaults,
-                    type: "create",
-                    description: "Continuously consume a trigger inbox: drain currently-available messages via onMessage, then subscribe to SSE notifications for new arrivals until aborted. A periodic safety drain runs every maxDrainIntervalSeconds (default: 300) to guarantee forward progress if SSE events are missed. Resolves cleanly on signal abort or ZapierAbortDrainSignal from a handler. Transient drain failures (5xx, 429, network blips) retry indefinitely with bounded backoff until they succeed or the watch is aborted; it rejects on a fail-fast handler error, an initialization_failure, or a permanent HTTP error. Real-time wake-up health is reported on stderr: a warning when wake-ups pause and the watch falls back to the safety drain, plus (with debug) transient reconnect notices. Persistent drain failures likewise warn once on stderr while bounded-backoff retries continue.",
-                    itemType: "void",
-                    // See drainTriggerInbox: override the doc generator's default
-                    // suffix so the rendered return type is Promise<void>, not
-                    // Promise<voidItem>.
-                    returnType: "void",
-                    inputSchema: WatchTriggerInboxSchema,
-                    resolvers: {
-                        inbox: triggerInboxResolver,
-                    },
-                    packages: ["sdk"],
-                },
-            },
-        },
-    };
-});

package/dist/plugins/triggers/watchTriggerInbox/sse.d.ts

@@ -1,32 +0,0 @@
-import type { ApiClient } from "../../../api";
-interface InboxSseEvent {
-    inbox_id: string;
-    count?: number;
-}
-/**
- * Streams the trigger inbox events endpoint and yields the notification frames
- * for this inbox. The transport (SSE connection, JSON parsing, reconnect-able
- * error mapping, abort/cleanup) lives in `api.fetchJsonStream`; this only adds
- * the inbox URL and the `inbox_id` filter, skipping any frame whose data was
- * not valid JSON.
- *
- * `onOpen` fires once the connection is live (response ok, body present) and
- * before the first frame. The endpoint is edge-triggered with no replay, so a
- * caller must drain on `onOpen` to pick up messages that arrived before this
- * connection existed — a frame alone never covers that window.
- *
- * The generator returns (without throwing) when the signal is aborted, when
- * the server closes the connection (JWT expiry, clean shutdown), or when the
- * body is empty. For a non-ok response `api.fetchJsonStream` throws a
- * `ZapierError` carrying the HTTP `statusCode`; `isPermanentHttpError`
- * classifies it so the caller can tell permanent (4xx) failures from transient
- * ones.
- */
-export declare function readInboxEvents({ api, inboxId, signal, onOpen, }: {
-    api: ApiClient;
-    inboxId: string;
-    signal?: AbortSignal;
-    onOpen?: () => void;
-}): AsyncGenerator<InboxSseEvent>;
-export {};
-//# sourceMappingURL=sse.d.ts.map

package/dist/plugins/triggers/watchTriggerInbox/sse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/watchTriggerInbox/sse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,UAAU,aAAa;IACrB,QAAQ,EAAE,MAAM,CAAC;IAIjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAuB,eAAe,CAAC,EACrC,GAAG,EACH,OAAO,EACP,MAAM,EACN,MAAM,GACP,EAAE;IACD,GAAG,EAAE,SAAS,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB,GAAG,cAAc,CAAC,aAAa,CAAC,CAqBhC"}

package/dist/plugins/triggers/watchTriggerInbox/sse.js

@@ -1,36 +0,0 @@
-/**
- * Streams the trigger inbox events endpoint and yields the notification frames
- * for this inbox. The transport (SSE connection, JSON parsing, reconnect-able
- * error mapping, abort/cleanup) lives in `api.fetchJsonStream`; this only adds
- * the inbox URL and the `inbox_id` filter, skipping any frame whose data was
- * not valid JSON.
- *
- * `onOpen` fires once the connection is live (response ok, body present) and
- * before the first frame. The endpoint is edge-triggered with no replay, so a
- * caller must drain on `onOpen` to pick up messages that arrived before this
- * connection existed — a frame alone never covers that window.
- *
- * The generator returns (without throwing) when the signal is aborted, when
- * the server closes the connection (JWT expiry, clean shutdown), or when the
- * body is empty. For a non-ok response `api.fetchJsonStream` throws a
- * `ZapierError` carrying the HTTP `statusCode`; `isPermanentHttpError`
- * classifies it so the caller can tell permanent (4xx) failures from transient
- * ones.
- */
-export async function* readInboxEvents({ api, inboxId, signal, onOpen, }) {
-    for await (const message of api.fetchJsonStream(`/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}/events`, { method: "GET", signal, authRequired: true, onOpen })) {
-        if (!message.parsed)
-            continue;
-        const parsed = message.data;
-        if (typeof parsed === "object" &&
-            parsed !== null &&
-            typeof parsed.inbox_id === "string" &&
-            // Only wake on a frame for this inbox. Case-insensitive: the endpoint
-            // echoes the canonical lowercase UUID, but resolveTriggerInboxId passes
-            // a UUID-shaped `inbox` through unchanged, so its casing may differ.
-            parsed.inbox_id.toLowerCase() ===
-                inboxId.toLowerCase()) {
-            yield parsed;
-        }
-    }
-}

package/dist/plugins/waitForNewConnection/index.d.ts

@@ -1,209 +0,0 @@
-import { type WaitForNewConnectionItem } from "./schemas";
-export declare const waitForNewConnectionPlugin: (sdk: {
-    context: {
-        api: import("../..").ApiClient;
-        resolveCredentials: () => Promise<string | {
-            clientId: string;
-            clientSecret: string;
-            type?: "client_credentials" | undefined;
-            baseUrl?: string | undefined;
-            scope?: string | undefined;
-        } | {
-            clientId: string;
-            type?: "pkce" | undefined;
-            baseUrl?: string | undefined;
-            scope?: string | undefined;
-        } | undefined>;
-    };
-} & {
-    context: {
-        getResolvedManifest: () => Promise<import("../manifest").Manifest | null>;
-        getVersionedImplementationId: (appKey: string) => Promise<string | null>;
-        resolveAppKeys: ({ appKeys }: {
-            appKeys: string[];
-        }) => Promise<import("../..").ResolvedAppLocator[]>;
-        updateManifestEntry: (options: import("../manifest").UpdateManifestEntryOptions) => Promise<import("../manifest").UpdateManifestEntryResult>;
-        addActionEntry: (options: import("../manifest").AddActionEntryOptions) => Promise<import("../manifest").AddActionEntryResult>;
-        findActionEntry: ({ name, manifest, }: {
-            name: string;
-            manifest: import("../manifest").Manifest;
-        }) => import("../manifest").ActionEntry | null;
-        listActionEntries: ({ configPath, }?: {
-            configPath?: string;
-        }) => Promise<Array<[string, import("../manifest").ActionEntry]>>;
-        deleteActionEntry: ({ name, configPath, skipWrite, }: {
-            name: string;
-            configPath?: string;
-            skipWrite?: boolean;
-        }) => Promise<import("../manifest").Manifest>;
-        hasActionEntry: ({ name, manifest, }: {
-            name: string;
-            manifest: import("../manifest").Manifest;
-        }) => boolean;
-        findManifestEntry: typeof import("../manifest").findManifestEntry;
-        readManifestFromFile: typeof import("../manifest").readManifestFromFile;
-        getManifestConnections: () => Promise<Record<string, {
-            connectionId: string | number;
-        }> | null>;
-    };
-} & {
-    getApp: (options?: {
-        app: string;
-    } | {
-        appKey: string;
-    } | undefined) => Promise<{
-        data: {
-            slug: string;
-            title: string;
-            key: string;
-            implementation_id: string;
-            description?: string | undefined;
-            is_hidden?: boolean | undefined;
-            auth_type?: string | undefined;
-            actions?: {
-                read?: number | undefined;
-                read_bulk?: number | undefined;
-                write?: number | undefined;
-                search?: number | undefined;
-                search_or_write?: number | undefined;
-                search_and_write?: number | undefined;
-                filter?: number | undefined;
-            } | undefined;
-            is_deprecated?: boolean | undefined;
-            is_beta?: boolean | undefined;
-            is_premium?: boolean | undefined;
-            age_in_days?: number | undefined;
-            banner?: string | undefined;
-            categories?: {
-                id: number;
-                name: string;
-                slug: string;
-            }[] | undefined;
-            images?: {
-                url_16x16?: string | undefined;
-                url_32x32?: string | undefined;
-                url_64x64?: string | undefined;
-                url_128x128?: string | undefined;
-            } | undefined;
-            popularity?: number | undefined;
-            has_filters?: boolean | undefined;
-            has_reads?: boolean | undefined;
-            has_searches?: boolean | undefined;
-            has_searches_or_writes?: boolean | undefined;
-            has_upfront_fields?: boolean | undefined;
-            has_writes?: boolean | undefined;
-            is_built_in?: boolean | undefined;
-            is_featured?: boolean | undefined;
-            is_invite?: boolean | undefined;
-            is_public?: boolean | undefined;
-            is_upcoming?: boolean | undefined;
-            visibility?: string | undefined;
-            primary_color?: string | undefined;
-            secondary_color?: string | undefined;
-            classification?: string | undefined;
-            api_docs_url?: string | undefined;
-            image?: string | undefined;
-            version?: string | undefined;
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            getApp: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    listApps: (options?: ({
-        search?: string | undefined;
-        apps?: string[] | undefined;
-        appKeys?: string[] | undefined;
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-    } & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        slug: string;
-        title: string;
-        key: string;
-        implementation_id: string;
-        description?: string | undefined;
-        is_hidden?: boolean | undefined;
-        auth_type?: string | undefined;
-        actions?: {
-            read?: number | undefined;
-            read_bulk?: number | undefined;
-            write?: number | undefined;
-            search?: number | undefined;
-            search_or_write?: number | undefined;
-            search_and_write?: number | undefined;
-            filter?: number | undefined;
-        } | undefined;
-        is_deprecated?: boolean | undefined;
-        is_beta?: boolean | undefined;
-        is_premium?: boolean | undefined;
-        age_in_days?: number | undefined;
-        banner?: string | undefined;
-        categories?: {
-            id: number;
-            name: string;
-            slug: string;
-        }[] | undefined;
-        images?: {
-            url_16x16?: string | undefined;
-            url_32x32?: string | undefined;
-            url_64x64?: string | undefined;
-            url_128x128?: string | undefined;
-        } | undefined;
-        popularity?: number | undefined;
-        has_filters?: boolean | undefined;
-        has_reads?: boolean | undefined;
-        has_searches?: boolean | undefined;
-        has_searches_or_writes?: boolean | undefined;
-        has_upfront_fields?: boolean | undefined;
-        has_writes?: boolean | undefined;
-        is_built_in?: boolean | undefined;
-        is_featured?: boolean | undefined;
-        is_invite?: boolean | undefined;
-        is_public?: boolean | undefined;
-        is_upcoming?: boolean | undefined;
-        visibility?: string | undefined;
-        primary_color?: string | undefined;
-        secondary_color?: string | undefined;
-        classification?: string | undefined;
-        api_docs_url?: string | undefined;
-        image?: string | undefined;
-        version?: string | undefined;
-    }>;
-} & {
-    context: {
-        meta: {
-            listApps: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    context: import("../eventEmission").EventEmissionContext;
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    waitForNewConnection: (options?: {
-        app: string;
-        startedAt: number;
-        timeoutMs?: number | undefined;
-        pollIntervalMs?: number | undefined;
-    } | undefined) => Promise<{
-        data: WaitForNewConnectionItem;
-    }>;
-} & {
-    context: {
-        meta: {
-            waitForNewConnection: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type WaitForNewConnectionPluginProvides = ReturnType<typeof waitForNewConnectionPlugin>;
-//# sourceMappingURL=index.d.ts.map