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

package/dist/resources-B9JIzIvl.d.ts

@@ -0,0 +1,704 @@
+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);
+}
+type FederatedSessionIdentity = Readonly<{
+  email: string | null;
+  id: string;
+  name: string | null;
+  organizationId: string;
+}>;
+type FederatedAuthState = Readonly<{
+  status: "anonymous";
+}> | Readonly<{
+  status: "redirecting";
+}> | Readonly<{
+  expiresAt: number;
+  identity?: FederatedSessionIdentity;
+  status: "authenticated";
+}> | Readonly<{
+  status: "expired";
+}> | Readonly<{
+  error: FederatedAuthError;
+  status: "error";
+}>;
+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;
+}>;
+type ClientFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+type FederatedAuthOptions = Readonly<{
+  clientId: string;
+  crypto?: Pick<Crypto, "getRandomValues" | "subtle">;
+  fetch?: ClientFetch;
+  navigate?: (url: string) => void;
+  now?: () => number;
+  redirectUri: string;
+  scopes: readonly string[];
+  sessionStorage?: Pick<Storage, "getItem" | "removeItem" | "setItem">;
+  tenantUrl: string;
+}>;
+declare const createFederatedAuth: (options: FederatedAuthOptions) => FederatedAuth;
+type JsonValue$1 = boolean | null | number | readonly JsonValue$1[] | Readonly<{
+  readonly [key: string]: JsonValue$1;
+}> | string;
+type JsonObject = Readonly<Record<string, JsonValue$1>>;
+type WorkflowInvokeTarget = {
+  workflowId: string;
+  workflowFqn?: never;
+} | {
+  workflowFqn: string;
+  workflowId?: never;
+};
+/** Addresses an Agent by its UUID or its in-organization FQN. */
+type AgentInvokeTarget = {
+  agentId: string;
+  agentFqn?: never;
+} | {
+  agentFqn: string;
+  agentId?: never;
+};
+/** Starts a conversation with an Agent, or continues an existing one. */
+type ConversationContinueTarget = (AgentInvokeTarget & {
+  conversationId?: never;
+}) | {
+  agentFqn?: never;
+  agentId?: never;
+  conversationId: string;
+};
+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.
+ */
+interface ConversationTurn {
+  completedAt: string | null;
+  createdAt: string;
+  input: unknown;
+  message: string | null;
+  output?: unknown;
+  runId: string;
+  status: ConversationTurnStatus;
+}
+interface ConversationHistory {
+  agentId: string;
+  conversationId: string;
+  createdAt: string;
+  turns: ConversationTurn[];
+}
+interface QueryFilter {
+  caseSensitive?: boolean;
+  field: string;
+  op: "eq" | "neq" | "in" | "contains" | "gt" | "gte" | "lt" | "lte" | "exists";
+  value?: unknown;
+}
+interface SearchQuery {
+  cursor?: string;
+  entitySchemaId: string;
+  fields?: string[];
+  filters?: QueryFilter[];
+  limit?: number;
+  text?: string;
+}
+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";
+});
+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";
+};
+interface EnvelopeSuccess<Id extends string, Result> {
+  correlationId: string;
+  operationId: Id;
+  result: Result;
+}
+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>;
+type ExternalApplicationOperationId = ExternalApplicationOperationRequest["operationId"];
+type ExternalApplicationOperationRequestFor<Id extends ExternalApplicationOperationId> = Extract<ExternalApplicationOperationRequest, {
+  operationId: Id;
+}>;
+type ExternalApplicationOperationSuccessFor<Id extends ExternalApplicationOperationId> = Extract<ExternalApplicationOperationSuccess, {
+  operationId: Id;
+}>;
+/** Generated, curated external-application operation authority. */
+declare const clientOperationIds: readonly ["context_get", "knowledge_query", "knowledge_get_entity_schema_snapshot", "knowledge_search_entities", "knowledge_facets", "knowledge_get_schema_query_context", "knowledge_autocomplete", "knowledge_get_entity", "knowledge_create_entity", "knowledge_update_entity", "knowledge_upsert_entity", "knowledge_delete_entity", "knowledge_traverse", "knowledge_create_relation", "knowledge_update_relation", "knowledge_delete_relation", "agents_list", "agents_invoke", "skills_list", "skills_invoke", "workflows_list", "workflows_invoke", "runs_get", "runs_stream", "runs_cancel", "attachments_upload", "attachments_download_url", "conversations_continue", "conversations_history"];
+type ClientOperationId = ExternalApplicationOperationId;
+declare const isClientOperationId: (value: string) => value is ClientOperationId;
+interface ClientOperationDefinition<Input, Output> {
+  readonly input: Input;
+  readonly output: Output;
+}
+type ClientOperationMap = Readonly<{ [Id in ClientOperationId]: ClientOperationDefinition<ExternalApplicationOperationRequestFor<Id>["input"], ExternalApplicationOperationSuccessFor<Id>["result"]>; }>;
+type ClientOperationInput<Operations extends ClientOperationMap, Id extends ClientOperationId> = Operations[Id]["input"];
+type ClientOperationOutput<Operations extends ClientOperationMap, Id extends ClientOperationId> = Operations[Id]["output"];
+type OperationExecutionOptions = Readonly<{
+  organizationId: string;
+  signal?: AbortSignal;
+}>;
+interface TypedOperationExecutor<Operations extends ClientOperationMap> {
+  readonly execute: <Id extends ClientOperationId>(operationId: Id, input: ClientOperationInput<Operations, Id>, options?: OperationExecutionOptions) => Promise<CiResult<ClientOperationOutput<Operations, Id>>>;
+}
+type JsonValue = null | boolean | number | string | readonly JsonValue[] | Readonly<{
+  [key: string]: JsonValue;
+}>;
+type CiErrorCode = "unauthenticated" | "forbidden" | "not_found" | "conflict" | "invalid_request" | "rate_limited" | "unavailable" | "internal";
+type CiError = Readonly<{
+  code: CiErrorCode;
+  message: string;
+  retryable: boolean;
+  details?: Readonly<Record<string, JsonValue>>;
+}>;
+type CiResult<Value> = Readonly<{
+  correlationId: string;
+  ok: true;
+  value: Value;
+}> | Readonly<{
+  correlationId: string;
+  error: CiError;
+  ok: false;
+}>;
+type OperationRequest<Id extends ClientOperationId> = ExternalApplicationOperationRequestFor<Id>;
+type OperationSuccess<Id extends ClientOperationId> = ExternalApplicationOperationSuccessFor<Id>;
+type ProxyAuthentication = Readonly<{
+  auth: Readonly<{
+    getAccessToken: () => Promise<string> | string;
+  }>;
+  mode: "federated";
+}> | Readonly<{
+  credentials?: RequestCredentials;
+  mode: "server_delegated";
+}>;
+type ProxyTransportOptions = Readonly<{
+  authentication: ProxyAuthentication;
+  fetch?: ClientFetch;
+  path: string;
+  serverUrl: string;
+}>;
+declare const createProxyTransport: <Operations extends ClientOperationMap>(options: ProxyTransportOptions) => TypedOperationExecutor<Operations>;
+type ResourceJsonValue = null | boolean | number | string | readonly ResourceJsonValue[] | Readonly<{
+  [key: string]: ResourceJsonValue;
+}>;
+/** Opaque wire identity. Callers must not infer or concatenate its internals. */
+type ResourceId = string;
+type ResourceRecordId = ResourceId;
+/** Opaque concurrency token independent from source timestamps. */
+type ResourceRevision = string;
+/** Opaque pagination position issued and consumed only by a resource adapter. */
+type ResourceCursor = string;
+type IdempotencyKey = string;
+type ResourceIdentityField = Readonly<{
+  name: string;
+  type: "number" | "string";
+}>;
+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;
+}>;
+type ResourcePaginationMode = "cursor" | "page";
+type PortableResourceSchema = Readonly<Record<string, ResourceJsonValue>>;
+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;
+  }>;
+}>;
+type FilterValue = ResourceJsonValue | readonly ResourceJsonValue[];
+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";
+}>;
+type ResourceSort = Readonly<{
+  direction: "asc" | "desc";
+  field: string;
+}>;
+type ResourcePagination = Readonly<{
+  mode: "cursor";
+  cursor?: ResourceCursor;
+  limit: number;
+}> | Readonly<{
+  mode: "page";
+  page: number;
+  pageSize: number;
+}>;
+type ResourceListQuery = Readonly<{
+  filter?: ResourceFilter;
+  includeDeleted?: boolean;
+  pagination: ResourcePagination;
+  sort?: readonly ResourceSort[];
+  textSearch?: string;
+}>;
+type ResourceRecord<Entity> = Readonly<{
+  deletedAt?: string;
+  id: ResourceRecordId;
+  revision: ResourceRevision;
+  value: Entity;
+}>;
+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;
+}>;
+type ResourceErrorCode = "capability_not_supported" | "conflict" | "forbidden" | "internal" | "invalid_request" | "not_found" | "rate_limited" | "transport_error" | "unauthenticated" | "unavailable";
+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;
+}>;
+type ResourceResult<Value> = Readonly<{
+  correlationId: string;
+  ok: true;
+  value: Value;
+}> | Readonly<{
+  correlationId: string;
+  error: ResourceError;
+  ok: false;
+}>;
+type ResourceRequestOptions = Readonly<{
+  signal?: AbortSignal;
+}>;
+type ResourceListRequest = Readonly<{
+  operation: "list";
+  query: ResourceListQuery;
+  requestId: string;
+  resourceId: string;
+}>;
+type ResourceGetRequest = Readonly<{
+  id: ResourceRecordId;
+  includeDeleted?: boolean;
+  operation: "get";
+  requestId: string;
+  resourceId: string;
+}>;
+type ResourceCreateRequest<Create> = Readonly<{
+  idempotencyKey: IdempotencyKey;
+  operation: "create";
+  requestId: string;
+  resourceId: string;
+  value: Create;
+}>;
+type ResourceUpdateRequest<Update> = Readonly<{
+  expectedRevision: ResourceRevision;
+  id: ResourceRecordId;
+  idempotencyKey?: IdempotencyKey;
+  operation: "update";
+  requestId: string;
+  resourceId: string;
+  value: Update;
+}>;
+type ResourceLifecycleRequest = Readonly<{
+  expectedRevision: ResourceRevision;
+  id: ResourceRecordId;
+  idempotencyKey?: IdempotencyKey;
+  operation: "hard_delete" | "restore" | "soft_delete";
+  requestId: string;
+  resourceId: string;
+}>;
+type ResourceTransportRequest = ResourceCreateRequest<unknown> | ResourceGetRequest | ResourceLifecycleRequest | ResourceListRequest | ResourceUpdateRequest<unknown>;
+interface ResourceTransport {
+  readonly execute: (request: ResourceTransportRequest, options?: ResourceRequestOptions) => Promise<ResourceResult<unknown>>;
+}
+type ResourceMutationInput<Value> = Readonly<{
+  expectedRevision: ResourceRevision;
+  id: ResourceRecordId;
+  idempotencyKey?: IdempotencyKey;
+  value: Value;
+}>;
+type ResourceLifecycleInput = Readonly<{
+  expectedRevision: ResourceRevision;
+  id: ResourceRecordId;
+  idempotencyKey?: IdempotencyKey;
+}>;
+type ResourceCreateInput<Value> = Readonly<{
+  idempotencyKey: IdempotencyKey;
+  value: Value;
+}>;
+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>>>;
+}
+/** Common entity operations. Generic resource lifecycle/cursor APIs remain separate. */
+type EntityOperation = "list" | "get" | "create" | "update" | "delete";
+type EntityListQuery = Omit<ResourceListQuery, "pagination" | "includeDeleted"> & Readonly<{
+  pagination: Extract<ResourcePagination, {
+    mode: "page";
+  }>;
+}>;
+type EntityPage<Value> = Extract<ResourceListResult<Value>, {
+  pagination: "page";
+}>;
+type EntityCreateInput<Value> = ResourceCreateInput<Value>;
+type EntityUpdateInput<Patch> = ResourceMutationInput<Patch> & Readonly<{
+  idempotencyKey: IdempotencyKey;
+}>;
+type EntityDeleteInput = ResourceLifecycleInput & Readonly<{
+  idempotencyKey: IdempotencyKey;
+}>;
+type EntityRequestIdentity = Readonly<{
+  requestId: string;
+  resourceId: string;
+}>;
+type EntityRequest<Create = unknown, Patch = unknown> = EntityRequestIdentity & (Readonly<{
+  operation: "list";
+  query: EntityListQuery;
+}> | Readonly<{
+  operation: "get";
+  id: ResourceRecordId;
+}> | (Readonly<{
+  operation: "create";
+}> & EntityCreateInput<Create>) | (Readonly<{
+  operation: "update";
+}> & EntityUpdateInput<Patch>) | (Readonly<{
+  operation: "delete";
+}> & EntityDeleteInput));
+type EntityOperationResult<Value, Operation extends EntityOperation> = Operation extends "list" ? EntityPage<Value> : ResourceRecord<Value>;
+/** Codecs return safe typed failures without coercing values or performing I/O. */
+type EntityProtocol<Value, Create = Value, Patch = Partial<Value>> = Readonly<{
+  decodeRequest: (input: unknown) => ResourceResult<EntityRequest<Create, Patch>>;
+  decodeResult: <Operation extends EntityOperation>(operation: Operation, input: unknown, correlationId: string) => ResourceResult<EntityOperationResult<Value, Operation>>;
+}>;
+interface EntityTransport {
+  readonly execute: (request: EntityRequest, options?: ResourceRequestOptions) => Promise<ResourceResult<unknown>>;
+}
+/** A logical write retains its key, payload and edited revision on explicit resubmission. */
+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>>>;
+}
+type ClientOptions<Value, Create, Patch> = Readonly<{
+  definition: ResourceDefinition<Value, Create, Patch>;
+  requestId?: () => string;
+}>;
+declare function createResourceClient<Value, Create = Value, Patch = Partial<Value>>(options: ClientOptions<Value, Create, Patch> & Readonly<{
+  protocol: "entity";
+  transport: EntityTransport;
+}>): EntityClient<Value, Create, Patch>;
+declare function createResourceClient<Value, Create = Value, Patch = Partial<Value>>(options: ClientOptions<Value, Create, Patch> & Readonly<{
+  transport: ResourceTransport;
+}>): ResourceClient<Value, Create, Patch>;
+/** Common entity wire codec; transport and persistence remain with their owners. */
+declare const createEntityProtocol: <Value, Create = Value, Patch = Partial<Value>>(definition: ResourceDefinition<Value, Create, Patch>) => EntityProtocol<Value, Create, Patch>;
+type EntityHttpDestination = Readonly<{
+  kind: "gateway";
+  endpoint: string;
+}> | Readonly<{
+  kind: "ci";
+  tenantUrl: string;
+  schemaFqn: string;
+  organizationId: string;
+}>;
+type EntityHttpTransportOptions = Readonly<{
+  destination: EntityHttpDestination;
+  authentication: ProxyAuthentication;
+  fetch?: ClientFetch;
+}>;
+declare const createEntityHttpTransport: (options: EntityHttpTransportOptions) => EntityTransport;
+export { CiErrorCode as $, ResourceIdentityField as A, ResourceRecord as B, ResourceCursor as C, FederatedAuthError as Ct, ResourceFilter as D, FederatedSessionIdentity as Dt, ResourceErrorCode as E, FederatedAuthState as Et, ResourceListRequest as F, ResourceSort as G, ResourceRequestOptions as H, ResourceListResult as I, ResourceUpdateRequest as J, ResourceTransport as K, ResourceMutationInput as L, ResourceLifecycleInput as M, ResourceLifecycleRequest as N, ResourceGetRequest as O, createFederatedAuth as Ot, ResourceListQuery as P, CiError as Q, ResourcePagination as R, ResourceCreateRequest as S, FederatedAuth as St, ResourceError as T, FederatedAuthOptions as Tt, ResourceResult as U, ResourceRecordId as V, ResourceRevision as W, ProxyTransportOptions as X, ProxyAuthentication as Y, createProxyTransport as Z, IdempotencyKey as _, KnowledgeQuery as _t, createResourceClient as a, ClientOperationId as at, ResourceClient as b, WorkflowInvokeTarget as bt, EntityDeleteInput as c, ClientOperationOutput as ct, EntityOperationResult as d, clientOperationIds as dt, CiResult as et, EntityPage as f, isClientOperationId as ft, EntityUpdateInput as g, JsonObject as gt, EntityTransport as h, ConversationHistory as ht, createEntityProtocol as i, ClientOperationDefinition as it, ResourceJsonValue as j, ResourceId as k, EntityListQuery as l, OperationExecutionOptions as lt, EntityRequest as m, ConversationContinueTarget as mt, EntityHttpTransportOptions as n, OperationRequest as nt, EntityClient as o, ClientOperationInput as ot, EntityProtocol as p, AgentInvokeTarget as pt, ResourceTransportRequest as q, createEntityHttpTransport as r, OperationSuccess as rt, EntityCreateInput as s, ClientOperationMap as st, EntityHttpDestination as t, JsonValue as tt, EntityOperation as u, TypedOperationExecutor as ut, PortableResourceSchema as v, QueryFilter as vt, ResourceDefinition as w, FederatedAuthErrorCode as wt, ResourceCreateInput as x, ClientFetch as xt, ResourceCapabilities as y, SearchQuery as yt, ResourcePaginationMode as z };