@oomol-lab/open-connector 1.6.5 → 1.8.0

package/src/providers/keepa/deal-attributes.d.ts

@@ -0,0 +1 @@
+export declare const keepaDealAttributeNames: readonly ["material", "type", "manufacturer", "brand", "model", "color", "size", "unitType", "scent", "itemForm", "pattern", "style", "itemTypeKeyword", "targetAudienceKeyword", "edition", "format", "author", "binding", "languages", "brandStoreName", "brandStoreUrlName", "websiteDisplayGroup", "websiteDisplayGroupName", "salesRankDisplayGroup"];

package/src/providers/keepa/deal-attributes.js

@@ -0,0 +1,26 @@
+export const keepaDealAttributeNames = [
+    "material",
+    "type",
+    "manufacturer",
+    "brand",
+    "model",
+    "color",
+    "size",
+    "unitType",
+    "scent",
+    "itemForm",
+    "pattern",
+    "style",
+    "itemTypeKeyword",
+    "targetAudienceKeyword",
+    "edition",
+    "format",
+    "author",
+    "binding",
+    "languages",
+    "brandStoreName",
+    "brandStoreUrlName",
+    "websiteDisplayGroup",
+    "websiteDisplayGroupName",
+    "salesRankDisplayGroup",
+];

package/src/providers/keepa/runtime.js

@@ -1,6 +1,7 @@
 import { compactObject, optionalRawString, optionalRecord, rawStringOrNull } from "../../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, ProviderRequestError, providerUserAgent, readProviderTextBody, requiredInputString, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, providerInputError, ProviderRequestError, providerUserAgent, readProviderTextBody, requiredInputString, } from "../provider-runtime.js";
 import { keepaDealPriceTypes as dealPriceTypes, keepaHistoryTypes as historyTypes } from "./actions.js";
+import { keepaDealAttributeNames } from "./deal-attributes.js";
 export const keepaApiBaseUrl = "https://api.keepa.com";
 const keepaTimeStartMinutes = 21_564_000;
 const keepaDefaultTimeoutMs = 120_000;
@@ -211,6 +212,137 @@ export const keepaActionHandlers = {
             meta: normalizeMeta(payload),
         };
     },
+    async search_products(input, context) {
+        const marketplace = requireMarketplace(input.marketplace);
+        const payload = await requestKeepaAction(context, {
+            path: "/search",
+            query: {
+                domain: marketplaceDomainIdByCode[marketplace],
+                type: "product",
+                term: requiredInputString(input.term, "term"),
+                ...(input.asinsOnly === true ? { "asins-only": 1 } : {}),
+                ...buildStatsQuery(input),
+                ...(typeof input.updateHours === "number" ? { update: input.updateHours } : {}),
+                ...(input.includeHistory === false ? { history: 0 } : {}),
+                ...(input.includeRating === true ? { rating: 1 } : {}),
+            },
+        });
+        const products = readObjectArray(payload.products).map(normalizeProductSnapshot);
+        return {
+            marketplace,
+            asins: input.asinsOnly === true ? readStringArray(payload.asinList) : products.map((product) => product.asin),
+            products,
+            meta: normalizeMeta(payload),
+        };
+    },
+    async lookup_categories(input, context) {
+        const marketplace = requireMarketplace(input.marketplace);
+        const categoryIds = readIntegerArray(input.categoryIds);
+        if (categoryIds.includes(0) && categoryIds.length !== 1) {
+            throw providerInputError("root category lookup must use categoryIds [0] alone");
+        }
+        const payload = await requestKeepaAction(context, {
+            path: "/category",
+            query: {
+                domain: marketplaceDomainIdByCode[marketplace],
+                category: categoryIds.join(","),
+                parents: input.includeParents === true ? 1 : 0,
+            },
+        });
+        return {
+            marketplace,
+            categories: objectMapValues(payload.categories),
+            categoryParents: objectMapValues(payload.categoryParents),
+            meta: normalizeMeta(payload),
+        };
+    },
+    async find_sellers(input, context) {
+        const marketplace = requireMarketplace(input.marketplace);
+        const filters = optionalRecord(input.filters);
+        if (!filters)
+            throw providerInputError("filters must be an object");
+        if (!Object.keys(filters).some((key) => !["page", "perPage", "sort", "minMatch"].includes(key))) {
+            throw providerInputError("Seller Finder requires at least one business filter");
+        }
+        const page = typeof filters.page === "number" ? filters.page : 0;
+        const perPage = filters.perPage === 0 ? 100 : typeof filters.perPage === "number" ? filters.perPage : 50;
+        if (page > 0 && page * perPage >= 10_000) {
+            throw providerInputError("Seller Finder page starts beyond the 10000-result limit");
+        }
+        const payload = await requestKeepaAction(context, {
+            path: "/sellerquery",
+            query: { domain: marketplaceDomainIdByCode[marketplace] },
+            body: filters,
+        });
+        return {
+            marketplace,
+            sellerIds: readStringArray(payload.sellerIdList),
+            totalResults: asNullableInteger(payload.totalResults),
+            meta: normalizeMeta(payload),
+        };
+    },
+    async get_most_rated_sellers(input, context) {
+        const marketplace = requireMarketplace(input.marketplace);
+        const payload = await requestKeepaAction(context, {
+            path: "/topseller",
+            query: { domain: marketplaceDomainIdByCode[marketplace] },
+        });
+        const window = windowList(readStringArray(payload.sellerIdList), input);
+        return { marketplace, sellerIds: window.items, ...window.info, meta: normalizeMeta(payload) };
+    },
+    async get_seller_storefront(input, context) {
+        const marketplace = requireMarketplace(input.marketplace);
+        const sellerId = requiredInputString(input.sellerId, "sellerId");
+        const payload = await requestKeepaAction(context, {
+            path: "/seller",
+            query: { domain: marketplaceDomainIdByCode[marketplace], seller: sellerId, storefront: 1 },
+        });
+        const seller = optionalRecord(optionalRecord(payload.sellers)?.[sellerId]);
+        const asins = readStringArray(seller?.asinList);
+        const lastSeen = Array.isArray(seller?.asinListLastSeen) ? seller.asinListLastSeen : [];
+        const window = windowList(asins.map((asin, index) => ({ asin, lastSeen: asNullableInteger(lastSeen[index]) })), input);
+        const { asinList: _asinList, asinListLastSeen: _asinListLastSeen, ...sellerWithoutList } = seller ?? {};
+        return {
+            marketplace,
+            seller: seller ? normalizeSeller(sellerId, sellerWithoutList) : null,
+            items: window.items,
+            ...window.info,
+            meta: normalizeMeta(payload),
+        };
+    },
+    async get_lightning_deal(input, context) {
+        const marketplace = requireMarketplace(input.marketplace);
+        const payload = await requestKeepaAction(context, {
+            path: "/lightningdeal",
+            query: {
+                domain: marketplaceDomainIdByCode[marketplace],
+                asin: requiredInputString(input.asin, "asin"),
+                ...(typeof input.state === "string" ? { state: input.state } : {}),
+            },
+        });
+        return {
+            marketplace,
+            lightningDeals: readObjectArray(payload.lightningDeals),
+            meta: normalizeMeta(payload),
+        };
+    },
+    async list_lightning_deals(input, context) {
+        const marketplace = requireMarketplace(input.marketplace);
+        const payload = await requestKeepaAction(context, {
+            path: "/lightningdeal",
+            query: {
+                domain: marketplaceDomainIdByCode[marketplace],
+                ...(typeof input.state === "string" ? { state: input.state } : {}),
+            },
+        });
+        const window = windowList(readObjectArray(payload.lightningDeals), input);
+        return {
+            marketplace,
+            lightningDeals: window.items,
+            ...window.info,
+            meta: normalizeMeta(payload),
+        };
+    },
 };
 export async function validateKeepaCredential(apiKey, fetcher, signal) {
     const payload = await requestKeepa({
@@ -232,39 +364,80 @@ export async function validateKeepaCredential(apiKey, fetcher, signal) {
         },
     };
 }
+function requestKeepaAction(context, input) {
+    return requestKeepa({ ...input, context, phase: "execute" });
+}
 function buildProductQuery(input, marketplace, history) {
-    const asins = readAsinArray(input.asins);
-    assertProductRequestRules(input, asins);
+    const asins = input.asins === undefined ? [] : readAsinArray(input.asins);
+    const codes = readStringArray(input.codes).map((code) => code.trim());
+    if ((asins.length === 0) === (codes.length === 0)) {
+        throw providerInputError("provide either asins or codes");
+    }
+    const itemCount = asins.length || codes.length;
+    if (typeof input.offers === "number" && itemCount > 20) {
+        throw providerInputError("offers can only be requested for up to 20 ASINs or product codes");
+    }
+    if (input.codeLimit !== undefined && codes.length === 0) {
+        throw providerInputError("codeLimit requires codes");
+    }
+    if (input.onlyLiveOffers === true && typeof input.offers !== "number") {
+        throw providerInputError("onlyLiveOffers requires offers");
+    }
+    if (input.includeStock === true && typeof input.offers !== "number") {
+        throw providerInputError("includeStock requires offers");
+    }
     return {
-        asin: asins.join(","),
+        ...(asins.length > 0 ? { asin: asins.join(",") } : { code: codes.join(",") }),
         domain: marketplaceDomainIdByCode[marketplace],
         history: history ? 1 : 0,
-        ...(typeof input.statsDays === "number" ? { stats: input.statsDays } : {}),
+        ...buildStatsQuery(input),
+        ...(typeof input.codeLimit === "number" ? { "code-limit": input.codeLimit } : {}),
         ...(typeof input.updateHours === "number" ? { update: input.updateHours } : {}),
         ...(typeof input.offers === "number" ? { offers: input.offers } : {}),
         ...(input.onlyLiveOffers === true ? { "only-live-offers": 1 } : {}),
         ...(input.includeBuyBox === true ? { buybox: 1 } : {}),
         ...(input.includeRating === true ? { rating: 1 } : {}),
+        ...(input.includeVideos === true ? { videos: 1 } : {}),
+        ...(input.includeAPlus === true ? { aplus: 1 } : {}),
+        ...(input.includeStock === true ? { stock: 1 } : {}),
+        ...(input.includeHistoricalVariations === true ? { "historical-variations": 1 } : {}),
     };
 }
+function buildStatsQuery(input) {
+    const range = optionalRecord(input.statsRange);
+    if (input.statsDays !== undefined && range) {
+        throw providerInputError("statsDays and statsRange are mutually exclusive");
+    }
+    if (range) {
+        const start = typeof range.start === "number" ? range.start : Date.parse(String(range.start));
+        const end = typeof range.end === "number" ? range.end : Date.parse(String(range.end));
+        if (typeof range.start !== typeof range.end || start >= end) {
+            throw providerInputError("statsRange requires matching types and start before end");
+        }
+        return { stats: `${range.start},${range.end}` };
+    }
+    return typeof input.statsDays === "number" ? { stats: input.statsDays } : {};
+}
 function buildDealRequest(input, marketplace, priceType) {
     const metricDefinition = keepaMetricByType.get(priceType);
     if (!metricDefinition) {
-        throw new ProviderRequestError(400, `unsupported deal price type: ${priceType}`);
+        throw providerInputError(`unsupported deal price type: ${priceType}`);
     }
     const sortName = typeof input.sortBy === "string" && input.sortBy in dealSortTypeByName
         ? input.sortBy
         : "newest";
     const sortType = dealSortTypeByName[sortName];
     if (sortType === 1 && input.invertSort === true) {
-        throw new ProviderRequestError(400, "newest deal sorting cannot be inverted");
+        throw providerInputError("newest deal sorting cannot be inverted");
     }
     const ranges = {
         currentRange: readOptionalIntegerArray(input.currentRange),
         deltaRange: readOptionalIntegerArray(input.deltaRange),
         deltaPercentRange: readOptionalIntegerArray(input.deltaPercentRange),
+        deltaLastRange: readOptionalIntegerArray(input.deltaLastRange),
         salesRankRange: readOptionalIntegerArray(input.salesRankRange),
     };
+    const attributes = Object.fromEntries(keepaDealAttributeNames.map((name) => [name, readOptionalStringArray(input[name])]));
     return compactObject({
         page: typeof input.page === "number" ? input.page : 0,
         domainId: marketplaceDomainIdByCode[marketplace],
@@ -274,13 +447,17 @@ function buildDealRequest(input, marketplace, priceType) {
         isLowest: input.isLowestEver === true,
         isLowest90: input.isLowest90Days === true,
         isLowestOffer: input.isLowestOffer === true,
+        isHighest: input.isHighest === true,
         isBackInStock: input.isBackInStock === true,
         isOutOfStock: input.isOutOfStock === true,
         hasReviews: input.hasReviews === true,
         isPrimeExclusive: input.isPrimeExclusive === true,
         mustHaveAmazonOffer: input.mustHaveAmazonOffer === true,
         mustNotHaveAmazonOffer: input.mustNotHaveAmazonOffer === true,
-        filterErotic: true,
+        filterErotic: typeof input.filterErotic === "boolean" ? input.filterErotic : undefined,
+        singleVariation: input.singleVariation === true,
+        isRisers: input.isRisers === true,
+        warehouseConditions: readOptionalIntegerArray(input.warehouseConditions),
         isRangeEnabled: Object.values(ranges).some((value) => value !== undefined),
         isFilterEnabled: [
             input.isLowestEver,
@@ -292,16 +469,38 @@ function buildDealRequest(input, marketplace, priceType) {
             input.isPrimeExclusive,
             input.mustHaveAmazonOffer,
             input.mustNotHaveAmazonOffer,
+            input.isHighest,
+            input.singleVariation,
+            input.isRisers,
+            input.warehouseConditions,
             input.minimumRating,
             input.titleSearch,
-        ].some((value) => value !== undefined && value !== false),
+            ...Object.values(attributes),
+        ].some((value) => value !== undefined && value !== false) || input.filterErotic !== undefined,
         includeCategories: readOptionalIntegerArray(input.includeCategories),
         excludeCategories: readOptionalIntegerArray(input.excludeCategories),
-        titleSearch: optionalRawString(input.titleSearch),
+        titleSearch: typeof input.titleSearch === "string" ? input.titleSearch : undefined,
         minRating: typeof input.minimumRating === "number" ? input.minimumRating : undefined,
         ...ranges,
+        ...attributes,
     });
 }
+function windowList(items, input) {
+    const offset = typeof input.offset === "number" ? input.offset : 0;
+    const limit = input.limit === null ? null : typeof input.limit === "number" ? input.limit : 100;
+    const result = items.slice(offset, limit === null ? undefined : offset + limit);
+    const next = offset + result.length;
+    const hasMore = next < items.length;
+    return {
+        items: result,
+        info: {
+            totalAvailable: items.length,
+            returnedCount: result.length,
+            hasMore,
+            nextOffset: hasMore ? next : null,
+        },
+    };
+}
 async function requestKeepa(input) {
     const url = new URL(input.path, keepaApiBaseUrl);
     url.searchParams.set("key", input.context.apiKey);
@@ -617,14 +816,6 @@ function validateCategorySearchTerm(term) {
         throw new ProviderRequestError(400, "each category search keyword must contain at least three characters");
     }
 }
-function assertProductRequestRules(input, asins) {
-    if (typeof input.offers === "number" && asins.length > 20) {
-        throw new ProviderRequestError(400, "offers can only be requested for up to 20 ASINs");
-    }
-    if (input.onlyLiveOffers === true && typeof input.offers !== "number") {
-        throw new ProviderRequestError(400, "onlyLiveOffers requires offers");
-    }
-}
 function requireInputObject(value, fieldName) {
     const object = optionalRecord(value);
     if (!object) {
@@ -683,6 +874,9 @@ function readIntegerArray(value) {
 function readOptionalIntegerArray(value) {
     return Array.isArray(value) ? readIntegerArray(value) : undefined;
 }
+function readOptionalStringArray(value) {
+    return Array.isArray(value) ? readStringArray(value) : undefined;
+}
 function objectMapValues(value) {
     const object = optionalRecord(value);
     if (!object) {

package/src/providers/kingdee/executors.js

@@ -26,7 +26,7 @@ export const proxy = defineProviderProxy({
     allowedEndpoint: isBusinessEndpoint,
     allowPrivateNetwork: isPrivateNetworkAccessAllowed,
     sensitiveHeaders: ["kdservice-sessionid"],
-    redirect: "error",
+    redirect: "manual",
     async customizeRequest({ context, fetcher, headers }) {
         const values = (await requireCustomCredential(context, service)).values;
         const kingdee = readCredential(values);

package/src/providers/kingdee/runtime.js

@@ -57,7 +57,7 @@ export async function login(credential, fetcher, parentSignal) {
     return runProviderRequest({ label: "Kingdee login", signal: parentSignal }, async (signal) => {
         const response = await fetcher(new URL("Kingdee.BOS.WebApi.ServicesStub.AuthService.LoginByAppSecret.common.kdsvc", credential.baseUrl), {
             method: "POST",
-            redirect: "error",
+            redirect: "manual",
             signal,
             headers: { "content-type": "application/json", accept: "application/json" },
             body: JSON.stringify({
@@ -111,7 +111,7 @@ async function execute(action, input, context) {
         const response = await context.fetcher(new URL(`Kingdee.BOS.WebApi.ServicesStub.DynamicFormService.${kingdeeMethods[action]}.common.kdsvc`, context.credential.baseUrl), {
             method: "POST",
             signal,
-            redirect: "error",
+            redirect: "manual",
             headers: { "content-type": "application/json", "kdservice-sessionid": sessionId },
             body: JSON.stringify(body),
         });

package/src/providers/kuaidi100/runtime.js

@@ -150,7 +150,7 @@ function withKuaidi100Client(context, phase, run) {
         transport: "streamable_http",
         fetcher: context.fetcher,
         headers: { responseFormat: "json", "user-agent": providerUserAgent },
-        redirect: "error",
+        redirect: "manual",
         signal: context.signal,
         mapError: (error) => mapKuaidi100McpError(error, phase),
     }, run);

package/src/providers/linear/executors.d.ts

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { PollDefinition } from "../../triggers/common/poll.ts";
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
 interface LinearActionContext {
     authorization: string;
@@ -10,4 +12,5 @@ export declare const executors: ProviderExecutors;
 export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
 export declare function fetchLinearViewer(authorization: string, fetcher: typeof fetch): Promise<Record<string, unknown>>;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];
 export {};

package/src/providers/linear/executors.js

@@ -1,5 +1,6 @@
 import { compactObject, optionalBoolean } from "../../core/cast.js";
-import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, toProviderProxyError, } from "../provider-runtime.js";
+import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, toProviderProxyError, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { linearIssueChanged } from "./trigger-on-issue-changed.js";
 const linearApiBaseUrl = "https://api.linear.app";
 const linearGraphqlUrl = "https://api.linear.app/graphql";
 const linearFetch = createProviderFetch({ skipDnsValidation: true });
@@ -697,8 +698,8 @@ export const linearActionHandlers = {
     async list_linear_issues(input, context) {
         const assigneeId = await resolveAssigneeFilterId(context, getOptionalString(input.assignee_id));
         const payload = await linearGraphqlOperation(context, `
-        query ListLinearIssues($after: String, $first: Int, $filter: IssueFilter) {
-          issues(after: $after, first: $first, includeArchived: false, filter: $filter) {
+        query ListLinearIssues($after: String, $first: Int, $filter: IssueFilter, $includeArchived: Boolean, $orderBy: PaginationOrderBy) {
+          issues(after: $after, first: $first, includeArchived: $includeArchived, filter: $filter, orderBy: $orderBy) {
             nodes {
               ${issueFields}
             }
@@ -710,7 +711,9 @@ export const linearActionHandlers = {
       `, {
             after: getOptionalString(input.after),
             first: getOptionalNumber(input.first),
-            filter: buildIssuesFilter(getOptionalString(input.project_id), assigneeId),
+            filter: buildIssuesFilter(getOptionalString(input.project_id), assigneeId, getOptionalString(input.updated_after)),
+            includeArchived: optionalBoolean(input.include_archived) ?? false,
+            orderBy: getOptionalString(input.order_by),
         });
         return {
             issues: (payload.issues?.nodes ?? []).map(mapIssueSummary),
@@ -1051,7 +1054,7 @@ export const proxy = async (input, context) => {
         const response = await linearFetch(url, init);
         if (!response.ok) {
             const text = await readProviderProxyErrorMessage(response, "");
-            throw new ProviderRequestError(response.status, text || `linear request failed with HTTP ${response.status}`);
+            throw new ProviderRequestError(response.status, text || `linear request failed with HTTP ${response.status}`, withRetryAfterSeconds(response));
         }
         return { ok: true, response: await readProviderProxyResponse(response) };
     }
@@ -1117,7 +1120,7 @@ async function linearGraphqlRequest(authorization, fetcher, query, variables) {
     });
     const body = await readJson(response);
     if (!response.ok) {
-        throwLinearHttpError(response.status, body);
+        throwLinearHttpError(response.status, body, withRetryAfterSeconds(response));
     }
     return body;
 }
@@ -1454,10 +1457,11 @@ async function resolveAssigneeFilterId(context, assigneeId) {
     const viewer = await fetchLinearViewer(context.authorization, context.fetcher);
     return String(viewer.id);
 }
-function buildIssuesFilter(projectId, assigneeId) {
+function buildIssuesFilter(projectId, assigneeId, updatedAfter) {
     const filter = compactObject({
         project: projectId ? { id: { eq: projectId } } : undefined,
         assignee: assigneeId ? { id: { eq: assigneeId } } : undefined,
+        updatedAt: updatedAfter ? { gte: updatedAfter } : undefined,
     });
     return Object.keys(filter).length > 0 ? filter : undefined;
 }
@@ -1800,7 +1804,7 @@ async function readJson(response) {
         };
     }
 }
-function throwLinearHttpError(status, body) {
+function throwLinearHttpError(status, body, details) {
     const message = extractErrorMessage(body);
     if (status === 400) {
         throw new ProviderRequestError(400, message);
@@ -1809,7 +1813,7 @@ function throwLinearHttpError(status, body) {
         throw new ProviderRequestError(401, message);
     }
     if (status === 429) {
-        throw new ProviderRequestError(429, message);
+        throw new ProviderRequestError(429, message, details);
     }
     throw new ProviderRequestError(502, message, status >= 500 ? 500 : status);
 }
@@ -1901,3 +1905,4 @@ function asOptionalObject(value) {
     }
     return value;
 }
+export const triggers = [linearIssueChanged];

package/src/providers/linear/trigger-on-issue-changed.d.ts

@@ -0,0 +1,2 @@
+import type { PollDefinition } from "../../triggers/common/poll.ts";
+export declare const linearIssueChanged: PollDefinition;

package/src/providers/linear/trigger-on-issue-changed.definition.d.ts

@@ -0,0 +1,5 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const uuidPattern: string;
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "poll";
+};

package/src/providers/linear/trigger-on-issue-changed.definition.js

@@ -0,0 +1,43 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+export const uuidPattern = "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$";
+const issueSchema = s.object({
+    id: s.string(),
+    identifier: s.string(),
+    title: s.string(),
+    url: s.string(),
+    teamId: s.string(),
+    createdAt: s.string(),
+    updatedAt: s.string(),
+    state: s.object({ id: s.string(), name: s.string(), type: s.string() }, { additionalProperties: false, required: ["id", "name", "type"] }),
+}, {
+    additionalProperties: false,
+    required: ["id", "identifier", "title", "url", "teamId", "createdAt", "updatedAt", "state"],
+});
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "teamId",
+            jsonSchema: { ...s.string({ pattern: uuidPattern }), title: "Team ID" },
+            nullable: false,
+            description: "Linear Team UUID. Use Copy model UUID in Linear to find it.",
+        },
+        {
+            handle: "stateIds",
+            jsonSchema: {
+                ...s.array(s.string({ pattern: uuidPattern }), { uniqueItems: true, maxItems: 50 }),
+                title: "Issue statuses",
+            },
+            nullable: false,
+            value: [],
+            description: "Choose statuses from the selected Team. Empty means all statuses. Matches the current status, not every transition into it.",
+        },
+    ],
+    definitionVersion: 2,
+    description: "Watches new and updated issues in a Linear team with periodic checks. Starts from now without running existing issues. Reports observed current states, not deletions or every intermediate status change.",
+    displayName: "Issue Created or Updated",
+    key: "linear.on_issue_changed",
+    name: "on_issue_changed",
+    outputs: [{ handle: "events", jsonSchema: s.array(issueSchema), nullable: false }],
+    provider: "linear",
+    type: "poll",
+};