@farm.js/core 0.1.0-beta.0

package/dist/client-D_yUjVhe.d.mts

@@ -0,0 +1,402 @@
+import { F as FarmIntegrationAPI, a as FarmIntegrationAPIOperation } from './integration-api-CHT2OKAf.mjs';
+import { F as FarmClientCacheKey } from './client-cache-D-EZ7XVW.mjs';
+
+/**
+ * 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>;
+
+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>;
+};
+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 = string | {
+    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> | 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 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;
+    };
+};
+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 InferEndpointInput<T> = T extends {
+    __types: {
+        body: infer TBody;
+        query: infer TQuery;
+    };
+} ? Simplify<BodyInputProp<TBody> & QueryInputProp<TQuery>> : {};
+type InferEndpointOutput<T> = T extends {
+    __types: {
+        response: infer R;
+    };
+} ? R : any;
+type EndpointMethod<T = any> = (<TUpdates extends readonly unknown[] = readonly OptimisticUpdate[]>(...args: HasRequiredKeys<InferEndpointInput<T>> extends true ? [
+    options: InferEndpointInput<T>,
+    clientOptions?: ClientOptions<InferEndpointOutput<T>, Error, TUpdates>
+] : [
+    options?: InferEndpointInput<T>,
+    clientOptions?: ClientOptions<InferEndpointOutput<T>, Error, TUpdates>
+]) => Promise<APIResult<InferEndpointOutput<T>, Error>>) & 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>;
+/**
+ * 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 APIClientOptions as A, integrationsServer as B, type CacheKey as C, type IntegrationClient as D, type IntegrationClientAliases as E, type IntegrationClientRoot as F, type IntegrationClientOptions as G, type IntegrationClientRequestOptions as H, type InvalidateTarget as I, type IntegrationAPI as J, type IntegrationClients as K, type IntegrationClientData as L, type IntegrationOperationResult as M, type InferIntegrationOperationBody as N, type OptimisticUpdate as O, type InferIntegrationOperationQuery as P, type InferIntegrationOperationResponse as Q, type RequestEvent as R, type ServerAPIClientOptions as S, type IntegrationServerClient as T, type IntegrationServerClientAliases as U, type IntegrationServerClientOptions as V, type IntegrationServerClientRequestOptions as W, type IntegrationServerClientRoot as X, type IntegrationServerRequestLike as Y, type APIClientWithoutIntegrationsOptions as a, type ServerAPIClientWithoutIntegrationsOptions as b, type StatusPhase as c, type StatusEvent as d, type APIResult as e, type ResponseEvent as f, type CachePolicy as g, type CacheOptions as h, type RetryOptions as i, type InvalidateOptions as j, type OptimisticOptions as k, type ClientOptions as l, type RouteAPIClient as m, type APIClient as n, type ServerAPIClient as o, createAPIClient as p, createServerAPIClient as q, createIntegrationClient as r, IntegrationClientError as s, createIntegrationApi as t, createIntegrationClients as u, createIntegrations as v, createIntegrationServerClient as w, getIntegrationAPIManifest as x, integrationClients as y, integrationsClient as z };