@oomol-lab/open-connector 1.7.0 → 1.8.0

package/src/triggers/common/integration.d.ts

@@ -0,0 +1,115 @@
+import type { TriggerConfigOption, TriggerConfigOptionsContext } from "./configOptions.ts";
+import type { ConnectorProxyRequest, ConnectorProxyResult, ConnectorProxy } from "./proxy.ts";
+import type { IntegrationEndpointMethod, JsonValue, TriggerKeySnapshot } from "./types.ts";
+export declare const maximumIntegrationBodyBytes: number;
+export declare const maximumIntegrationDeliveryPages = 5;
+export interface ListenerReadContext {
+    readonly checkpoint: JsonValue;
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly connector: ConnectorProxy;
+    readonly now: Date;
+    readonly signal?: AbortSignal;
+}
+export interface ListenerPage {
+    readonly checkpoint: JsonValue;
+    readonly dedupeKey: string;
+    readonly hasMore: boolean;
+    readonly outputs: Readonly<Record<string, JsonValue>> | null;
+}
+export interface ListenerSource {
+    readonly intervalMs: number;
+    readonly read: (context: ListenerReadContext) => Promise<ListenerPage>;
+}
+export declare function validateListenerPage(value: unknown): asserts value is ListenerPage;
+export type IntegrationReceiveResult = {
+    readonly outcome: "wake";
+} | {
+    readonly checkpoint?: JsonValue;
+    readonly continue?: boolean;
+    readonly dedupeKey?: string;
+    readonly outcome: "event";
+    readonly outputs: Readonly<Record<string, JsonValue>>;
+} | {
+    readonly checkpoint?: JsonValue;
+    readonly continue?: boolean;
+    readonly outcome: "ignored";
+    readonly reason: string;
+} | {
+    readonly body: string;
+    readonly contentType: string;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly outcome: "respond";
+    readonly status: number;
+};
+export interface IntegrationStateContext {
+    readonly checkpoint: JsonValue;
+    readonly subscription: Readonly<Record<string, JsonValue>>;
+    readonly saveCheckpoint: (checkpoint: JsonValue) => Promise<void>;
+    readonly saveSubscription: (subscription: Readonly<Record<string, JsonValue>>, reconcileAt: Date) => Promise<void>;
+}
+export interface IntegrationReceiveContext {
+    readonly eventSourceId?: string;
+    readonly signal?: AbortSignal;
+    readonly admit: boolean;
+    readonly allow?: () => Promise<boolean>;
+    readonly bindingId: string;
+    readonly callbackSecret: string;
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly connector: ConnectorProxy;
+    readonly current: boolean;
+    readonly header: (name: string) => string | undefined;
+    readonly method: IntegrationEndpointMethod;
+    readonly now: Date;
+    readonly payload: JsonValue;
+    readonly query: (name: string) => string | undefined;
+    readonly rawBody: Uint8Array;
+    readonly state?: IntegrationStateContext;
+}
+export interface IntegrationReconcileContext {
+    readonly active: boolean;
+    readonly callbackSecret: string;
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly connector: ConnectorProxy;
+    readonly endpointUrl: string;
+    readonly idempotencyKey: string;
+    readonly now: Date;
+    readonly signal?: AbortSignal;
+    readonly state?: IntegrationStateContext;
+}
+export interface IntegrationReconcileResult {
+    readonly outcome: "pending" | "ready";
+}
+export interface ResourceSubscription {
+    readonly key: string;
+    readonly subscribe: ConnectorProxyRequest;
+    readonly unsubscribe: ConnectorProxyRequest;
+    readonly inspect?: ConnectorProxyRequest;
+}
+export interface ResourceDefinition {
+    readonly subscriptions: (config: Readonly<Record<string, JsonValue>>) => readonly ResourceSubscription[];
+    readonly response: (result: ConnectorProxyResult) => Readonly<Record<string, JsonValue>>;
+}
+export interface IntegrationDefinition {
+    readonly resources?: ResourceDefinition;
+    readonly eventSource?: "feishu";
+    readonly configOptions?: (context: TriggerConfigOptionsContext) => Promise<readonly TriggerConfigOption[]>;
+    readonly listener?: ListenerSource;
+    readonly initialState?: {
+        readonly checkpoint: JsonValue;
+        readonly subscription: Readonly<Record<string, JsonValue>>;
+    };
+    readonly receive: (context: IntegrationReceiveContext) => IntegrationReceiveResult | Promise<IntegrationReceiveResult>;
+    readonly reconcile: (context: IntegrationReconcileContext) => Promise<IntegrationReconcileResult>;
+    readonly snapshot: TriggerKeySnapshot & {
+        readonly type: "integration";
+    };
+}
+export declare class IntegrationConnectionError extends Error {
+    readonly name = "IntegrationConnectionError";
+}
+export declare class PermanentIntegrationError extends Error {
+    readonly name = "PermanentIntegrationError";
+}
+export declare class TransientIntegrationError extends Error {
+    readonly name = "TransientIntegrationError";
+}

package/src/triggers/common/integration.js

@@ -0,0 +1,31 @@
+import { isJsonObject, isJsonValue } from "./json.js";
+export const maximumIntegrationBodyBytes = 64 * 1024;
+export const maximumIntegrationDeliveryPages = 5;
+const encoder = new TextEncoder();
+export function validateListenerPage(value) {
+    if (!isJsonObject(value) ||
+        value.checkpoint == null ||
+        !isJsonValue(value.checkpoint) ||
+        typeof value.hasMore != "boolean") {
+        throw new TypeError("Listener page must contain a JSON checkpoint and a boolean hasMore.");
+    }
+    if (typeof value.dedupeKey != "string" ||
+        value.dedupeKey.length == 0 ||
+        encoder.encode(value.dedupeKey).byteLength > 1024) {
+        throw new TypeError("Listener page identity must contain between 1 and 1024 bytes.");
+    }
+    if (value.outputs !== null && !isJsonObject(value.outputs))
+        throw new TypeError("Listener page outputs must be an object or null.");
+    if (encoder.encode(JSON.stringify(value.checkpoint)).byteLength > 64 * 1024) {
+        throw new TypeError("Listener checkpoint exceeds 64 KiB.");
+    }
+}
+export class IntegrationConnectionError extends Error {
+    name = "IntegrationConnectionError";
+}
+export class PermanentIntegrationError extends Error {
+    name = "PermanentIntegrationError";
+}
+export class TransientIntegrationError extends Error {
+    name = "TransientIntegrationError";
+}

package/src/triggers/common/json.d.ts

@@ -0,0 +1,6 @@
+export type JsonValue = null | boolean | number | string | readonly JsonValue[] | JsonObject;
+export type JsonObject = {
+    readonly [key: string]: JsonValue;
+};
+export declare function isJsonValue(value: unknown): value is JsonValue;
+export declare function isJsonObject(value: unknown): value is JsonObject;

package/src/triggers/common/json.js

@@ -0,0 +1,91 @@
+function hasJsonShape(root) {
+    if (root === null || typeof root == "boolean" || typeof root == "string")
+        return true;
+    if (typeof root == "number")
+        return Number.isFinite(root);
+    if (typeof root != "object")
+        return false;
+    const ancestors = new Set();
+    const pending = [];
+    let value = root;
+    traversal: while (true) {
+        let keys;
+        let arrayLength;
+        if (Array.isArray(value)) {
+            arrayLength = value.length;
+            keys = Reflect.ownKeys(value);
+            if (keys.length != arrayLength + 1)
+                return false;
+        }
+        else {
+            const prototype = Reflect.getPrototypeOf(value);
+            if (prototype != Object.prototype && prototype != null)
+                return false;
+            keys = Reflect.ownKeys(value);
+            arrayLength = undefined;
+        }
+        ancestors.add(value);
+        let index = 0;
+        while (true) {
+            if (index >= keys.length) {
+                ancestors.delete(value);
+                const parent = pending.pop();
+                if (parent === undefined)
+                    return true;
+                value = parent.value;
+                keys = parent.keys;
+                arrayLength = parent.arrayLength;
+                index = parent.index;
+                continue;
+            }
+            const key = keys[index++];
+            if (arrayLength !== undefined) {
+                if (key == "length")
+                    continue;
+                if (typeof key != "string")
+                    return false;
+                const arrayIndex = Number(key);
+                if (!Number.isSafeInteger(arrayIndex) ||
+                    arrayIndex < 0 ||
+                    arrayIndex >= arrayLength ||
+                    String(arrayIndex) != key)
+                    return false;
+            }
+            else if (typeof key != "string") {
+                return false;
+            }
+            const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
+            if (descriptor?.enumerable != true || !Object.hasOwn(descriptor, "value"))
+                return false;
+            const child = descriptor.value;
+            if (child === null || typeof child == "boolean" || typeof child == "string")
+                continue;
+            if (typeof child == "number") {
+                if (!Number.isFinite(child))
+                    return false;
+                continue;
+            }
+            if (typeof child != "object" || ancestors.has(child))
+                return false;
+            pending.push({ value, keys, arrayLength, index });
+            value = child;
+            continue traversal;
+        }
+    }
+}
+export function isJsonValue(value) {
+    try {
+        return hasJsonShape(value);
+    }
+    catch {
+        return false;
+    }
+}
+export function isJsonObject(value) {
+    try {
+        return value != null && typeof value == "object" && !Array.isArray(value) && hasJsonShape(value);
+    }
+    catch {
+        return false;
+    }
+}

package/src/triggers/common/poll.d.ts

@@ -0,0 +1,41 @@
+import type { TriggerConfigOption, TriggerConfigOptionsContext } from "./configOptions.ts";
+import type { ConnectorProxy } from "./proxy.ts";
+import type { JsonValue, TriggerKeySnapshot } from "./types.ts";
+export declare const maximumPollCheckpointBytes: number;
+export declare const maximumPollDedupeKeyBytes = 1024;
+export declare const maximumPollEventsPerPage = 100;
+export interface PollEvent {
+    readonly dedupeKey: string;
+    readonly payload: Readonly<Record<string, JsonValue>>;
+}
+export interface PollResult {
+    readonly checkpoint: JsonValue;
+    readonly events: readonly PollEvent[];
+    readonly filtered?: number;
+    readonly hasMore?: boolean;
+}
+export interface PollContext {
+    readonly checkpoint: JsonValue;
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly connector: ConnectorProxy;
+    readonly now: Date;
+    readonly signal?: AbortSignal;
+}
+export declare function eventsPollOutputs(events: readonly PollEvent[]): Readonly<Record<string, JsonValue>>;
+export interface PollDefinition {
+    readonly buildOutputs: (events: readonly PollEvent[]) => Readonly<Record<string, JsonValue>>;
+    readonly configOptions?: (context: TriggerConfigOptionsContext) => Promise<readonly TriggerConfigOption[]>;
+    readonly poll: (context: PollContext) => Promise<PollResult>;
+    readonly snapshot: TriggerKeySnapshot & {
+        readonly type: "poll";
+    };
+}
+export declare class PollConnectionError extends Error {
+    readonly name = "PollConnectionError";
+}
+export declare class PermanentPollError extends Error {
+    readonly name = "PermanentPollError";
+}
+export declare class TransientPollError extends Error {
+    readonly name = "TransientPollError";
+}

package/src/triggers/common/poll.js

@@ -0,0 +1,15 @@
+export const maximumPollCheckpointBytes = 64 * 1024;
+export const maximumPollDedupeKeyBytes = 1024;
+export const maximumPollEventsPerPage = 100;
+export function eventsPollOutputs(events) {
+    return { events: events.map((event) => event.payload) };
+}
+export class PollConnectionError extends Error {
+    name = "PollConnectionError";
+}
+export class PermanentPollError extends Error {
+    name = "PermanentPollError";
+}
+export class TransientPollError extends Error {
+    name = "TransientPollError";
+}

package/src/triggers/common/proxy.d.ts

@@ -0,0 +1,14 @@
+export interface ConnectorProxyRequest {
+    readonly body?: unknown;
+    readonly endpoint: string;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly method: "DELETE" | "GET" | "PATCH" | "POST" | "PUT";
+    readonly query?: Readonly<Record<string, boolean | number | string | null>>;
+}
+export interface ConnectorProxyResult {
+    readonly data: unknown;
+    readonly status: number;
+}
+export interface ConnectorProxy {
+    execute(request: ConnectorProxyRequest, signal?: AbortSignal): Promise<ConnectorProxyResult>;
+}

package/src/triggers/common/proxy.js

@@ -0,0 +1 @@
+export {};

package/src/triggers/common/types.d.ts

@@ -0,0 +1,42 @@
+export type { JsonValue } from "./json.ts";
+import type { JsonValue } from "./json.ts";
+export interface Port {
+    readonly handle: string;
+    readonly jsonSchema: boolean | Readonly<Record<string, unknown>>;
+    readonly nullable: boolean;
+    readonly description?: string;
+}
+export interface InputPort extends Port {
+    readonly value?: JsonValue;
+}
+export interface Group {
+    readonly group: string;
+    readonly collapsed?: boolean;
+}
+interface TriggerKeySnapshotBase {
+    readonly configInputs: readonly (InputPort | Group)[];
+    readonly definitionVersion: number;
+    readonly description: string;
+    readonly displayName: string;
+    readonly key: string;
+    readonly name: string;
+    readonly outputs: readonly Port[];
+    readonly provider: string;
+}
+export type IntegrationEndpointMethod = "DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT";
+export type IntegrationBodyFormat = "form" | "json" | "multipart" | "text";
+export interface IntegrationEndpointDeclaration {
+    readonly body: {
+        readonly allowArray: boolean;
+        readonly allowEmpty: boolean;
+        readonly formats: readonly IntegrationBodyFormat[];
+    };
+    readonly methods: readonly IntegrationEndpointMethod[];
+    readonly successStatus: number;
+}
+export type TriggerKeySnapshot = (TriggerKeySnapshotBase & {
+    readonly type: "poll";
+}) | (TriggerKeySnapshotBase & {
+    readonly endpoint: IntegrationEndpointDeclaration;
+    readonly type: "integration";
+});

package/src/triggers/common/types.js

@@ -0,0 +1 @@
+export {};

package/src/triggers/maintenance.d.ts

@@ -0,0 +1,40 @@
+import type { ActionPolicyService } from "../core/action-policy.ts";
+import type { RuntimeLogger } from "../core/types.ts";
+import type { IRuntimePolicyStore } from "../server/storage/runtime-policy-store.ts";
+import type { IRuntimeTokenStore } from "../server/storage/runtime-token-service.ts";
+import type { TriggerStore } from "./store.ts";
+import type { TriggerRunner } from "./trigger-runner.ts";
+export interface TriggerSubscriptionSummary {
+    id: string;
+    mode: "webhook" | "resource" | "resource-set";
+    tokenId: string;
+    connectionId: string;
+    providerAccountId: string;
+    triggerId: string;
+    requestKey: string;
+    status: "active" | "deleting" | "deleted" | "abandoned";
+    reconcileAt: number;
+}
+interface TriggerMaintenanceOptions {
+    store: TriggerStore;
+    runner: TriggerRunner;
+    tokens: IRuntimeTokenStore;
+    runtimePolicy: IRuntimePolicyStore;
+    deploymentPolicy: ActionPolicyService;
+    logger?: RuntimeLogger;
+}
+export declare class TriggerMaintenance {
+    private readonly options;
+    private readonly shutdown;
+    private pending?;
+    private timer?;
+    constructor(options: TriggerMaintenanceOptions);
+    list(): Promise<TriggerSubscriptionSummary[]>;
+    cancel(id: string, signal: AbortSignal): Promise<void>;
+    abandon(id: string, signal: AbortSignal): Promise<void>;
+    run(): Promise<void>;
+    start(): void;
+    close(): Promise<void>;
+    private runBatch;
+}
+export {};

package/src/triggers/maintenance.js

@@ -0,0 +1,120 @@
+import { HttpRequestError } from "../server/api/http-utils.js";
+import { withSubscription } from "./subscriptions.js";
+export class TriggerMaintenance {
+    options;
+    shutdown = new AbortController();
+    pending;
+    timer;
+    constructor(options) {
+        this.options = options;
+    }
+    async list() {
+        return (await this.options.store.list())
+            .filter((record) => record.mode !== "resource-set")
+            .map((record) => ({
+            id: record.id,
+            mode: record.mode,
+            tokenId: record.tokenId,
+            connectionId: record.connectionId,
+            providerAccountId: record.providerAccountId,
+            triggerId: record.triggerId,
+            requestKey: record.requestKey,
+            status: record.status,
+            reconcileAt: record.reconcileAt,
+        }));
+    }
+    async cancel(id, signal) {
+        await withSubscription(this.options.store, id, signal, async (record, save) => {
+            if (record.mode === "resource-set")
+                throw new HttpRequestError("invalid_input", "Cancel the owning resource subscriptions.");
+            if (record.status === "deleted" || record.status === "abandoned")
+                return;
+            record.status = "deleting";
+            await save();
+            await this.options.runner.cleanup(record, save, signal);
+        });
+    }
+    async abandon(id, signal) {
+        await withSubscription(this.options.store, id, signal, async (record, save) => {
+            if (record.mode === "resource-set")
+                throw new HttpRequestError("invalid_input", "Abandon the owning resource subscriptions.");
+            if (record.status === "deleted" || record.status === "abandoned")
+                return;
+            if (record.mode === "resource")
+                await this.options.runner.abandonResource(record, signal);
+            record.status = "abandoned";
+            await save();
+        });
+    }
+    run() {
+        if (this.shutdown.signal.aborted)
+            return Promise.resolve();
+        this.pending ??= this.runBatch()
+            .catch(() => {
+            this.options.logger?.warn({ errorCode: "trigger_cleanup_failed" }, "Trigger cleanup batch failed; pending work is retained");
+        })
+            .finally(() => {
+            this.pending = undefined;
+        });
+        return this.pending;
+    }
+    start() {
+        if (this.timer || this.pending || this.shutdown.signal.aborted)
+            return;
+        const tick = () => {
+            void this.run().finally(() => {
+                if (this.shutdown.signal.aborted)
+                    return;
+                this.timer = setTimeout(tick, 60_000);
+                this.timer.unref?.();
+            });
+        };
+        tick();
+    }
+    async close() {
+        this.shutdown.abort();
+        clearTimeout(this.timer);
+        await this.pending;
+    }
+    async runBatch() {
+        const deadline = Date.now() + 50_000;
+        const records = await this.options.store.listFlowTriggersForMaintenance(Date.now(), 10);
+        for (const candidate of records) {
+            if (this.shutdown.signal.aborted || Date.now() >= deadline)
+                return;
+            const signal = AbortSignal.any([
+                this.shutdown.signal,
+                AbortSignal.timeout(Math.max(1, Math.min(45_000, deadline - Date.now()))),
+            ]);
+            try {
+                await withSubscription(this.options.store, candidate.id, signal, async (record, save) => {
+                    if (record.status === "deleted" || record.status === "abandoned")
+                        return;
+                    const token = (await this.options.tokens.list()).find((token) => token.id === record.tokenId);
+                    const runtime = await this.options.runtimePolicy.get();
+                    const policy = this.options.deploymentPolicy.createSnapshot(runtime?.rules, token, runtime?.updatedAt);
+                    if (record.status === "active" &&
+                        token &&
+                        policy.evaluateTrigger(record.triggerId).allowed &&
+                        policy.evaluateConnection(record.connectionId).allowed) {
+                        await save();
+                        return;
+                    }
+                    record.status = "deleting";
+                    await save();
+                    try {
+                        await this.options.runner.cleanup(record, save, signal);
+                    }
+                    catch (error) {
+                        if (!signal.aborted)
+                            await save();
+                        throw error;
+                    }
+                });
+            }
+            catch {
+                this.options.logger?.warn({ subscriptionId: candidate.id, errorCode: "trigger_cleanup_failed" }, "Trigger subscription cleanup failed; pending work is retained");
+            }
+        }
+    }
+}

package/src/triggers/metadata.d.ts

@@ -0,0 +1,8 @@
+export interface TriggerPermission {
+    id: string;
+    name: string;
+    description: string;
+    providerPermissions: readonly string[];
+    instructions?: string;
+    providerScopeAlternatives?: readonly string[];
+}

package/src/triggers/metadata.js

@@ -0,0 +1 @@
+export {};

package/src/triggers/request.d.ts

@@ -0,0 +1,33 @@
+import type { JsonValue } from "./common/types.ts";
+interface ConfigRequest {
+    config: Readonly<Record<string, JsonValue>>;
+}
+export type TriggerRequest = (ConfigRequest & {
+    operation: "options";
+    field: string;
+}) | (ConfigRequest & {
+    operation: "read";
+    checkpoint: JsonValue;
+}) | (ConfigRequest & {
+    operation: "reconcile";
+    subscriptionId?: string;
+    requestKey: string;
+    endpointUrl: string;
+    active: boolean;
+}) | {
+    operation: "receive";
+    subscriptionId: string;
+    method: "GET" | "POST" | "HEAD" | "PUT" | "PATCH" | "DELETE";
+    headers: Record<string, string>;
+    query: Record<string, string>;
+    rawBody: string;
+    admit: boolean;
+    current: boolean;
+} | (ConfigRequest & {
+    operation: "resource";
+    requestKey: string;
+    active: boolean;
+});
+export declare function readTriggerRequest(value: unknown): TriggerRequest;
+export declare function triggerOperationSchema(): Record<string, unknown>;
+export {};

package/src/triggers/request.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { HttpRequestError } from "../server/api/http-utils.js";
+const config = z.record(z.string(), z.json());
+const subscriptionId = z.string().min(1).max(128);
+const requestKey = z.string().min(1).max(512);
+const requestSchema = z.discriminatedUnion("operation", [
+    z.strictObject({ operation: z.literal("options"), config, field: z.string().min(1).max(128) }),
+    z.strictObject({ operation: z.literal("read"), config, checkpoint: z.json() }),
+    z.strictObject({
+        operation: z.literal("reconcile"),
+        config,
+        subscriptionId: subscriptionId.optional(),
+        requestKey,
+        endpointUrl: z.url().max(4096),
+        active: z.boolean(),
+    }),
+    z.strictObject({
+        operation: z.literal("receive"),
+        subscriptionId,
+        method: z.enum(["GET", "POST", "HEAD", "PUT", "PATCH", "DELETE"]),
+        headers: z.record(z.string(), z.string().max(8192)),
+        query: z.record(z.string(), z.string().max(8192)),
+        rawBody: z
+            .string()
+            .max(90000)
+            .regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/),
+        admit: z.boolean(),
+        current: z.boolean(),
+    }),
+    z.strictObject({ operation: z.literal("resource"), config, requestKey, active: z.boolean() }),
+]);
+export function readTriggerRequest(value) {
+    const result = requestSchema.safeParse(value);
+    if (!result.success)
+        throw new HttpRequestError("invalid_input", "Invalid Trigger operation input.");
+    if (result.data.operation === "read" && Buffer.byteLength(JSON.stringify(result.data.checkpoint)) > 65536)
+        throw new HttpRequestError("invalid_input", "Trigger checkpoint exceeds 64 KiB.");
+    if (result.data.operation === "receive") {
+        const headers = {};
+        for (const [key, value] of Object.entries(result.data.headers)) {
+            const name = key.toLowerCase();
+            if (name in headers)
+                throw new HttpRequestError("invalid_input", "Duplicate webhook header.");
+            headers[name] = value;
+        }
+        result.data.headers = headers;
+    }
+    return result.data;
+}
+export function triggerOperationSchema() {
+    return z.toJSONSchema(requestSchema);
+}

package/src/triggers/resources.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationReconcileResult, ResourceDefinition } from "./common/integration.ts";
+import type { ConnectorProxy } from "./common/proxy.ts";
+import type { TriggerRequest } from "./request.ts";
+import type { TriggerSubscription, TriggerStore } from "./store.ts";
+import type { SubscriptionOwner } from "./subscriptions.ts";
+export declare function executeResourceSubscription(store: TriggerStore, definition: ResourceDefinition, owner: SubscriptionOwner, input: Extract<TriggerRequest, {
+    operation: "resource";
+}>, proxy: ConnectorProxy, signal: AbortSignal): Promise<IntegrationReconcileResult>;
+export declare function executeResourceSubscriptionOperation(store: TriggerStore, definition: ResourceDefinition, consumer: TriggerSubscription, saveConsumer: () => Promise<void>, input: Extract<TriggerRequest, {
+    operation: "resource";
+}>, proxy: ConnectorProxy, signal: AbortSignal): Promise<IntegrationReconcileResult>;
+export declare function abandonResourceSubscription(store: TriggerStore, definition: ResourceDefinition, consumer: TriggerSubscription, signal: AbortSignal): Promise<void>;