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

package/dist/runtime/web.d.ts

@@ -0,0 +1,776 @@
+// Generated by dts-bundle-generator v9.5.1
+
+export type PrincipalKind = "detached_user" | "service_principal";
+export type DelegatedSubjectPolicy = "allowed" | "forbidden" | "required";
+export type AuthorizationRequirement = Readonly<{
+	delegatedSubject?: DelegatedSubjectPolicy;
+	organization: "required";
+	principalKinds: readonly PrincipalKind[];
+	scopes: readonly string[];
+}>;
+export type ExternalAuditSubject = Readonly<{
+	issuer: string;
+	mappedCiUserId?: string;
+	subject: string;
+}>;
+export type GatewayCallerIdentity = Readonly<{
+	audience: readonly string[];
+	binding: string;
+	expiresAt: number;
+	installationId: string;
+	issuer: string;
+	organizationId: string;
+	principalKind: PrincipalKind;
+	requestId: string;
+	scopes: readonly string[];
+	subject: string;
+}>;
+export type GatewayInvocationContext = Readonly<{
+	caller: GatewayCallerIdentity;
+	correlationId: string;
+	externalAuditSubject?: ExternalAuditSubject;
+	organizationId: string;
+}>;
+export type JsonPrimitive = boolean | null | number | string;
+export type JsonValue = JsonObject | JsonPrimitive | readonly JsonValue[];
+export interface JsonObject {
+	readonly [key: string]: JsonValue;
+}
+declare const Draft202012Dialect: "https://json-schema.org/draft/2020-12/schema";
+/** JSON-compatible Draft 2020-12 vocabulary used for portable manifests. */
+export type JsonSchemaDocument = JsonObject & Readonly<{
+	$anchor?: string;
+	$comment?: string;
+	$defs?: Readonly<Record<string, JsonSchemaDocument>>;
+	$dynamicAnchor?: string;
+	$dynamicRef?: string;
+	$id?: string;
+	$ref?: string;
+	$schema?: typeof Draft202012Dialect;
+	additionalProperties?: boolean | JsonSchemaDocument;
+	allOf?: readonly JsonSchemaDocument[];
+	anyOf?: readonly JsonSchemaDocument[];
+	const?: JsonValue;
+	contains?: JsonSchemaDocument;
+	default?: JsonValue;
+	dependentRequired?: Readonly<Record<string, readonly string[]>>;
+	description?: string;
+	else?: JsonSchemaDocument;
+	enum?: readonly JsonValue[];
+	exclusiveMaximum?: number;
+	exclusiveMinimum?: number;
+	format?: string;
+	if?: JsonSchemaDocument;
+	items?: JsonSchemaDocument;
+	maxItems?: number;
+	maxLength?: number;
+	maxProperties?: number;
+	maximum?: number;
+	minItems?: number;
+	minLength?: number;
+	minProperties?: number;
+	minimum?: number;
+	multipleOf?: number;
+	not?: JsonSchemaDocument;
+	oneOf?: readonly JsonSchemaDocument[];
+	pattern?: string;
+	patternProperties?: Readonly<Record<string, JsonSchemaDocument>>;
+	prefixItems?: readonly JsonSchemaDocument[];
+	properties?: Readonly<Record<string, JsonSchemaDocument>>;
+	required?: readonly string[];
+	then?: JsonSchemaDocument;
+	title?: string;
+	type?: "array" | "boolean" | "integer" | "null" | "number" | "object" | "string" | readonly ("array" | "boolean" | "integer" | "null" | "number" | "object" | "string")[];
+	unevaluatedItems?: boolean | JsonSchemaDocument;
+	unevaluatedProperties?: boolean | JsonSchemaDocument;
+	uniqueItems?: boolean;
+}>;
+export type ProjectionFidelity = "exact" | "structural";
+export type PackageSchemaProjection = Readonly<{
+	dialect: typeof Draft202012Dialect;
+	document: JsonSchemaDocument;
+	fidelity: ProjectionFidelity;
+}>;
+/** Closed public principal vocabulary accepted by a gateway operation. */
+export type PortableOperationPrincipalKind = "detached_user" | "service_principal";
+/** Explicit delegated-subject requirement reviewed with an operation. */
+export type PortableOperationDelegatedSubjectPolicy = "allowed" | "forbidden" | "required";
+/** Fully materialized authorization policy for one exposed operation. */
+export type PortableOperationAuthorization = Readonly<{
+	delegatedSubject: PortableOperationDelegatedSubjectPolicy;
+	organization: "required";
+	principalKinds: readonly PortableOperationPrincipalKind[];
+	scopes: readonly string[];
+}>;
+/** Observable side-effect class reviewed before an operation becomes a tool. */
+export type PortableOperationEffect = "external_side_effect" | "read" | "write";
+/** The replay guarantee supplied by the operation implementation. */
+export type PortableOperationIdempotency = "idempotent" | "requires_key" | "safe";
+/** Explicit, bounded retry permission for callers of the operation. */
+export type PortableOperationRetryPolicy = Readonly<{
+	mode: "never";
+}> | Readonly<{
+	maxAttempts: number;
+	mode: "idempotent_only";
+}>;
+/** Execution lifecycle and maximum wall-clock duration. */
+export type PortableOperationExecutionPolicy = Readonly<{
+	mode: "synchronous";
+	timeoutMs: number;
+}>;
+/** Per-invocation transport bounds. */
+export type PortableOperationLimits = Readonly<{
+	maxRequestBytes: number;
+	maxResponseBytes: number;
+}>;
+/**
+ * Complete JSON-only operation contract reviewed by a host. Executable
+ * handlers remain in a server runtime sidecar and never enter this descriptor.
+ */
+export type PortableOperationDeclaration = Readonly<{
+	authorization: PortableOperationAuthorization;
+	description: string;
+	effects: PortableOperationEffect;
+	execution: PortableOperationExecutionPolicy;
+	id: string;
+	idempotency: PortableOperationIdempotency;
+	input: PackageSchemaProjection;
+	limits: PortableOperationLimits;
+	output: PackageSchemaProjection;
+	retry: PortableOperationRetryPolicy;
+	title: string;
+	version: string;
+}>;
+/** One catalog and identity namespace for an ordered operation list. */
+export type OperationDomainDeclaration<Operation extends PortableOperationDeclaration = PortableOperationDeclaration> = Readonly<{
+	description?: string;
+	displayOrder?: number;
+	icon?: string;
+	id: string;
+	operations: readonly Operation[];
+	tags?: readonly string[];
+	title: string;
+}>;
+export type DatasetProviderResult<Value> = Readonly<{
+	status: "success";
+	value: Value;
+}> | Readonly<{
+	status: "failure";
+	error: DatasetProviderError;
+}>;
+export type DatasetScalarType = "boolean" | "string" | "int64" | "float64" | "decimal" | "date" | "timestamp" | "duration" | "json";
+export type DatasetValue = Readonly<{
+	kind: "null";
+}> | Readonly<{
+	kind: "boolean";
+	value: boolean;
+}> | Readonly<{
+	kind: "string";
+	value: string;
+}> | Readonly<{
+	kind: "int64";
+	value: string;
+}> | Readonly<{
+	kind: "float64";
+	value: number;
+}> | Readonly<{
+	kind: "decimal";
+	value: string;
+}> | Readonly<{
+	kind: "date";
+	value: string;
+}> | Readonly<{
+	kind: "timestamp";
+	value: string;
+}> | Readonly<{
+	kind: "duration";
+	value: string;
+}> | Readonly<{
+	kind: "json";
+	value: JsonValue;
+}>;
+export type DatasetPredicateOperator = "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "is_null" | "is_not_null" | "contains" | "starts_with";
+export type DatasetAggregateOperation = "count" | "count_distinct" | "sum" | "min" | "max" | "avg";
+export type DatasetQueryIntent = "records" | "aggregate" | "time_series";
+export type DatasetTimeBucket = "hour" | "day" | "week" | "month";
+export type DatasetPredicate = Readonly<{
+	kind: "predicate";
+	fieldId: string;
+	operator: DatasetPredicateOperator;
+	values: readonly DatasetValue[];
+}>;
+export type DatasetFilter = DatasetPredicate | Readonly<{
+	kind: "and" | "or";
+	filters: readonly DatasetFilter[];
+}> | Readonly<{
+	kind: "not";
+	filter: DatasetFilter;
+}>;
+export type DatasetOrder = Readonly<{
+	fieldOrAlias: string;
+	direction: "asc" | "desc";
+}>;
+export type DatasetOperation = Readonly<{
+	kind: "records";
+	projection: readonly string[];
+	filter?: DatasetFilter;
+	orderBy: readonly DatasetOrder[];
+	cursor?: string;
+}> | Readonly<{
+	kind: "aggregate";
+	filter?: DatasetFilter;
+	groupBy: readonly string[];
+	measures: readonly Readonly<{
+		alias: string;
+		operation: DatasetAggregateOperation;
+		fieldId?: string;
+	}>[];
+	orderBy: readonly DatasetOrder[];
+	cursor?: string;
+}> | Readonly<{
+	kind: "time_series";
+	timeFieldId: string;
+	measure: Readonly<{
+		alias: string;
+		operation: DatasetAggregateOperation;
+		fieldId?: string;
+	}>;
+	bucket: DatasetTimeBucket;
+	order: "asc" | "desc";
+	filter?: DatasetFilter;
+	cursor?: string;
+}>;
+export type DatasetProviderCapabilities = Readonly<{
+	intents: readonly DatasetQueryIntent[];
+	predicates: readonly DatasetPredicateOperator[];
+	aggregates: readonly DatasetAggregateOperation[];
+	grouping: boolean;
+	ordering: boolean;
+	pagination: boolean;
+	definitionRefresh: boolean;
+	limits: Readonly<{
+		maxRows: number;
+		maxBytes: number;
+		timeoutMs: number;
+		maxPageRows: number;
+	}>;
+}>;
+export type SafeDiagnostic = Readonly<{
+	code: string;
+	message: string;
+	fieldId?: string;
+}>;
+export type ConnectorContext = Readonly<{
+	correlationId: string;
+	deadlineEpochMs: number;
+}>;
+export type DatasetSourceLocation = Readonly<{
+	segments: readonly [
+		Readonly<{
+			kind: "container";
+			opaqueId: string;
+			label: string;
+		}>,
+		...Readonly<{
+			kind: "container" | "dataset";
+			opaqueId: string;
+			label: string;
+		}>[]
+	];
+}>;
+export type DatasetDefinition = Readonly<{
+	version: 1;
+	fields: readonly Readonly<{
+		id: string;
+		name: string;
+		type: DatasetScalarType;
+		nullable: boolean;
+		semantic?: string;
+	}>[];
+	measures: readonly Readonly<{
+		id: string;
+		name: string;
+		resultType: DatasetScalarType;
+	}>[];
+	relationships: readonly Readonly<{
+		id: string;
+		fromFieldId: string;
+		toFieldId: string;
+		cardinality: "one_to_one" | "one_to_many" | "many_to_one" | "many_to_many";
+	}>[];
+}>;
+export type Bounds = Readonly<{
+	maxRows: number;
+	maxBytes: number;
+	timeoutMs: number;
+}>;
+export type QueryInput = ConnectorContext & Readonly<{
+	location: DatasetSourceLocation;
+	definitionRevisionId: string;
+	definition: DatasetDefinition;
+	operation: DatasetOperation;
+	bounds: Bounds;
+}>;
+export type DatasetRecordPage = Readonly<{
+	columns: readonly Readonly<{
+		fieldId: string;
+		type: DatasetScalarType;
+	}>[];
+	rows: readonly (readonly DatasetValue[])[];
+	nextCursor?: string;
+	rowCount: number;
+	byteCount: number;
+	observedAt: string;
+}>;
+export type DatasetResultPage = (Readonly<{
+	kind: "records";
+}> & DatasetRecordPage) | Readonly<{
+	kind: "aggregate";
+	columns: readonly Readonly<{
+		alias: string;
+		type: DatasetScalarType;
+	}>[];
+	rows: readonly (readonly DatasetValue[])[];
+	nextCursor?: string;
+	rowCount: number;
+	byteCount: number;
+	observedAt: string;
+}> | Readonly<{
+	kind: "time_series";
+	valueType: DatasetScalarType;
+	points: readonly Readonly<{
+		time: string;
+		value: DatasetValue;
+	}>[];
+	nextCursor?: string;
+	pointCount: number;
+	byteCount: number;
+	observedAt: string;
+}>;
+export type DatasetProviderError = Readonly<{
+	kind: "not_ready" | "incompatible_source" | "unsupported_operation" | "policy_not_pushable" | "invalid_cursor" | "timeout" | "permission_denied" | "provider_unavailable" | "provider_rejected" | "invalid_provider_response";
+	diagnostics: readonly SafeDiagnostic[];
+}> | Readonly<{
+	kind: "limit_exceeded";
+	limit: "rows" | "bytes" | "timeout";
+	diagnostics: readonly SafeDiagnostic[];
+}> | Readonly<{
+	kind: "throttled";
+	retryAfterMs?: number;
+	diagnostics: readonly SafeDiagnostic[];
+}>;
+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 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 ResourceListRequest = Readonly<{
+	operation: "list";
+	query: ResourceListQuery;
+	requestId: string;
+	resourceId: string;
+}>;
+export type ResourceGetRequest = Readonly<{
+	id: ResourceRecordId;
+	includeDeleted?: boolean;
+	operation: "get";
+	requestId: string;
+	resourceId: string;
+}>;
+export type ResourceCreateRequest<Create> = Readonly<{
+	idempotencyKey: IdempotencyKey;
+	operation: "create";
+	requestId: string;
+	resourceId: string;
+	value: Create;
+}>;
+export type ResourceUpdateRequest<Update> = Readonly<{
+	expectedRevision: ResourceRevision;
+	id: ResourceRecordId;
+	idempotencyKey?: IdempotencyKey;
+	operation: "update";
+	requestId: string;
+	resourceId: string;
+	value: Update;
+}>;
+export type ResourceLifecycleRequest = Readonly<{
+	expectedRevision: ResourceRevision;
+	id: ResourceRecordId;
+	idempotencyKey?: IdempotencyKey;
+	operation: "hard_delete" | "restore" | "soft_delete";
+	requestId: string;
+	resourceId: string;
+}>;
+export type ResourceTransportRequest = ResourceCreateRequest<unknown> | ResourceGetRequest | ResourceLifecycleRequest | ResourceListRequest | ResourceUpdateRequest<unknown>;
+/** Application login identities are separate from gateway machine callers. */
+export type ApplicationUserIdentity = Readonly<{
+	kind: "local_user";
+	id: string;
+	email: string;
+	name: string | null;
+} | {
+	kind: "ci_user";
+	id: string;
+	email: string | null;
+	name: string | null;
+	issuer: string;
+	organizationId: string;
+}>;
+export type ApplicationUserSession = Readonly<{
+	identity: ApplicationUserIdentity;
+	expiresAt: Date;
+}>;
+/** Constructed only after user/app/organization authorization at server ingress.
+ * Canonical identities survive proxy hops and scope mutation receipts; credentials
+ * and request/correlation IDs are deliberately not part of that logical identity.
+ */
+export type EntityInvocationContext = Readonly<{
+	applicationId: string;
+	issuer: string;
+	organizationId: string;
+	resourceId: string;
+	roles: readonly string[];
+	scopes: readonly string[];
+	teamIds: readonly string[];
+	user: ApplicationUserIdentity;
+}>;
+export type ApplicationUserAuth = Readonly<{
+	mode: "federated" | "local";
+	handler: (request: Request) => Promise<Response>;
+	/** Returns null only when the request has no valid application session. */
+	getSession: (request: Request) => Promise<ApplicationUserSession | null>;
+	/** Server-only current CI authority. The host still owns resource/operation policy.
+	 * Null means no valid CI session or no current role/team policy supplied by CI.
+	 */
+	getEntityContext: (request: Request, resourceId: string) => Promise<EntityInvocationContext | null>;
+	/** Server-only Delegated access token. Absent for local application login. */
+	getAccessToken?: (request: Request) => Promise<string | null>;
+}>;
+/** Full inventory only: no filters, text search or caller-selected ordering.
+ * Continue consecutive pages with the first watermark. A conflict requires restart.
+ */
+export type ResourceInventoryRequest = Readonly<{
+	page: number;
+	pageSize: number;
+	watermark?: string;
+}>;
+export type GatewayResourceOperation = ResourceTransportRequest["operation"];
+export type GatewayResourceAuthorization = Readonly<Partial<Record<GatewayResourceOperation, AuthorizationRequirement>>>;
+export type GatewayResourceDefinition<Entity = unknown, Create = Entity, Update = Partial<Entity>> = Readonly<{
+	authorization: GatewayResourceAuthorization;
+	definition: ResourceDefinition<Entity, Create, Update>;
+	execute: (request: ResourceTransportRequest, context: GatewayInvocationContext, options?: Readonly<{
+		signal?: AbortSignal;
+	}>) => Promise<ResourceResult<unknown>>;
+	scan?: (request: ResourceInventoryRequest & Readonly<{
+		requestId: string;
+		resourceId: string;
+	}>, context: GatewayInvocationContext, options?: Readonly<{
+		signal?: AbortSignal;
+	}>) => Promise<ResourceResult<unknown>>;
+	changes?: (request: Readonly<{
+		cursor?: string;
+		limit: number;
+		requestId: string;
+		resourceId: string;
+	}>, context: GatewayInvocationContext, options?: Readonly<{
+		signal?: AbortSignal;
+	}>) => Promise<ResourceResult<unknown>>;
+}>;
+/**
+ * Runtime dispatch validates the declared input schema before invoking a
+ * handler. The bivariant call signature lets domains retain heterogeneous,
+ * strongly typed handlers while exposing one erased operation collection.
+ */
+export type GatewayOperationHandler<Input = unknown, Output = unknown> = {
+	bivarianceHack(request: Readonly<{
+		context: GatewayInvocationContext;
+		/** Validated caller key; the handler owns durable replay storage. */
+		idempotencyKey?: string;
+		input: Input;
+		signal: AbortSignal;
+	}>): Promise<Output>;
+}["bivarianceHack"];
+export type GatewayOperationDefinition<Input = unknown, Output = unknown> = Omit<PortableOperationDeclaration, "input" | "output"> & Readonly<{
+	handler: GatewayOperationHandler<Input, Output>;
+	input: PackageSchemaProjection;
+	output: PackageSchemaProjection;
+}>;
+export type GatewayOperationManifest = Omit<GatewayOperationDefinition, "handler"> & Readonly<{
+	canonicalReference: string;
+}>;
+export type GatewayOperationDomainDefinition = OperationDomainDeclaration<GatewayOperationDefinition>;
+export type GatewayOperationDomainManifest = OperationDomainDeclaration<GatewayOperationManifest>;
+/** CI destination marker only; source records are shared across all connections. */
+export type OrganizationBinding = Readonly<{
+	mode: "installed_organization";
+}>;
+export type GatewayKnowledgeResourceExposure = Readonly<{
+	resource: GatewayResourceDefinition;
+	access: "read" | "read_write";
+}>;
+export type GatewayDatasetBinding = Readonly<{
+	id: string;
+	title: string;
+	definition: DatasetDefinition;
+	authorization: AuthorizationRequirement;
+	providerFqn: string;
+	query: (input: QueryInput, context: GatewayInvocationContext, options: Readonly<{
+		signal: AbortSignal;
+	}>) => Promise<DatasetProviderResult<DatasetResultPage>>;
+}>;
+export type GatewayDatasetManifest = Omit<GatewayDatasetBinding, "query"> & Readonly<{
+	capabilities: DatasetProviderCapabilities;
+}>;
+export type GatewayDefinitionInput = Readonly<{
+	knowledge?: readonly GatewayKnowledgeResourceExposure[];
+	datasets?: readonly GatewayDatasetBinding[];
+	id: string;
+	operationDomains: readonly GatewayOperationDomainDefinition[];
+	organizationBinding?: OrganizationBinding;
+	protocolVersion?: "2";
+	version: string;
+}>;
+export type GatewayManifest = Readonly<{
+	capabilities: Readonly<{
+		resources: boolean;
+	}>;
+	datasets: readonly GatewayDatasetManifest[];
+	knowledge: readonly Readonly<{
+		id: string;
+		access: "read" | "read_write";
+		definition: GatewayResourceDefinition["definition"];
+		fullInventory: boolean;
+		incrementalChanges: boolean;
+	}>[];
+	contentHash: string;
+	id: string;
+	operationDomains: readonly GatewayOperationDomainManifest[];
+	organizationBinding: OrganizationBinding;
+	protocolVersion: "2";
+	revision: string;
+	version: string;
+}>;
+export type GatewayProposal = Readonly<{
+	gatewayId: string;
+	gatewayVersion: string;
+	knowledge: GatewayManifest["knowledge"];
+	operationDomains: readonly GatewayOperationDomainManifest[];
+	revision: string;
+}>;
+export interface DefinedGateway {
+	readonly input: GatewayDefinitionInput;
+	readonly resource: (id: string) => GatewayResourceDefinition | undefined;
+	readonly dataset: (id: string) => GatewayDatasetBinding | undefined;
+	readonly manifest: GatewayManifest;
+	readonly proposal: GatewayProposal;
+}
+export interface GatewayKernel {
+	readonly handle: (request: Request) => Promise<Response>;
+	readonly manifest: DefinedGateway["manifest"];
+}
+export interface ExternalApplicationExternalAuditSubject {
+	readonly issuer: string;
+	readonly mappedUserId?: string;
+	readonly subjectId: string;
+}
+export interface ConfidentialCredentials {
+	readonly clientId: string;
+	readonly clientSecret: string;
+}
+export interface RotatingConfidentialCredentialProvider {
+	readonly getCredentials: () => ConfidentialCredentials | Promise<ConfidentialCredentials>;
+}
+export type ConfidentialCredentialProvider = ConfidentialCredentials | RotatingConfidentialCredentialProvider;
+export type ServiceServerAuthentication = Readonly<{
+	credentials: ConfidentialCredentialProvider;
+	mode: "service";
+}>;
+/** Application credentials authorize each call for a required Audit subject in one configured organization. */
+export type ServiceCapabilityAuthorization = Readonly<{
+	authentication: ServiceServerAuthentication;
+	/**
+	 * Who makes each forwarded call; defaults to `"service"`. `"anonymous_visitor"`
+	 * marks each call as made by the anonymous visitor the Audit subject names:
+	 * the backend then runs only the Agent's own bindings and never the
+	 * application's service authority. A visitor is never a CI user, so an Audit
+	 * subject carrying `mappedUserId` is refused with `401`.
+	 */
+	caller?: "anonymous_visitor" | "service";
+	getAuditSubject: (request: Request) => Promise<ExternalApplicationExternalAuditSubject | null>;
+	organizationId: string;
+}>;
+export type UserAuthScopePolicy = Readonly<{
+	readScope: string;
+	writeScope: string;
+}>;
+export type CiResourceBinding<Value = unknown, Create = Value, Patch = Partial<Value>> = Readonly<{
+	definition: ResourceDefinition<Value, Create, Patch>;
+	schemaFqn: string;
+}>;
+export type CiResourcesOptions = Readonly<{
+	auth: Pick<ApplicationUserAuth, "getEntityContext">;
+	bindings: readonly CiResourceBinding[];
+	fetch?: typeof globalThis.fetch;
+	organizationId: string;
+	policy?: UserAuthScopePolicy;
+	tenantUrl: string;
+}>;
+export type BffResourceMount = Readonly<{
+	basePath: string;
+	handler: (request: Request) => Promise<Response>;
+}>;
+/** Dedicated Capability forwarding: the user's delegated token by default, or service credentials with an Audit subject. */
+export type ExternalApplicationBffCapabilities = Readonly<{
+	basePath?: string;
+	fetch?: typeof globalThis.fetch;
+	tenantUrl: string;
+}> & (Readonly<{
+	authentication?: never;
+}> | ServiceCapabilityAuthorization);
+export type ExternalApplicationBffOptions = Readonly<{
+	auth: ApplicationUserAuth;
+	authBasePath?: string;
+	capabilities?: ExternalApplicationBffCapabilities;
+	ciResources?: Omit<CiResourcesOptions, "auth">;
+	publicOrigin: string;
+	resources?: readonly BffResourceMount[];
+}>;
+export type ExternalApplicationBff = (request: Request) => Promise<Response>;
+export type WorkflowTarget = Readonly<{
+	workflowId: string;
+	workflowFqn?: never;
+}> | Readonly<{
+	workflowFqn: string;
+	workflowId?: never;
+}>;
+export type FixedWorkflowRouteOptions<Input, Params = Record<string, never>> = Readonly<{
+	auth: Pick<ApplicationUserAuth, "getAccessToken" | "getEntityContext">;
+	fetch?: typeof globalThis.fetch;
+	publicOrigin: string;
+	tenantUrl: string;
+	validate: (body: unknown, params: Params) => Input;
+	resourceId: string;
+	requiredScopes?: readonly string[];
+	idempotencyKey?: (input: Input, context: EntityInvocationContext, request: Request) => string | null;
+	authorize?: (request: Request) => Promise<EntityInvocationContext | Response>;
+	getAccessToken?: (request: Request) => Promise<string | null>;
+}> & WorkflowTarget;
+export type GatewayWebHandler = (request: Request) => Promise<Response>;
+export type GatewayRuntimeKernel = Pick<GatewayKernel, "handle">;
+export declare const cookies: (request: Request) => string | null, createCiResourceMounts: (options: CiResourcesOptions) => {
+	basePath: string;
+	handler: (request: Request) => Promise<Response>;
+}[], createExternalApplicationBff: (options: ExternalApplicationBffOptions) => ExternalApplicationBff, createFixedWorkflowRoute: <Input, Params = Record<string, never>>(options: FixedWorkflowRouteOptions<Input, Params>) => ((request: Request, params: Params) => Promise<Response>), createGatewayWebHandler: (kernel: GatewayRuntimeKernel) => GatewayWebHandler, headers: (request: Request) => Headers, publicOriginFromHeaders: (headerList: Headers, fallbackOrigin: string) => string, requestWithPublicOrigin: (request: Request, publicOrigin: string) => Request;
+
+export {};