@slates/provider 1.0.0-rc.34 → 1.0.0-rc.35

package/dist/index.d.ts

@@ -535,6 +535,40 @@ declare let runWithContext: <InputType extends {}, RV>(context: SlatePublicConte
 declare let getCurrentContext: <ConfigType extends {}, AuthType extends {}, InputType extends {}>() => SlateContext<ConfigType, AuthType, InputType>;
 declare let getRuntimeInfo: () => Readonly<SlateRuntimeInfo> | null;
 
+interface SlateOption {
+    value: string | number;
+    label: string;
+    description?: string;
+}
+interface SlateOptionListPage {
+    options: SlateOption[];
+    nextPageToken?: any | null;
+}
+type SlateOptionListHandler<ConfigType extends {}, AuthType extends {}, ParamsType extends {} = {}> = (context: SlateContext<ConfigType, AuthType, {
+    query: string | null;
+    pageToken: any | null;
+    params: ParamsType;
+}>) => Promise<SlateOptionListPage>;
+interface SlateOptionListParameters<ConfigType extends {}, AuthType extends {}, ParamsSchema extends z$1.ZodObject<any> = z$1.ZodObject<{}>> {
+    key: string;
+    /** Made strict when declared, so params with a key the schema does not name are rejected. */
+    paramsSchema?: ParamsSchema;
+    list: SlateOptionListHandler<ConfigType, AuthType, z$1.output<ParamsSchema>>;
+}
+/** A list of options other integrations can link their selection fields to. */
+declare class SlateOptionList<ConfigType extends {}, AuthType extends {}, ParamsSchema extends z$1.ZodObject<any> = z$1.ZodObject<{}>> {
+    private readonly _spec;
+    private readonly _params;
+    private readonly _paramsSchema;
+    private constructor();
+    static create<ConfigType extends {}, AuthType extends {}, ParamsSchema extends z$1.ZodObject<any> = z$1.ZodObject<{}>>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateOptionListParameters<ConfigType, AuthType, ParamsSchema>): SlateOptionList<ConfigType, AuthType, ParamsSchema>;
+    get spec(): SlateSpecification<ConfigType, AuthType>;
+    get key(): string;
+    get paramsSchema(): z$1.ZodObject<any, z$1.core.$strip>;
+    get list(): SlateOptionListHandler<ConfigType, AuthType, z$1.core.output<ParamsSchema>>;
+}
+declare let optionList: <ConfigType extends {}, AuthType extends {}, ParamsSchema extends z$1.ZodObject<any> = z$1.ZodObject<{}>>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateOptionListParameters<ConfigType, AuthType, ParamsSchema>) => SlateOptionList<ConfigType, AuthType, ParamsSchema>;
+
 declare let SlateDefaultPollingIntervalSeconds: number;
 type SlateTriggerRoutingMatcher = Record<string, any>;
 type SlateTriggerGroupSelection = Record<string, any>;
@@ -548,6 +582,23 @@ interface SlateWebhookTarget {
     targetOwnership: SlateWebhookTargetOwnership;
 }
 type SlateTriggerGroupRoutingMatchersHandler<ConfigType extends {}, AuthType extends {}> = (context: SlateContext<ConfigType, AuthType, {}>) => Promise<SlateTriggerRoutingMatcher[]>;
+/** Lists the values an account can pick for one selection field. `selection` holds what is entered so far and may be incomplete. */
+type SlateTriggerGroupSelectionOptionsHandler<ConfigType extends {}, AuthType extends {}> = (context: SlateContext<ConfigType, AuthType, {
+    query: string | null;
+    pageToken: any | null;
+    selection: SlateTriggerGroupSelection;
+}>) => Promise<SlateOptionListPage>;
+/** An option list exported by another integration, run with that integration's connection for the same account. */
+interface SlateLinkedOptionList {
+    /** Registry name of the integration, as `<scope>/<name>`. */
+    slate: string;
+    optionList: string;
+    params?: Record<string, any>;
+}
+interface SlateTriggerGroupSelectionOptionsSources<ConfigType extends {}, AuthType extends {}> {
+    list?: SlateTriggerGroupSelectionOptionsHandler<ConfigType, AuthType>;
+    linked?: SlateLinkedOptionList;
+}
 type SlateTriggerGroupPollHandler<ConfigType extends {}, AuthType extends {}> = (context: SlateContext<ConfigType, AuthType, {
     state: any | null;
     selection?: SlateTriggerGroupSelection;
@@ -736,6 +787,7 @@ interface SlateTriggerGroupParameters<ConfigType extends {}, AuthType extends {}
     webhook?: SlateTriggerGroupWebhookParameters<ConfigType, AuthType>;
     gateway?: SlateTriggerGroupGatewayParameters<ConfigType, AuthType>;
     routingMatchers: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType>;
+    selectionOptions?: Record<string, SlateTriggerGroupSelectionOptionsSources<ConfigType, AuthType>>;
 }
 declare class SlateTriggerGroup<ConfigType extends {}, AuthType extends {}, InputType extends {} = Record<string, unknown>> {
     private readonly _spec;
@@ -754,6 +806,7 @@ declare class SlateTriggerGroup<ConfigType extends {}, AuthType extends {}, Inpu
     get webhook(): SlateTriggerGroupWebhookParameters<ConfigType, AuthType> | undefined;
     get gateway(): SlateTriggerGroupGatewayParameters<ConfigType, AuthType> | undefined;
     get routingMatchers(): SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType>;
+    get selectionOptions(): Record<string, SlateTriggerGroupSelectionOptionsSources<ConfigType, AuthType>>;
 }
 declare class SlateTriggerGroupBuilder<ConfigType extends {}, AuthType extends {}, InputType extends {} = Record<string, unknown>> {
     #private;
@@ -776,6 +829,12 @@ declare class SlateTriggerGroupBuilder<ConfigType extends {}, AuthType extends {
     /** Receive events over a platform-managed persistent connection (e.g. a WebSocket gateway). */
     gateway(props: SlateTriggerGroupGatewayParameters<ConfigType, AuthType>): SlateTriggerGroupBuilder<ConfigType, AuthType, InputType>;
     routingMatchers(handler: SlateTriggerGroupRoutingMatchersHandler<ConfigType, AuthType>): SlateTriggerGroupBuilder<ConfigType, AuthType, InputType>;
+    /**
+     * Lets the dashboard offer a list for these selection fields instead of a typed-in value.
+     * Each field must be a top-level property of the selection schema, which must be a zod object.
+     * For an array property the listed options are values for its items.
+     */
+    selectionOptions(declarations: Record<string, SlateTriggerGroupSelectionOptionsSources<ConfigType, AuthType>>): SlateTriggerGroupBuilder<ConfigType, AuthType, InputType>;
     build(): SlateTriggerGroup<ConfigType, AuthType, InputType>;
 }
 declare let triggerGroup: <ConfigType extends {}, AuthType extends {}, InputType extends {} = Record<string, unknown>>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateTriggerGroupCreateParameters<InputType>) => SlateTriggerGroupBuilder<ConfigType, AuthType, InputType>;
@@ -835,6 +894,7 @@ interface SlateActionParametersTrigger<ConfigType extends {}, AuthType extends {
     triggerGroup: SlateTriggerGroup<ConfigType, AuthType>;
     matches: SlateTriggerMatchesHandler;
     map: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
+    eventAttributes?: string[];
 }
 type SlateActionParametersAny<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> = SlateActionParametersTool<ConfigType, AuthType, InputType, OutputType> | SlateActionParametersTrigger<ConfigType, AuthType, InputType, OutputType>;
 type SlateActionCreateParameters<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> = SlateActionParametersAny<ConfigType, AuthType, InputType, OutputType> & SlateActionParameters & {
@@ -890,6 +950,11 @@ declare class SlateActionBuilder<Type extends SlateActionType, ConfigType extend
     triggerGroup(group: SlateTriggerGroup<ConfigType, AuthType>): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result, IsPublic>;
     matches(handler: SlateTriggerMatchesHandler): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result, IsPublic>;
     map(handler: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result, IsPublic>;
+    /**
+     * Returns the values of these top-level output fields with every mapped event, so events
+     * can be filtered by them. Strings, finite numbers, booleans and arrays of those are used.
+     */
+    eventAttributes(fields: (keyof OutputType & string)[]): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result, IsPublic>;
     build(): Result;
 }
 
@@ -970,6 +1035,7 @@ interface SlateTriggerParameters<ConfigType extends {}, AuthType extends {}, Inp
     triggerGroup: SlateTriggerGroup<ConfigType, AuthType>;
     matches: SlateTriggerMatchesHandler;
     map: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
+    eventAttributes?: string[];
 }
 declare class SlateTrigger<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {
     type: string;
@@ -980,6 +1046,7 @@ declare class SlateTrigger<ConfigType extends {}, AuthType extends {}, InputType
     get triggerGroup(): SlateTriggerGroup<ConfigType, AuthType, Record<string, unknown>>;
     get matches(): SlateTriggerMatchesHandler;
     get map(): SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
+    get eventAttributes(): string[];
 }
 declare let trigger: <ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateActionParameters) => SlateActionBuilder<"trigger", ConfigType, AuthType, {}, {}, SlateTrigger<any, any, any, any>, false>;
 
@@ -1263,6 +1330,7 @@ declare class Slate<ConfigType extends {}, AuthType extends {}> {
     private readonly _triggerGroups;
     private readonly _toolCategories;
     private readonly _toolCategoryKeysByActionKey;
+    private readonly _optionLists;
     private constructor();
     static create<ConfigType extends {}, AuthType extends {}>(params: {
         spec: SlateSpecification<ConfigType, AuthType>;
@@ -1271,12 +1339,14 @@ declare class Slate<ConfigType extends {}, AuthType extends {}> {
         adapters?: SlateAdapter<ConfigType, AuthType>[];
         triggerGroups?: SlateTriggerGroup<ConfigType, AuthType>[];
         toolCategories?: SlateToolCategory[];
+        optionLists?: SlateOptionList<ConfigType, AuthType, any>[];
     }): Slate<ConfigType, AuthType>;
     get spec(): SlateSpecification<ConfigType, AuthType>;
     get actions(): (SlateTrigger<ConfigType, AuthType, any, any> | SlateTool<ConfigType, AuthType, any, any>)[];
     get adapters(): SlateAdapter<ConfigType, AuthType>[];
     get triggerGroups(): SlateTriggerGroup<ConfigType, AuthType, Record<string, unknown>>[];
     get toolCategories(): SlateToolCategory[];
+    get optionLists(): SlateOptionList<ConfigType, AuthType, any>[];
     getToolCategoryKeys(actionKey: string): string[];
 }
 
@@ -1311,4 +1381,4 @@ declare let skipWebhook: (reason: string, response?: Response | SlateWebhookHttp
     response: Response | SlateWebhookHttpResponseInit;
 };
 
-export { API_ERROR_MAX_DETAILS, API_ERROR_MAX_MESSAGE_LENGTH, API_ERROR_TRUNCATED_PLACEHOLDER, AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX, type ApiErrorBuildHelpers, type ApiErrorDetailOptions, type ApiErrorResponse, type ApiErrorStatus, type ApiErrorTextOptions, type ApiServiceError, type AuthConfigSecretFilter, AuthConfigSecretRedactor, type BoundedApiErrorDetailOptions, type BuildApiServiceErrorOptions, type CreateHmacSignatureOptions, type DecodeApiErrorBodyOptions, GET_FILE_URL_TOOL_ID, type GetFileUrlHandler, type GetFileUrlToolInput, type GetFileUrlToolOutput, type NormalizeOAuthTokenResponseOptions, type OAuthExpiresAtOptions, type OAuthRefreshTokenFallbackMode, type OAuthTokenResponse, type SeenEntry, Slate, SlateAction, SlateActionBuilder, type SlateActionCreateParameters, type SlateActionDocsReference, type SlateActionParameters, type SlateActionParametersAny, type SlateActionParametersTool, type SlateActionParametersTrigger, type SlateActionScopeClause, type SlateActionScopeClauseInput, type SlateActionScopeValue, type SlateActionScopes, type SlateActionScopesInput, type SlateActionType, SlateAdapter, type SlateAdapterCapability, SlateAdapterSpec, type SlateAdapterSpecParameters, type SlateAddAttachmentContent, type SlateAddAttachmentInput, type SlateAttachment, type SlateAttachmentInlineContent, type SlateAttachmentUploadReferenceContent, type SlateAttachmentUrlContent, SlateAuth, type SlateAuthDocsReference, type SlateAuthType, type SlateAuthWithCustomData, type SlateAuthWithNone, type SlateAuthWithOauth, type SlateAuthWithServiceAccount, type SlateAuthWithToken, type SlateAuthenticatedAxiosDefaults, type SlateAxiosDefaults, type SlateAxiosErrorAdapter, type SlateAxiosErrorOptions, SlateConfig, type SlateConfigDocsReference, SlateContext, SlateDeclarationError, SlateDefaultPollingIntervalSeconds, type SlateDirectUploadInput, type SlateDocsReference, SlateError, type SlateErrorInput, type SlateErrorIssue, type SlateErrorKind, type SlateErrorProviderInfo, type SlateErrorResponse, type SlateErrorUpstreamInfo, type SlateGatewayEvent, type SlateLiveInvocationInfo, type SlateLogEntry, type SlateLogFields, type SlateLogListener, type SlateLogMessageInput, type SlateLogType, SlateLogger, type SlateProviderDocsReference, SlatePublicContext, SlatePublicTool, type SlatePublicToolInvocationHandler, type SlatePublicToolParameters, type SlateRuntimeInfo, type SlateServiceErrorData, SlateSpecification, type SlateSpecificationCreateParameters, type SlateSpecificationParameters, SlateTool, SlateToolCategory, type SlateToolCategoryParameters, type SlateToolInvocationHandler, type SlateToolParameters, SlateTrigger, SlateTriggerGroup, SlateTriggerGroupBuilder, type SlateTriggerGroupCreateParameters, type SlateTriggerGroupGatewayConnectHandler, type SlateTriggerGroupGatewayParameters, type SlateTriggerGroupGatewayReceiveHandler, type SlateTriggerGroupParameters, type SlateTriggerGroupPollHandler, type SlateTriggerGroupPollingParameters, type SlateTriggerGroupRoutingMatchersHandler, type SlateTriggerGroupSelection, type SlateTriggerGroupWebhookAutoRegistrationParameters, type SlateTriggerGroupWebhookDeliveryConfigParameters, type SlateTriggerGroupWebhookManualRegistrationParameters, type SlateTriggerGroupWebhookParameters, type SlateTriggerMappingHandler, type SlateTriggerMatchesHandler, type SlateTriggerParameters, type SlateTriggerRoutingMatcher, type SlateTypedDocsReference, type SlateWebhookDeliveryAuthenticateHandler, type SlateWebhookDeliveryAuthentication, type SlateWebhookExpandHandler, type SlateWebhookHttpResponseInit, type SlateWebhookManualFinishHandler, type SlateWebhookManualSetupHandler, type SlateWebhookProcessHandler, type SlateWebhookRegisterHandler, type SlateWebhookRegistrationResult, type SlateWebhookRenewHandler, type SlateWebhookSkipped, type SlateWebhookTarget, type SlateWebhookTargetListHandler, type SlateWebhookTargetOwnership, type SlateWebhookUnregisterHandler, type VerifyHmacSignatureOptions, adapterSpec, allOf, anyOf, assertNewPageToken, auth, axios, buildApiServiceError, collectApiErrorDetails, config, createApiServiceError, createAuthenticatedAxios, createAxios, createBase64Attachment, createHmacSignature, createSlateError, createTextAttachment, createUrlAttachment, decodeApiErrorBody, extractApiErrorMessage, getApiErrorResponse, getApiErrorResponseWithBody, getApiErrorStatus, getBase64ByteLength, getCurrentContext, getFileUrlTool, getFileUrlToolInputSchema, getFileUrlToolOutputSchema, getGraphWebhookValidationResponse, getMetaWebhookVerificationResponse, getOAuthExpiresAtFromExpiresIn, getResponseHeaderValue, getRuntimeInfo, getServiceErrorData, getUpstreamErrorStatus, graphWebhookHttp, inferSlateErrorFromAxios, isApiErrorRecord, isAxiosErrorLike, isServiceErrorData, isUrlEmbeddedCredential, looksLikeHtmlErrorBody, mapServiceErrorCode, mapServiceErrorToSlateErrorInput, mergeScopes, metaWebhookHttp, normalizeOAuthTokenResponse, parseWithServiceError, pickDefined, pruneSeenEntries, publicTool, pushBoundedApiErrorDetail, readApiErrorText, redactUrlAttachmentSecrets, rememberPageToken, requestAxios, requestAxiosData, runWithContext, scopeClause, seenEntryKey, seenEntrySchema, setIfDefined, skipWebhook, spec, statusLabelForApiError, timingSafeStringEqual, tool, toolCategory, trigger, triggerGroup, truncateApiErrorMessage, uploadAttachmentDirect, validateScopes, verifyHmacSignature };
+export { API_ERROR_MAX_DETAILS, API_ERROR_MAX_MESSAGE_LENGTH, API_ERROR_TRUNCATED_PLACEHOLDER, AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX, type ApiErrorBuildHelpers, type ApiErrorDetailOptions, type ApiErrorResponse, type ApiErrorStatus, type ApiErrorTextOptions, type ApiServiceError, type AuthConfigSecretFilter, AuthConfigSecretRedactor, type BoundedApiErrorDetailOptions, type BuildApiServiceErrorOptions, type CreateHmacSignatureOptions, type DecodeApiErrorBodyOptions, GET_FILE_URL_TOOL_ID, type GetFileUrlHandler, type GetFileUrlToolInput, type GetFileUrlToolOutput, type NormalizeOAuthTokenResponseOptions, type OAuthExpiresAtOptions, type OAuthRefreshTokenFallbackMode, type OAuthTokenResponse, type SeenEntry, Slate, SlateAction, SlateActionBuilder, type SlateActionCreateParameters, type SlateActionDocsReference, type SlateActionParameters, type SlateActionParametersAny, type SlateActionParametersTool, type SlateActionParametersTrigger, type SlateActionScopeClause, type SlateActionScopeClauseInput, type SlateActionScopeValue, type SlateActionScopes, type SlateActionScopesInput, type SlateActionType, SlateAdapter, type SlateAdapterCapability, SlateAdapterSpec, type SlateAdapterSpecParameters, type SlateAddAttachmentContent, type SlateAddAttachmentInput, type SlateAttachment, type SlateAttachmentInlineContent, type SlateAttachmentUploadReferenceContent, type SlateAttachmentUrlContent, SlateAuth, type SlateAuthDocsReference, type SlateAuthType, type SlateAuthWithCustomData, type SlateAuthWithNone, type SlateAuthWithOauth, type SlateAuthWithServiceAccount, type SlateAuthWithToken, type SlateAuthenticatedAxiosDefaults, type SlateAxiosDefaults, type SlateAxiosErrorAdapter, type SlateAxiosErrorOptions, SlateConfig, type SlateConfigDocsReference, SlateContext, SlateDeclarationError, SlateDefaultPollingIntervalSeconds, type SlateDirectUploadInput, type SlateDocsReference, SlateError, type SlateErrorInput, type SlateErrorIssue, type SlateErrorKind, type SlateErrorProviderInfo, type SlateErrorResponse, type SlateErrorUpstreamInfo, type SlateGatewayEvent, type SlateLinkedOptionList, type SlateLiveInvocationInfo, type SlateLogEntry, type SlateLogFields, type SlateLogListener, type SlateLogMessageInput, type SlateLogType, SlateLogger, type SlateOption, SlateOptionList, type SlateOptionListHandler, type SlateOptionListPage, type SlateOptionListParameters, type SlateProviderDocsReference, SlatePublicContext, SlatePublicTool, type SlatePublicToolInvocationHandler, type SlatePublicToolParameters, type SlateRuntimeInfo, type SlateServiceErrorData, SlateSpecification, type SlateSpecificationCreateParameters, type SlateSpecificationParameters, SlateTool, SlateToolCategory, type SlateToolCategoryParameters, type SlateToolInvocationHandler, type SlateToolParameters, SlateTrigger, SlateTriggerGroup, SlateTriggerGroupBuilder, type SlateTriggerGroupCreateParameters, type SlateTriggerGroupGatewayConnectHandler, type SlateTriggerGroupGatewayParameters, type SlateTriggerGroupGatewayReceiveHandler, type SlateTriggerGroupParameters, type SlateTriggerGroupPollHandler, type SlateTriggerGroupPollingParameters, type SlateTriggerGroupRoutingMatchersHandler, type SlateTriggerGroupSelection, type SlateTriggerGroupSelectionOptionsHandler, type SlateTriggerGroupSelectionOptionsSources, type SlateTriggerGroupWebhookAutoRegistrationParameters, type SlateTriggerGroupWebhookDeliveryConfigParameters, type SlateTriggerGroupWebhookManualRegistrationParameters, type SlateTriggerGroupWebhookParameters, type SlateTriggerMappingHandler, type SlateTriggerMatchesHandler, type SlateTriggerParameters, type SlateTriggerRoutingMatcher, type SlateTypedDocsReference, type SlateWebhookDeliveryAuthenticateHandler, type SlateWebhookDeliveryAuthentication, type SlateWebhookExpandHandler, type SlateWebhookHttpResponseInit, type SlateWebhookManualFinishHandler, type SlateWebhookManualSetupHandler, type SlateWebhookProcessHandler, type SlateWebhookRegisterHandler, type SlateWebhookRegistrationResult, type SlateWebhookRenewHandler, type SlateWebhookSkipped, type SlateWebhookTarget, type SlateWebhookTargetListHandler, type SlateWebhookTargetOwnership, type SlateWebhookUnregisterHandler, type VerifyHmacSignatureOptions, adapterSpec, allOf, anyOf, assertNewPageToken, auth, axios, buildApiServiceError, collectApiErrorDetails, config, createApiServiceError, createAuthenticatedAxios, createAxios, createBase64Attachment, createHmacSignature, createSlateError, createTextAttachment, createUrlAttachment, decodeApiErrorBody, extractApiErrorMessage, getApiErrorResponse, getApiErrorResponseWithBody, getApiErrorStatus, getBase64ByteLength, getCurrentContext, getFileUrlTool, getFileUrlToolInputSchema, getFileUrlToolOutputSchema, getGraphWebhookValidationResponse, getMetaWebhookVerificationResponse, getOAuthExpiresAtFromExpiresIn, getResponseHeaderValue, getRuntimeInfo, getServiceErrorData, getUpstreamErrorStatus, graphWebhookHttp, inferSlateErrorFromAxios, isApiErrorRecord, isAxiosErrorLike, isServiceErrorData, isUrlEmbeddedCredential, looksLikeHtmlErrorBody, mapServiceErrorCode, mapServiceErrorToSlateErrorInput, mergeScopes, metaWebhookHttp, normalizeOAuthTokenResponse, optionList, parseWithServiceError, pickDefined, pruneSeenEntries, publicTool, pushBoundedApiErrorDetail, readApiErrorText, redactUrlAttachmentSecrets, rememberPageToken, requestAxios, requestAxiosData, runWithContext, scopeClause, seenEntryKey, seenEntrySchema, setIfDefined, skipWebhook, spec, statusLabelForApiError, timingSafeStringEqual, tool, toolCategory, trigger, triggerGroup, truncateApiErrorMessage, uploadAttachmentDirect, validateScopes, verifyHmacSignature };

package/dist/index.module.js

@@ -1853,6 +1853,45 @@ var isClause = (value) => typeof value === "object" && value !== null && "OR" in
 var isScopes = (value) => typeof value === "object" && value !== null && "AND" in value && Array.isArray(value.AND);
 
 // src/action/builder.ts
+var EVENT_ATTRIBUTE_KEY_PATTERN = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
+var EVENT_ATTRIBUTE_MAX_KEYS = 8;
+var checkEventAttributeNames = (fields) => {
+  if (!Array.isArray(fields)) {
+    throw new SlateDeclarationError("Event attributes must be a list of output field names");
+  }
+  if (fields.length > EVENT_ATTRIBUTE_MAX_KEYS) {
+    throw new SlateDeclarationError(
+      `A trigger can declare at most ${EVENT_ATTRIBUTE_MAX_KEYS} event attributes`
+    );
+  }
+  let seen = /* @__PURE__ */ new Set();
+  for (let field of fields) {
+    if (typeof field !== "string" || !EVENT_ATTRIBUTE_KEY_PATTERN.test(field)) {
+      throw new SlateDeclarationError(
+        `Event attribute "${field}" must start with a letter and contain only letters, digits and underscores (at most 64 characters)`
+      );
+    }
+    if (seen.has(field)) {
+      throw new SlateDeclarationError(`Event attribute "${field}" is declared more than once`);
+    }
+    seen.add(field);
+  }
+};
+var checkEventAttributeFields = (fields, outputSchema) => {
+  if (outputSchema._zod?.def?.type !== "object") {
+    throw new SlateDeclarationError(
+      "Event attributes require the output schema to be a zod object"
+    );
+  }
+  let shape = outputSchema.shape;
+  for (let field of fields) {
+    if (!Object.hasOwn(shape, field)) {
+      throw new SlateDeclarationError(
+        `Event attribute "${field}" is not a top-level property of the output schema`
+      );
+    }
+  }
+};
 var SlateActionBuilder = class {
   constructor(type, spec2, params, factory, isPublicTool = false) {
     this.type = type;
@@ -1878,6 +1917,7 @@ var SlateActionBuilder = class {
   #triggerGroup = null;
   #triggerMatches = null;
   #triggerMap = null;
+  #eventAttributes = null;
   #interfaceLocked = false;
   input(schema) {
     if (this.#interfaceLocked) {
@@ -1948,6 +1988,21 @@ var SlateActionBuilder = class {
     this.#triggerMap = handler;
     return this;
   }
+  /**
+   * Returns the values of these top-level output fields with every mapped event, so events
+   * can be filtered by them. Strings, finite numbers, booleans and arrays of those are used.
+   */
+  eventAttributes(fields) {
+    if (this.type !== "trigger") {
+      throw new SlateDeclarationError("eventAttributes can only be set for trigger actions");
+    }
+    checkEventAttributeNames(fields);
+    if (this.#outputSchema) {
+      checkEventAttributeFields(fields, this.#outputSchema);
+    }
+    this.#eventAttributes = [...fields];
+    return this;
+  }
   build() {
     let scopes = this.#scopes ?? this.params.scopes;
     if (scopes) {
@@ -1975,11 +2030,15 @@ var SlateActionBuilder = class {
     if (this.type === "trigger" && !this.#triggerMap) {
       throw new SlateDeclarationError("Trigger map handler is not defined");
     }
+    if (this.#eventAttributes) {
+      checkEventAttributeFields(this.#eventAttributes, this.#outputSchema);
+    }
     let triggerParams = this.type === "trigger" ? {
       type: "trigger",
       triggerGroup: this.#triggerGroup,
       matches: this.#triggerMatches,
-      map: this.#triggerMap
+      map: this.#triggerMap,
+      ...this.#eventAttributes?.length ? { eventAttributes: this.#eventAttributes } : {}
     } : null;
     return this.factory({
       ...this.params,
@@ -2051,6 +2110,41 @@ var getFileUrlTool = (spec2, handleGetFileUrl) => tool(spec2, {
   };
 }).build();
 
+// src/action/optionList.ts
+import { z as z2 } from "zod";
+var SlateOptionList = class _SlateOptionList {
+  constructor(_spec, _params, _paramsSchema) {
+    this._spec = _spec;
+    this._params = _params;
+    this._paramsSchema = _paramsSchema;
+  }
+  _spec;
+  _params;
+  _paramsSchema;
+  static create(spec2, params) {
+    let paramsSchema = params.paramsSchema ?? z2.object({});
+    if (paramsSchema?._zod?.def?.type !== "object") {
+      throw new SlateDeclarationError(
+        `Option list "${params.key}" params schema must be a zod object`
+      );
+    }
+    return new _SlateOptionList(spec2, params, paramsSchema.strict());
+  }
+  get spec() {
+    return this._spec;
+  }
+  get key() {
+    return this._params.key;
+  }
+  get paramsSchema() {
+    return this._paramsSchema;
+  }
+  get list() {
+    return this._params.list;
+  }
+};
+var optionList = (spec2, params) => SlateOptionList.create(spec2, params);
+
 // src/action/publicTool.ts
 var SlatePublicTool = class {
   constructor() {
@@ -2104,11 +2198,13 @@ var SlateTrigger = class _SlateTrigger extends SlateAction {
   #triggerGroup;
   #matches;
   #map;
+  #eventAttributes;
   constructor(spec2, inputSchema, outputSchema, params) {
     super("trigger", spec2, inputSchema, outputSchema, params);
     this.#triggerGroup = params.triggerGroup;
     this.#matches = params.matches;
     this.#map = params.map;
+    this.#eventAttributes = params.eventAttributes ?? [];
   }
   static create(spec2, params) {
     return new SlateActionBuilder("trigger", spec2, params, (params2) => {
@@ -2125,12 +2221,53 @@ var SlateTrigger = class _SlateTrigger extends SlateAction {
   get map() {
     return this.#map;
   }
+  get eventAttributes() {
+    return [...this.#eventAttributes];
+  }
 };
 var trigger = (spec2, params) => SlateTrigger.create(spec2, params);
 
 // src/action/triggerGroup.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var SlateDefaultPollingIntervalSeconds = 60 * 10;
+var LINKED_SLATE_PATTERN = /^[^/\s]+\/[^/\s]+$/;
+var checkSelectionOptions = (field, sources, shape) => {
+  if (!Object.hasOwn(shape, field)) {
+    throw new SlateDeclarationError(
+      `Selection field "${field}" is not a top-level property of the selection schema`
+    );
+  }
+  if (typeof sources !== "object" || sources === null) {
+    throw new SlateDeclarationError(
+      `Selection field "${field}" must be declared as { list, linked }`
+    );
+  }
+  let { list, linked } = sources;
+  if (!list && !linked) {
+    throw new SlateDeclarationError(
+      `Selection field "${field}" needs its own options list, a linked option list, or both`
+    );
+  }
+  if (list !== void 0 && typeof list !== "function") {
+    throw new SlateDeclarationError(`Selection field "${field}" list must be a function`);
+  }
+  if (linked) {
+    if (typeof linked.slate !== "string" || !LINKED_SLATE_PATTERN.test(linked.slate)) {
+      throw new SlateDeclarationError(
+        `Selection field "${field}" links to slate "${linked.slate}", which must be written as <scope>/<name>`
+      );
+    }
+    if (typeof linked.optionList !== "string" || !linked.optionList.trim()) {
+      throw new SlateDeclarationError(
+        `Selection field "${field}" must name the option list it links to`
+      );
+    }
+  }
+  return {
+    ...list ? { list } : {},
+    ...linked ? { linked } : {}
+  };
+};
 var SlateTriggerGroup = class _SlateTriggerGroup {
   constructor(_spec, _params) {
     this._spec = _spec;
@@ -2157,7 +2294,7 @@ var SlateTriggerGroup = class _SlateTriggerGroup {
     return this._params.metadata;
   }
   get eventSchema() {
-    return this._params.eventSchema ?? z2.object({}).passthrough();
+    return this._params.eventSchema ?? z3.object({}).passthrough();
   }
   get source() {
     return this._params.source;
@@ -2177,6 +2314,9 @@ var SlateTriggerGroup = class _SlateTriggerGroup {
   get routingMatchers() {
     return this._params.routingMatchers;
   }
+  get selectionOptions() {
+    return this._params.selectionOptions ?? {};
+  }
 };
 var SlateTriggerGroupBuilder = class {
   constructor(spec2, params, factory) {
@@ -2192,6 +2332,7 @@ var SlateTriggerGroupBuilder = class {
   #webhook = null;
   #gateway = null;
   #routingMatchers = null;
+  #selectionOptions = {};
   polling(props) {
     if (this.#source) {
       throw new SlateDeclarationError("Trigger group invocation is already defined");
@@ -2263,6 +2404,27 @@ var SlateTriggerGroupBuilder = class {
     this.#routingMatchers = handler;
     return this;
   }
+  /**
+   * Lets the dashboard offer a list for these selection fields instead of a typed-in value.
+   * Each field must be a top-level property of the selection schema, which must be a zod object.
+   * For an array property the listed options are values for its items.
+   */
+  selectionOptions(declarations) {
+    let schema = this.params.selectionSchema;
+    if (!schema) {
+      throw new SlateDeclarationError("Selection options require a selection schema");
+    }
+    if (schema._zod?.def?.type !== "object") {
+      throw new SlateDeclarationError(
+        "Selection options require the selection schema to be a zod object"
+      );
+    }
+    let shape = schema.shape;
+    for (let [field, sources] of Object.entries(declarations)) {
+      this.#selectionOptions[field] = checkSelectionOptions(field, sources, shape);
+    }
+    return this;
+  }
   build() {
     if (!this.#source) {
       throw new SlateDeclarationError(
@@ -2278,7 +2440,8 @@ var SlateTriggerGroupBuilder = class {
       polling: this.#polling ?? void 0,
       webhook: this.#webhook ?? void 0,
       gateway: this.#gateway ?? void 0,
-      routingMatchers: this.#routingMatchers
+      routingMatchers: this.#routingMatchers,
+      selectionOptions: this.#selectionOptions
     });
   }
 };
@@ -3037,8 +3200,8 @@ var verifyHmacSignature = (options) => timingSafeStringEqual(createHmacSignature
 
 // src/dedup/index.ts
 import { createHash } from "crypto";
-import { z as z3 } from "zod";
-var seenEntrySchema = z3.object({ key: z3.string().min(1), at: z3.number().finite() });
+import { z as z4 } from "zod";
+var seenEntrySchema = z4.object({ key: z4.string().min(1), at: z4.number().finite() });
 var seenEntryKey = (idempotencyKey) => createHash("sha256").update(idempotencyKey).digest("base64url").slice(0, 16);
 var pruneSeenEntries = (entries, options) => {
   let kept = [];
@@ -3190,13 +3353,14 @@ var assertNewPageToken = (seen, token, repeated) => {
 
 // src/specification/slate.ts
 var Slate = class _Slate {
-  constructor(_spec, _actions, _adapters, _triggerGroups, _toolCategories, _toolCategoryKeysByActionKey) {
+  constructor(_spec, _actions, _adapters, _triggerGroups, _toolCategories, _toolCategoryKeysByActionKey, _optionLists) {
     this._spec = _spec;
     this._actions = _actions;
     this._adapters = _adapters;
     this._triggerGroups = _triggerGroups;
     this._toolCategories = _toolCategories;
     this._toolCategoryKeysByActionKey = _toolCategoryKeysByActionKey;
+    this._optionLists = _optionLists;
   }
   _spec;
   _actions;
@@ -3204,6 +3368,7 @@ var Slate = class _Slate {
   _triggerGroups;
   _toolCategories;
   _toolCategoryKeysByActionKey;
+  _optionLists;
   static create(params) {
     let adapters = params.adapters ?? [];
     let actions = [...params.triggers, ...params.tools];
@@ -3247,6 +3412,16 @@ var Slate = class _Slate {
         `Only one trigger group may use manual webhook registration or a delivery config, but found: ${configuredWebhookTriggerGroups.map((group) => group.key).join(", ")}`
       );
     }
+    let optionLists = params.optionLists ?? [];
+    let seenOptionListKeys = /* @__PURE__ */ new Set();
+    for (let list of optionLists) {
+      if (seenOptionListKeys.has(list.key)) {
+        throw new SlateDeclarationError(
+          `Option list "${list.key}" is registered more than once`
+        );
+      }
+      seenOptionListKeys.add(list.key);
+    }
     let toolCategories = params.toolCategories ?? [];
     let toolCategoryKeysByActionKey = resolveToolCategoryMembership(toolCategories, actions);
     return new _Slate(
@@ -3255,7 +3430,8 @@ var Slate = class _Slate {
       adapters,
       triggerGroups,
       toolCategories,
-      toolCategoryKeysByActionKey
+      toolCategoryKeysByActionKey,
+      optionLists
     );
   }
   get spec() {
@@ -3273,6 +3449,9 @@ var Slate = class _Slate {
   get toolCategories() {
     return this._toolCategories ?? [];
   }
+  get optionLists() {
+    return this._optionLists ?? [];
+  }
   // Keys of the tool categories an action belongs to, in declared category order.
   getToolCategoryKeys(actionKey) {
     return [...this._toolCategoryKeysByActionKey?.get(actionKey) ?? []];
@@ -3346,7 +3525,7 @@ var resolveToolCategoryMembership = (toolCategories, actions) => {
 };
 
 // src/specification/specification.ts
-import z4 from "zod";
+import z5 from "zod";
 var SlateSpecification = class _SlateSpecification {
   constructor(_config, _auth, _params) {
     this._config = _config;
@@ -3363,7 +3542,7 @@ var SlateSpecification = class _SlateSpecification {
     return this._config.configSchema;
   }
   get authSchema() {
-    return "outputSchema" in this._auth ? this._auth.outputSchema : z4.object({});
+    return "outputSchema" in this._auth ? this._auth.outputSchema : z5.object({});
   }
   get config() {
     return this._config;
@@ -3467,6 +3646,7 @@ export {
   SlateDefaultPollingIntervalSeconds,
   SlateError,
   SlateLogger,
+  SlateOptionList,
   SlatePublicContext,
   SlatePublicTool,
   SlateSpecification,
@@ -3521,6 +3701,7 @@ export {
   mergeScopes,
   metaWebhookHttp,
   normalizeOAuthTokenResponse,
+  optionList,
   parseWithServiceError,
   pickDefined,
   pruneSeenEntries,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider",
-  "version": "1.0.0-rc.34",
+  "version": "1.0.0-rc.35",
   "publishConfig": {
     "access": "public"
   },

package/src/action/action.ts

@@ -92,6 +92,7 @@ export interface SlateActionParametersTrigger<
   triggerGroup: SlateTriggerGroup<ConfigType, AuthType>;
   matches: SlateTriggerMatchesHandler;
   map: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
+  eventAttributes?: string[];
 }
 
 export type SlateActionParametersAny<

package/src/action/builder.ts

@@ -17,6 +17,51 @@ import type {
 import { validateScopes } from './scopes';
 import type { SlateTriggerGroup } from './triggerGroup';
 
+// Mirrors the event attribute limits in @slates/proto.
+let EVENT_ATTRIBUTE_KEY_PATTERN = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
+let EVENT_ATTRIBUTE_MAX_KEYS = 8;
+
+let checkEventAttributeNames = (fields: string[]) => {
+  if (!Array.isArray(fields)) {
+    throw new SlateDeclarationError('Event attributes must be a list of output field names');
+  }
+  if (fields.length > EVENT_ATTRIBUTE_MAX_KEYS) {
+    throw new SlateDeclarationError(
+      `A trigger can declare at most ${EVENT_ATTRIBUTE_MAX_KEYS} event attributes`
+    );
+  }
+
+  let seen = new Set<string>();
+  for (let field of fields) {
+    if (typeof field !== 'string' || !EVENT_ATTRIBUTE_KEY_PATTERN.test(field)) {
+      throw new SlateDeclarationError(
+        `Event attribute "${field}" must start with a letter and contain only letters, digits and underscores (at most 64 characters)`
+      );
+    }
+    if (seen.has(field)) {
+      throw new SlateDeclarationError(`Event attribute "${field}" is declared more than once`);
+    }
+    seen.add(field);
+  }
+};
+
+let checkEventAttributeFields = (fields: string[], outputSchema: z.ZodType<any>) => {
+  if ((outputSchema as any)._zod?.def?.type !== 'object') {
+    throw new SlateDeclarationError(
+      'Event attributes require the output schema to be a zod object'
+    );
+  }
+
+  let shape = (outputSchema as z.ZodObject<any>).shape;
+  for (let field of fields) {
+    if (!Object.hasOwn(shape, field)) {
+      throw new SlateDeclarationError(
+        `Event attribute "${field}" is not a top-level property of the output schema`
+      );
+    }
+  }
+};
+
 export class SlateActionBuilder<
   Type extends SlateActionType,
   ConfigType extends {},
@@ -39,6 +84,7 @@ export class SlateActionBuilder<
   #triggerMatches: SlateTriggerMatchesHandler | null = null;
   #triggerMap: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType> | null =
     null;
+  #eventAttributes: string[] | null = null;
   #interfaceLocked = false;
 
   constructor(
@@ -190,6 +236,26 @@ export class SlateActionBuilder<
     return this;
   }
 
+  /**
+   * Returns the values of these top-level output fields with every mapped event, so events
+   * can be filtered by them. Strings, finite numbers, booleans and arrays of those are used.
+   */
+  eventAttributes(
+    fields: (keyof OutputType & string)[]
+  ): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result, IsPublic> {
+    if (this.type !== 'trigger') {
+      throw new SlateDeclarationError('eventAttributes can only be set for trigger actions');
+    }
+
+    checkEventAttributeNames(fields);
+    if (this.#outputSchema) {
+      checkEventAttributeFields(fields, this.#outputSchema);
+    }
+
+    this.#eventAttributes = [...fields];
+    return this;
+  }
+
   build() {
     let scopes = this.#scopes ?? this.params.scopes;
     if (scopes) {
@@ -219,6 +285,9 @@ export class SlateActionBuilder<
     if (this.type === 'trigger' && !this.#triggerMap) {
       throw new SlateDeclarationError('Trigger map handler is not defined');
     }
+    if (this.#eventAttributes) {
+      checkEventAttributeFields(this.#eventAttributes, this.#outputSchema);
+    }
 
     let triggerParams: SlateActionParametersTrigger<
       ConfigType,
@@ -231,7 +300,10 @@ export class SlateActionBuilder<
             type: 'trigger',
             triggerGroup: this.#triggerGroup!,
             matches: this.#triggerMatches!,
-            map: this.#triggerMap! as any
+            map: this.#triggerMap! as any,
+            ...(this.#eventAttributes?.length
+              ? { eventAttributes: this.#eventAttributes }
+              : {})
           }
         : null;
 

package/src/action/index.ts

@@ -1,6 +1,7 @@
 export * from './action';
 export * from './builder';
 export * from './getFileUrlTool';
+export * from './optionList';
 export * from './publicTool';
 export * from './scopes';
 export * from './tool';