@automate.ax/catalog 0.55.0

package/dist/triggers/brevo.js

@@ -0,0 +1,65 @@
+import { brevoService } from "../catalog.js";
+const BREVO_ACCOUNT = {
+    connectionOptions: [
+        {
+            requiredScopes: [],
+        },
+    ],
+    serviceId: brevoService.id,
+};
+export const brevoTriggerDefinitions = {
+    brevoTransactionalBlocked: {
+        account: BREVO_ACCOUNT,
+        name: "Brevo email blocked",
+        type: "brevo.transactional.blocked",
+    },
+    brevoTransactionalClicked: {
+        account: BREVO_ACCOUNT,
+        name: "Brevo email clicked",
+        type: "brevo.transactional.clicked",
+    },
+    brevoTransactionalDeferred: {
+        account: BREVO_ACCOUNT,
+        name: "Brevo email deferred",
+        type: "brevo.transactional.deferred",
+    },
+    brevoTransactionalDelivered: {
+        account: BREVO_ACCOUNT,
+        name: "Brevo email delivered",
+        type: "brevo.transactional.delivered",
+    },
+    brevoTransactionalEvent: {
+        account: BREVO_ACCOUNT,
+        type: "brevo.transactional.event",
+    },
+    brevoTransactionalHardBounced: {
+        account: BREVO_ACCOUNT,
+        name: "Brevo email hard bounced",
+        type: "brevo.transactional.hardBounced",
+    },
+    brevoTransactionalMarkedAsSpam: {
+        account: BREVO_ACCOUNT,
+        name: "Brevo email marked as spam",
+        type: "brevo.transactional.markedAsSpam",
+    },
+    brevoTransactionalOpened: {
+        account: BREVO_ACCOUNT,
+        name: "Brevo email opened",
+        type: "brevo.transactional.opened",
+    },
+    brevoTransactionalSent: {
+        account: BREVO_ACCOUNT,
+        name: "Brevo email sent",
+        type: "brevo.transactional.sent",
+    },
+    brevoTransactionalSoftBounced: {
+        account: BREVO_ACCOUNT,
+        name: "Brevo email soft bounced",
+        type: "brevo.transactional.softBounced",
+    },
+    brevoTransactionalUnsubscribed: {
+        account: BREVO_ACCOUNT,
+        name: "Brevo email unsubscribed",
+        type: "brevo.transactional.unsubscribed",
+    },
+};

package/dist/triggers/core.d.ts

@@ -0,0 +1,50 @@
+export declare const coreTriggerDefinitions: {
+    readonly automationInvoked: {
+        readonly getDetails: ({ config }: import("..").TriggerPresentationContext) => {
+            label: string;
+            value: string;
+        }[];
+        readonly icon: "automation";
+        readonly name: "Invocation";
+        readonly type: "automation.invoked";
+    };
+    readonly cronTick: {
+        readonly getDetails: ({ config }: import("..").TriggerPresentationContext) => {
+            label: string;
+            value: string;
+        }[];
+        readonly icon: "schedule";
+        readonly name: "Cron schedule";
+        readonly type: "cron.tick";
+    };
+    readonly httpRequest: {
+        readonly getDetails: ({ appOrigin, automationId, config, hookSlot, projectId }: import("..").TriggerPresentationContext) => {
+            copyable: true;
+            label: string;
+            value: string;
+        }[];
+        readonly icon: "webhook";
+        readonly name: "HTTP request";
+        readonly type: "http.request";
+    };
+};
+export type HttpTriggerScope = "trigger" | "automation" | "project";
+export interface HttpTriggerEndpointOptions {
+    appOrigin: string;
+    automationId: string;
+    hookSlot: number;
+    projectId: string;
+    scope: HttpTriggerScope;
+}
+/**
+ * Returns the public URL for one deployed HTTP trigger.
+ *
+ * @param options - Public origin and trigger identity.
+ */
+export declare function getHttpTriggerEndpoint(options: HttpTriggerEndpointOptions): string;
+/**
+ * Returns the durable endpoint identity for one configured HTTP scope.
+ *
+ * @param options - Trigger and owning resource identity.
+ */
+export declare function getHttpTriggerEndpointKey(options: Omit<HttpTriggerEndpointOptions, "appOrigin">): string;

package/dist/triggers/core.js

@@ -0,0 +1,74 @@
+import * as z from "zod/mini";
+const CRON_PRESENTATION_CONFIG_SCHEMA = z.object({
+    schedule: z.string(),
+    timeZone: z.prefault(z.string(), "UTC"),
+});
+const HTTP_PRESENTATION_CONFIG_SCHEMA = z.object({
+    scope: z.prefault(z.enum(["trigger", "automation", "project"]), "trigger"),
+});
+const INVOCATION_PRESENTATION_CONFIG_SCHEMA = z.object({
+    entrypoint: z.string(),
+});
+export const coreTriggerDefinitions = {
+    automationInvoked: {
+        getDetails: ({ config }) => [
+            {
+                label: "Entrypoint",
+                value: INVOCATION_PRESENTATION_CONFIG_SCHEMA.parse(config).entrypoint,
+            },
+        ],
+        icon: "automation",
+        name: "Invocation",
+        type: "automation.invoked",
+    },
+    cronTick: {
+        getDetails: ({ config }) => {
+            const parsedConfig = CRON_PRESENTATION_CONFIG_SCHEMA.parse(config);
+            return [
+                { label: "Schedule", value: parsedConfig.schedule },
+                { label: "Time zone", value: parsedConfig.timeZone },
+            ];
+        },
+        icon: "schedule",
+        name: "Cron schedule",
+        type: "cron.tick",
+    },
+    httpRequest: {
+        getDetails: ({ appOrigin, automationId, config, hookSlot, projectId }) => [
+            {
+                copyable: true,
+                label: "URL",
+                value: getHttpTriggerEndpoint({
+                    appOrigin,
+                    automationId,
+                    hookSlot,
+                    projectId,
+                    scope: HTTP_PRESENTATION_CONFIG_SCHEMA.parse(config).scope,
+                }),
+            },
+        ],
+        icon: "webhook",
+        name: "HTTP request",
+        type: "http.request",
+    },
+};
+/**
+ * Returns the public URL for one deployed HTTP trigger.
+ *
+ * @param options - Public origin and trigger identity.
+ */
+export function getHttpTriggerEndpoint(options) {
+    return new URL(`/x/${getHttpTriggerEndpointKey(options)}/`, options.appOrigin).toString();
+}
+/**
+ * Returns the durable endpoint identity for one configured HTTP scope.
+ *
+ * @param options - Trigger and owning resource identity.
+ */
+export function getHttpTriggerEndpointKey(options) {
+    if (options.scope === "project")
+        return options.projectId;
+    if (options.scope === "automation")
+        return options.automationId;
+    return `${options.automationId}:${options.hookSlot}`;
+}

package/dist/triggers/github.d.ts

@@ -0,0 +1,228 @@
+export declare const githubTriggerDefinitions: {
+    readonly githubIssueClosed: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["issues:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.issue.closed";
+    };
+    readonly githubIssueEvent: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["issues:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.issue.event";
+    };
+    readonly githubIssueOpened: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["issues:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.issue.opened";
+    };
+    readonly githubIssueReopened: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["issues:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.issue.reopened";
+    };
+    readonly githubPullRequestClosed: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["pull_requests:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.pull-request.closed";
+    };
+    readonly githubPullRequestEvent: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["pull_requests:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.pull-request.event";
+    };
+    readonly githubPullRequestMerged: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["pull_requests:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.pull-request.merged";
+    };
+    readonly githubPullRequestOpened: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["pull_requests:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.pull-request.opened";
+    };
+    readonly githubPullRequestReadyForReview: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["pull_requests:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.pull-request.ready-for-review";
+    };
+    readonly githubPullRequestReviewApproved: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["pull_requests:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.pull-request-review.approved";
+    };
+    readonly githubPullRequestReviewChangesRequested: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["pull_requests:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly name: "GitHub pull request changes requested";
+        readonly type: "github.pull-request-review.changes-requested";
+    };
+    readonly githubPullRequestReviewDismissed: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["pull_requests:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.pull-request-review.dismissed";
+    };
+    readonly githubPullRequestReviewEvent: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["pull_requests:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.pull-request-review.event";
+    };
+    readonly githubPullRequestReviewSubmitted: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["pull_requests:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.pull-request-review.submitted";
+    };
+    readonly githubPullRequestSynchronized: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["pull_requests:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.pull-request.synchronized";
+    };
+    readonly githubPush: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["contents:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.push";
+    };
+    readonly githubReleaseEvent: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["contents:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.release.event";
+    };
+    readonly githubReleasePublished: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["contents:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.release.published";
+    };
+    readonly githubWorkflowRunCancelled: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["actions:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.workflow-run.cancelled";
+    };
+    readonly githubWorkflowRunCompleted: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["actions:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.workflow-run.completed";
+    };
+    readonly githubWorkflowRunEvent: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["actions:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.workflow-run.event";
+    };
+    readonly githubWorkflowRunFailed: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["actions:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.workflow-run.failed";
+    };
+    readonly githubWorkflowRunRequested: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["actions:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.workflow-run.requested";
+    };
+    readonly githubWorkflowRunStarted: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["actions:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.workflow-run.started";
+    };
+    readonly githubWorkflowRunSucceeded: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly ["actions:read"];
+            }];
+            readonly serviceId: "github";
+        };
+        readonly type: "github.workflow-run.succeeded";
+    };
+};

package/dist/triggers/github.js

@@ -0,0 +1,136 @@
+import { githubService } from "../catalog.js";
+const GITHUB_ISSUES_ACCOUNT = {
+    connectionOptions: [
+        {
+            requiredScopes: ["issues:read"],
+        },
+    ],
+    serviceId: githubService.id,
+};
+const GITHUB_PULL_REQUESTS_ACCOUNT = {
+    connectionOptions: [
+        {
+            requiredScopes: ["pull_requests:read"],
+        },
+    ],
+    serviceId: githubService.id,
+};
+const GITHUB_CONTENTS_ACCOUNT = {
+    connectionOptions: [
+        {
+            requiredScopes: ["contents:read"],
+        },
+    ],
+    serviceId: githubService.id,
+};
+const GITHUB_ACTIONS_ACCOUNT = {
+    connectionOptions: [
+        {
+            requiredScopes: ["actions:read"],
+        },
+    ],
+    serviceId: githubService.id,
+};
+export const githubTriggerDefinitions = {
+    githubIssueClosed: {
+        account: GITHUB_ISSUES_ACCOUNT,
+        type: "github.issue.closed",
+    },
+    githubIssueEvent: {
+        account: GITHUB_ISSUES_ACCOUNT,
+        type: "github.issue.event",
+    },
+    githubIssueOpened: {
+        account: GITHUB_ISSUES_ACCOUNT,
+        type: "github.issue.opened",
+    },
+    githubIssueReopened: {
+        account: GITHUB_ISSUES_ACCOUNT,
+        type: "github.issue.reopened",
+    },
+    githubPullRequestClosed: {
+        account: GITHUB_PULL_REQUESTS_ACCOUNT,
+        type: "github.pull-request.closed",
+    },
+    githubPullRequestEvent: {
+        account: GITHUB_PULL_REQUESTS_ACCOUNT,
+        type: "github.pull-request.event",
+    },
+    githubPullRequestMerged: {
+        account: GITHUB_PULL_REQUESTS_ACCOUNT,
+        type: "github.pull-request.merged",
+    },
+    githubPullRequestOpened: {
+        account: GITHUB_PULL_REQUESTS_ACCOUNT,
+        type: "github.pull-request.opened",
+    },
+    githubPullRequestReadyForReview: {
+        account: GITHUB_PULL_REQUESTS_ACCOUNT,
+        type: "github.pull-request.ready-for-review",
+    },
+    githubPullRequestReviewApproved: {
+        account: GITHUB_PULL_REQUESTS_ACCOUNT,
+        type: "github.pull-request-review.approved",
+    },
+    githubPullRequestReviewChangesRequested: {
+        account: GITHUB_PULL_REQUESTS_ACCOUNT,
+        name: "GitHub pull request changes requested",
+        type: "github.pull-request-review.changes-requested",
+    },
+    githubPullRequestReviewDismissed: {
+        account: GITHUB_PULL_REQUESTS_ACCOUNT,
+        type: "github.pull-request-review.dismissed",
+    },
+    githubPullRequestReviewEvent: {
+        account: GITHUB_PULL_REQUESTS_ACCOUNT,
+        type: "github.pull-request-review.event",
+    },
+    githubPullRequestReviewSubmitted: {
+        account: GITHUB_PULL_REQUESTS_ACCOUNT,
+        type: "github.pull-request-review.submitted",
+    },
+    githubPullRequestSynchronized: {
+        account: GITHUB_PULL_REQUESTS_ACCOUNT,
+        type: "github.pull-request.synchronized",
+    },
+    githubPush: {
+        account: GITHUB_CONTENTS_ACCOUNT,
+        type: "github.push",
+    },
+    githubReleaseEvent: {
+        account: GITHUB_CONTENTS_ACCOUNT,
+        type: "github.release.event",
+    },
+    githubReleasePublished: {
+        account: GITHUB_CONTENTS_ACCOUNT,
+        type: "github.release.published",
+    },
+    githubWorkflowRunCancelled: {
+        account: GITHUB_ACTIONS_ACCOUNT,
+        type: "github.workflow-run.cancelled",
+    },
+    githubWorkflowRunCompleted: {
+        account: GITHUB_ACTIONS_ACCOUNT,
+        type: "github.workflow-run.completed",
+    },
+    githubWorkflowRunEvent: {
+        account: GITHUB_ACTIONS_ACCOUNT,
+        type: "github.workflow-run.event",
+    },
+    githubWorkflowRunFailed: {
+        account: GITHUB_ACTIONS_ACCOUNT,
+        type: "github.workflow-run.failed",
+    },
+    githubWorkflowRunRequested: {
+        account: GITHUB_ACTIONS_ACCOUNT,
+        type: "github.workflow-run.requested",
+    },
+    githubWorkflowRunStarted: {
+        account: GITHUB_ACTIONS_ACCOUNT,
+        type: "github.workflow-run.started",
+    },
+    githubWorkflowRunSucceeded: {
+        account: GITHUB_ACTIONS_ACCOUNT,
+        type: "github.workflow-run.succeeded",
+    },
+};

package/dist/triggers/google.d.ts

@@ -0,0 +1,126 @@
+export declare const googleTriggerDefinitions: {
+    readonly gmailLabelAdded: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly [{
+                    readonly requirements: readonly ["https://mail.google.com/", "https://www.googleapis.com/auth/gmail.modify", "https://www.googleapis.com/auth/gmail.readonly"];
+                    readonly type: "or";
+                }];
+            }];
+            readonly serviceId: "google";
+        };
+        readonly type: "gmail.label.added";
+    };
+    readonly gmailLabelRemoved: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly [{
+                    readonly requirements: readonly ["https://mail.google.com/", "https://www.googleapis.com/auth/gmail.modify", "https://www.googleapis.com/auth/gmail.readonly"];
+                    readonly type: "or";
+                }];
+            }];
+            readonly serviceId: "google";
+        };
+        readonly type: "gmail.label.removed";
+    };
+    readonly gmailMessageReceived: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly [{
+                    readonly requirements: readonly ["https://mail.google.com/", "https://www.googleapis.com/auth/gmail.modify", "https://www.googleapis.com/auth/gmail.readonly"];
+                    readonly type: "or";
+                }];
+            }];
+            readonly serviceId: "google";
+        };
+        readonly name: "Gmail email received";
+        readonly type: "gmail.message.received";
+    };
+    readonly gmailMessageSent: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly [{
+                    readonly requirements: readonly ["https://mail.google.com/", "https://www.googleapis.com/auth/gmail.modify", "https://www.googleapis.com/auth/gmail.readonly"];
+                    readonly type: "or";
+                }];
+            }];
+            readonly serviceId: "google";
+        };
+        readonly name: "Gmail email sent";
+        readonly type: "gmail.message.sent";
+    };
+    readonly googleCalendarEventCreated: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly [{
+                    readonly requirements: readonly ["https://www.googleapis.com/auth/calendar", "https://www.googleapis.com/auth/calendar.readonly", "https://www.googleapis.com/auth/calendar.events", "https://www.googleapis.com/auth/calendar.events.readonly", "https://www.googleapis.com/auth/calendar.events.owned"];
+                    readonly type: "or";
+                }];
+            }];
+            readonly serviceId: "google";
+        };
+        readonly name: "Google Calendar event created";
+        readonly type: "googleCalendar.event.created";
+    };
+    readonly googleCalendarEventDeleted: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly [{
+                    readonly requirements: readonly ["https://www.googleapis.com/auth/calendar", "https://www.googleapis.com/auth/calendar.readonly", "https://www.googleapis.com/auth/calendar.events", "https://www.googleapis.com/auth/calendar.events.readonly", "https://www.googleapis.com/auth/calendar.events.owned"];
+                    readonly type: "or";
+                }];
+            }];
+            readonly serviceId: "google";
+        };
+        readonly name: "Google Calendar event deleted";
+        readonly type: "googleCalendar.event.deleted";
+    };
+    readonly googleCalendarEventUpdated: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly [{
+                    readonly requirements: readonly ["https://www.googleapis.com/auth/calendar", "https://www.googleapis.com/auth/calendar.readonly", "https://www.googleapis.com/auth/calendar.events", "https://www.googleapis.com/auth/calendar.events.readonly", "https://www.googleapis.com/auth/calendar.events.owned"];
+                    readonly type: "or";
+                }];
+            }];
+            readonly serviceId: "google";
+        };
+        readonly name: "Google Calendar event updated";
+        readonly type: "googleCalendar.event.updated";
+    };
+    readonly googleFormsFormChanged: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly [{
+                    readonly requirements: readonly ["https://www.googleapis.com/auth/drive", "https://www.googleapis.com/auth/drive.file", "https://www.googleapis.com/auth/drive.readonly", "https://www.googleapis.com/auth/forms.body", "https://www.googleapis.com/auth/forms.body.readonly"];
+                    readonly type: "or";
+                }];
+            }];
+            readonly serviceId: "google";
+        };
+        readonly name: "Google Form changed";
+        readonly type: "googleForms.form.changed";
+    };
+    readonly googleFormsResponseSubmitted: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly requiredScopes: readonly [{
+                    readonly requirements: readonly ["https://www.googleapis.com/auth/drive", "https://www.googleapis.com/auth/drive.file", "https://www.googleapis.com/auth/drive.readonly", "https://www.googleapis.com/auth/forms.body", "https://www.googleapis.com/auth/forms.body.readonly"];
+                    readonly type: "or";
+                }, {
+                    readonly requirements: readonly [{
+                        readonly requirements: readonly ["https://www.googleapis.com/auth/drive", "https://www.googleapis.com/auth/drive.file", "https://www.googleapis.com/auth/forms.responses.readonly"];
+                        readonly type: "or";
+                    }, {
+                        readonly requirements: readonly ["https://www.googleapis.com/auth/drive", "https://www.googleapis.com/auth/drive.file", "https://www.googleapis.com/auth/drive.readonly", "https://www.googleapis.com/auth/forms.body", "https://www.googleapis.com/auth/forms.body.readonly"];
+                        readonly type: "or";
+                    }];
+                    readonly type: "and";
+                }];
+            }];
+            readonly serviceId: "google";
+        };
+        readonly name: "Google Form response submitted";
+        readonly type: "googleForms.response.submitted";
+    };
+};