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

package/dist/runtime/effect.d.ts

@@ -0,0 +1,954 @@
+// Generated by dts-bundle-generator v9.5.1
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+/** 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;
+}>;
+/** 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 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 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>;
+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;
+}>;
+/** Common entity operations. Generic resource lifecycle/cursor APIs remain separate. */
+export type EntityOperation = "list" | "get" | "create" | "update" | "delete";
+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;
+}>;
+export type EntityRequestIdentity = Readonly<{
+	requestId: string;
+	resourceId: string;
+}>;
+export 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));
+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 ResourceChange<Entity> = Readonly<{
+	kind: "upsert";
+	record: ResourceRecord<Entity>;
+}> | Readonly<{
+	kind: "tombstone";
+	id: string;
+	revision: string;
+	deletedAt: string;
+}>;
+export type ResourceChangePage<Entity> = Readonly<{
+	changes: readonly ResourceChange<Entity>[];
+	nextCursor?: string;
+}>;
+/** 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 ResourceInventoryPage<Entity> = Extract<ResourceListResult<Entity>, {
+	pagination: "page";
+}> & Readonly<{
+	/** Resource-scoped committed change cursor; consume deltas strictly after it. */
+	watermark: string;
+}>;
+export type ResourceMutation = Readonly<{
+	id: string;
+	expectedRevision: string;
+}>;
+export interface CrudRepository<Entity, Create = Entity, Update = Partial<Entity>> {
+	readonly list: (query: ResourceListQuery, context?: EntityInvocationContext) => Promise<ResourceListResult<Entity>>;
+	readonly scan?: (request: ResourceInventoryRequest) => Promise<ResourceInventoryPage<Entity>>;
+	readonly get?: (id: string, includeDeleted?: boolean, context?: EntityInvocationContext) => Promise<ResourceRecord<Entity>>;
+	readonly create?: (value: Create, idempotencyKey: string, context?: EntityInvocationContext) => Promise<ResourceRecord<Entity>>;
+	readonly update?: (input: ResourceMutation & Readonly<{
+		value: Update;
+	}>, context?: EntityInvocationContext) => Promise<ResourceRecord<Entity>>;
+	readonly hardDelete?: (input: ResourceMutation, context?: EntityInvocationContext) => Promise<void>;
+	readonly softDelete?: (input: ResourceMutation, context?: EntityInvocationContext) => Promise<ResourceRecord<Entity>>;
+	readonly restore?: (input: ResourceMutation, context?: EntityInvocationContext) => Promise<ResourceRecord<Entity>>;
+	readonly changes?: (input: Readonly<{
+		cursor?: string;
+		limit: number;
+	}>) => Promise<ResourceChangePage<Entity>>;
+}
+/** A configured local or CI-backed binding; no storage policy is exposed to browsers. */
+export type EntityResourceDefinition<Value = unknown, Create = Value, Patch = Partial<Value>> = Readonly<{
+	definition: ResourceDefinition<Value, Create, Patch>;
+	execute: (request: EntityRequest<Create, Patch>, context: EntityInvocationContext, options?: Readonly<{
+		signal?: AbortSignal;
+	}>) => Promise<ResourceResult<EntityPage<Value> | ResourceRecord<Value>>>;
+}>;
+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>>;
+}>;
+export type CrudResource<Entity = unknown, Create = Entity, Update = Partial<Entity>> = GatewayResourceDefinition<Entity, Create, Update> & Readonly<{
+	executeCrud: (request: ResourceTransportRequest, context: EntityInvocationContext) => Promise<ResourceResult<unknown>>;
+}>;
+export type ResourceHttpHandlerOptions<Value = unknown, Create = Value, Patch = Partial<Value>> = Readonly<{
+	resource: CrudResource<Value, Create, Patch> | EntityResourceDefinition<Value, Create, Patch>;
+	/** Mount path including the entity name, e.g. /api/leads. */
+	basePath: string;
+	/** Host verifies the current CI session and resource policy; no browser identity is trusted. */
+	authorize: (request: Request, operation: ResourceTransportRequest["operation"] | EntityOperation) => Promise<EntityInvocationContext | Response>;
+	maxBodyBytes?: number;
+}>;
+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;
+}>;
+export type FormLayout = "stacked" | "two_column";
+/**
+ * Renderer identifier owned by the consuming product. It remains open so
+ * external packages can declare their own widget implementations.
+ */
+export type FormWidget = string;
+export type FieldValidationRule = Readonly<{
+	type: "required";
+	code?: string;
+	message?: string;
+}> | Readonly<{
+	type: "min_length" | "max_length" | "min" | "max";
+	value: number;
+	code?: string;
+	message?: string;
+}> | Readonly<{
+	type: "pattern";
+	value: string;
+	code?: string;
+	message?: string;
+}> | Readonly<{
+	type: "integer" | "json" | "non_empty_array";
+	code?: string;
+	message?: string;
+}>;
+export type SelectOption = Readonly<{
+	value: string;
+	label?: string;
+	locked?: boolean;
+}>;
+export type DynamicFormAiFillConfig = Readonly<{
+	prompt: string;
+	buttonLabel?: string;
+	retryable?: boolean;
+}>;
+/**
+ * Package-owned, serializable select-control options. The renderer may add
+ * runtime-only resolution metadata separately, but package declarations use
+ * only this protocol.
+ */
+export type SelectOptions<Field extends string = string> = Readonly<{
+	options?: readonly (string | SelectOption)[];
+	allowCustom?: boolean;
+	searchable?: boolean;
+	allowClear?: boolean;
+	dataSource?: string;
+	dependencies?: readonly Field[];
+	submit?: boolean;
+	readonlyOnUpdate?: boolean;
+	preventSaveWhenEmpty?: boolean;
+	selectionMetadataField?: Field;
+	aiFill?: DynamicFormAiFillConfig;
+}>;
+export type VisibilityCondition<Field extends string = string> = Readonly<{
+	field: Field;
+	equals?: JsonValue;
+	notEquals?: JsonValue;
+	in?: readonly JsonValue[];
+	notIn?: readonly JsonValue[];
+	isSet?: boolean;
+	isNotSet?: boolean;
+}>;
+export type FieldVisibilityRule<Field extends string = string> = Readonly<{
+	visibleWhen: VisibilityCondition<Field> | readonly VisibilityCondition<Field>[];
+	logic?: "and" | "or";
+}>;
+export type FieldUiSchema<Field extends string = string> = Readonly<{
+	"ui:widget"?: FormWidget;
+	"ui:placeholder"?: string;
+	"ui:help"?: string;
+	"ui:disabled"?: boolean;
+	"ui:readonly"?: boolean;
+	"ui:order"?: number;
+	"ui:suggestedName"?: string;
+	"ui:validation"?: readonly FieldValidationRule[];
+	"ui:options"?: SelectOptions<Field>;
+}>;
+export type FormMarkdownBlock = Readonly<{
+	md: string;
+}>;
+export type FormSectionItem<Field extends string = string> = Field | FormMarkdownBlock;
+export type FormSection<Field extends string = string> = Readonly<{
+	title?: string | null;
+	description?: string | null;
+	items: readonly FormSectionItem<Field>[];
+	layout?: FormLayout | null;
+}>;
+export type FormStep<Field extends string = string> = Readonly<{
+	id: string;
+	title: string;
+	description?: string | null;
+	includeInBasicInfo?: boolean | null;
+	items: readonly FormSectionItem<Field>[];
+	visibility?: FieldVisibilityRule<Field> | null;
+}>;
+export type FormMetadata<Field extends string> = Readonly<{
+	createSteps?: readonly FormStep<Field>[];
+	layout?: FormLayout;
+	uiSchema?: Partial<Record<Field, FieldUiSchema<Field>>>;
+	updateSections?: readonly FormSection<Field>[];
+	visibility?: Partial<Record<Field, FieldVisibilityRule<Field>>>;
+}>;
+/** 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;
+}>;
+declare const ConsumerProfileIds: readonly [
+	"runtime_json",
+	"ai_function_input",
+	"interactive_form",
+	"workflow_value",
+	"studio_props",
+	"knowledge_record"
+];
+export type ConsumerProfileId = (typeof ConsumerProfileIds)[number];
+export type ConsumerProfileDiagnostic = Readonly<{
+	code: "fidelity_not_supported" | "invalid_default" | "invalid_root" | "recursive_reference" | "remote_reference" | "unknown_vocabulary" | "unsupported_keyword";
+	location: string;
+	profile: ConsumerProfileId;
+	reason: 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[];
+}>;
+/**
+ * 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 type GatewayRuntimeKernel = Pick<GatewayKernel, "handle">;
+export type EffectCrudResourceOptions<Entity, Create, Update, Error, Requirements> = Readonly<{
+	definition: ResourceDefinition<Entity, Create, Update>;
+	authorization: GatewayResourceAuthorization;
+	repository: Effect.Effect<CrudRepository<Entity, Create, Update>, Error, Requirements>;
+}>;
+export type ResourceProjectionDiagnostic = Readonly<{
+	code: "unsupported_refinement" | "unsupported_transform" | "unsupported_schema" | ConsumerProfileDiagnostic["code"];
+	location: string;
+	reason: string;
+}>;
+export type ResourceSchemaProjection = Readonly<{
+	success: true;
+	schema: JsonSchemaDocument;
+	fidelity: "exact";
+	metadata?: FormMetadata<string>;
+}> | Readonly<{
+	success: false;
+	diagnostics: readonly ResourceProjectionDiagnostic[];
+}>;
+declare class GatewayEffectRuntimeError extends Error {
+	readonly _tag = "GatewayEffectRuntimeError";
+	readonly name = "GatewayEffectRuntimeError";
+	readonly cause: unknown;
+	constructor(cause: unknown);
+}
+export type GatewayEffectHandler = (request: Request) => Effect.Effect<Response, GatewayEffectRuntimeError>;
+export type ResourceEffectHandlerOptions<E = never, R = never, Value = unknown, Create = Value, Patch = Partial<Value>> = Omit<ResourceHttpHandlerOptions<Value, Create, Patch>, "authorize"> & Readonly<{
+	authorize: (request: Request, operation: Parameters<ResourceHttpHandlerOptions["authorize"]>[1]) => Effect.Effect<EntityInvocationContext | Response, E, R>;
+}>;
+export declare const createGatewayEffectHandler: (kernel: GatewayRuntimeKernel) => GatewayEffectHandler;
+export declare const createResourceEffectHandler: <E, R, Value = unknown, Create = Value, Patch = Partial<Value>>(options: ResourceEffectHandlerOptions<E, R, Value, Create, Patch>) => (request: Request) => import("effect/Effect").Effect<Response, E | GatewayEffectRuntimeError, R>;
+export declare const DateTimeString: import("effect/Schema").String;
+declare const GatewayEffectRuntimeError$1: typeof GatewayEffectRuntimeError;
+export declare const jsonSchema: (schema: import("effect/Schema").Top) => JsonSchemaDocument;
+export declare const projectResourceSchema: (schema: import("effect/Schema").Top, metadata?: FormMetadata<string>) => ResourceSchemaProjection;
+export declare const makeEffectCrudResource: <Entity, Create = Entity, Update = Partial<Entity>, Error = never, Requirements = never>(options: EffectCrudResourceOptions<Entity, Create, Update, Error, Requirements>) => import("effect/Effect").Effect<CrudResource<Entity, Create, Update>, Error, Requirements>;
+export declare const UuidV7: import("effect/Schema").String;
+type GatewayEffectRuntimeError$1 = GatewayEffectRuntimeError;
+
+export {
+	GatewayEffectRuntimeError$1 as GatewayEffectRuntimeError,
+};
+
+export {};