@collective-intelligence/external-apps-client-sdk-react 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,2 @@
+"use client";
+import{EntityForm,EntityList,EntityRuntimeProvider,EntityTable,FederatedAuthError,__export,createDelegatedEntitySource,defineEntity,useEntityViewState,useMemoryEntityViewState}from"./index-6memxjn1.js";var exports_src={};__export(exports_src,{useWorkflows:()=>useWorkflows,useSkills:()=>useSkills,useSession:()=>useSession,useRuns:()=>useRuns,useOrganizationClient:()=>useOrganizationClient,useMemoryEntityViewState:()=>useMemoryEntityViewState,useKnowledge:()=>useKnowledge,useEntityViewState:()=>useEntityViewState,useCollectiveIntelligenceClient:()=>useCollectiveIntelligenceClient,useCollectiveIntelligenceAuth:()=>useCollectiveIntelligenceAuth,useClientContext:()=>useClientContext,useAttachments:()=>useAttachments,useAgents:()=>useAgents,useAgentInvocation:()=>useAgentInvocation,defineEntity:()=>defineEntity,createPromptKeyHandler:()=>createPromptKeyHandler,createDelegatedEntitySource:()=>createDelegatedEntitySource,clientSdkReactEntrypoint:()=>clientSdkReactEntrypoint,SessionGate:()=>SessionGate,LoginCallbackPrimitive:()=>LoginCallbackPrimitive,LoginCallback:()=>LoginCallback,LoginButton:()=>LoginButton,EntityTable:()=>EntityTable,EntityList:()=>EntityList,EntityForm:()=>EntityForm,CollectiveIntelligenceProvider:()=>CollectiveIntelligenceProvider,CollectiveIntelligenceLoginProvider:()=>CollectiveIntelligenceLoginProvider,AgentPromptPrimitive:()=>AgentPromptPrimitive,AgentPrompt:()=>AgentPrompt});import{useCallback,useId,useState as useState2}from"react";import{QueryClient,QueryClientProvider}from"@tanstack/react-query";import{createContext,useContext,useMemo,useState}from"react";import{jsxDEV}from"react/jsx-dev-runtime";var ClientContext=createContext(null);var CollectiveIntelligenceProvider=(props)=>{const{clientFactory}=props;const[queryClient]=useState(()=>new QueryClient({defaultOptions:{mutations:{retry:false},queries:{retry:false}}}));const ownedClient=useMemo(()=>clientFactory===undefined?undefined:clientFactory(),[clientFactory]);const client=props.client??ownedClient;if(client===undefined){throw new TypeError("A client or clientFactory is required")}return jsxDEV(ClientContext.Provider,{value:client,children:jsxDEV(QueryClientProvider,{client:queryClient,children:props.entitySource===undefined?props.children:jsxDEV(EntityRuntimeProvider,{source:props.entitySource,children:props.children},undefined,false,undefined,this)},undefined,false,undefined,this)},undefined,false,undefined,this)};var useCollectiveIntelligenceClient=()=>{const client=useContext(ClientContext);if(client===null){throw new Error("CollectiveIntelligenceProvider must wrap Collective Intelligence hooks")}return client};var useOrganizationClient=(organizationId)=>{const client=useCollectiveIntelligenceClient();return useMemo(()=>client.forOrganization(organizationId),[client,organizationId])};var useKnowledge=(organizationId)=>useOrganizationClient(organizationId).knowledge;var useAgents=(organizationId)=>useOrganizationClient(organizationId).agents;var useSkills=(organizationId)=>useOrganizationClient(organizationId).skills;var useWorkflows=(organizationId)=>useOrganizationClient(organizationId).workflows;var useRuns=(organizationId)=>useOrganizationClient(organizationId).runs;var useAttachments=(organizationId)=>useOrganizationClient(organizationId).attachments;var useClientContext=(organizationId)=>useOrganizationClient(organizationId).context;import{jsxDEV as jsxDEV2}from"react/jsx-dev-runtime";var ignoreSubmit=()=>false;var createPromptKeyHandler=(onSubmit)=>(event)=>{if(event.key==="Enter"&&!event.shiftKey&&!event.isComposing){event.preventDefault();onSubmit()}};var AgentPromptPrimitive=({autoFocus=false,className,components,id,label,onChange,onSubmit,pending,status,style,submitLabel="Send",value})=>{const Form=components?.Form??"form";const Label=components?.Label??"label";const Textarea=components?.Textarea??"textarea";const Button=components?.Button??"button";const Status=components?.Status??"div";const statusId=`${id}-status`;const submit=(event)=>{event.preventDefault();if(!pending){onSubmit()}};const onKeyDown=(event)=>{createPromptKeyHandler(pending?ignoreSubmit:onSubmit)({isComposing:event.nativeEvent.isComposing,key:event.key,preventDefault:()=>{event.preventDefault()},shiftKey:event.shiftKey})};return jsxDEV2(Form,{className:["ci-agent-prompt",className].filter(Boolean).join(" "),onSubmit:submit,style,children:[jsxDEV2(Label,{className:"ci-agent-prompt__label",htmlFor:id,children:label},undefined,false,undefined,this),jsxDEV2(Textarea,{"aria-describedby":statusId,autoFocus,className:"ci-agent-prompt__input",disabled:pending,id,onChange:(event)=>{onChange(event.currentTarget.value)},onKeyDown,value},undefined,false,undefined,this),jsxDEV2(Button,{className:"ci-agent-prompt__submit",disabled:pending||value.trim().length===0,type:"submit",children:submitLabel},undefined,false,undefined,this),jsxDEV2(Status,{"aria-live":"polite",className:"ci-agent-prompt__status",id:statusId,children:status},undefined,false,undefined,this)]},undefined,true,undefined,this)};var useAgentInvocation=(organizationId)=>{const{agents}=useOrganizationClient(organizationId);const[state,setState]=useState2({status:"idle"});const invoke=useCallback(async(input)=>{setState({status:"submitting"});try{const result=await agents.invoke(input);setState(result.ok?{result,status:"success"}:{result,status:"failure"});return result}catch(error){setState({error,status:"error"});throw error}},[agents]);return{invoke,reset:()=>{setState({status:"idle"})},state}};var invocationStatus=(state)=>{switch(state.status){case"submitting":{return"Sending"}case"success":{return"Request started"}case"failure":{return state.result.error.message}case"error":{return"Request failed"}case"idle":{return null}default:{return null}}};var EMPTY_AGENT_PROMPT_COMPONENTS={};var EMPTY_AGENT_PROMPT_STYLE={};var createDefaultIdempotencyKey=()=>globalThis.crypto.randomUUID();var AgentPrompt=({agentId,autoFocus=false,className="",components=EMPTY_AGENT_PROMPT_COMPONENTS,createIdempotencyKey=createDefaultIdempotencyKey,label="Message",onResult,organizationId,style=EMPTY_AGENT_PROMPT_STYLE,submitLabel="Send"})=>{const id=`ci-agent-prompt-${useId().replaceAll(":","")}`;const[value,setValue]=useState2("");const invocation=useAgentInvocation(organizationId);const submit=()=>{const prompt=value.trim();if(prompt.length===0||invocation.state.status==="submitting"){return}const submitInvocation=async()=>{try{const result=await invocation.invoke({agentId,idempotencyKey:createIdempotencyKey(),input:{prompt}});if(result.ok){setValue("")}onResult?.(result)}catch{}};submitInvocation()};return jsxDEV2(AgentPromptPrimitive,{autoFocus,className,components,id,label,onChange:setValue,onSubmit:submit,pending:invocation.state.status==="submitting",status:invocationStatus(invocation.state),style,submitLabel,value},undefined,false,undefined,this)};import{createContext as createContext2,useCallback as useCallback2,useContext as useContext2,useEffect,useMemo as useMemo2,useSyncExternalStore}from"react";import{jsxDEV as jsxDEV3}from"react/jsx-dev-runtime";var AuthContext=createContext2(null);var toFederatedAuthError=(error)=>new FederatedAuthError("authorization_failed",error.message);var unknownAuthError=()=>new FederatedAuthError("authorization_failed","Sign in failed");var CollectiveIntelligenceLoginProvider=(props)=>{const state=useSyncExternalStore(props.auth.subscribe,props.auth.getState,props.auth.getState);const contextValue=useMemo2(()=>({auth:props.auth,state}),[props.auth,state]);return jsxDEV3(AuthContext.Provider,{value:contextValue,children:props.clientFactory===undefined?jsxDEV3(CollectiveIntelligenceProvider,{client:props.client,entitySource:props.entitySource,children:props.children},undefined,false,undefined,this):jsxDEV3(CollectiveIntelligenceProvider,{clientFactory:props.clientFactory,entitySource:props.entitySource,children:props.children},undefined,false,undefined,this)},undefined,false,undefined,this)};var useCollectiveIntelligenceAuth=()=>{const value=useContext2(AuthContext);if(value===null){throw new Error("CollectiveIntelligenceLoginProvider must wrap authentication bindings")}return{...value,beginLogin:value.auth.beginLogin,completeLogin:value.auth.completeLogin,logout:value.auth.logout,reauthorize:value.auth.reauthorize}};var LoginButton=({children="Sign in with Collective Intelligence",className,components,disabled=false,onError,returnTo,style})=>{const{auth,state}=useCollectiveIntelligenceAuth();const Button=components?.Button??"button";const redirecting=state.status==="redirecting";const onClick=useCallback2((event)=>{event.preventDefault();const target=returnTo??globalThis.location.href;const begin=async()=>{try{await auth.beginLogin({returnTo:target})}catch(error){onError?.(error instanceof Error?toFederatedAuthError(error):unknownAuthError())}};begin()},[auth,onError,returnTo]);return jsxDEV3(Button,{"aria-busy":redirecting,className:["ci-login-button",className].filter(Boolean).join(" "),disabled:disabled||redirecting,onClick,style,type:"button",children},undefined,false,undefined,this)};var callbackMessage=(state)=>{switch(state.status){case"authenticated":{return"Sign in complete"}case"error":{return state.error.message}case"expired":{return"Sign in expired"}case"anonymous":case"redirecting":{return"Completing sign in"}default:{return"Completing sign in"}}};var LoginCallbackPrimitive=({className,components,state,style})=>{const Status=components?.Status??"div";return jsxDEV3(Status,{"aria-live":"polite",className:["ci-login-callback",className].filter(Boolean).join(" "),style,children:callbackMessage(state)},undefined,false,undefined,this)};var LoginCallback=({callbackUrl,onComplete,onError,...primitiveProps})=>{const{auth,state}=useCollectiveIntelligenceAuth();useEffect(()=>{const url=callbackUrl??globalThis.location.href;const complete=async()=>{try{const{returnTo}=await auth.completeLogin(url);onComplete?.(returnTo)}catch(error){onError?.(error instanceof Error?toFederatedAuthError(error):unknownAuthError())}};complete()},[auth,callbackUrl,onComplete,onError]);return jsxDEV3(LoginCallbackPrimitive,{...primitiveProps,state},undefined,false,undefined,this)};var useSession=()=>{const{state}=useCollectiveIntelligenceAuth();return state};var SessionGate=({children,fallback=null})=>{const session=useSession();if(session.status!=="authenticated"){return fallback}return children};"use client";var clientSdkReactEntrypoint="react";"use client";var{AgentPrompt:AgentPrompt2,AgentPromptPrimitive:AgentPromptPrimitive2,CollectiveIntelligenceLoginProvider:CollectiveIntelligenceLoginProvider2,CollectiveIntelligenceProvider:CollectiveIntelligenceProvider2,LoginButton:LoginButton2,LoginCallback:LoginCallback2,LoginCallbackPrimitive:LoginCallbackPrimitive2,SessionGate:SessionGate2,clientSdkReactEntrypoint:clientSdkReactEntrypoint2,createPromptKeyHandler:createPromptKeyHandler2,useAgents:useAgents2,useAttachments:useAttachments2,useClientContext:useClientContext2,useCollectiveIntelligenceAuth:useCollectiveIntelligenceAuth2,useCollectiveIntelligenceClient:useCollectiveIntelligenceClient2,useKnowledge:useKnowledge2,useOrganizationClient:useOrganizationClient2,useRuns:useRuns2,useSession:useSession2,useSkills:useSkills2,useWorkflows:useWorkflows2,useAgentInvocation:useAgentInvocation2}=exports_src;export{useWorkflows2 as useWorkflows,useSkills2 as useSkills,useSession2 as useSession,useRuns2 as useRuns,useOrganizationClient2 as useOrganizationClient,useKnowledge2 as useKnowledge,useCollectiveIntelligenceClient2 as useCollectiveIntelligenceClient,useCollectiveIntelligenceAuth2 as useCollectiveIntelligenceAuth,useClientContext2 as useClientContext,useAttachments2 as useAttachments,useAgents2 as useAgents,useAgentInvocation2 as useAgentInvocation,createPromptKeyHandler2 as createPromptKeyHandler,clientSdkReactEntrypoint2 as clientSdkReactEntrypoint,SessionGate2 as SessionGate,LoginCallbackPrimitive2 as LoginCallbackPrimitive,LoginCallback2 as LoginCallback,LoginButton2 as LoginButton,CollectiveIntelligenceProvider2 as CollectiveIntelligenceProvider,CollectiveIntelligenceLoginProvider2 as CollectiveIntelligenceLoginProvider,AgentPromptPrimitive2 as AgentPromptPrimitive,AgentPrompt2 as AgentPrompt};

package/dist/resources.d.ts

@@ -0,0 +1,662 @@
+// Generated by dts-bundle-generator v9.5.1
+
+import { ComponentType, ReactNode } from 'react';
+
+export type FederatedAuthErrorCode = "configuration_error" | "invalid_return_target" | "invalid_callback" | "invalid_state" | "transaction_expired" | "authorization_failed" | "token_exchange_failed" | "reauthorization_required";
+declare class FederatedAuthError extends Error {
+	readonly code: FederatedAuthErrorCode;
+	constructor(code: FederatedAuthErrorCode, message: string);
+}
+export type FederatedSessionIdentity = Readonly<{
+	email: string | null;
+	id: string;
+	name: string | null;
+	organizationId: string;
+}>;
+export type FederatedAuthState = Readonly<{
+	status: "anonymous";
+}> | Readonly<{
+	status: "redirecting";
+}> | Readonly<{
+	expiresAt: number;
+	identity?: FederatedSessionIdentity;
+	status: "authenticated";
+}> | Readonly<{
+	status: "expired";
+}> | Readonly<{
+	error: FederatedAuthError;
+	status: "error";
+}>;
+export type ClientFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export type ResourceJsonValue = null | boolean | number | string | readonly ResourceJsonValue[] | Readonly<{
+	[key: string]: ResourceJsonValue;
+}>;
+/** Opaque wire identity. Callers must not infer or concatenate its internals. */
+export type ResourceId = string;
+export type ResourceRecordId = ResourceId;
+/** Opaque concurrency token independent from source timestamps. */
+export type ResourceRevision = string;
+/** Opaque pagination position issued and consumed only by a resource adapter. */
+export type ResourceCursor = string;
+export type IdempotencyKey = string;
+export type ResourceIdentityField = Readonly<{
+	name: string;
+	type: "number" | "string";
+}>;
+export type ResourceCapabilities = Readonly<{
+	create?: boolean;
+	/** Common entity deletion is always soft deletion. */
+	delete?: boolean;
+	get?: boolean;
+	hardDelete?: boolean;
+	includeDeleted?: boolean;
+	restore?: boolean;
+	search: true;
+	softDelete?: boolean;
+	update?: boolean;
+}>;
+export type ResourcePaginationMode = "cursor" | "page";
+export type PortableResourceSchema = Readonly<Record<string, ResourceJsonValue>>;
+export type ResourceDefinition<Entity, Create = Entity, Update = Partial<Entity>> = Readonly<{
+	capabilities: ResourceCapabilities;
+	concurrency: "revision";
+	id: string;
+	identity: Readonly<{
+		fields: readonly [
+			ResourceIdentityField,
+			...ResourceIdentityField[]
+		];
+	}>;
+	query: Readonly<{
+		filterableFields: readonly string[];
+		pagination: Readonly<{
+			modes: readonly ResourcePaginationMode[];
+		}>;
+		sortableFields: readonly string[];
+		textSearchFields?: readonly string[];
+	}>;
+	schemas: Readonly<{
+		create?: PortableResourceSchema;
+		entity: PortableResourceSchema;
+		update?: PortableResourceSchema;
+	}>;
+	version: string;
+	/** Portable UI metadata; required/enum/nullability remain in schemas. */
+	metadata?: Readonly<Record<string, ResourceJsonValue>>;
+	/** Type-only slots keep definition values portable and serializable. */
+	readonly __types?: Readonly<{
+		create: Create;
+		entity: Entity;
+		update: Update;
+	}>;
+}>;
+export type FilterValue = ResourceJsonValue | readonly ResourceJsonValue[];
+export type ResourceFilter = Readonly<{
+	field: string;
+	operator: "contains" | "ends_with" | "eq" | "gt" | "gte" | "in" | "lt" | "lte" | "ne" | "not_in" | "starts_with";
+	value: FilterValue;
+}> | Readonly<{
+	field: string;
+	operator: "is_not_null" | "is_null";
+}> | Readonly<{
+	filters: readonly ResourceFilter[];
+	operator: "and" | "or";
+}> | Readonly<{
+	filter: ResourceFilter;
+	operator: "not";
+}>;
+export type ResourceSort = Readonly<{
+	direction: "asc" | "desc";
+	field: string;
+}>;
+export type ResourcePagination = Readonly<{
+	mode: "cursor";
+	cursor?: ResourceCursor;
+	limit: number;
+}> | Readonly<{
+	mode: "page";
+	page: number;
+	pageSize: number;
+}>;
+export type ResourceListQuery = Readonly<{
+	filter?: ResourceFilter;
+	includeDeleted?: boolean;
+	pagination: ResourcePagination;
+	sort?: readonly ResourceSort[];
+	textSearch?: string;
+}>;
+export type ResourceRecord<Entity> = Readonly<{
+	deletedAt?: string;
+	id: ResourceRecordId;
+	revision: ResourceRevision;
+	value: Entity;
+}>;
+export type ResourceListResult<Entity> = Readonly<{
+	items: readonly ResourceRecord<Entity>[];
+	nextCursor?: ResourceCursor;
+	pagination: "cursor";
+}> | Readonly<{
+	items: readonly ResourceRecord<Entity>[];
+	page: number;
+	pageSize: number;
+	pagination: "page";
+	totalItems: number;
+	totalPages: number;
+}>;
+export type ResourceErrorCode = "capability_not_supported" | "conflict" | "forbidden" | "internal" | "invalid_request" | "not_found" | "rate_limited" | "transport_error" | "unauthenticated" | "unavailable";
+export type ResourceError = Readonly<{
+	code: ResourceErrorCode;
+	/** Client-observed dispatch outcome; uncertainty never proves rollback. */
+	outcome?: "not_dispatched" | "rejected" | "uncertain";
+	details?: Readonly<Record<string, ResourceJsonValue>>;
+	message: string;
+	retryable: boolean;
+}>;
+export type ResourceResult<Value> = Readonly<{
+	correlationId: string;
+	ok: true;
+	value: Value;
+}> | Readonly<{
+	correlationId: string;
+	error: ResourceError;
+	ok: false;
+}>;
+export type ResourceRequestOptions = Readonly<{
+	signal?: AbortSignal;
+}>;
+export type ResourceMutationInput<Value> = Readonly<{
+	expectedRevision: ResourceRevision;
+	id: ResourceRecordId;
+	idempotencyKey?: IdempotencyKey;
+	value: Value;
+}>;
+export type ResourceLifecycleInput = Readonly<{
+	expectedRevision: ResourceRevision;
+	id: ResourceRecordId;
+	idempotencyKey?: IdempotencyKey;
+}>;
+export type ResourceCreateInput<Value> = Readonly<{
+	idempotencyKey: IdempotencyKey;
+	value: Value;
+}>;
+export interface ResourceClient<Entity, Create = Entity, Update = Partial<Entity>> {
+	readonly capabilities: ResourceCapabilities;
+	readonly create: (input: ResourceCreateInput<Create>, options?: ResourceRequestOptions) => Promise<ResourceResult<ResourceRecord<Entity>>>;
+	readonly definition: ResourceDefinition<Entity, Create, Update>;
+	readonly get: (input: Readonly<{
+		id: ResourceRecordId;
+		includeDeleted?: boolean;
+	}>, options?: ResourceRequestOptions) => Promise<ResourceResult<ResourceRecord<Entity>>>;
+	readonly hardDelete: (input: ResourceLifecycleInput, options?: ResourceRequestOptions) => Promise<ResourceResult<void>>;
+	readonly list: (query: ResourceListQuery, options?: ResourceRequestOptions) => Promise<ResourceResult<ResourceListResult<Entity>>>;
+	readonly restore: (input: ResourceLifecycleInput, options?: ResourceRequestOptions) => Promise<ResourceResult<ResourceRecord<Entity>>>;
+	readonly softDelete: (input: ResourceLifecycleInput, options?: ResourceRequestOptions) => Promise<ResourceResult<ResourceRecord<Entity>>>;
+	readonly update: (input: ResourceMutationInput<Update>, options?: ResourceRequestOptions) => Promise<ResourceResult<ResourceRecord<Entity>>>;
+}
+export type EntityListQuery = Omit<ResourceListQuery, "pagination" | "includeDeleted"> & Readonly<{
+	pagination: Extract<ResourcePagination, {
+		mode: "page";
+	}>;
+}>;
+export type EntityPage<Value> = Extract<ResourceListResult<Value>, {
+	pagination: "page";
+}>;
+export type EntityCreateInput<Value> = ResourceCreateInput<Value>;
+export type EntityUpdateInput<Patch> = ResourceMutationInput<Patch> & Readonly<{
+	idempotencyKey: IdempotencyKey;
+}>;
+export type EntityDeleteInput = ResourceLifecycleInput & Readonly<{
+	idempotencyKey: IdempotencyKey;
+}>;
+/** A logical write retains its key, payload and edited revision on explicit resubmission. */
+export interface EntityClient<Value, Create = Value, Patch = Partial<Value>> {
+	readonly definition: ResourceDefinition<Value, Create, Patch>;
+	readonly list: (query: EntityListQuery, options?: ResourceRequestOptions) => Promise<ResourceResult<EntityPage<Value>>>;
+	readonly get: (input: Readonly<{
+		id: ResourceRecordId;
+	}>, options?: ResourceRequestOptions) => Promise<ResourceResult<ResourceRecord<Value>>>;
+	readonly create: (input: EntityCreateInput<Create>) => Promise<ResourceResult<ResourceRecord<Value>>>;
+	readonly update: (input: EntityUpdateInput<Patch>) => Promise<ResourceResult<ResourceRecord<Value>>>;
+	readonly delete: (input: EntityDeleteInput) => Promise<ResourceResult<ResourceRecord<Value>>>;
+}
+export declare class ResourceQueryError extends Error {
+	readonly correlationId: string;
+	readonly resourceError: ResourceError;
+	constructor(correlationId: string, error: ResourceError);
+}
+export declare const unwrapResourceResult: <Value>(result: ResourceResult<Value>) => Value;
+export type ResourceAuthState = Readonly<{
+	status: "authenticated";
+}> | Readonly<{
+	status: "expired";
+}> | Readonly<{
+	status: "forbidden";
+}> | Readonly<{
+	status: "reauthentication_required";
+}> | Readonly<{
+	status: "unauthenticated";
+}>;
+export declare const mapResourceAuthState: (source: FederatedAuthState | ResourceResult<unknown>) => ResourceAuthState;
+export declare const hasResourceCapability: (capabilities: ResourceCapabilities, capability: keyof ResourceCapabilities) => boolean;
+export type ResourceListSlotProps<Entity> = Readonly<{
+	getItemKey: (item: ResourceRecord<Entity>) => string;
+	items: readonly ResourceRecord<Entity>[];
+	renderItem: (item: ResourceRecord<Entity>) => ReactNode;
+}>;
+export type ResourcePaginationSlotProps = Readonly<{
+	currentPage?: number;
+	hasNextPage: boolean;
+	hasPreviousPage: boolean;
+	isPending: boolean;
+	onNext: () => void;
+	onPrevious: () => void;
+}>;
+export type ResourceStatusSlotProps = Readonly<{
+	authState: ResourceAuthState;
+	error?: Error;
+	pending: boolean;
+}>;
+export type ResourceListProps<Entity, Create, Update> = Readonly<{
+	client: ResourceClient<Entity, Create, Update>;
+	components: Readonly<{
+		List: ComponentType<ResourceListSlotProps<Entity>>;
+		Pagination?: ComponentType<ResourcePaginationSlotProps>;
+		Status?: ComponentType<ResourceStatusSlotProps>;
+	}>;
+	query: ResourceListQuery;
+	renderItem: (item: ResourceRecord<Entity>) => ReactNode;
+	onQueryChange?: (query: ResourceListQuery) => void;
+}>;
+export declare const ResourceList: <Entity, Create, Update>({ client, components, onQueryChange, query, renderItem }: ResourceListProps<Entity, Create, Update>) => import("react").JSX.Element;
+export type ResourceCapabilityActionProps = Readonly<{
+	capability: keyof ResourceCapabilities;
+	children: ReactNode;
+	components: Readonly<{
+		Action: ComponentType<Readonly<{
+			children: ReactNode;
+			disabled: boolean;
+		}>>;
+	}>;
+	unsupported?: "disable" | "hide";
+}>;
+export declare const ResourceCapabilityAction: ({ capability, children, components, unsupported }: ResourceCapabilityActionProps) => import("react").JSX.Element | null;
+export type ResourceFilterProps = Readonly<{
+	components: Readonly<{
+		Filter: ComponentType<Readonly<{
+			label: string;
+			onChange: (value: string) => void;
+			value: string;
+		}>>;
+	}>;
+	label?: string;
+	onQueryChange: (query: ResourceListQuery) => void;
+	query: ResourceListQuery;
+}>;
+declare const ResourceFilter$1: ({ components, label, onQueryChange, query }: ResourceFilterProps) => import("react").JSX.Element;
+export type ResourcePaginationProps<Entity> = Readonly<{
+	components: Readonly<{
+		Pagination: ComponentType<ResourcePaginationSlotProps>;
+	}>;
+	isPending?: boolean;
+	onQueryChange: (query: ResourceListQuery) => void;
+	query: ResourceListQuery;
+	result: ResourceListResult<Entity>;
+}>;
+declare const ResourcePagination$1: <Entity>({ components, isPending, onQueryChange, query, result }: ResourcePaginationProps<Entity>) => import("react").JSX.Element;
+export type ResourceTableColumn<Entity> = Readonly<{
+	id: string;
+	label: ReactNode;
+	render: (record: ResourceRecord<Entity>) => ReactNode;
+}>;
+export type ResourceTableProps<Entity, Create, Update> = Readonly<{
+	caption: ReactNode;
+	client: ResourceClient<Entity, Create, Update>;
+	columns: readonly ResourceTableColumn<Entity>[];
+	components: Readonly<{
+		Status?: ComponentType<ResourceStatusSlotProps>;
+		Table: ComponentType<Readonly<{
+			caption: ReactNode;
+			columns: readonly ResourceTableColumn<Entity>[];
+			getRowKey: (row: ResourceRecord<Entity>) => string;
+			renderCell: (row: ResourceRecord<Entity>, column: ResourceTableColumn<Entity>) => ReactNode;
+			rows: readonly ResourceRecord<Entity>[];
+		}>>;
+	}>;
+	query: ResourceListQuery;
+}>;
+export declare const ResourceTable: <Entity, Create, Update>({ caption, client, columns, components, query }: ResourceTableProps<Entity, Create, Update>) => import("react").JSX.Element;
+export type ResourceLifecycleActionProps<Entity, Create, Update> = Readonly<{
+	children: ReactNode;
+	client: ResourceClient<Entity, Create, Update>;
+	components: Readonly<{
+		Action: ComponentType<Readonly<{
+			children: ReactNode;
+			disabled: boolean;
+			onClick: () => void;
+			pending: boolean;
+		}>>;
+	}>;
+	input: ResourceLifecycleInput;
+	operation: "hard_delete" | "restore" | "soft_delete";
+	unsupported?: "disable" | "hide";
+}>;
+export declare const ResourceLifecycleAction: <Entity, Create, Update>({ children, client, components, input, operation, unsupported }: ResourceLifecycleActionProps<Entity, Create, Update>) => import("react").JSX.Element | null;
+export type ResourceProviderProps = Readonly<{
+	authState: ResourceAuthState;
+	capabilities: ResourceCapabilities;
+	children: ReactNode;
+	organizationId: string;
+}>;
+export declare const ResourceProvider: ({ authState, capabilities, children, organizationId }: ResourceProviderProps) => import("react").JSX.Element;
+export type EntityIdentity = Readonly<{
+	sourceId: string;
+	applicationId: string;
+	userId: string;
+	organizationId: string;
+}>;
+export type EntitySourceState = Readonly<{
+	status: "authenticated";
+	identity: EntityIdentity;
+}> | Readonly<{
+	status: "unauthenticated" | "expired" | "forbidden";
+}>;
+/** Configured authenticated client boundary. Snapshots are stable until identity changes. */
+export interface EntitySource {
+	readonly getSnapshot: () => EntitySourceState;
+	readonly subscribe: (notify: () => void) => () => void;
+	readonly bind: <Value, Create, Patch>(contract: ResourceDefinition<Value, Create, Patch>) => EntityClient<Value, Create, Patch>;
+}
+export type DelegatedIdentity = Readonly<{
+	organizationId: string;
+	userId: string;
+}>;
+export type DelegatedEntitySourceOptions = Readonly<{
+	applicationId: string;
+	fetch?: ClientFetch;
+	getIdentity: () => DelegatedIdentity | null;
+	getStatus: () => string;
+	origin: string;
+	pathFor?: (contract: Readonly<{
+		id: string;
+	}>) => string;
+	sourceId?: string;
+	subscribe: (notify: () => void) => () => void;
+}>;
+/** Binds entity contracts to same-origin Resource proxy routes from the current session. */
+export declare const createDelegatedEntitySource: (options: DelegatedEntitySourceOptions) => EntitySource;
+export declare const useEntityList: <Value, Create, Patch>(contract: ResourceDefinition<Value, Create, Patch>, query: EntityListQuery) => {
+	authState: EntitySourceState;
+	capabilities: Readonly<{
+		create?: boolean;
+		delete?: boolean;
+		get?: boolean;
+		hardDelete?: boolean;
+		includeDeleted?: boolean;
+		restore?: boolean;
+		search: true;
+		softDelete?: boolean;
+		update?: boolean;
+	}>;
+	data: NoInfer<Readonly<{
+		items: readonly Readonly<{
+			deletedAt?: string;
+			id: ResourceRecordId;
+			revision: ResourceRevision;
+			value: Value;
+		}>[];
+		page: number;
+		pageSize: number;
+		pagination: "page";
+		totalItems: number;
+		totalPages: number;
+	}>> | undefined;
+	empty: boolean;
+	error: Error | null;
+	loading: boolean;
+	refresh: () => Promise<void>;
+	refreshing: boolean;
+};
+export declare const useEntityRecord: <Value, Create, Patch>(contract: ResourceDefinition<Value, Create, Patch>, input: Readonly<{
+	id: string;
+}>) => {
+	authState: EntitySourceState;
+	capabilities: Readonly<{
+		create?: boolean;
+		delete?: boolean;
+		get?: boolean;
+		hardDelete?: boolean;
+		includeDeleted?: boolean;
+		restore?: boolean;
+		search: true;
+		softDelete?: boolean;
+		update?: boolean;
+	}>;
+	data: NoInfer<Readonly<{
+		deletedAt?: string;
+		id: ResourceRecordId;
+		revision: ResourceRevision;
+		value: Value;
+	}>> | undefined;
+	error: Error | null;
+	loading: boolean;
+	refresh: () => Promise<void>;
+	refreshing: boolean;
+};
+export declare const useEntityUpdate: <Value, Create, Patch>(contract: ResourceDefinition<Value, Create, Patch>, target: Readonly<{
+	id: string;
+}>) => {
+	available: boolean;
+	data: Readonly<{
+		deletedAt?: string;
+		id: ResourceRecordId;
+		revision: ResourceRevision;
+		value: Value;
+	}> | undefined;
+	error: ResourceQueryError | null;
+	pending: boolean;
+	resubmit: () => Promise<ResourceResult<Readonly<{
+		deletedAt?: string;
+		id: ResourceRecordId;
+		revision: ResourceRevision;
+		value: Value;
+	}>>>;
+	status: "pending" | "success" | "idle" | "conflict" | "uncertain" | "rejected";
+	submit: (input: Omit<EntityUpdateInput<Patch>, "id" | "idempotencyKey">) => Promise<ResourceResult<Readonly<{
+		deletedAt?: string;
+		id: ResourceRecordId;
+		revision: ResourceRevision;
+		value: Value;
+	}>>>;
+	submitted: EntityUpdateInput<Patch> | undefined;
+};
+export declare const useEntityCreate: <Value, Create, Patch>(contract: ResourceDefinition<Value, Create, Patch>) => {
+	available: boolean;
+	data: Readonly<{
+		deletedAt?: string;
+		id: ResourceRecordId;
+		revision: ResourceRevision;
+		value: Value;
+	}> | undefined;
+	error: ResourceQueryError | null;
+	pending: boolean;
+	resubmit: () => Promise<ResourceResult<Readonly<{
+		deletedAt?: string;
+		id: ResourceRecordId;
+		revision: ResourceRevision;
+		value: Value;
+	}>>>;
+	status: "pending" | "success" | "idle" | "conflict" | "uncertain" | "rejected";
+	submit: (input: Omit<Readonly<{
+		idempotencyKey: IdempotencyKey;
+		value: Create;
+	}>, "idempotencyKey">) => Promise<ResourceResult<Readonly<{
+		deletedAt?: string;
+		id: ResourceRecordId;
+		revision: ResourceRevision;
+		value: Value;
+	}>>>;
+	submitted: Readonly<{
+		idempotencyKey: IdempotencyKey;
+		value: Create;
+	}> | undefined;
+};
+export declare const useEntityDelete: <Value, Create, Patch>(contract: ResourceDefinition<Value, Create, Patch>, target: Readonly<{
+	id: string;
+}>) => {
+	available: boolean;
+	data: Readonly<{
+		deletedAt?: string;
+		id: ResourceRecordId;
+		revision: ResourceRevision;
+		value: Value;
+	}> | undefined;
+	error: ResourceQueryError | null;
+	pending: boolean;
+	resubmit: () => Promise<ResourceResult<Readonly<{
+		deletedAt?: string;
+		id: ResourceRecordId;
+		revision: ResourceRevision;
+		value: Value;
+	}>>>;
+	status: "pending" | "success" | "idle" | "conflict" | "uncertain" | "rejected";
+	submit: (input: Omit<EntityDeleteInput, "id" | "idempotencyKey">) => Promise<ResourceResult<Readonly<{
+		deletedAt?: string;
+		id: ResourceRecordId;
+		revision: ResourceRevision;
+		value: Value;
+	}>>>;
+	submitted: EntityDeleteInput | undefined;
+};
+export type ResourceValue = string | number | boolean | null | readonly ResourceValue[] | ResourceObject;
+export interface ResourceObject {
+	readonly [key: string]: ResourceValue;
+}
+/** Display-ready controls. Schema inference and registry selection belong to the consumer. */
+export type ResourceField = Readonly<{
+	name: string;
+	label: string;
+	control: "text" | "email" | "number" | "checkbox" | "date" | "datetime-local" | "select" | "custom";
+	required?: boolean;
+	readOnly?: boolean;
+	nullable?: boolean;
+	options?: readonly Readonly<{
+		label: string;
+		value: string | number | boolean;
+	}>[];
+}>;
+export type ResourceFieldControlProps = Readonly<{
+	field: ResourceField;
+	id: string;
+	value: ResourceValue | undefined;
+	disabled: boolean;
+	errorId?: string | undefined;
+	onChange: (value: ResourceValue) => void;
+}>;
+export type EntityFieldKey<Value> = Extract<keyof Value, string>;
+export type EntityFieldConfig = Readonly<{
+	control?: ResourceField["control"] | string;
+	label: string;
+	readOnly?: boolean;
+	renderer?: string;
+}>;
+export type EntityViewVariant<Value> = Readonly<{
+	columns: readonly EntityFieldKey<Value>[];
+}>;
+export type EntityConfiguration<Value> = Readonly<{
+	fields: Readonly<Partial<Record<EntityFieldKey<Value>, EntityFieldConfig>>>;
+	forms: Readonly<{
+		create: Readonly<{
+			fields: readonly EntityFieldKey<Value>[];
+		}>;
+		update: Readonly<{
+			fields: readonly EntityFieldKey<Value>[];
+		}>;
+	}>;
+	list: Readonly<{
+		description?: EntityFieldKey<Value>;
+		title: EntityFieldKey<Value>;
+	}>;
+	table: Readonly<{
+		columns: readonly EntityFieldKey<Value>[];
+		variants?: Readonly<Record<string, EntityViewVariant<Value>>>;
+	}>;
+}>;
+export type EntityDeclaration<Value, Create, Patch> = Readonly<{
+	config: EntityConfiguration<Value>;
+	contract: ResourceDefinition<Value, Create, Patch>;
+}>;
+export type EntityControlRegistry = Readonly<Record<string, (props: ResourceFieldControlProps) => ReactNode>>;
+export type EntityRendererRegistry<Value> = Readonly<Record<string, (input: Readonly<{
+	field: string;
+	record: ResourceRecord<Value>;
+}>) => ReactNode>>;
+export declare const defineEntity: <Value extends {
+	readonly [Key in keyof Value]: ResourceJsonValue;
+}, Create, Patch>(declaration: EntityDeclaration<Value, Create, Patch>) => EntityDeclaration<Value, Create, Patch>;
+export type JsonObject<Value = Readonly<Record<string, ResourceJsonValue>>> = {
+	readonly [Key in keyof Value]: ResourceJsonValue;
+};
+export type ViewStateProps = Readonly<{
+	namespace: string;
+	viewState?: "url";
+}> | Readonly<{
+	namespace?: never;
+	viewState: "memory";
+}>;
+export type SharedViewProps<Value, Create, Patch> = Readonly<{
+	entity: EntityDeclaration<Value, Create, Patch>;
+	empty?: ReactNode;
+	pageSize?: number;
+	renderers?: EntityRendererRegistry<Value>;
+	variant?: string;
+}>;
+export type EntityTableProps<Value extends JsonObject<Value>, Create, Patch> = SharedViewProps<Value, Create, Patch> & ViewStateProps;
+export type EntityListProps<Value extends JsonObject<Value>, Create, Patch> = SharedViewProps<Value, Create, Patch> & ViewStateProps;
+export declare const EntityTable: <Value extends JsonObject<Value>, Create, Patch>(props: EntityTableProps<Value, Create, Patch>) => import("react").JSX.Element;
+export declare const EntityList: <Value extends JsonObject<Value>, Create, Patch>(props: EntityListProps<Value, Create, Patch>) => import("react").JSX.Element;
+export type SharedEntityFormProps<Value extends JsonObject<Value>, Create, Patch> = Readonly<{
+	controls?: EntityControlRegistry;
+	entity: EntityDeclaration<Value, Create, Patch>;
+	initialValues?: Readonly<Record<string, ResourceValue>>;
+	onCancel?: () => void;
+	onSuccess?: (record: ResourceRecord<Value>) => void;
+}>;
+export type EntityFormProps<Value extends JsonObject<Value>, Create, Patch> = (SharedEntityFormProps<Value, Create, Patch> & Readonly<{
+	mode: "create";
+}>) | (SharedEntityFormProps<Value, Create, Patch> & Readonly<{
+	mode: "update";
+	record: ResourceRecord<Value>;
+}>);
+export declare const EntityForm: <Value extends JsonObject<Value>, Create, Patch>(props: EntityFormProps<Value, Create, Patch>) => import("react").JSX.Element;
+export type EntityViewOptions = Readonly<{
+	contract?: ResourceDefinition<unknown, unknown, unknown>;
+	pageSize?: number;
+}>;
+export type EntityViewState = Readonly<{
+	filter: ResourceFilter | null;
+	page: number;
+	pageSize: number;
+	sort: readonly ResourceSort[];
+	textSearch: string;
+}>;
+export type EntityViewStateController = Readonly<{
+	query: EntityListQuery;
+	state: EntityViewState;
+	setFilter: (filter: ResourceFilter | null) => void;
+	setPage: (page: number) => void;
+	setPageSize: (pageSize: number) => void;
+	setSort: (sort: readonly ResourceSort[]) => void;
+	setTextSearch: (textSearch: string) => void;
+}>;
+export declare const useEntityViewState: (namespace: string, input?: EntityViewOptions) => EntityViewStateController;
+export declare const useMemoryEntityViewState: (input?: Readonly<{
+	pageSize?: number;
+}>) => EntityViewStateController;
+export type ResourceLifecycleOperation = "hard_delete" | "restore" | "soft_delete";
+
+export {
+	ResourceFilter$1 as ResourceFilter,
+	ResourcePagination$1 as ResourcePagination,
+};
+
+export {};