@farm.js/core 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/client-Nn0q4eO4.d.ts

@@ -0,0 +1,447 @@
+import { F as FarmIntegrationAPI, a as FarmIntegrationAPIOperation } from './integration-api-CHT2OKAf.js';
+import { F as FarmClientCacheKey } from './client-cache-CIlyBlmx.js';
+import { DefinedCacheKey, RouteDataCacheKey, InferCacheKeyData } from './cache.js';
+import { F as FarmAPIStream } from './transport-BmbGTXA5.js';
+
+/**
+ * Small per-call integration metadata. When sent from a browser, values are
+ * client-controlled and should be validated before authorization decisions.
+ */
+type IntegrationClientData = Record<string, unknown>;
+type IntegrationClientOptions = {
+    baseURL?: string;
+    headers?: Record<string, string>;
+    credentials?: RequestCredentials;
+    data?: IntegrationClientData;
+    isServer?: false | undefined;
+};
+type IntegrationRequestOptionsBase = {
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    credentials?: RequestCredentials;
+    data?: IntegrationClientData;
+};
+type IntegrationClientRequestOptions = IntegrationRequestOptionsBase;
+type IntegrationServerRequestLike = Request | {
+    url?: string;
+    headers?: HeadersInit;
+};
+type IntegrationServerClientOptions = Omit<IntegrationClientOptions, "isServer"> & {
+    isServer: true;
+    request?: IntegrationServerRequestLike;
+    forwardHeaders?: boolean | readonly string[];
+};
+type IntegrationServerClientRequestOptions = IntegrationRequestOptionsBase & {
+    baseURL?: string;
+    request?: IntegrationServerRequestLike;
+    forwardHeaders?: boolean | readonly string[];
+};
+declare class IntegrationClientError<TData = unknown> extends Error {
+    readonly status: number;
+    readonly response: Response;
+    readonly data: TData | undefined;
+    constructor(message: string, response: Response, data?: TData);
+}
+type IntegrationOperationResult<TData = unknown, TError = IntegrationClientError<unknown> | Error> = {
+    data: TData | null;
+    error: TError | null;
+};
+type ExtractOperationBody<T> = T extends {
+    __types?: {
+        body: infer TBody;
+    };
+} ? TBody : never;
+type ExtractOperationQuery<T> = T extends {
+    __types?: {
+        query: infer TQuery;
+    };
+} ? TQuery : never;
+type ExtractOperationResponse<T> = T extends {
+    __types?: {
+        response: infer TResponse;
+    };
+} ? TResponse : unknown;
+type InferIntegrationOperationBody<T> = ExtractOperationBody<T>;
+type InferIntegrationOperationQuery<T> = ExtractOperationQuery<T>;
+type InferIntegrationOperationResponse<T> = ExtractOperationResponse<T>;
+type IsNever$1<T> = [T] extends [never] ? true : false;
+type OperationInput<T> = IsNever$1<ExtractOperationBody<T>> extends true ? IsNever$1<ExtractOperationQuery<T>> extends true ? {} : {
+    query?: ExtractOperationQuery<T>;
+} : IsNever$1<ExtractOperationQuery<T>> extends true ? {
+    body: ExtractOperationBody<T>;
+} : {
+    body: ExtractOperationBody<T>;
+    query?: ExtractOperationQuery<T>;
+};
+type ClientOperation<T> = (options?: OperationInput<T>, requestOptions?: IntegrationClientRequestOptions) => Promise<IntegrationOperationResult<ExtractOperationResponse<T>>>;
+type ServerOperation<T> = (options?: OperationInput<T>, requestOptions?: IntegrationServerClientRequestOptions) => Promise<IntegrationOperationResult<ExtractOperationResponse<T>>>;
+type IsUnion<T, U = T> = T extends any ? ([U] extends [T] ? false : true) : never;
+type SingleKey<T> = [T] extends [never] ? never : IsUnion<T> extends true ? never : T;
+type ExtractAPIFromSource<TSource> = TSource extends {
+    api?: infer TAPI;
+} ? NonNullable<TAPI> extends FarmIntegrationAPI ? NonNullable<TAPI> : never : TSource extends FarmIntegrationAPI ? TSource : never;
+type SourceKeysWithAPI<TSources extends Record<string, any>> = {
+    [K in keyof TSources]: [ExtractAPIFromSource<TSources[K]>] extends [never] ? never : K;
+}[keyof TSources];
+type IsServerRegisteredOperation<T> = T extends {
+    isServer: true;
+} ? true : false;
+type ClientOperationKeys<TAPI> = {
+    [K in keyof TAPI]: TAPI[K] extends FarmIntegrationAPIOperation<any, any, any, any> ? IsServerRegisteredOperation<TAPI[K]> extends true ? never : K : never;
+}[keyof TAPI];
+type ClientNamespaceShape<TAPI> = {
+    [K in keyof TAPI as TAPI[K] extends FarmIntegrationAPIOperation<any, any, any, any> ? IsServerRegisteredOperation<TAPI[K]> extends true ? never : K : K]: TAPI[K] extends FarmIntegrationAPIOperation<any, any, any, any> ? ClientOperation<TAPI[K]> : TAPI[K] extends Record<string, any> ? IntegrationAPIToClient<TAPI[K]> : never;
+};
+type SingleClientOperationKey<TAPI> = Exclude<keyof TAPI, ClientOperationKeys<TAPI>> extends never ? SingleKey<ClientOperationKeys<TAPI>> : never;
+type IntegrationAPIToClient<TAPI> = TAPI extends FarmIntegrationAPIOperation<any, any, any, any> ? ClientOperation<TAPI> : TAPI extends Record<string, any> ? [SingleClientOperationKey<TAPI>] extends [never] ? ClientNamespaceShape<TAPI> : SingleClientOperationKey<TAPI> extends keyof TAPI ? ClientOperation<TAPI[SingleClientOperationKey<TAPI>]> & ClientNamespaceShape<TAPI> : ClientNamespaceShape<TAPI> : never;
+type IntegrationClient<TSources extends Record<string, any>> = {
+    [K in SourceKeysWithAPI<TSources>]: IntegrationAPIToClient<ExtractAPIFromSource<TSources[K]>>;
+};
+type IntegrationClientRoot<TSources extends Record<string, any>> = {
+    integrations: IntegrationClient<TSources>;
+};
+type ServerOperationKeys<TAPI> = {
+    [K in keyof TAPI]: TAPI[K] extends FarmIntegrationAPIOperation<any, any, any> ? K : never;
+}[keyof TAPI];
+type ServerNamespaceShape<TAPI> = {
+    [K in keyof TAPI]: TAPI[K] extends FarmIntegrationAPIOperation<any, any, any> ? ServerOperation<TAPI[K]> : TAPI[K] extends Record<string, any> ? IntegrationAPIToServerClient<TAPI[K]> : never;
+};
+type SingleServerOperationKey<TAPI> = Exclude<keyof TAPI, ServerOperationKeys<TAPI>> extends never ? SingleKey<ServerOperationKeys<TAPI>> : never;
+type IntegrationAPIToServerClient<TAPI> = TAPI extends FarmIntegrationAPIOperation<any, any, any> ? ServerOperation<TAPI> : TAPI extends Record<string, any> ? [SingleServerOperationKey<TAPI>] extends [never] ? ServerNamespaceShape<TAPI> : SingleServerOperationKey<TAPI> extends keyof TAPI ? ServerOperation<TAPI[SingleServerOperationKey<TAPI>]> & ServerNamespaceShape<TAPI> : ServerNamespaceShape<TAPI> : never;
+type IntegrationServerClient<TSources extends Record<string, any>> = {
+    [K in SourceKeysWithAPI<TSources>]: IntegrationAPIToServerClient<ExtractAPIFromSource<TSources[K]>>;
+};
+type IntegrationServerClientRoot<TSources extends Record<string, any>> = {
+    integrations: IntegrationServerClient<TSources>;
+};
+type IntegrationClientAliases<TSources extends Record<string, any>> = IntegrationClient<TSources> & {
+    integrations: IntegrationClient<TSources>;
+};
+type IntegrationServerClientAliases<TSources extends Record<string, any>> = IntegrationServerClient<TSources> & {
+    integrations: IntegrationServerClient<TSources>;
+};
+type IntegrationAPI<TSources extends Record<string, any>> = IntegrationClientAliases<TSources> & {
+    server: (options: Omit<IntegrationServerClientOptions, "isServer">) => IntegrationServerClientAliases<TSources>;
+};
+type IntegrationClients<TSources extends Record<string, any>> = {
+    api: IntegrationServerClientAliases<TSources>;
+    apiClient: IntegrationClientAliases<TSources>;
+};
+declare function createIntegrationClient<TSources extends Record<string, any>>(sources: {
+    integrations: TSources;
+}, options: IntegrationServerClientOptions): IntegrationServerClientAliases<TSources>;
+declare function createIntegrationClient<TSources extends Record<string, any>>(sources: {
+    integrations: TSources;
+}, options?: IntegrationClientOptions): IntegrationClientAliases<TSources>;
+declare function createIntegrationClient<TSources extends Record<string, any>>(sources: TSources, options: IntegrationServerClientOptions): IntegrationServerClient<TSources>;
+declare function createIntegrationClient<TSources extends Record<string, any>>(sources: TSources, options?: IntegrationClientOptions): IntegrationClient<TSources>;
+declare function integrationsClient<TSources extends Record<string, any>>(): IntegrationClientAliases<TSources>;
+declare function integrationsClient<TSources extends Record<string, any>>(options: IntegrationClientOptions): IntegrationClientAliases<TSources>;
+declare function integrationsServer<TSources extends Record<string, any>>(): IntegrationServerClientAliases<TSources>;
+declare function integrationsServer<TSources extends Record<string, any>>(options: Omit<IntegrationServerClientOptions, "isServer">): IntegrationServerClientAliases<TSources>;
+declare function createIntegrationServerClient<TSources extends Record<string, any>>(sources: {
+    integrations: TSources;
+}): IntegrationServerClientAliases<TSources>;
+declare function createIntegrationServerClient<TSources extends Record<string, any>>(sources: TSources): IntegrationServerClient<TSources>;
+declare function createIntegrationServerClient<TSources extends Record<string, any>>(sources: {
+    integrations: TSources;
+}, options: Omit<IntegrationServerClientOptions, "isServer">): IntegrationServerClientAliases<TSources>;
+declare function createIntegrationServerClient<TSources extends Record<string, any>>(sources: TSources, options: Omit<IntegrationServerClientOptions, "isServer">): IntegrationServerClient<TSources>;
+declare function createIntegrationApi<TSources extends Record<string, any>>(sources: {
+    integrations: TSources;
+}, options?: IntegrationClientOptions): IntegrationAPI<TSources>;
+declare function createIntegrationClients<TSources extends Record<string, any>>(clientOptions?: IntegrationClientOptions, serverOptions?: Omit<IntegrationServerClientOptions, "isServer">): IntegrationClients<TSources>;
+declare function createIntegrationClients<TSources extends Record<string, any>>(sources: TSources, clientOptions?: IntegrationClientOptions, serverOptions?: Omit<IntegrationServerClientOptions, "isServer">): IntegrationClients<TSources>;
+declare function createIntegrationClients<TSources extends Record<string, any>>(sources: {
+    integrations: TSources;
+}, clientOptions?: IntegrationClientOptions, serverOptions?: Omit<IntegrationServerClientOptions, "isServer">): IntegrationClients<TSources>;
+declare function createIntegrations<TSources extends Record<string, any>>(clientOptions?: IntegrationClientOptions, serverOptions?: Omit<IntegrationServerClientOptions, "isServer">): IntegrationClients<TSources>;
+declare function createIntegrations<TSources extends Record<string, any>>(sources: TSources, clientOptions?: IntegrationClientOptions, serverOptions?: Omit<IntegrationServerClientOptions, "isServer">): IntegrationClients<TSources>;
+declare function createIntegrations<TSources extends Record<string, any>>(sources: {
+    integrations: TSources;
+}, clientOptions?: IntegrationClientOptions, serverOptions?: Omit<IntegrationServerClientOptions, "isServer">): IntegrationClients<TSources>;
+declare function getIntegrationAPIManifest(): Record<string, FarmIntegrationAPI>;
+declare function integrationClients<TSources extends Record<string, any>>(clientOptions?: IntegrationClientOptions, serverOptions?: Omit<IntegrationServerClientOptions, "isServer">): IntegrationClients<TSources>;
+declare function integrationClients<TSources extends Record<string, any>>(sources: TSources, clientOptions?: IntegrationClientOptions, serverOptions?: Omit<IntegrationServerClientOptions, "isServer">): IntegrationClients<TSources>;
+declare function integrationClients<TSources extends Record<string, any>>(sources: {
+    integrations: TSources;
+}, clientOptions?: IntegrationClientOptions, serverOptions?: Omit<IntegrationServerClientOptions, "isServer">): IntegrationClients<TSources>;
+
+declare const FARM_API_ROUTE_REF_SYMBOL: unique symbol;
+declare const FARM_API_ROUTE_META_SYMBOL: unique symbol;
+type APIRouteRefMetadata = {
+    path: string;
+    method: string;
+    baseURL: string;
+    sameOrigin: boolean;
+};
+type APIClientOptions = {
+    baseURL?: string;
+    headers?: Record<string, string>;
+    credentials?: RequestCredentials;
+    cacheDefaults?: CacheOptions;
+    integrations?: IntegrationClientOptions;
+};
+type APIClientWithoutIntegrationsOptions = Omit<APIClientOptions, "integrations"> & {
+    integrations: false;
+};
+type ServerAPIClientOptions = {
+    integrations?: Omit<IntegrationServerClientOptions, "isServer">;
+};
+type ServerAPIClientWithoutIntegrationsOptions = Omit<ServerAPIClientOptions, "integrations"> & {
+    integrations: false;
+};
+type StatusPhase = "idle" | "pending" | "success" | "error" | "revalidating" | "invalidated";
+type StatusEvent<TData = unknown, TError = unknown> = {
+    phase: StatusPhase;
+    requestId: string;
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD";
+    key: string;
+    input?: unknown;
+    data?: TData;
+    error?: TError;
+    isBackground?: boolean;
+    timestamp: number;
+};
+type CacheKey<TData = unknown> = string & {
+    readonly __farmCacheData?: TData;
+};
+type APIResult<TData = unknown, TError = Error> = {
+    data: TData | undefined;
+    error: TError | null;
+    key: CacheKey<TData>;
+};
+declare class APIClientError<TCode extends string = string, TData = unknown, TStatus extends number = number> extends Error {
+    readonly code: TCode;
+    readonly data: TData;
+    readonly status: TStatus;
+    readonly response?: Response;
+    constructor(code: TCode, data: TData, options: {
+        status: TStatus;
+        message: string;
+        response?: Response;
+    });
+}
+type APIClientSystemError = APIClientError<"http_error", unknown, number> | APIClientError<"network_error", unknown, 0>;
+type RequestEvent = {
+    requestId: string;
+    method: StatusEvent["method"];
+    key: string;
+    path: string;
+    input?: unknown;
+    attempt: number;
+    timestamp: number;
+};
+type ResponseEvent<TData = unknown, TError = Error> = {
+    requestId: string;
+    method: StatusEvent["method"];
+    key: string;
+    path: string;
+    input?: unknown;
+    attempt: number;
+    timestamp: number;
+    response?: Response;
+    data?: TData;
+    error?: TError;
+    ok?: boolean;
+    status?: number;
+};
+type CachePolicy = "cache-first" | "network-only" | "stale-while-revalidate";
+type CacheOptions = {
+    key?: FarmClientCacheKey;
+    policy?: CachePolicy;
+    staleTime?: number;
+    gcTime?: number;
+    dedupeMs?: number;
+};
+type RetryOptions = {
+    count?: number;
+    delay?: number | ((attempt: number) => number);
+};
+type InvalidateTarget = FarmClientCacheKey | {
+    key: FarmClientCacheKey;
+} | {
+    path: string;
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD";
+    input?: unknown;
+} | [CallableRouteRef<any>, unknown?];
+type InvalidateOptions = InvalidateTarget[] | {
+    targets: InvalidateTarget[];
+    refetch?: boolean;
+};
+type OptimisticUpdate = [CallableRouteRef<any>, unknown, (prev: any) => any] | [CacheKey<any> | DefinedCacheKey<any> | string, (prev: any) => any];
+type OptimisticOptions<TUpdates extends readonly unknown[] = readonly OptimisticUpdate[]> = {
+    update: TUpdates & NormalizeOptimisticUpdates<TUpdates>;
+    rollbackOnError?: boolean;
+};
+type ClientOptions<TData = unknown, TError = unknown, TUpdates extends readonly unknown[] = readonly OptimisticUpdate[]> = {
+    key?: CacheKey<TData> | FarmClientCacheKey;
+    cache?: CacheOptions;
+    retry?: RetryOptions;
+    invalidate?: InvalidateOptions;
+    optimistic?: OptimisticOptions<TUpdates>;
+    onRequest?: (event: RequestEvent) => void;
+    onResponse?: (data: TData | undefined, error: TError | null, event: ResponseEvent<TData, TError>) => void;
+    onSuccess?: (data: TData) => void;
+    onError?: (err: TError) => void;
+    onSettled?: (data?: TData, err?: TError | null) => void;
+    onStatus?: (event: StatusEvent<TData, TError>) => void;
+};
+type AnyRouteRef = (...args: any[]) => any;
+type RouteRef<TData = any, TInput = any> = {
+    readonly __farmRouteInput: TInput;
+    readonly __farmRouteData: TData;
+};
+type CallableRouteRef<TData = any, TInput = any> = AnyRouteRef & RouteRef<TData, TInput>;
+type InferRouteInput<TRoute> = TRoute extends {
+    readonly __farmRouteInput: infer TInput;
+} ? TInput : never;
+type InferRouteData<TRoute> = TRoute extends {
+    readonly __farmRouteData: infer TData;
+} ? TData : never;
+type NormalizeOptimisticUpdate<TUpdate> = TUpdate extends readonly [
+    infer TRoute,
+    unknown,
+    (prev: any) => any
+] ? TRoute extends RouteRef<any, any> ? [
+    TRoute,
+    InferRouteInput<TRoute> | undefined,
+    (prev: InferRouteData<TRoute> | undefined) => InferRouteData<TRoute>
+] : never : TUpdate extends readonly [infer TKey, (prev: any) => any] ? TKey extends DefinedCacheKey<any, RouteDataCacheKey> ? [TKey, (prev: InferCacheKeyData<TKey> | undefined) => InferCacheKeyData<TKey>] : TKey extends CacheKey<infer TData> ? [TKey, (prev: TData | undefined) => TData] : TKey extends string ? [TKey, (prev: unknown) => unknown] : never : never;
+type NormalizeOptimisticUpdates<TUpdates extends readonly unknown[]> = {
+    [K in keyof TUpdates]: NormalizeOptimisticUpdate<TUpdates[K]>;
+};
+type TypedEndpointLike = {
+    __types: {
+        body: any;
+        query: any;
+        response: any;
+        errors?: any;
+    };
+};
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type IsNever<T> = [T] extends [never] ? true : false;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type RequiredKeys<T> = T extends object ? {
+    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+}[keyof T] : never;
+type BodyInputProp<TValue> = IsNever<TValue> extends true ? {} : IsAny<TValue> extends true ? {
+    body?: TValue;
+} : undefined extends TValue ? {
+    body?: TValue;
+} : {
+    body: TValue;
+};
+type QueryInputProp<TValue> = IsNever<TValue> extends true ? {} : IsAny<TValue> extends true ? {
+    query?: TValue;
+} : undefined extends TValue ? {
+    query?: TValue;
+} : RequiredKeys<TValue> extends never ? {
+    query?: TValue;
+} : {
+    query: TValue;
+};
+type HasRequiredKeys<T> = RequiredKeys<T> extends never ? false : true;
+type InferEndpointBody<T> = T extends {
+    __types: {
+        inputBody: infer TInputBody;
+    };
+} ? TInputBody : T extends {
+    __types: {
+        body: infer TBody;
+    };
+} ? TBody : never;
+type InferEndpointInput<T> = T extends {
+    __types: {
+        query: infer TQuery;
+    };
+} ? Simplify<BodyInputProp<InferEndpointBody<T>> & QueryInputProp<TQuery>> : {};
+type InferEndpointOutput<T> = T extends {
+    __types: {
+        response: infer R;
+    };
+} ? R extends {
+    readonly __farmStreamItem: infer TItem;
+} ? FarmAPIStream<TItem> : R : any;
+type InferEndpointError<T> = T extends {
+    __types: {
+        errors: infer TErrors;
+    };
+} ? keyof TErrors extends never ? Error : {
+    [TCode in keyof TErrors]: TErrors[TCode] extends {
+        data: infer TData;
+        status: infer TStatus extends number;
+    } ? APIClientError<TCode & string, TData, TStatus> : never;
+}[keyof TErrors] | APIClientSystemError : Error;
+type EndpointMethod<T = any> = (<TUpdates extends readonly unknown[] = readonly OptimisticUpdate[]>(...args: HasRequiredKeys<InferEndpointInput<T>> extends true ? [
+    options: InferEndpointInput<T>,
+    clientOptions?: ClientOptions<InferEndpointOutput<T>, InferEndpointError<T>, TUpdates>
+] : [
+    options?: InferEndpointInput<T>,
+    clientOptions?: ClientOptions<InferEndpointOutput<T>, InferEndpointError<T>, TUpdates>
+]) => Promise<APIResult<InferEndpointOutput<T>, InferEndpointError<T>>>) & RouteRef<InferEndpointOutput<T>, InferEndpointInput<T>>;
+type RouterToClient<T> = {
+    [K in keyof T]: T[K] extends TypedEndpointLike ? EndpointMethod<T[K]> : T[K] extends Record<string, any> ? RouterToClient<T[K]> : EndpointMethod<T[K]>;
+};
+type RouteAPIClient<TRouter extends Record<string, any>> = RouterToClient<TRouter>;
+type APIClient<TRouter extends Record<string, any>, TIntegrations extends Record<string, any> = {}> = RouteAPIClient<TRouter> & IntegrationClientRoot<TIntegrations>;
+type ServerAPIClient<TEndpoints extends Record<string, any>, TIntegrations extends Record<string, any> = {}> = TEndpoints & IntegrationServerClientRoot<TIntegrations>;
+/**
+ * Create a typed RPC client for Farm.js API routes
+ *
+ * Returns a nested proxy that supports:
+ * - api.hello.get({ query: { name: 'World' } })
+ * - api['auth/login'].post({ body: { email: '...', password: '...' } })
+ * - api.users.get({ query: { limit: '10' } })
+ * - api.integrations.billing.checkout({ body: { priceId: 'price_...' } })
+ *
+ * @example
+ * ```typescript
+ * import { createAPIClient } from 'farm/client';
+ * import type { APIRouter } from '@/api';
+ * import type { AppIntegrations } from '@/lib/integrations';
+ *
+ * export const api = createAPIClient<APIRouter, AppIntegrations>();
+ *
+ * // Use it (nested property access)
+ * const result = await api.hello.get({ query: { name: 'World' } });
+ * if (result.error) console.error(result.error);
+ * else console.log(result.data);
+ *
+ * // Or with string keys for nested paths
+ * const result = await api['auth/login'].post({
+ *   body: { email: 'test@example.com', password: 'pass123' }
+ * });
+ *
+ * // Integration APIs live under a reserved namespace.
+ * const checkout = await api.integrations.billing.checkout({
+ *   body: { priceId: 'price_123' }
+ * });
+ * ```
+ */
+declare function createAPIClient<TRouter extends Record<string, any>>(options: APIClientWithoutIntegrationsOptions): RouteAPIClient<TRouter>;
+declare function createAPIClient<TRouter extends Record<string, any>, TIntegrations extends Record<string, any> = {}>(options?: APIClientOptions): APIClient<TRouter, TIntegrations>;
+declare function isAPIRouteRef(value: unknown): value is CallableRouteRef;
+declare function getAPIRouteRefMetadata(value: unknown): APIRouteRefMetadata | null;
+/**
+ * Server-side API client that calls endpoints directly as functions
+ * No HTTP overhead for app endpoints, and registered integration routes can be exposed at
+ * api.integrations.* where Farm can dispatch them directly to the integration handler.
+ *
+ * @example
+ * ```typescript
+ * import { createServerAPIClient } from 'farm/client';
+ * import type { AppIntegrations } from '@/lib/integrations';
+ *
+ * export const api = createServerAPIClient<{}, AppIntegrations>({});
+ *
+ * const result = await api.integrations.billing.status();
+ * ```
+ */
+declare function createServerAPIClient<TEndpoints extends Record<string, any>>(endpoints: TEndpoints): TEndpoints;
+declare function createServerAPIClient<TEndpoints extends Record<string, any>>(endpoints: TEndpoints, options: ServerAPIClientWithoutIntegrationsOptions): TEndpoints;
+declare function createServerAPIClient<TEndpoints extends Record<string, any>, TIntegrations extends Record<string, any> = {}>(endpoints: TEndpoints, options?: ServerAPIClientOptions): ServerAPIClient<TEndpoints, TIntegrations>;
+
+export { type IntegrationServerClientAliases as $, type APIRouteRefMetadata as A, createIntegrationClients as B, type CacheKey as C, createIntegrations as D, createIntegrationServerClient as E, FARM_API_ROUTE_REF_SYMBOL as F, getIntegrationAPIManifest as G, integrationClients as H, type InvalidateTarget as I, integrationsClient as J, integrationsServer as K, type IntegrationClient as L, type IntegrationClientAliases as M, type IntegrationClientRoot as N, type OptimisticUpdate as O, type IntegrationClientOptions as P, type IntegrationClientRequestOptions as Q, type RequestEvent as R, type ServerAPIClientOptions as S, type IntegrationAPI as T, type IntegrationClients as U, type IntegrationClientData as V, type IntegrationOperationResult as W, type InferIntegrationOperationBody as X, type InferIntegrationOperationQuery as Y, type InferIntegrationOperationResponse as Z, type IntegrationServerClient as _, FARM_API_ROUTE_META_SYMBOL as a, type IntegrationServerClientOptions as a0, type IntegrationServerClientRequestOptions as a1, type IntegrationServerClientRoot as a2, type IntegrationServerRequestLike as a3, type APIClientOptions as b, type APIClientWithoutIntegrationsOptions as c, type ServerAPIClientWithoutIntegrationsOptions as d, type StatusPhase as e, type StatusEvent as f, type APIResult as g, APIClientError as h, type APIClientSystemError as i, type ResponseEvent as j, type CachePolicy as k, type CacheOptions as l, type RetryOptions as m, type InvalidateOptions as n, type OptimisticOptions as o, type ClientOptions as p, type RouteAPIClient as q, type APIClient as r, type ServerAPIClient as s, createAPIClient as t, isAPIRouteRef as u, getAPIRouteRefMetadata as v, createServerAPIClient as w, createIntegrationClient as x, IntegrationClientError as y, createIntegrationApi as z };

package/dist/client-cache-CIlyBlmx.d.ts

@@ -0,0 +1,6 @@
+import { RouteDataCacheKey } from './cache.js';
+
+type FarmClientCacheKey = RouteDataCacheKey;
+type FarmClientCacheStatus = "idle" | "pending" | "success" | "error";
+
+export type { FarmClientCacheKey as F, FarmClientCacheStatus as a };

package/dist/client-cache-D-EZ7XVW.d.mts

@@ -0,0 +1,6 @@
+import { RouteDataCacheKey } from './cache.mjs';
+
+type FarmClientCacheKey = RouteDataCacheKey;
+type FarmClientCacheStatus = "idle" | "pending" | "success" | "error";
+
+export type { FarmClientCacheKey as F, FarmClientCacheStatus as a };