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

package/dist/index.d.ts

@@ -0,0 +1,958 @@
+// Generated by dts-bundle-generator v9.5.1
+
+import { CSSProperties, ElementType, 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 FederatedAuth = Readonly<{
+	beginLogin: (options: Readonly<{
+		returnTo: string;
+	}>) => Promise<string>;
+	completeLogin: (callbackUrl: string) => Promise<Readonly<{
+		returnTo: string;
+	}>>;
+	getAccessToken: () => Promise<string>;
+	getState: () => FederatedAuthState;
+	logout: () => Promise<void>;
+	reauthorize: (options?: Readonly<{
+		returnTo?: string;
+	}>) => Promise<string>;
+	subscribe: (listener: (state: FederatedAuthState) => void) => () => void;
+}>;
+export type ClientFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export type JsonValue$1 = boolean | null | number | readonly JsonValue$1[] | Readonly<{
+	readonly [key: string]: JsonValue$1;
+}> | string;
+export type JsonObject = Readonly<Record<string, JsonValue$1>>;
+export type WorkflowInvokeTarget = {
+	workflowId: string;
+	workflowFqn?: never;
+} | {
+	workflowFqn: string;
+	workflowId?: never;
+};
+/** Addresses an Agent by its UUID or its in-organization FQN. */
+export type AgentInvokeTarget = {
+	agentId: string;
+	agentFqn?: never;
+} | {
+	agentFqn: string;
+	agentId?: never;
+};
+/** Starts a conversation with an Agent, or continues an existing one. */
+export type ConversationContinueTarget = (AgentInvokeTarget & {
+	conversationId?: never;
+}) | {
+	agentFqn?: never;
+	agentId?: never;
+	conversationId: string;
+};
+export type ConversationTurnStatus = "accepted" | "cancelled" | "failed" | "running" | "succeeded";
+/**
+ * One conversation turn: the application's input, the Agent's final message
+ * once its run succeeded, and the Agent Output the run saved, if any.
+ * `runId` identifies the turn and its producing run.
+ */
+export interface ConversationTurn {
+	completedAt: string | null;
+	createdAt: string;
+	input: unknown;
+	message: string | null;
+	output?: unknown;
+	runId: string;
+	status: ConversationTurnStatus;
+}
+export interface ConversationHistory {
+	agentId: string;
+	conversationId: string;
+	createdAt: string;
+	turns: ConversationTurn[];
+}
+export interface QueryFilter {
+	caseSensitive?: boolean;
+	field: string;
+	op: "eq" | "neq" | "in" | "contains" | "gt" | "gte" | "lt" | "lte" | "exists";
+	value?: unknown;
+}
+export interface SearchQuery {
+	cursor?: string;
+	entitySchemaId: string;
+	fields?: string[];
+	filters?: QueryFilter[];
+	limit?: number;
+	text?: string;
+}
+export type KnowledgeQuery = {
+	entityId: string;
+	op: "get";
+} | {
+	anchorEntityId: string;
+	filters?: QueryFilter[];
+	limit?: number;
+	op: "related";
+	relationSchemaId: string;
+	text?: string;
+} | (SearchQuery & {
+	op: "search";
+}) | {
+	entitySchemaId: string;
+	fields: string[];
+	filters?: QueryFilter[];
+	op: "facets";
+	text?: string;
+} | (SearchQuery & {
+	op: "autocomplete";
+});
+export type ExternalApplicationOperationRequest = {
+	input: JsonObject | unknown[];
+	operationId: "context_get";
+} | {
+	input: {
+		query: KnowledgeQuery;
+	};
+	operationId: "knowledge_query";
+} | {
+	input: {
+		schemaId: string;
+	};
+	operationId: "knowledge_get_entity_schema_snapshot";
+} | {
+	input: SearchQuery;
+	operationId: "knowledge_search_entities";
+} | {
+	input: {
+		entitySchemaId: string;
+		fields: string[];
+		filters?: QueryFilter[];
+		text?: string;
+	};
+	operationId: "knowledge_facets";
+} | {
+	input: {
+		entitySchemaId: string;
+	};
+	operationId: "knowledge_get_schema_query_context";
+} | {
+	input: SearchQuery;
+	operationId: "knowledge_autocomplete";
+} | {
+	input: {
+		entityId: string;
+	};
+	operationId: "knowledge_get_entity";
+} | {
+	input: {
+		entity: {
+			data: JsonObject;
+			description?: string;
+			entitySchemaId: string;
+			name: string;
+		};
+		idempotencyKey: string;
+	};
+	operationId: "knowledge_create_entity";
+} | {
+	input: {
+		entity: {
+			data?: JsonObject;
+			description?: string;
+			name?: string;
+		};
+		entityId: string;
+		expectedVersion: number;
+		idempotencyKey: string;
+	};
+	operationId: "knowledge_update_entity";
+} | {
+	input: {
+		entity: {
+			data: JsonObject;
+			description?: string;
+			entitySchemaId: string;
+			name: string;
+		};
+		entitySchemaId: string;
+		externalIdentity: {
+			source: string;
+			value: string;
+		};
+		idempotencyKey: string;
+	};
+	operationId: "knowledge_upsert_entity";
+} | {
+	input: {
+		entityId: string;
+		expectedVersion: number;
+		idempotencyKey: string;
+	};
+	operationId: "knowledge_delete_entity";
+} | {
+	input: {
+		anchorEntityId: string;
+		direction?: "incoming" | "outgoing" | "both";
+		limit?: number;
+		maxDepth?: number;
+		relationSchemaId?: string;
+	};
+	operationId: "knowledge_traverse";
+} | {
+	input: {
+		idempotencyKey: string;
+		relation: {
+			data?: JsonObject;
+			relationSchemaId: string;
+			sourceId: string;
+			targetId: string;
+		};
+	};
+	operationId: "knowledge_create_relation";
+} | {
+	input: {
+		expectedVersion: number;
+		idempotencyKey: string;
+		relation: {
+			data?: JsonObject;
+		};
+		relationId: string;
+	};
+	operationId: "knowledge_update_relation";
+} | {
+	input: {
+		expectedVersion: number;
+		idempotencyKey: string;
+		relationId: string;
+	};
+	operationId: "knowledge_delete_relation";
+} | {
+	input: {
+		filter?: JsonObject;
+	};
+	operationId: "agents_list";
+} | {
+	input: {
+		idempotencyKey: string;
+		input: unknown;
+	} & AgentInvokeTarget;
+	operationId: "agents_invoke";
+} | {
+	input: {
+		filter?: JsonObject;
+	};
+	operationId: "skills_list";
+} | {
+	input: {
+		idempotencyKey: string;
+		input: unknown;
+		skillId: string;
+	};
+	operationId: "skills_invoke";
+} | {
+	input: {
+		filter?: JsonObject;
+	};
+	operationId: "workflows_list";
+} | {
+	input: {
+		idempotencyKey: string;
+		input: unknown;
+	} & WorkflowInvokeTarget;
+	operationId: "workflows_invoke";
+} | {
+	input: {
+		runId: string;
+	};
+	operationId: "runs_get";
+} | {
+	input: {
+		afterCursor?: string;
+		runId: string;
+	};
+	operationId: "runs_stream";
+} | {
+	input: {
+		runId: string;
+	};
+	operationId: "runs_cancel";
+} | {
+	input: {
+		contentBase64: string;
+		contentType: string;
+		fileName: string;
+		runId: string;
+		sizeBytes: number;
+	};
+	operationId: "attachments_upload";
+} | {
+	input: {
+		attachmentId: string;
+		runId: string;
+	};
+	operationId: "attachments_download_url";
+} | {
+	input: {
+		idempotencyKey: string;
+		input: unknown;
+	} & ConversationContinueTarget;
+	operationId: "conversations_continue";
+} | {
+	input: {
+		conversationId: string;
+	};
+	operationId: "conversations_history";
+};
+export interface EnvelopeSuccess<Id extends string, Result> {
+	correlationId: string;
+	operationId: Id;
+	result: Result;
+}
+export type ExternalApplicationOperationSuccess = EnvelopeSuccess<"context_get", JsonObject> | EnvelopeSuccess<"knowledge_query", JsonObject> | EnvelopeSuccess<"knowledge_get_entity_schema_snapshot", JsonObject> | EnvelopeSuccess<"knowledge_search_entities", JsonObject> | EnvelopeSuccess<"knowledge_facets", JsonObject> | EnvelopeSuccess<"knowledge_get_schema_query_context", JsonObject> | EnvelopeSuccess<"knowledge_autocomplete", JsonObject> | EnvelopeSuccess<"knowledge_get_entity", JsonObject> | EnvelopeSuccess<"knowledge_create_entity", JsonObject> | EnvelopeSuccess<"knowledge_update_entity", JsonObject> | EnvelopeSuccess<"knowledge_upsert_entity", JsonObject> | EnvelopeSuccess<"knowledge_delete_entity", JsonObject> | EnvelopeSuccess<"knowledge_traverse", JsonObject> | EnvelopeSuccess<"knowledge_create_relation", JsonObject> | EnvelopeSuccess<"knowledge_update_relation", JsonObject> | EnvelopeSuccess<"knowledge_delete_relation", JsonObject> | EnvelopeSuccess<"agents_list", JsonObject> | EnvelopeSuccess<"agents_invoke", {
+	runId: string;
+}> | EnvelopeSuccess<"skills_list", JsonObject> | EnvelopeSuccess<"skills_invoke", {
+	runId: string;
+}> | EnvelopeSuccess<"workflows_list", JsonObject> | EnvelopeSuccess<"workflows_invoke", {
+	runId: string;
+}> | EnvelopeSuccess<"runs_get", JsonObject> | EnvelopeSuccess<"runs_stream", {
+	events: JsonObject[];
+	nextCursor: string | null;
+}> | EnvelopeSuccess<"runs_cancel", JsonObject> | EnvelopeSuccess<"attachments_upload", {
+	attachmentId: string;
+}> | EnvelopeSuccess<"attachments_download_url", {
+	expiresAt: string;
+	url: string;
+}> | EnvelopeSuccess<"conversations_continue", {
+	conversationId: string;
+	runId: string;
+}> | EnvelopeSuccess<"conversations_history", ConversationHistory>;
+export type ExternalApplicationOperationId = ExternalApplicationOperationRequest["operationId"];
+export type ExternalApplicationOperationRequestFor<Id extends ExternalApplicationOperationId> = Extract<ExternalApplicationOperationRequest, {
+	operationId: Id;
+}>;
+export type ExternalApplicationOperationSuccessFor<Id extends ExternalApplicationOperationId> = Extract<ExternalApplicationOperationSuccess, {
+	operationId: Id;
+}>;
+export type ClientOperationId = ExternalApplicationOperationId;
+export interface ClientOperationDefinition<Input, Output> {
+	readonly input: Input;
+	readonly output: Output;
+}
+export type ClientOperationMap = Readonly<{
+	[Id in ClientOperationId]: ClientOperationDefinition<ExternalApplicationOperationRequestFor<Id>["input"], ExternalApplicationOperationSuccessFor<Id>["result"]>;
+}>;
+export type ClientOperationInput<Operations extends ClientOperationMap, Id extends ClientOperationId> = Operations[Id]["input"];
+export type ClientOperationOutput<Operations extends ClientOperationMap, Id extends ClientOperationId> = Operations[Id]["output"];
+export type OperationExecutionOptions = Readonly<{
+	organizationId: string;
+	signal?: AbortSignal;
+}>;
+export interface TypedOperationExecutor<Operations extends ClientOperationMap> {
+	readonly execute: <Id extends ClientOperationId>(operationId: Id, input: ClientOperationInput<Operations, Id>, options?: OperationExecutionOptions) => Promise<CiResult<ClientOperationOutput<Operations, Id>>>;
+}
+export type JsonValue = null | boolean | number | string | readonly JsonValue[] | Readonly<{
+	[key: string]: JsonValue;
+}>;
+export type CiErrorCode = "unauthenticated" | "forbidden" | "not_found" | "conflict" | "invalid_request" | "rate_limited" | "unavailable" | "internal";
+export type CiError = Readonly<{
+	code: CiErrorCode;
+	message: string;
+	retryable: boolean;
+	details?: Readonly<Record<string, JsonValue>>;
+}>;
+export type CiResult<Value> = Readonly<{
+	correlationId: string;
+	ok: true;
+	value: Value;
+}> | Readonly<{
+	correlationId: string;
+	error: CiError;
+	ok: false;
+}>;
+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 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 type CiStreamPage = ClientOperationOutput<ClientOperationMap, "runs_stream">;
+export type FollowRunOptions = Readonly<{
+	/**
+	 * Total wait before `followRun` throws "Run did not finish". Defaults to
+	 * {@link DEFAULT_FOLLOW_RUN_DEADLINE_MS}.
+	 */
+	deadlineMs?: number;
+	/**
+	 * First wait between polls in milliseconds (default 50). It doubles while
+	 * no new event arrives, up to one second or `idleMs` if larger.
+	 */
+	idleMs?: number;
+	now?: () => number;
+	runId: string;
+	/** Stops following and cancels in-flight requests made by `runs.follow`. */
+	signal?: AbortSignal;
+	sleep?: (ms: number) => Promise<void>;
+}>;
+declare const clientSdkProtocolVersion: "v1";
+export type SignalOptions = Readonly<{
+	signal?: AbortSignal;
+}>;
+export type FollowRunCall<Scoped extends boolean> = Scoped extends true ? (options: FollowRunOptions) => Promise<CiStreamPage> : (options: FollowRunOptions & Readonly<{
+	organizationId: string;
+}>) => Promise<CiStreamPage>;
+export type ScopedOperation<Operations extends ClientOperationMap, Id extends ClientOperationId> = (input: ClientOperationInput<Operations, Id>, options?: SignalOptions) => Promise<CiResult<ClientOperationOutput<Operations, Id>>>;
+export type RootOperation<Operations extends ClientOperationMap, Id extends ClientOperationId> = (input: ClientOperationInput<Operations, Id> & Readonly<{
+	organizationId: string;
+}>, options?: SignalOptions) => Promise<CiResult<ClientOperationOutput<Operations, Id>>>;
+export type DomainOperation<Operations extends ClientOperationMap, Id extends ClientOperationId, Scoped extends boolean> = Scoped extends true ? ScopedOperation<Operations, Id> : RootOperation<Operations, Id>;
+export type ClientDomains<Operations extends ClientOperationMap, Scoped extends boolean> = Readonly<{
+	agents: Readonly<{
+		invoke: DomainOperation<Operations, "agents_invoke", Scoped>;
+		list: DomainOperation<Operations, "agents_list", Scoped>;
+	}>;
+	attachments: Readonly<{
+		downloadUrl: DomainOperation<Operations, "attachments_download_url", Scoped>;
+		upload: DomainOperation<Operations, "attachments_upload", Scoped>;
+	}>;
+	context: Readonly<{
+		get: DomainOperation<Operations, "context_get", Scoped>;
+	}>;
+	knowledge: Readonly<{
+		autocomplete: DomainOperation<Operations, "knowledge_autocomplete", Scoped>;
+		createEntity: DomainOperation<Operations, "knowledge_create_entity", Scoped>;
+		createRelation: DomainOperation<Operations, "knowledge_create_relation", Scoped>;
+		deleteEntity: DomainOperation<Operations, "knowledge_delete_entity", Scoped>;
+		deleteRelation: DomainOperation<Operations, "knowledge_delete_relation", Scoped>;
+		facets: DomainOperation<Operations, "knowledge_facets", Scoped>;
+		getEntity: DomainOperation<Operations, "knowledge_get_entity", Scoped>;
+		getEntitySchemaSnapshot: DomainOperation<Operations, "knowledge_get_entity_schema_snapshot", Scoped>;
+		getSchemaQueryContext: DomainOperation<Operations, "knowledge_get_schema_query_context", Scoped>;
+		query: DomainOperation<Operations, "knowledge_query", Scoped>;
+		searchEntities: DomainOperation<Operations, "knowledge_search_entities", Scoped>;
+		traverse: DomainOperation<Operations, "knowledge_traverse", Scoped>;
+		updateEntity: DomainOperation<Operations, "knowledge_update_entity", Scoped>;
+		updateRelation: DomainOperation<Operations, "knowledge_update_relation", Scoped>;
+		upsertEntity: DomainOperation<Operations, "knowledge_upsert_entity", Scoped>;
+	}>;
+	runs: Readonly<{
+		cancel: DomainOperation<Operations, "runs_cancel", Scoped>;
+		follow: FollowRunCall<Scoped>;
+		get: DomainOperation<Operations, "runs_get", Scoped>;
+		stream: DomainOperation<Operations, "runs_stream", Scoped>;
+	}>;
+	skills: Readonly<{
+		invoke: DomainOperation<Operations, "skills_invoke", Scoped>;
+		list: DomainOperation<Operations, "skills_list", Scoped>;
+	}>;
+	workflows: Readonly<{
+		invoke: DomainOperation<Operations, "workflows_invoke", Scoped>;
+		list: DomainOperation<Operations, "workflows_list", Scoped>;
+	}>;
+}>;
+export type OrganizationClient<Operations extends ClientOperationMap> = ClientDomains<Operations, true> & Readonly<{
+	organizationId: string;
+}>;
+export type ClientSdkClient<Operations extends ClientOperationMap> = Omit<ClientDomains<Operations, false>, "context"> & TypedOperationExecutor<Operations> & Readonly<{
+	context: ClientDomains<Operations, false>["context"] & Readonly<{
+		forOrganization: (organizationId: string) => OrganizationClient<Operations>;
+	}>;
+	forOrganization: (organizationId: string) => OrganizationClient<Operations>;
+	protocolVersion: typeof clientSdkProtocolVersion;
+}>;
+export type PromptKeyEvent = Readonly<{
+	isComposing: boolean;
+	key: string;
+	preventDefault: () => void;
+	shiftKey: boolean;
+}>;
+export declare const createPromptKeyHandler: (onSubmit: () => void) => (event: PromptKeyEvent) => void;
+export type AgentPromptComponents = Readonly<{
+	Button?: ElementType;
+	Form?: ElementType;
+	Label?: ElementType;
+	Status?: ElementType;
+	Textarea?: ElementType;
+}>;
+export type AgentPromptPrimitiveProps = Readonly<{
+	autoFocus?: boolean;
+	className?: string;
+	components?: AgentPromptComponents;
+	id: string;
+	label: ReactNode;
+	onChange: (value: string) => void;
+	onSubmit: () => void;
+	pending: boolean;
+	status?: ReactNode;
+	style?: CSSProperties;
+	submitLabel?: ReactNode;
+	value: string;
+}>;
+export declare const AgentPromptPrimitive: ({ autoFocus, className, components, id, label, onChange, onSubmit, pending, status, style, submitLabel, value }: AgentPromptPrimitiveProps) => import("react").JSX.Element;
+export type AgentInvokeInput = ClientOperationInput<ClientOperationMap, "agents_invoke">;
+export type AgentInvokeResult = Awaited<ReturnType<OrganizationClient<ClientOperationMap>["agents"]["invoke"]>>;
+export type AgentInvocationState = Readonly<{
+	status: "idle";
+}> | Readonly<{
+	status: "submitting";
+}> | Readonly<{
+	result: Extract<AgentInvokeResult, {
+		ok: true;
+	}>;
+	status: "success";
+}> | Readonly<{
+	result: Extract<AgentInvokeResult, {
+		ok: false;
+	}>;
+	status: "failure";
+}> | Readonly<{
+	error: unknown;
+	status: "error";
+}>;
+export declare const useAgentInvocation: (organizationId: string) => {
+	readonly invoke: (input: AgentInvokeInput) => Promise<AgentInvokeResult>;
+	readonly reset: () => void;
+	readonly state: AgentInvocationState;
+};
+export type AgentPromptProps = Readonly<{
+	agentId: string;
+	autoFocus?: boolean;
+	className?: string;
+	components?: AgentPromptComponents;
+	createIdempotencyKey?: () => string;
+	label?: ReactNode;
+	onResult?: (result: AgentInvokeResult) => void;
+	organizationId: string;
+	style?: CSSProperties;
+	submitLabel?: ReactNode;
+}>;
+export declare const AgentPrompt: ({ agentId, autoFocus, className, components, createIdempotencyKey, label, onResult, organizationId, style, submitLabel }: AgentPromptProps) => 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 type Client = ClientSdkClient<ClientOperationMap>;
+export type Organization = OrganizationClient<ClientOperationMap>;
+export type CollectiveIntelligenceProviderProps = Readonly<{
+	entitySource?: EntitySource | undefined;
+} & ({
+	children: ReactNode;
+	client: Client;
+	clientFactory?: never;
+} | {
+	children: ReactNode;
+	client?: never;
+	clientFactory: () => Client;
+})>;
+export declare const CollectiveIntelligenceProvider: (props: CollectiveIntelligenceProviderProps) => import("react").JSX.Element;
+export declare const useCollectiveIntelligenceClient: () => Client;
+export declare const useOrganizationClient: (organizationId: string) => OrganizationClient<ClientOperationMap>;
+export declare const useKnowledge: (organizationId: string) => Organization["knowledge"];
+export declare const useAgents: (organizationId: string) => Organization["agents"];
+export declare const useSkills: (organizationId: string) => Organization["skills"];
+export declare const useWorkflows: (organizationId: string) => Organization["workflows"];
+export declare const useRuns: (organizationId: string) => Organization["runs"];
+export declare const useAttachments: (organizationId: string) => Organization["attachments"];
+export declare const useClientContext: (organizationId: string) => Organization["context"];
+export type AuthContextValue = Readonly<{
+	auth: FederatedAuth;
+	state: FederatedAuthState;
+}>;
+export type CollectiveIntelligenceLoginProviderProps = Readonly<{
+	auth: FederatedAuth;
+} & CollectiveIntelligenceProviderProps>;
+export declare const CollectiveIntelligenceLoginProvider: (props: CollectiveIntelligenceLoginProviderProps) => import("react").JSX.Element;
+export type CollectiveIntelligenceAuthBinding = AuthContextValue & Readonly<{
+	beginLogin: FederatedAuth["beginLogin"];
+	completeLogin: FederatedAuth["completeLogin"];
+	logout: FederatedAuth["logout"];
+	reauthorize: FederatedAuth["reauthorize"];
+}>;
+export declare const useCollectiveIntelligenceAuth: () => CollectiveIntelligenceAuthBinding;
+export type LoginButtonComponents = Readonly<{
+	Button?: ElementType;
+}>;
+export type LoginButtonProps = Readonly<{
+	children?: ReactNode;
+	className?: string;
+	components?: LoginButtonComponents;
+	disabled?: boolean;
+	onError?: (error: FederatedAuthError) => void;
+	returnTo?: string;
+	style?: CSSProperties;
+}>;
+export declare const LoginButton: ({ children, className, components, disabled, onError, returnTo, style }: LoginButtonProps) => import("react").JSX.Element;
+export type LoginCallbackComponents = Readonly<{
+	Status?: ElementType;
+}>;
+export type LoginCallbackPrimitiveProps = Readonly<{
+	className?: string;
+	components?: LoginCallbackComponents;
+	state: FederatedAuthState;
+	style?: CSSProperties;
+}>;
+export declare const LoginCallbackPrimitive: ({ className, components, state, style }: LoginCallbackPrimitiveProps) => import("react").JSX.Element;
+export type LoginCallbackProps = Omit<LoginCallbackPrimitiveProps, "state"> & Readonly<{
+	callbackUrl?: string;
+	onComplete?: (returnTo: string) => void;
+	onError?: (error: FederatedAuthError) => void;
+}>;
+export declare const LoginCallback: ({ callbackUrl, onComplete, onError, ...primitiveProps }: LoginCallbackProps) => import("react").JSX.Element;
+export type SessionGateProps = Readonly<{
+	children: ReactNode;
+	fallback?: ReactNode;
+}>;
+/** Current federated session state from the nearest login provider. */
+export declare const useSession: () => FederatedAuthState;
+/** Renders children only when the BFF sealed-cookie session is authenticated. */
+export declare const SessionGate: ({ children, fallback }: SessionGateProps) => ReactNode;
+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>;
+type JsonObject$1<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$1<Value>, Create, Patch> = SharedViewProps<Value, Create, Patch> & ViewStateProps;
+export type EntityListProps<Value extends JsonObject$1<Value>, Create, Patch> = SharedViewProps<Value, Create, Patch> & ViewStateProps;
+export declare const EntityTable: <Value extends JsonObject$1<Value>, Create, Patch>(props: EntityTableProps<Value, Create, Patch>) => import("react").JSX.Element;
+export declare const EntityList: <Value extends JsonObject$1<Value>, Create, Patch>(props: EntityListProps<Value, Create, Patch>) => import("react").JSX.Element;
+export type SharedEntityFormProps<Value extends JsonObject$1<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$1<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$1<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 declare const clientSdkReactEntrypoint: "react";
+
+export {};