@stepper-io/core 1.0.0

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 Paperform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,528 @@
+interface AuthenticationBase {
+    test: Invoke<any, Input>;
+    label?: string | Invoke<string, Input>;
+    /**
+     * If true, the data returned by the test function will be stored in the credentials object (available on Context.auth for actions/triggers).
+     **/
+    storeTestResult?: boolean;
+}
+interface BasicAuthentication extends AuthenticationBase {
+    type: 'basic';
+    fields?: InputFields;
+}
+interface OAuth2Authentication extends AuthenticationBase {
+    type: 'oauth2';
+    oauth2: {
+        authorizationUrl: string | Invoke<string, InputField[]>;
+        accessTokenUrl: string | Invoke<string, InputField[]>;
+        refreshAccessTokenUrl: string | Invoke<string, InputField[]>;
+        scopes: string[];
+        enablePkce?: boolean;
+        clientCredentialsIn?: 'headers' | 'body' | 'both';
+        detectOAuth2Error?: (response: Response, errorText: string) => {
+            isOAuth2Error: boolean;
+            errorType: 'invalid_grant' | 'invalid_token' | 'other' | null;
+            errorDescription: string;
+        } | null;
+    };
+    fields?: InputFields;
+}
+interface CustomAuthentication extends AuthenticationBase {
+    type: 'custom';
+    fields: InputFields;
+    custom?: {
+        redirectUrl: string | Invoke<string, InputField[]>;
+        handleReturnUrl: Invoke<any, any>;
+        handleRefreshCredentials?: Invoke<any, any>;
+    };
+}
+interface BearerAuthentication extends AuthenticationBase {
+    type: 'bearer';
+    fields?: InputFields;
+}
+interface NoneAuthentication extends AuthenticationBase {
+    type: 'none';
+}
+type DynamicList = Invoke<PaginatedResponse, any>;
+interface DropdownOption {
+    id: string | number;
+    label: string;
+    value?: {
+        [key: string]: any;
+    };
+}
+interface BaseInputField {
+    key: string;
+    required: boolean;
+    label: string;
+    helpText?: string;
+    multiple?: boolean;
+    instructions?: string;
+    example?: string | {
+        [key: string]: any;
+    };
+    create?: undefined;
+    inputType?: string;
+    dependencies?: string[];
+    hidden?: boolean;
+}
+interface BaseInputFieldSingleValue extends BaseInputField {
+    multiple?: false;
+    value?: string;
+    default?: string;
+    type: 'string' | 'text' | 'number' | 'integer' | 'boolean' | 'datetime' | 'password';
+}
+interface HTMLInputField extends BaseInputField {
+    multiple?: false;
+    type: 'html';
+    value?: string;
+    default?: string;
+}
+interface MarkdownInputField extends BaseInputField {
+    multiple?: false;
+    type: 'markdown';
+    value?: string;
+    default?: string;
+}
+interface BaseInputFieldMultipleValue extends BaseInputField {
+    multiple: true;
+    type: 'string' | 'text' | 'number' | 'integer' | 'boolean' | 'datetime' | 'password';
+    value?: string[];
+    default?: string[];
+}
+interface EmbeddedInputField extends Omit<BaseInputField, 'create'> {
+    multiple?: false;
+    type: 'embedded';
+    value?: DropdownOption;
+    default?: DropdownOption;
+    html: string | ((context: Context) => string) | ((context: Context) => Promise<string>);
+    create?: {
+        action: string;
+    };
+}
+interface ObjectValue {
+    [key: string]: any;
+}
+interface ObjectInputField extends BaseInputField {
+    type: 'object';
+    value?: ObjectValue;
+    default?: ObjectValue;
+    fields?: InputField[];
+    allowAny?: boolean;
+}
+interface RefInputField extends BaseInputField {
+    type: 'ref';
+    default?: null;
+    ref?: {
+        types: ('scalar-array' | 'complex-array' | 'scalar' | 'complex')[];
+    };
+}
+interface MessageField extends Omit<BaseInputFieldSingleValue, 'type'> {
+    type: 'message';
+    message: string;
+    copyText?: string;
+}
+interface ErrorField extends Omit<BaseInputFieldSingleValue, 'type'> {
+    type: 'error';
+    message: string;
+    copyText?: string;
+}
+interface DropdownInputFieldSingleValue extends Omit<BaseInputField, 'create'> {
+    key: string;
+    type: 'dropdown';
+    multiple?: false;
+    /**
+     * @deprecated Now always allowed
+     */
+    allowCustom?: boolean;
+    searchable?: boolean;
+    customLabel?: string;
+    create?: {
+        action: string;
+    };
+    default?: DropdownOption;
+    options: DropdownOption[] | DynamicList;
+    value?: DropdownOption;
+}
+interface SchemaInputField extends BaseInputField {
+    type: 'schema';
+    value?: unknown;
+    default?: unknown;
+    hidden?: boolean;
+}
+interface DropdownInputFieldMultipleValue extends BaseInputField {
+    type: 'dropdown';
+    multiple: true;
+    /**
+     * @deprecated Now always allowed
+     */
+    allowCustom?: boolean;
+    searchable?: boolean;
+    create?: undefined;
+    default?: DropdownOption[];
+    options: DropdownOption[] | DynamicList;
+    value?: DropdownOption[];
+}
+type InputField = RefInputField | HTMLInputField | MarkdownInputField | BaseInputFieldSingleValue | BaseInputFieldMultipleValue | DropdownInputFieldSingleValue | DropdownInputFieldMultipleValue | SchemaInputField | EmbeddedInputField | MessageField | ErrorField | ObjectInputField;
+type DynamicInputFields = (context: Context) => Promise<InputField[]> | InputField[];
+type InputFields = (InputField | DynamicInputFields)[];
+type RequestClient = (url: string | URL, options?: RequestInit) => Promise<Response>;
+type TemporaryFile = {
+    type: 'base64';
+    fileName?: string;
+    mimeType?: string;
+    base64: string;
+} | {
+    type: 'url';
+    fileName?: string;
+    mimeType?: string;
+    url: string;
+};
+type SubscriptionOptionFilter = {
+    path: string;
+    value: string | number | boolean | string[] | number[] | boolean[] | null;
+    operator: 'eq' | 'ne' | 'in' | 'nin' | 'gt' | 'gte' | 'lt' | 'lte' | 'contains' | 'notContains' | 'notIn';
+}[];
+type SubscriptionOptions = {
+    channel: string;
+    filters?: SubscriptionOptionFilter;
+};
+type API = {
+    request: RequestClient;
+    get: RequestClient;
+    post: RequestClient;
+    patch: RequestClient;
+    put: RequestClient;
+    delete: RequestClient;
+    callbackUrl: () => Promise<string>;
+    notificationUrl: () => Promise<{
+        success: string;
+        failure: string;
+    }>;
+    storeTemporaryFile: (file: TemporaryFile) => Promise<string>;
+    log: (message: string) => void;
+    hash: (input: string, algorithm: 'sha256' | 'sha512' | 'md5') => Promise<string>;
+    JSON: {
+        parse: (input: string) => any;
+        stringify: (input: any) => string;
+    };
+    events: {
+        subscribe: (subscriptionOptions: SubscriptionOptions) => Promise<{
+            subscriptionId: string;
+        }>;
+        unsubscribe: (subscriptionId: string) => Promise<void>;
+    };
+    kv: {
+        get: (key: string) => Promise<string | null>;
+        set: (key: string, value: string, options?: {
+            ttl?: number;
+        }) => Promise<void>;
+        delete: (key: string) => Promise<void>;
+    };
+    error: {
+        unknown: (message: string, details?: unknown) => void;
+        notFound: (message: string, details?: unknown) => void;
+        nonRetryable: (message: string, details?: unknown) => void;
+        rateLimitHit: (message: string, retryAfter?: number | Date, details?: unknown) => void;
+        staleAuthentication: (message: string, details?: unknown) => void;
+        criticalAuthentication: (message: string, details?: unknown) => void;
+    };
+    resolveURLParameters: (value: string) => string;
+};
+type ErrorType = 'unknown' | 'notFound' | 'nonRetryable' | 'rateLimitHit' | 'criticalAuthentication' | 'staleAuthentication';
+declare class BaseError extends Error {
+    type: ErrorType;
+    details?: unknown;
+    constructor(message: string, type: ErrorType, details?: unknown);
+}
+declare class UnknownError extends BaseError {
+    constructor(message: string, details?: unknown);
+}
+declare class NonRetryableError extends BaseError {
+    constructor(message: string, details?: unknown);
+}
+declare class NotFoundError extends BaseError {
+    constructor(message: string, details?: unknown);
+}
+declare class RateLimitHitError extends BaseError {
+    retryAfter?: number | Date;
+    constructor(message: string, retryAfter?: number | Date, details?: unknown);
+}
+declare class CriticalAuthenticationError extends BaseError {
+    constructor(message: string, details?: unknown);
+}
+declare class StaleAuthenticationError extends BaseError {
+    constructor(message: string, details?: unknown);
+}
+type ErrorTypes = typeof UnknownError | typeof NonRetryableError | typeof RateLimitHitError | typeof CriticalAuthenticationError | typeof StaleAuthenticationError;
+type Input = {
+    [key: string]: any;
+};
+type Context<TInput extends Input = Input> = {
+    input: TInput;
+    env: any;
+    auth: any;
+    app: StepperApp;
+    api: API;
+    metadata?: ContextMetadata;
+};
+type ContextMetadata = {
+    invocationId?: string;
+    runId?: string;
+    workflowId?: string;
+    [key: string]: any;
+};
+type Invoke<TResponse, TInput extends Input> = (context: Context<TInput>) => Promise<TResponse> | TResponse;
+type Descriptions = {
+    key: string;
+    label: string;
+    helpText?: string;
+    example?: string;
+}[];
+type DescribeResponse<TResponse, TInput extends Input> = (context: Context<TInput>, response: TResponse) => Promise<Descriptions> | Descriptions;
+interface Callable<TResponse, TInput extends Input> {
+    fields?: InputFields;
+    invoke: Invoke<TResponse, TInput>;
+    exampleItem?: any;
+    describe?: DescribeResponse<TResponse, TInput>;
+}
+interface CallableList<TResponse, TInput extends Input> extends Callable<TResponse, TInput> {
+    exampleItem?: DropdownOption | Invoke<DropdownOption, TInput>;
+}
+interface DefaultAction<TResponse, TInput extends Input> {
+    key: string;
+    name: string;
+    async?: false;
+    description: string;
+    aiHelp?: string;
+    hidden?: boolean;
+    icon?: string;
+    verb: 'create' | 'update' | 'delete' | 'lookup';
+    call: Callable<TResponse, TInput>;
+    cost?: number | Invoke<number, TInput>;
+}
+interface ListAction<TResponse, TInput extends {
+    [key: string]: any;
+}> extends Omit<DefaultAction<TResponse, TInput>, 'call' | 'verb'> {
+    verb: 'list';
+    searchable?: false;
+    call: CallableList<PaginatedResponse, TInput & {
+        nextCursor?: string | number;
+        search?: string;
+    }>;
+}
+interface CreateListOptionAction<TResponse, TInput extends {
+    [key: string]: any;
+}> extends Omit<DefaultAction<TResponse, TInput>, 'call' | 'verb'> {
+    verb: 'create-option';
+    call: Callable<DropdownOption, TInput>;
+}
+interface AsyncAction<TResponse, TInput extends {
+    [key: string]: any;
+}> extends Omit<DefaultAction<TResponse, TInput>, 'call' | 'async'> {
+    async: true;
+    call: Callable<{
+        expiresAt?: number;
+        treatExpiryAsSuccess?: boolean;
+    } | undefined, TInput>;
+}
+interface SearchListAction<TInput extends {
+    [key: string]: any;
+}> {
+    key: string;
+    name: string;
+    async?: false;
+    description: string;
+    icon?: string;
+    hidden?: boolean;
+    verb: 'list';
+    searchable: true;
+    cost?: number | Invoke<number, TInput>;
+    call: CallableList<PaginatedResponse, TInput & {
+        search?: string;
+        nextCursor?: string | number;
+    }>;
+}
+interface PaginatedResponse {
+    items: DropdownOption[];
+    hasMore?: boolean;
+    nextCursor: string | number | null;
+}
+type Action<TResponse extends any = any, TInput extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}> = AsyncAction<TResponse, TInput> | DefaultAction<TResponse, TInput> | ListAction<TResponse, TInput> | SearchListAction<TInput> | CreateListOptionAction<TResponse, TInput>;
+interface BaseTrigger {
+    key: string;
+    name: string;
+    description: string;
+    poll: CallableList<PaginatedResponse, any>;
+    intervalMinutes?: number;
+    icon?: string;
+    hidden?: boolean;
+}
+interface PollingTrigger extends BaseTrigger {
+    type: 'polling';
+}
+interface WebhookPayload {
+    method: string;
+    headers?: Record<string, string | string[]>;
+    query?: Record<string, string | string[]>;
+    body?: any;
+    raw?: string;
+    received_at?: string;
+}
+interface WebhookBaseTrigger extends BaseTrigger {
+    type: 'webhook';
+    subscribe: Invoke<{
+        hookId: string | number;
+    }, {
+        [key: string]: any;
+        webhookUrl: string;
+    }>;
+    unsubscribe: Invoke<any, {
+        hookId: string | number;
+    }>;
+    disableListen?: boolean;
+}
+interface WebhookSourceTrigger extends WebhookBaseTrigger {
+    eventSource: 'webhook';
+    handleWebhook: Invoke<any, {
+        webhookPayload: WebhookPayload;
+    } & {
+        [key: string]: any;
+    }>;
+}
+interface WebhookPollSourceTrigger extends WebhookBaseTrigger {
+    eventSource: 'poll';
+}
+type WebhookTrigger = WebhookSourceTrigger | WebhookPollSourceTrigger;
+interface ManualTrigger {
+    key: string;
+    name: string;
+    description: string;
+    type: 'manual';
+    icon?: string;
+    fields: InputFields;
+    hidden?: boolean;
+}
+type Trigger = PollingTrigger | WebhookTrigger | ManualTrigger;
+type GlobalWebhookEvent = {
+    channel: string;
+    payload: WebhookPayload;
+};
+interface GlobalWebhookResponse {
+    events: GlobalWebhookEvent[] | null;
+}
+interface GlobalWebhook {
+    key: string;
+    name: string;
+    handleGlobalWebhook: Invoke<GlobalWebhookResponse | Response, {
+        webhookPayload: WebhookPayload;
+    }>;
+}
+type FlowRequestConfiguration = {
+    setBaseURI: (uri: string) => void;
+    setHeader: (key: string, value: string) => void;
+};
+type RequestMiddleware = {
+    before?: (request: FlowRequestConfiguration, context: Context) => void;
+    after?: (response: Response, context: Context<[]>) => Promise<Response> | Response;
+    disableDefaultErrorHandling?: boolean;
+};
+type Authentication = BasicAuthentication | OAuth2Authentication | CustomAuthentication | BearerAuthentication | NoneAuthentication;
+interface DependencyInfo {
+    dependencies: string[] | null;
+    hasLimitations: boolean;
+    limitations: string[];
+    limitationMessages?: string[];
+    hasDynamicFields: boolean;
+}
+interface AppDependenciesMap {
+    actions: {
+        [key: string]: DependencyInfo;
+    };
+    triggers: {
+        [key: string]: DependencyInfo;
+    };
+    connection?: DependencyInfo;
+}
+interface StepperApp {
+    key: string;
+    name: string;
+    icon: string;
+    url: string;
+    description: string;
+    version: number;
+    platformVersion: string;
+    authentication: Authentication;
+    isPlatformApp?: boolean;
+    actions: Action[] | ((context: Context) => Promise<Action[]> | Action[]);
+    triggers: Trigger[] | ((context: Context) => Promise<Trigger[]> | Trigger[]);
+    globalWebhooks?: GlobalWebhook[];
+    requestMiddleware?: RequestMiddleware;
+    parameterDependencies?: AppDependenciesMap;
+}
+declare function app(app: StepperApp): StepperApp;
+declare function action<TResponse, TInput extends {
+    [key: string]: any;
+}>(action: Action<TResponse, TInput>): Action<TResponse, TInput>;
+declare function trigger(trigger: Trigger): Trigger;
+declare function authentication(authentication: Authentication): Authentication;
+/**
+ * HTTP status code types - matches Hono's exact type structure
+ * @see https://github.com/honojs/hono
+ */
+type InfoStatusCode = 100 | 101 | 102 | 103;
+type SuccessStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
+type DeprecatedStatusCode = 305 | 306;
+type RedirectStatusCode = 300 | 301 | 302 | 303 | 304 | DeprecatedStatusCode | 307 | 308;
+type ClientErrorStatusCode = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451;
+type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
+type UnofficialStatusCode = -1;
+type StatusCode = InfoStatusCode | SuccessStatusCode | RedirectStatusCode | ClientErrorStatusCode | ServerErrorStatusCode | UnofficialStatusCode;
+type ContentlessStatusCode = 101 | 204 | 205 | 304;
+type ContentfulStatusCode = Exclude<StatusCode, ContentlessStatusCode>;
+/**
+ * HTTP status code type alias - use ContentfulStatusCode for responses with content
+ */
+type HTTPStatusCode = ContentfulStatusCode;
+/**
+ * HTTP Error classes for proper status code handling in HTTP responses
+ * These are used by app-wrapper and dispatcher to return correct HTTP status codes
+ */
+declare class HTTPError extends Error {
+    readonly statusCode: HTTPStatusCode;
+    readonly details?: any | undefined;
+    readonly __stepperHttpError: true;
+    constructor(message: string, statusCode: HTTPStatusCode, details?: any | undefined);
+    /**
+     * Type guard - safe across package boundaries (unlike instanceof)
+     * Uses brand property to avoid false positives from duck typing
+     */
+    static is(error: unknown): error is HTTPError;
+    static hasStatus(error: unknown, statusCode: HTTPStatusCode): boolean;
+}
+declare class HTTPNotFoundError extends HTTPError {
+    constructor(message: string, details?: any);
+    static is(error: unknown): error is HTTPNotFoundError;
+}
+declare class BadRequestError extends HTTPError {
+    constructor(message: string, details?: any);
+    static is(error: unknown): error is BadRequestError;
+}
+declare class UnprocessableEntityError extends HTTPError {
+    constructor(message: string, details?: any);
+    static is(error: unknown): error is UnprocessableEntityError;
+}
+declare class UnauthorizedError extends HTTPError {
+    constructor(message: string, details?: any);
+    static is(error: unknown): error is UnauthorizedError;
+}
+declare class ForbiddenError extends HTTPError {
+    constructor(message: string, details?: any);
+    static is(error: unknown): error is ForbiddenError;
+}
+
+export { type API, type Action, type AppDependenciesMap, type Authentication, BadRequestError, BaseError, type BasicAuthentication, type BearerAuthentication, type Callable, type CallableList, type ClientErrorStatusCode, type ContentfulStatusCode, type ContentlessStatusCode, type Context, type ContextMetadata, CriticalAuthenticationError, type CustomAuthentication, type DependencyInfo, type DeprecatedStatusCode, type DescribeResponse, type Descriptions, type DropdownInputFieldMultipleValue, type DropdownInputFieldSingleValue, type DropdownOption, type DynamicList, type EmbeddedInputField, type ErrorField, type ErrorType, type ErrorTypes, type FlowRequestConfiguration, ForbiddenError, type GlobalWebhook, type GlobalWebhookEvent, type GlobalWebhookResponse, HTTPError, HTTPNotFoundError, type HTTPStatusCode, type InfoStatusCode, type Input, type InputField, type InputFields, type Invoke, type ManualTrigger, type MessageField, NonRetryableError, type NoneAuthentication, NotFoundError, type OAuth2Authentication, type ObjectInputField, type PaginatedResponse, type PollingTrigger, RateLimitHitError, type RedirectStatusCode, type RefInputField, type RequestClient, type RequestMiddleware, type SchemaInputField, type ServerErrorStatusCode, StaleAuthenticationError, type StatusCode, type StepperApp, type SubscriptionOptionFilter, type SubscriptionOptions, type SuccessStatusCode, type TemporaryFile, type Trigger, UnauthorizedError, UnknownError, type UnofficialStatusCode, UnprocessableEntityError, type WebhookBaseTrigger, type WebhookPayload, type WebhookPollSourceTrigger, type WebhookSourceTrigger, type WebhookTrigger, action, app, authentication, trigger };

package/dist/index.mjs

@@ -0,0 +1,135 @@
+// src/index.ts
+var BaseError = class extends Error {
+  constructor(message, type, details) {
+    super(message);
+    this.type = type;
+    this.details = details;
+  }
+};
+var UnknownError = class extends BaseError {
+  constructor(message, details) {
+    super(message, "unknown", details);
+  }
+};
+var NonRetryableError = class extends BaseError {
+  constructor(message, details) {
+    super(message, "nonRetryable", details);
+  }
+};
+var NotFoundError = class extends BaseError {
+  constructor(message, details) {
+    super(message, "notFound", details);
+  }
+};
+var RateLimitHitError = class extends BaseError {
+  constructor(message, retryAfter, details) {
+    super(message, "rateLimitHit", details);
+    this.retryAfter = retryAfter;
+  }
+};
+var CriticalAuthenticationError = class extends BaseError {
+  constructor(message, details) {
+    super(message, "criticalAuthentication", details);
+  }
+};
+var StaleAuthenticationError = class extends BaseError {
+  constructor(message, details) {
+    super(message, "staleAuthentication", details);
+  }
+};
+function app(app2) {
+  return app2;
+}
+function action(action2) {
+  return action2;
+}
+function trigger(trigger2) {
+  return trigger2;
+}
+function authentication(authentication2) {
+  return authentication2;
+}
+var HTTPError = class _HTTPError extends Error {
+  constructor(message, statusCode, details) {
+    super(message);
+    this.statusCode = statusCode;
+    this.details = details;
+    // Brand property to avoid duck typing issues with other error objects
+    this.__stepperHttpError = true;
+    this.name = "HTTPError";
+  }
+  /**
+   * Type guard - safe across package boundaries (unlike instanceof)
+   * Uses brand property to avoid false positives from duck typing
+   */
+  static is(error) {
+    return error instanceof Error && "__stepperHttpError" in error && error.__stepperHttpError === true && "statusCode" in error && typeof error.statusCode === "number";
+  }
+  static hasStatus(error, statusCode) {
+    return _HTTPError.is(error) && error.statusCode === statusCode;
+  }
+};
+var HTTPNotFoundError = class extends HTTPError {
+  constructor(message, details) {
+    super(message, 404, details);
+    this.name = "HTTPNotFoundError";
+  }
+  static is(error) {
+    return HTTPError.hasStatus(error, 404);
+  }
+};
+var BadRequestError = class extends HTTPError {
+  constructor(message, details) {
+    super(message, 400, details);
+    this.name = "BadRequestError";
+  }
+  static is(error) {
+    return HTTPError.hasStatus(error, 400);
+  }
+};
+var UnprocessableEntityError = class extends HTTPError {
+  constructor(message, details) {
+    super(message, 422, details);
+    this.name = "UnprocessableEntityError";
+  }
+  static is(error) {
+    return HTTPError.hasStatus(error, 422);
+  }
+};
+var UnauthorizedError = class extends HTTPError {
+  constructor(message, details) {
+    super(message, 401, details);
+    this.name = "UnauthorizedError";
+  }
+  static is(error) {
+    return HTTPError.hasStatus(error, 401);
+  }
+};
+var ForbiddenError = class extends HTTPError {
+  constructor(message, details) {
+    super(message, 403, details);
+    this.name = "ForbiddenError";
+  }
+  static is(error) {
+    return HTTPError.hasStatus(error, 403);
+  }
+};
+export {
+  BadRequestError,
+  BaseError,
+  CriticalAuthenticationError,
+  ForbiddenError,
+  HTTPError,
+  HTTPNotFoundError,
+  NonRetryableError,
+  NotFoundError,
+  RateLimitHitError,
+  StaleAuthenticationError,
+  UnauthorizedError,
+  UnknownError,
+  UnprocessableEntityError,
+  action,
+  app,
+  authentication,
+  trigger
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@stepper-io/core",
+  "version": "1.0.0",
+  "description": "Core types and runtime helpers for building Stepper apps",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "keywords": [
+    "stepper",
+    "stepper-io",
+    "integrations",
+    "types"
+  ],
+  "author": "Paperform",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/paperform-co/paperform.git",
+    "directory": "resources/stepper-io/core"
+  },
+  "homepage": "https://github.com/paperform-co/paperform/tree/main/resources/stepper-io/core",
+  "bugs": {
+    "url": "https://github.com/paperform-co/paperform/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  }
+}