@softr/sdk 0.0.7 → 0.0.11

package/dist/client.d.ts

@@ -0,0 +1,6 @@
+import "@tanstack/react-start/client-only";
+
+//#region src/client/timezone.d.ts
+declare function useUserTimezone(): void;
+//#endregion
+export { useUserTimezone };

package/dist/{react.js → client.js}

@@ -1,6 +1,7 @@
+import "@tanstack/react-start/client-only";
 import { useEffect } from "react";
 
-//#region src/react.ts
+//#region src/client/timezone.ts
 function useUserTimezone() {
 	useEffect(() => {
 		document.cookie = `user-timezone=${Intl.DateTimeFormat().resolvedOptions().timeZone}; path=/`;

package/dist/index.d.ts

@@ -1,23 +1,642 @@
-import { A as VisibilityHandle, C as AccessError, D as SoftrUserGroupId, E as SoftrContext, F as isUnauthenticatedError, I as q, M as isAccessError, N as isAlreadySignedInError, O as SoftrUserGroups, P as isForbiddenError, S as AccessCheck, T as RouteVisibility, _ as SoftrSDK, a as CreateOptions, b as WorkflowAPI, c as GetOptions, d as ListResult, f as MetricOptions, g as SoftrRecord, h as SoftrPermissions, i as ChartDataResult, j as defineVisibility, k as User, l as IntegrationAPI, m as SoftrMe, n as AuthAPI, o as DatasourceAPI, p as MetricResult, r as ChartDataOptions, s as DatasourcePermissions, t as AggregationFunction, u as ListOptions, v as SoftrUser, w as AccessReason, x as AccessBehaviour, y as UpdateOptions } from "./types-CjB4xUg-.js";
+import { n as SoftrUserGroups, r as User, t as SoftrUserGroupId } from "./user-D23hwTsf.js";
 import * as _tanstack_react_start0 from "@tanstack/react-start";
 
-//#region src/auth/session.d.ts
+//#region src/core/query.d.ts
 
+type LogicalOperator = "AND" | "OR";
+type FilterOperator = "IS" | "IS_NOT" | "EQUAL" | "NOT_EQUAL" | "IS_EMPTY" | "IS_NOT_EMPTY" | "IS_ONE_OF" | "IS_NONE_OF" | "HAS_ALL_OF" | "HAS_ONE_OF" | "HAS_NONE_OF" | "CONTAINS" | "INLINE_CONTAINS" | "GT" | "LT" | "GTE" | "LTE" | "BETWEEN" | "IS_NOT_BETWEEN" | "DOES_NOT_CONTAINS" | "STARTS_WITH" | "ENDS_WITH";
+type ConditionFieldType = "TEXT" | "BOOLEAN" | "NUMERIC" | "ARRAY" | "DATE";
+interface Filter {
+  subject: string;
+  operator: FilterOperator;
+  value?: unknown;
+  type: ConditionFieldType;
+}
+type ConstructableFilter = Filter & {
+  [INTERNAL_KIND]: "FILTER";
+};
+type ConstructableFilterGroup = {
+  logicalOperator: LogicalOperator;
+  filters: Array<ConstructableFilter | ConstructableFilterGroup>;
+  [INTERNAL_KIND]: "LOGICAL_GROUP";
+};
+interface SortingOptionItem {
+  sortingField: string;
+  sortType: "ASC" | "DESC";
+}
+type ConstructableOrderBy = SortingOptionItem & {
+  [INTERNAL_KIND]: "ORDER_BY";
+};
+type AnyConstructable = ConstructableFilter | ConstructableFilterGroup;
+declare const INTERNAL_KIND: unique symbol;
 /**
- * Returns the signed-in visitor, or `null` when nobody is signed in.
+ * Query builder for filter queries. This exist to alleviate the (LLM?) mental overhead. API filter schema is a bit
+ * verbose and confusing, even when dealing with very basic queries. So to fall into the pit of success, aim here
+ * is to simplify filtering as much as possible.
  *
- * Await it in the root route's `beforeLoad` to publish the visitor as route
- * context, which every `defineVisibility` guard then reads. It requires
- * {@link softrAuthMiddleware} to be registered.
+ * @example
+ * single filter
+ * ```tsx
+ * const query = q.text("title").contains("hello");
+ *
+ * const json = buildFilterCriteria(query);
+ * // result
+ * {
+ *   "filterCriteria": {
+ *     "filterConditionGroup": {
+ *       "logicalOperator": "AND"
+ *       "filterGroups": [{
+ *         "logicalOperator": "AND",
+ *         "filters": [{
+ *           "subject": "title",
+ *           "type": "TEXT",
+ *           "operator": "CONTAINS",
+ *           "value": "hello"
+ *         }],
+ *       }]
+ *     }
+ *   }
+ *  }
+ *
+ * ```
  *
  * @example
- * export const Route = createRootRouteWithContext<SoftrContext>()({
- *   beforeLoad: async () => ({ user: await getSoftrUser() }),
+ * combining multiple filters
+ * ```tsx
+ * const query = q.and(
+ *   q.text("title").contains("hello"),
+ *   q.number("views").is(100),
+ *   q.or(
+ *     q.text("author").is("John"),
+ *     q.boolean("isPublished").is(true)
+ *   )
+ * );
+ * ```
+ */
+declare const q: {
+  select<T extends Record<string, string>>(mapping: T): T;
+  and(...filters: AnyConstructable[]): ConstructableFilterGroup;
+  or(...filters: AnyConstructable[]): ConstructableFilterGroup;
+  text(subject: string): {
+    is(value: string): {
+      operator: "IS";
+      value: string;
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNot(value: string): {
+      operator: "IS_NOT";
+      value: string;
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    contains(value: string): {
+      operator: "CONTAINS";
+      value: string;
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isOneOf(value: string[]): {
+      operator: "IS_ONE_OF";
+      value: string[];
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNoneOf(value: string[]): {
+      operator: "IS_NONE_OF";
+      value: string[];
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    startsWith(value: string): {
+      operator: "STARTS_WITH";
+      value: string;
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    endsWith(value: string): {
+      operator: "ENDS_WITH";
+      value: string;
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    hasAllOf(value: string[]): {
+      operator: "HAS_ALL_OF";
+      value: string[];
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isEmpty(): {
+      operator: "IS_EMPTY";
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNotEmpty(): {
+      operator: "IS_NOT_EMPTY";
+      subject: string;
+      type: "TEXT";
+      [INTERNAL_KIND]: "FILTER";
+    };
+  };
+  boolean(subject: string): {
+    is(value: boolean): {
+      operator: "IS";
+      value: boolean;
+      subject: string;
+      type: "BOOLEAN";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNot(value: boolean): {
+      operator: "IS_NOT";
+      value: boolean;
+      subject: string;
+      type: "BOOLEAN";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isEmpty(): {
+      operator: "IS_EMPTY";
+      subject: string;
+      type: "BOOLEAN";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNotEmpty(): {
+      operator: "IS_NOT_EMPTY";
+      subject: string;
+      type: "BOOLEAN";
+      [INTERNAL_KIND]: "FILTER";
+    };
+  };
+  number(subject: string): {
+    is(value: number): {
+      operator: "IS";
+      value: string;
+      subject: string;
+      type: "NUMERIC";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNot(value: number): {
+      operator: "IS_NOT";
+      value: string;
+      subject: string;
+      type: "NUMERIC";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    gt(value: number): {
+      operator: "GT";
+      value: string;
+      subject: string;
+      type: "NUMERIC";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    gte(value: number): {
+      operator: "GTE";
+      value: string;
+      subject: string;
+      type: "NUMERIC";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    lt(value: number): {
+      operator: "LT";
+      value: string;
+      subject: string;
+      type: "NUMERIC";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    lte(value: number): {
+      operator: "LTE";
+      value: string;
+      subject: string;
+      type: "NUMERIC";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    between(start: number, end: number): {
+      operator: "BETWEEN";
+      value: string[];
+      subject: string;
+      type: "NUMERIC";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isEmpty(): {
+      operator: "IS_EMPTY";
+      subject: string;
+      type: "NUMERIC";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNotEmpty(): {
+      operator: "IS_NOT_EMPTY";
+      subject: string;
+      type: "NUMERIC";
+      [INTERNAL_KIND]: "FILTER";
+    };
+  };
+  array(subject: string): {
+    is(value: string[]): {
+      operator: "IS";
+      value: string[];
+      subject: string;
+      type: "ARRAY";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isOneOf(value: string[]): {
+      operator: "IS_ONE_OF";
+      value: string[];
+      subject: string;
+      type: "ARRAY";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNoneOf(value: string[]): {
+      operator: "IS_NONE_OF";
+      value: string[];
+      subject: string;
+      type: "ARRAY";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    hasAllOf(value: string[]): {
+      operator: "HAS_ALL_OF";
+      value: string[];
+      subject: string;
+      type: "ARRAY";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isEmpty(): {
+      operator: "IS_EMPTY";
+      subject: string;
+      type: "ARRAY";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNotEmpty(): {
+      operator: "IS_NOT_EMPTY";
+      subject: string;
+      type: "ARRAY";
+      [INTERNAL_KIND]: "FILTER";
+    };
+  };
+  date(subject: string): {
+    is(value: string): {
+      operator: "IS";
+      value: string;
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNot(value: string): {
+      operator: "IS_NOT";
+      value: string;
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    gt(value: string): {
+      operator: "GT";
+      value: string;
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    gte(value: string): {
+      operator: "GTE";
+      value: string;
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    lt(value: string): {
+      operator: "LT";
+      value: string;
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    lte(value: string): {
+      operator: "LTE";
+      value: string;
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    between(start: string, end: string): {
+      operator: "BETWEEN";
+      value: string[];
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNotBetween(start: string, end: string): {
+      operator: "IS_NOT_BETWEEN";
+      value: string[];
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isEmpty(): {
+      operator: "IS_EMPTY";
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+    isNotEmpty(): {
+      operator: "IS_NOT_EMPTY";
+      subject: string;
+      type: "DATE";
+      [INTERNAL_KIND]: "FILTER";
+    };
+  };
+  asc(subject: string): ConstructableOrderBy;
+  desc(subject: string): ConstructableOrderBy;
+};
+//#endregion
+//#region src/routes/visibility.d.ts
+/**
+ * Who may see a route.
+ *
+ * - `ALL_USERS` — everyone, signed in or not.
+ * - `NON_LOGGED_IN_USERS` — signed-out visitors only.
+ * - `LOGGED_IN_USERS` — signed-in visitors; with `userGroupIds`, only members of
+ *   at least one of those groups.
+ */
+type RouteVisibility = {
+  userGroup: "ALL_USERS";
+} | {
+  userGroup: "NON_LOGGED_IN_USERS";
+} | {
+  userGroup: "LOGGED_IN_USERS";
+  userGroupIds?: Array<SoftrUserGroupId>;
+};
+/** The route context the root route publishes: the visitor, or `null` when signed out. */
+type SoftrContext = {
+  user: User | null;
+};
+/**
+ * Why a visitor was denied.
+ *
+ * - `unauthenticated` — the route needs a signed-in visitor and there is none.
+ * - `forbidden` — signed in, but in none of the groups the route names.
+ * - `alreadySignedIn` — the route is for signed-out visitors only.
+ */
+declare const ACCESS_REASONS: readonly ["unauthenticated", "forbidden", "alreadySignedIn"];
+type AccessReason = (typeof ACCESS_REASONS)[number];
+/**
+ * What a guard does when it refuses a visitor: redirect to a path, or throw an
+ * {@link AccessError} for the route's `errorComponent` to render. A bare string
+ * is shorthand for redirecting there.
+ */
+type AccessBehaviour = string | {
+  strategy: "redirect";
+  to: string;
+} | {
+  strategy: "throw";
+};
+/** Per-reason overrides of the default {@link AccessBehaviour}. */
+type GuardOverrides = Partial<Record<AccessReason, AccessBehaviour>>;
+/** The result of {@link VisibilityHandle.check}: passed, or denied with a reason. */
+type AccessCheck = {
+  ok: true;
+} | {
+  ok: false;
+  reason: AccessReason;
+};
+/**
+ * The access error a guard throws. It is plain data, not an `Error` subclass, so
+ * take it as `unknown` in an `errorComponent` and narrow it with
+ * {@link isAccessError}. It carries the reason and nothing else: the error is
+ * serialized into the page, so it never names the groups the route wanted.
+ *
+ * @example
+ * errorComponent: ({ error }: { error: unknown }) =>
+ *   isAccessError(error) ? <NoAccess /> : <AppError />
+ */
+type AccessError = {
+  type: "access_error";
+  reason: AccessReason;
+};
+/**
+ * True for any access error thrown by a guard, whatever its reason.
+ *
+ * An access error arrives as `unknown` — hydrated from the page, or thrown by
+ * anything else at all — so every field is checked before it is narrowed.
+ */
+declare function isAccessError(error: unknown): error is AccessError;
+/** True for an access error thrown because nobody was signed in. */
+declare function isUnauthenticatedError(error: unknown): error is AccessError;
+/** True for an access error thrown because the visitor was in none of the groups. */
+declare function isForbiddenError(error: unknown): error is AccessError;
+/** True for an access error thrown because a signed-out-only route saw a user. */
+declare function isAlreadySignedInError(error: unknown): error is AccessError;
+type Narrowed<R extends RouteVisibility> = R extends {
+  userGroup: "LOGGED_IN_USERS";
+} ? SoftrContext & {
+  user: User;
+} : R extends {
+  userGroup: "NON_LOGGED_IN_USERS";
+} ? SoftrContext & {
+  user: null;
+} : SoftrContext;
+/** The four ways to apply a rule, returned by {@link defineVisibility}. */
+type VisibilityHandle<R extends RouteVisibility = RouteVisibility> = {
+  /**
+   * A `beforeLoad` handler that denies a visitor who fails the rule.
+   *
+   * By default an unauthenticated visitor is redirected to `/login`, an already
+   * signed-in one to `/`, and a forbidden one gets an {@link AccessError} thrown
+   * in place, for the route's `errorComponent` to render. Pass `overrides` to
+   * change what any one reason does.
+   *
+   * @example
+   * beforeLoad: visibility.guard({ unauthenticated: "/sign-in" })
+   */
+  guard(overrides?: GuardOverrides): (opts: {
+    context: SoftrContext;
+  }) => void;
+  /**
+   * Throws the same access error or redirect `guard()` would, for code that
+   * needs to run its own checks after the rule.
+   *
+   * @example
+   * beforeLoad: ({ context }) => {
+   *   visibility.assert(context)
+   *   if (context.user.trialExpired) throw redirect({ to: "/renew" })
+   * }
+   */
+  assert(context: SoftrContext): void;
+  /**
+   * Whether the visitor passes the rule. Narrows `context.user` where the rule
+   * allows it.
+   */
+  isAuthorized(context: SoftrContext): context is Narrowed<R>;
+  /** The decision and, when a visitor is refused, the reason. Throws nothing. */
+  check(context: SoftrContext): AccessCheck;
+};
+/**
+ * Declares who may see a route, and returns the handle that enforces it.
+ *
+ * One call per route file, at module scope: the build reads these declarations
+ * to publish the app's route visibility, so the rule must be a literal.
+ *
+ * @example
+ * const visibility = defineVisibility({ userGroup: "LOGGED_IN_USERS" })
+ *
+ * export const Route = createFileRoute("/about")({
+ *   beforeLoad: visibility.guard(),
+ *   component: About,
  * })
  */
-declare const getSoftrUser: _tanstack_react_start0.OptionalFetcher<undefined, undefined, Promise<User | null>>;
+declare function defineVisibility<const R extends RouteVisibility>(rule: R): VisibilityHandle<R>;
+//#endregion
+//#region src/types.d.ts
+interface SoftrUser {
+  id: string;
+  email: string;
+  name: string;
+  userGroupIds: Array<SoftrUserGroupId>;
+}
+interface DatasourcePermissions {
+  read: boolean;
+  create: boolean;
+  update: boolean;
+  delete: boolean;
+}
+interface SoftrPermissions {
+  datasources: Record<string, DatasourcePermissions>;
+  workflows: Record<string, boolean>;
+}
+interface SoftrMe {
+  user: SoftrUser | null;
+  permissions: SoftrPermissions;
+}
+type GetByIdOptions = {
+  id: string;
+  where?: never;
+  timeZone?: string;
+};
+type GetByWhereOptions = {
+  id?: never;
+  where: AnyConstructable;
+  timeZone?: string;
+};
+type GetOptions = GetByIdOptions | GetByWhereOptions;
+interface ListOptions {
+  /**
+   * Maps human-readable aliases to Softr field IDs.
+   * When provided, returned fields are keyed by alias instead of raw field ID.
+   */
+  select?: Record<string, string>;
+  where?: AnyConstructable;
+  orderBy?: ConstructableOrderBy | ConstructableOrderBy[];
+  /**
+   * Number of records to return per page. Defaults to 20, max 100.
+   */
+  limit?: number;
+  /**
+   * Offset to start from. Pass the `nextOffset` from a previous result to paginate.
+   * Omit or pass `null` to start from the beginning.
+   */
+  offset?: number | null;
+  /** Override the timezone for this request. */
+  timeZone?: string;
+}
+interface ListResult<T = SoftrRecord> {
+  records: T[];
+  total: number;
+  /** Offset to pass as `offset` in the next call, or `null` when there are no more pages. */
+  nextOffset: number | null;
+}
+interface SoftrRecord {
+  id: string;
+  fields: Record<string, unknown>;
+}
+type AggregationFunction = 'SUM' | 'AVG' | 'MAX' | 'MIN' | 'COUNT' | 'DISTINCT';
+interface MetricOptions {
+  select?: Record<string, string>;
+  where?: AnyConstructable;
+  aggregation: AggregationFunction;
+  /** Field alias (resolved via select) or raw field ID. Not required for COUNT. */
+  field?: string;
+  /** Override the timezone for this request. */
+  timeZone?: string;
+}
+interface MetricResult {
+  value: number | null;
+  executionTimestamp: Date;
+}
+interface ChartDataOptions {
+  select?: Record<string, string>;
+  where?: AnyConstructable;
+  /** Field alias (resolved via select) or raw field ID. */
+  groupBy: string | string[];
+  metrics: Record<string, {
+    field?: string;
+    aggregation: AggregationFunction;
+  }>;
+  orderBy?: ConstructableOrderBy;
+  /** Override the timezone for this request. */
+  timeZone?: string;
+}
+interface ChartDataResult {
+  data: Record<string, unknown>[];
+  executionTimestamp: Date;
+}
+interface CreateOptions {
+  fields: Record<string, unknown>;
+}
+interface UpdateOptions {
+  id: string;
+  fields: Record<string, unknown>;
+}
+interface DatasourceAPI {
+  list(options?: ListOptions): Promise<ListResult>;
+  get(options: GetOptions): Promise<SoftrRecord | null>;
+  create(options: CreateOptions): Promise<SoftrRecord>;
+  update(options: UpdateOptions): Promise<SoftrRecord>;
+  delete(id: string): Promise<void>;
+  metric(options: MetricOptions): Promise<MetricResult>;
+  chartData(options: ChartDataOptions): Promise<ChartDataResult>;
+}
+/**
+ * Proxy fetch for a configured integration (e.g. Google Calendar).
+ * Behaves like the native `fetch` API — requests are forwarded through
+ * Softr's proxy, which handles authentication with the third-party service.
+ *
+ * ⚠️ Caveats (same as the vibe block's `useProxyFetch`):
+ * - Body must be a string — FormData and other binary types are not supported.
+ * - Multi-value headers are flattened.
+ */
+interface IntegrationAPI {
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+}
+interface WorkflowAPI {
+  trigger(payload?: Record<string, unknown>): Promise<void>;
+}
+interface AuthAPI {
+  /** Sign in with email and password. Clears the cached me() result. */
+  login(credentials: {
+    email: string;
+    password: string;
+  }): Promise<void>;
+  /** Sign out the current user. Clears the cached me() result. */
+  logout(): Promise<void>;
+}
+interface SoftrSDK {
+  /**
+   * Fetch the current user and their permissions from /me.
+   * Cached for the lifetime of the instance — create a new instance per request on the server.
+   */
+  me(): Promise<SoftrMe>;
+  auth: AuthAPI;
+  datasource(id: string): DatasourceAPI;
+  integration(id: string): IntegrationAPI;
+  workflow(id: string): WorkflowAPI;
+}
 //#endregion
-//#region src/auth/middleware.d.ts
+//#region src/auth/isomorphic.d.ts
 /**
  * Resolves the Softr visitor for every request, so that `getSoftrUser` and the
  * route guards have someone to check.
@@ -33,5 +652,34 @@ declare const getSoftrUser: _tanstack_react_start0.OptionalFetcher<undefined, un
 declare function softrAuthMiddleware(): _tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, {
   user: User | null;
 }>;
+/**
+ * Returns the signed-in visitor, or `null` when nobody is signed in.
+ *
+ * Await it in the root route's `beforeLoad` to publish the visitor as route
+ * context, which every `defineVisibility` guard then reads. It requires
+ * {@link softrAuthMiddleware} to be registered.
+ *
+ * @example
+ * export const Route = createRootRouteWithContext<SoftrContext>()({
+ *   beforeLoad: async () => ({ user: await getSoftrUser() }),
+ * })
+ */
+declare const getSoftrUser: _tanstack_react_start0.OptionalFetcher<undefined, undefined, Promise<User | null>>;
+//#endregion
+//#region src/core/middleware.d.ts
+/**
+ * TanStack Start middleware. Injects a per-request Softr SDK instance with
+ * cookies forwarded automatically. The base URL is read from VITE_SOFTR_BASE_URL.
+ *
+ * @example
+ * import { withSDK } from '@softr/sdk'
+ *
+ * export const getProjects = createServerFn()
+ *   .middleware([withSDK])
+ *   .handler(({ context }) => context.sdk.datasource('ds_projects').list())
+ */
+declare const withSDK: _tanstack_react_start0.RequestMiddlewareAfterServer<{}, undefined, {
+  sdk: SoftrSDK;
+}>;
 //#endregion
-export { type AccessBehaviour, type AccessCheck, type AccessError, type AccessReason, type AggregationFunction, type AuthAPI, type ChartDataOptions, type ChartDataResult, type CreateOptions, type DatasourceAPI, type DatasourcePermissions, type GetOptions, type IntegrationAPI, type ListOptions, type ListResult, type MetricOptions, type MetricResult, type RouteVisibility, type SoftrContext, type SoftrMe, type SoftrPermissions, type SoftrRecord, type SoftrSDK, type SoftrUser, type SoftrUserGroupId, type SoftrUserGroups, type UpdateOptions, type User, type VisibilityHandle, type WorkflowAPI, defineVisibility, getSoftrUser, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError, q, softrAuthMiddleware };
+export { type AccessBehaviour, type AccessCheck, type AccessError, type AccessReason, type AggregationFunction, type AuthAPI, type ChartDataOptions, type ChartDataResult, type CreateOptions, type DatasourceAPI, type DatasourcePermissions, type GetOptions, type IntegrationAPI, type ListOptions, type ListResult, type MetricOptions, type MetricResult, type RouteVisibility, type SoftrContext, type SoftrMe, type SoftrPermissions, type SoftrRecord, type SoftrSDK, type SoftrUser, type SoftrUserGroupId, type SoftrUserGroups, type UpdateOptions, type User, type VisibilityHandle, type WorkflowAPI, defineVisibility, getSoftrUser, isAccessError, isAlreadySignedInError, isForbiddenError, isUnauthenticatedError, q, softrAuthMiddleware, withSDK };