@slates/provider 1.0.0-rc.15 → 1.0.0-rc.17

package/dist/index.d.cts

@@ -145,8 +145,10 @@ type SlateAuthWithToken<InputType extends {}, OutputType extends {
     docs?: SlateAuthDocsReference[];
     getOutput: (ctx: {
         input: InputType;
+        config?: SlateAuthCallbackConfig;
     }) => Promise<{
         output: OutputType;
+        scopes?: string[];
     }>;
     onInputChanged?: (params: {
         previousInput: InputType;
@@ -158,6 +160,8 @@ type SlateAuthWithToken<InputType extends {}, OutputType extends {
     getProfile?: (ctx: {
         output: OutputType;
         input: InputType;
+        scopes: string[];
+        config?: SlateAuthCallbackConfig;
     }) => Promise<{
         profile: Record<string, any>;
     }>;
@@ -170,8 +174,10 @@ type SlateAuthWithServiceAccount<InputType extends {}, OutputType extends {}> =
     docs?: SlateAuthDocsReference[];
     getOutput: (ctx: {
         input: InputType;
+        config?: SlateAuthCallbackConfig;
     }) => Promise<{
         output: OutputType;
+        scopes?: string[];
     }>;
     onInputChanged?: (params: {
         previousInput: InputType;
@@ -183,6 +189,8 @@ type SlateAuthWithServiceAccount<InputType extends {}, OutputType extends {}> =
     getProfile?: (ctx: {
         output: OutputType;
         input: InputType;
+        scopes: string[];
+        config?: SlateAuthCallbackConfig;
     }) => Promise<{
         profile: Record<string, any>;
     }>;
@@ -195,8 +203,10 @@ type SlateAuthWithCustomData<InputType extends {}, OutputType extends {}> = {
     docs?: SlateAuthDocsReference[];
     getOutput: (ctx: {
         input: InputType;
+        config?: SlateAuthCallbackConfig;
     }) => Promise<{
         output: OutputType;
+        scopes?: string[];
     }>;
     handleTokenRefresh?: (ctx: {
         output: OutputType;
@@ -204,6 +214,7 @@ type SlateAuthWithCustomData<InputType extends {}, OutputType extends {}> = {
         clientId: string;
         clientSecret: string;
         scopes: string[];
+        config?: SlateAuthCallbackConfig;
     }) => Promise<{
         output: OutputType;
         input?: InputType;
@@ -218,6 +229,8 @@ type SlateAuthWithCustomData<InputType extends {}, OutputType extends {}> = {
     getProfile?: (ctx: {
         output: OutputType;
         input: InputType;
+        scopes: string[];
+        config?: SlateAuthCallbackConfig;
     }) => Promise<{
         profile: Record<string, any>;
     }>;
@@ -261,6 +274,34 @@ declare class SlateAuth<OutputType extends {} = {}> {
 }
 declare let auth: <OutputType extends {} = {}>() => SlateAuth<OutputType>;
 
+type OAuthTokenResponse = {
+    access_token?: unknown;
+    refresh_token?: unknown;
+    expires_in?: unknown;
+    [key: string]: unknown;
+};
+type OAuthRefreshTokenFallbackMode = 'nullish' | 'falsy';
+type OAuthExpiresAtOptions = {
+    nowMs?: number;
+    providerLabel?: string;
+    operation?: string;
+    required?: boolean;
+    expiresInType?: 'number' | 'numberLike';
+    message?: string;
+};
+type NormalizeOAuthTokenResponseOptions = OAuthExpiresAtOptions & {
+    previousRefreshToken?: string;
+    refreshTokenFallbackMode?: OAuthRefreshTokenFallbackMode;
+    accessTokenMessage?: string;
+    expiresInMessage?: string;
+};
+declare let getOAuthExpiresAtFromExpiresIn: (expiresIn: unknown, options?: OAuthExpiresAtOptions) => string | undefined;
+declare let normalizeOAuthTokenResponse: (data: unknown, options?: NormalizeOAuthTokenResponseOptions) => {
+    token: string;
+    refreshToken: string | undefined;
+    expiresAt: string | undefined;
+};
+
 declare class SlateConfig<ConfigType extends {}> {
     #private;
     private constructor();
@@ -328,6 +369,7 @@ declare class SlateContext<ConfigType extends {}, AuthType extends {}, InputType
     get event(): Readonly<InputType>;
     get state(): "state" extends keyof InputType ? InputType["state"] : never;
     get request(): "request" extends keyof InputType ? InputType["request"] : never;
+    get registrationDetails(): "registrationDetails" extends keyof InputType ? InputType["registrationDetails"] : never;
     get auth(): Readonly<AuthType>;
     recordHttpTrace(trace: SlateHttpTrace): void;
     getHttpTraces(): {
@@ -396,6 +438,7 @@ interface SlateActionParameters {
     };
     metadata?: Record<string, any>;
     scopes?: SlateActionScopes;
+    authMethods?: string[];
     docs?: SlateActionDocsReference[];
 }
 type SlateToolInvocationHandler<ConfigType extends {}, AuthType extends {}, InputType extends {}, OutputType extends {}> = (context: SlateContext<ConfigType, AuthType, InputType>) => Promise<{
@@ -414,12 +457,41 @@ type SlateTriggerPollingHandler<ConfigType extends {}, AuthType extends {}, Inpu
     inputs: InputType[];
     updatedState?: any;
 }>;
+interface SlateWebhookHttpResponseInit {
+    status?: number;
+    headers?: Record<string, string>;
+    body?: string | Uint8Array | null;
+}
+type SlateWebhookHttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+interface SlateWebhookRequestMatcher {
+    method?: string;
+    hasQueryParam?: string;
+    hasHeader?: string;
+    jsonBodyField?: {
+        path: string;
+        equals?: string;
+    };
+    formBodyField?: {
+        path: string;
+        equals?: string;
+    };
+}
+interface SlateWebhookHttpOptions {
+    methods?: SlateWebhookHttpMethod[];
+    sync?: {
+        mode: 'never' | 'match' | 'always';
+        match?: SlateWebhookRequestMatcher[];
+        timeoutMs?: number;
+    };
+}
 type SlateTriggerWebhookRequestHandler<ConfigType extends {}, AuthType extends {}, InputType extends {}> = (context: SlateContext<ConfigType, AuthType, {
     request: Request;
     state: any | null;
+    registrationDetails: any | null;
 }>) => Promise<{
     inputs: InputType[];
     updatedState?: any;
+    response?: Response | SlateWebhookHttpResponseInit;
 }>;
 type SlateTriggerWebhookAutoRegistrationHandler<ConfigType extends {}, AuthType extends {}> = (context: SlateContext<ConfigType, AuthType, {
     webhookBaseUrl: string;
@@ -445,6 +517,7 @@ interface SlateActionParametersTrigger<ConfigType extends {}, AuthType extends {
     polling?: SlatePollingOptions;
     handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
     handleRequest?: SlateTriggerWebhookRequestHandler<ConfigType, AuthType, InputType>;
+    http?: SlateWebhookHttpOptions;
     pollEvents?: SlateTriggerPollingHandler<ConfigType, AuthType, InputType>;
     autoRegisterWebhook?: SlateTriggerWebhookAutoRegistrationHandler<ConfigType, AuthType>;
     autoUnregisterWebhook?: SlateTriggerWebhookAutoUnregistrationHandler<ConfigType, AuthType>;
@@ -479,6 +552,7 @@ declare abstract class SlateAction<Type extends SlateActionType, ConfigType exte
     get constraints(): string[] | undefined;
     get metadata(): Record<string, any> | undefined;
     get scopes(): SlateActionScopes | undefined;
+    get authMethods(): string[] | undefined;
     get docs(): SlateActionDocsReference[] | undefined;
 }
 
@@ -492,12 +566,15 @@ declare class SlateActionBuilder<Type extends SlateActionType, ConfigType extend
     input<NewInputType extends {}>(schema: z.ZodType<NewInputType>): SlateActionBuilder<Type, ConfigType, AuthType, NewInputType, OutputType, Result>;
     output<NewOutputType extends {}>(schema: z.ZodType<NewOutputType>): SlateActionBuilder<Type, ConfigType, AuthType, InputType, NewOutputType, Result>;
     scopes(scopes: SlateActionScopes): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result>;
+    authMethods(authMethods: string[]): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result>;
+    private validateAuthMethods;
     handleInvocation(handler: SlateToolInvocationHandler<ConfigType, AuthType, InputType, OutputType>): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result>;
     webhook(props: {
         handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
         handleRequest: SlateTriggerWebhookRequestHandler<ConfigType, AuthType, InputType>;
         autoRegisterWebhook?: SlateTriggerWebhookAutoRegistrationHandler<ConfigType, AuthType>;
         autoUnregisterWebhook?: SlateTriggerWebhookAutoUnregistrationHandler<ConfigType, AuthType>;
+        http?: SlateWebhookHttpOptions;
     }): SlateActionBuilder<Type, ConfigType, AuthType, InputType, OutputType, Result>;
     polling(props: {
         options?: SlatePollingOptions;
@@ -536,6 +613,7 @@ interface SlateTriggerParameters<ConfigType extends {}, AuthType extends {}, Inp
     polling?: SlatePollingOptions;
     handleEvent: SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
     handleRequest?: SlateTriggerWebhookRequestHandler<ConfigType, AuthType, InputType>;
+    http?: SlateWebhookHttpOptions;
     pollEvents?: SlateTriggerPollingHandler<ConfigType, AuthType, InputType>;
     autoRegisterWebhook?: SlateTriggerWebhookAutoRegistrationHandler<ConfigType, AuthType>;
     autoUnregisterWebhook?: SlateTriggerWebhookAutoUnregistrationHandler<ConfigType, AuthType>;
@@ -550,12 +628,69 @@ declare class SlateTrigger<ConfigType extends {}, AuthType extends {}, InputType
     get source(): "polling" | "webhook";
     get handleEvent(): SlateTriggerMappingHandler<ConfigType, AuthType, InputType, OutputType>;
     get handleRequest(): SlateTriggerWebhookRequestHandler<ConfigType, AuthType, InputType> | undefined;
+    get http(): SlateWebhookHttpOptions | undefined;
     get pollEvents(): SlateTriggerPollingHandler<ConfigType, AuthType, InputType> | undefined;
     get autoRegisterWebhook(): SlateTriggerWebhookAutoRegistrationHandler<ConfigType, AuthType> | undefined;
     get autoUnregisterWebhook(): SlateTriggerWebhookAutoUnregistrationHandler<ConfigType, AuthType> | undefined;
 }
 declare let trigger: <ConfigType extends {}, AuthType extends {}>(spec: SlateSpecification<ConfigType, AuthType>, params: SlateActionParameters) => SlateActionBuilder<"trigger", ConfigType, AuthType, {}, {}, SlateTrigger<any, any, any, any>>;
 
+type ApiErrorStatus = number | string;
+type ApiServiceError = ServiceError<ErrorRecord<any, any>>;
+type ApiErrorResponse = {
+    status?: ApiErrorStatus;
+    statusText?: string;
+    data?: unknown;
+};
+type ApiErrorDetailOptions = {
+    detailKeys?: readonly string[];
+    nestedKeys?: readonly string[];
+    includeNumbers?: boolean;
+    separator?: string;
+    fallbackMessage?: string;
+};
+type ApiErrorBuildHelpers = {
+    collectDetails: (value: unknown, details: string[], options?: ApiErrorDetailOptions) => void;
+    extractMessage: (error: unknown, options?: ApiErrorDetailOptions) => string;
+    getResponse: (error: unknown) => ApiErrorResponse | undefined;
+    getStatus: (error: unknown) => ApiErrorStatus | undefined;
+    isRecord: (value: unknown) => value is Record<string, unknown>;
+    statusLabelFor: (status?: ApiErrorStatus, statusText?: string) => string;
+};
+type BuildApiServiceErrorOptions = ApiErrorDetailOptions & {
+    providerLabel: string;
+    reason: string;
+    operation?: string;
+    extractMessage?: (error: unknown, helpers: ApiErrorBuildHelpers) => string | undefined;
+    extractResponse?: (error: unknown, helpers: ApiErrorBuildHelpers) => ApiErrorResponse | undefined;
+    extractStatus?: (error: unknown, response: ApiErrorResponse | undefined, helpers: ApiErrorBuildHelpers) => ApiErrorStatus | undefined;
+    extractUpstreamCode?: (error: unknown, response: ApiErrorResponse | undefined, helpers: ApiErrorBuildHelpers) => string | undefined;
+    formatMessage?: (parts: {
+        providerLabel: string;
+        operation: string;
+        statusLabel: string;
+        message: string;
+        response?: ApiErrorResponse;
+        status?: ApiErrorStatus;
+    }) => string;
+    parent?: unknown;
+};
+declare let isApiErrorRecord: (value: unknown) => value is Record<string, unknown>;
+declare let collectApiErrorDetails: (value: unknown, details: string[], options?: ApiErrorDetailOptions) => void;
+declare let getApiErrorResponse: (error: unknown) => ApiErrorResponse | undefined;
+declare let getApiErrorStatus: (error: unknown) => ApiErrorStatus | undefined;
+declare let statusLabelForApiError: (status?: ApiErrorStatus, statusText?: string) => string;
+declare let extractApiErrorMessage: (error: unknown, options?: ApiErrorDetailOptions & {
+    response?: ApiErrorResponse;
+}) => string;
+declare let createApiServiceError: (message: string, options?: {
+    reason?: string;
+    upstreamStatus?: ApiErrorStatus;
+    upstreamCode?: string;
+    parent?: unknown;
+}) => ServiceError<ErrorRecord<"bad_request", 400>>;
+declare let buildApiServiceError: (error: unknown, options: BuildApiServiceErrorOptions) => ServiceError<ErrorRecord<"bad_request", 400>>;
+
 declare class SlateError extends Error {
     cause?: unknown;
     data: SlateErrorResponse;
@@ -641,9 +776,40 @@ declare let mapServiceErrorToSlateErrorInput: (error: ServiceError<ErrorRecord<a
 interface SlateAxiosDefaults extends CreateAxiosDefaults {
     errorMapping?: SlateAxiosErrorOptions;
 }
+type SlateAxiosErrorAdapter = (error: unknown, operation: string) => unknown;
+interface SlateAuthenticatedAxiosDefaults extends SlateAxiosDefaults {
+    authHeader?: {
+        name?: string;
+        value: string;
+    };
+    contentType?: string | false;
+    errorAdapter?: (error: unknown) => unknown;
+}
 declare let createAxios: (config?: SlateAxiosDefaults) => AxiosInstance;
+declare let createAuthenticatedAxios: (config: SlateAuthenticatedAxiosDefaults) => AxiosInstance;
+declare let requestAxios: <T = unknown>(operation: string, request: () => Promise<AxiosResponse<T>>, errorAdapter: SlateAxiosErrorAdapter) => Promise<AxiosResponse<T, any, {}>>;
+declare let requestAxiosData: <T = unknown>(operation: string, request: () => Promise<AxiosResponse<T>>, errorAdapter: SlateAxiosErrorAdapter) => Promise<T>;
 declare let axios: AxiosInstance;
 
+interface CreateHmacSignatureOptions {
+    secret: string | Uint8Array;
+    payload: string | Uint8Array;
+    algorithm?: string;
+    digest: 'hex' | 'base64';
+    prefix?: string;
+}
+interface VerifyHmacSignatureOptions extends CreateHmacSignatureOptions {
+    signature: string;
+}
+declare let createHmacSignature: ({ secret, payload, algorithm, digest, prefix }: CreateHmacSignatureOptions) => string;
+declare let verifyHmacSignature: (options: VerifyHmacSignatureOptions) => boolean;
+
+declare let getResponseHeaderValue: (headers: unknown, name: string) => string | undefined;
+declare let getBase64ByteLength: (contentBase64: string) => number;
+
+declare let pickDefined: <T extends object>(value: T) => Partial<T> & Record<string, unknown>;
+declare let setIfDefined: (target: Record<string, unknown>, key: string, value: unknown) => Record<string, unknown>;
+
 declare class Slate<ConfigType extends {}, AuthType extends {}> {
     private readonly _spec;
     private readonly _actions;
@@ -657,4 +823,27 @@ declare class Slate<ConfigType extends {}, AuthType extends {}> {
     get actions(): (SlateTrigger<ConfigType, AuthType, any, any> | SlateTool<ConfigType, AuthType, any, any>)[];
 }
 
-export { 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, type SlateAttachment, type SlateAttachmentInlineContent, type SlateAttachmentUrlContent, SlateAuth, type SlateAuthDocsReference, type SlateAuthType, type SlateAuthWithCustomData, type SlateAuthWithNone, type SlateAuthWithOauth, type SlateAuthWithServiceAccount, type SlateAuthWithToken, type SlateAxiosDefaults, type SlateAxiosErrorOptions, SlateConfig, type SlateConfigDocsReference, SlateContext, SlateDeclarationError, SlateDefaultPollingIntervalSeconds, type SlateDocsReference, SlateError, type SlateErrorInput, type SlateErrorIssue, type SlateErrorKind, type SlateErrorProviderInfo, type SlateErrorResponse, type SlateErrorUpstreamInfo, type SlateLogEntry, type SlateLogFields, type SlateLogListener, type SlateLogMessageInput, type SlateLogType, SlateLogger, type SlatePollingOptions, type SlateProviderDocsReference, type SlateServiceErrorData, SlateSpecification, type SlateSpecificationCreateParameters, type SlateSpecificationParameters, SlateTool, type SlateToolInvocationHandler, type SlateToolParameters, SlateTrigger, type SlateTriggerMappingHandler, type SlateTriggerParameters, type SlateTriggerPollingHandler, type SlateTriggerWebhookAutoRegistrationHandler, type SlateTriggerWebhookAutoUnregistrationHandler, type SlateTriggerWebhookRequestHandler, type SlateTypedDocsReference, allOf, anyOf, auth, axios, config, createAxios, createBase64Attachment, createSlateError, createTextAttachment, createUrlAttachment, getCurrentContext, getServiceErrorData, inferSlateErrorFromAxios, isAxiosErrorLike, isServiceErrorData, mapServiceErrorCode, mapServiceErrorToSlateErrorInput, mergeScopes, runWithContext, scopeClause, spec, tool, trigger, validateScopes };
+declare const graphWebhookHttp: {
+    methods: "POST"[];
+    sync: {
+        mode: "match";
+        match: {
+            hasQueryParam: string;
+        }[];
+    };
+};
+declare let getGraphWebhookValidationResponse: (request: Request) => SlateWebhookHttpResponseInit | null;
+
+declare const metaWebhookHttp: {
+    methods: ("GET" | "POST")[];
+    sync: {
+        mode: "match";
+        match: {
+            method: string;
+            hasQueryParam: string;
+        }[];
+    };
+};
+declare let getMetaWebhookVerificationResponse: (request: Request, expectedVerifyToken: string | undefined) => SlateWebhookHttpResponseInit | null;
+
+export { type ApiErrorBuildHelpers, type ApiErrorDetailOptions, type ApiErrorResponse, type ApiErrorStatus, type ApiServiceError, type BuildApiServiceErrorOptions, type CreateHmacSignatureOptions, type NormalizeOAuthTokenResponseOptions, type OAuthExpiresAtOptions, type OAuthRefreshTokenFallbackMode, type OAuthTokenResponse, 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, type SlateAttachment, type SlateAttachmentInlineContent, 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 SlateDocsReference, SlateError, type SlateErrorInput, type SlateErrorIssue, type SlateErrorKind, type SlateErrorProviderInfo, type SlateErrorResponse, type SlateErrorUpstreamInfo, type SlateLogEntry, type SlateLogFields, type SlateLogListener, type SlateLogMessageInput, type SlateLogType, SlateLogger, type SlatePollingOptions, type SlateProviderDocsReference, type SlateServiceErrorData, SlateSpecification, type SlateSpecificationCreateParameters, type SlateSpecificationParameters, SlateTool, type SlateToolInvocationHandler, type SlateToolParameters, SlateTrigger, type SlateTriggerMappingHandler, type SlateTriggerParameters, type SlateTriggerPollingHandler, type SlateTriggerWebhookAutoRegistrationHandler, type SlateTriggerWebhookAutoUnregistrationHandler, type SlateTriggerWebhookRequestHandler, type SlateTypedDocsReference, type SlateWebhookHttpMethod, type SlateWebhookHttpOptions, type SlateWebhookHttpResponseInit, type SlateWebhookRequestMatcher, type VerifyHmacSignatureOptions, allOf, anyOf, auth, axios, buildApiServiceError, collectApiErrorDetails, config, createApiServiceError, createAuthenticatedAxios, createAxios, createBase64Attachment, createHmacSignature, createSlateError, createTextAttachment, createUrlAttachment, extractApiErrorMessage, getApiErrorResponse, getApiErrorStatus, getBase64ByteLength, getCurrentContext, getGraphWebhookValidationResponse, getMetaWebhookVerificationResponse, getOAuthExpiresAtFromExpiresIn, getResponseHeaderValue, getServiceErrorData, graphWebhookHttp, inferSlateErrorFromAxios, isApiErrorRecord, isAxiosErrorLike, isServiceErrorData, mapServiceErrorCode, mapServiceErrorToSlateErrorInput, mergeScopes, metaWebhookHttp, normalizeOAuthTokenResponse, pickDefined, requestAxios, requestAxiosData, runWithContext, scopeClause, setIfDefined, spec, statusLabelForApiError, tool, trigger, validateScopes, verifyHmacSignature };