@useairfoil/connector-kit 0.4.0 → 0.5.1

package/dist/index-D54ySAKn.d.ts

@@ -0,0 +1,14 @@
+import * as effect_Types0 from "effect/Types";
+import * as effect_Cause0 from "effect/Cause";
+
+//#region src/errors/connector-error.d.ts
+declare const ConnectorError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => effect_Cause0.YieldableError & {
+  readonly _tag: "ConnectorError";
+} & Readonly<A>;
+declare class ConnectorError extends ConnectorError_base<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+//#endregion
+export { ConnectorError as t };
+//# sourceMappingURL=index-D54ySAKn.d.ts.map

package/dist/index-DtJX_tic.d.ts

@@ -0,0 +1,153 @@
+import { t as ConnectorError } from "./index-D54ySAKn.js";
+import { b as WebhookHandler, d as ResourceMutation, f as ResourceName, g as ResourceSchema, i as DeleteValue, l as ResourceDefinition, n as ConnectorDefinition, r as Cursor, s as PageFetch, t as ChangesFetch } from "./types-B35J5YPu.js";
+import { i as Publisher } from "./service-IE5qaf9x.js";
+import { i as StateStore } from "./index-Coh_SkBs.js";
+import { Config, Context, Duration, Effect, Layer } from "effect";
+import { HttpRouter } from "effect/unstable/http";
+import * as effect_unstable_http_HttpClient0 from "effect/unstable/http/HttpClient";
+import * as effect_unstable_http_HttpServerError0 from "effect/unstable/http/HttpServerError";
+
+//#region src/connector-app/check.d.ts
+type ResourceCheckResult = {
+  readonly _tag: "ok";
+} | {
+  readonly _tag: "error";
+  readonly message: string;
+};
+type CheckOptions<Name extends string> = {
+  readonly resources: ReadonlyArray<Name>;
+};
+type ResourceCheckResults<Name extends PropertyKey> = { readonly [Key in Name]: ResourceCheckResult };
+type CheckResult<Resources extends ReadonlyArray<ResourceDefinition>, Name extends ResourceName<Resources> = ResourceName<Resources>> = ResourceCheckResults<Name>;
+type CheckFailure = {
+  readonly message: string;
+};
+/**
+ * Builds the connector service from its layer and validates only the selected
+ * resources. The layer remains open until every check finishes.
+ */
+declare function check<Identifier, const Resources extends ReadonlyArray<ResourceDefinition>, E extends CheckFailure, R, const Name extends ResourceName<Resources>>(service: Context.Key<Identifier, ConnectorDefinition<Resources>>, layer: Layer.Layer<Identifier, E, R>, options: CheckOptions<Name>): Effect.Effect<CheckResult<Resources, Name>, never, R>;
+//#endregion
+//#region src/core/builder.d.ts
+declare const Connector: {
+  define: <const Resources extends ReadonlyArray<ResourceDefinition>>(definition: ConnectorDefinition<Resources>) => ConnectorDefinition<Resources>;
+};
+declare const Resource: {
+  entity: <S extends ResourceSchema, Payload = never, R = never, const Name extends string = string>(definition: ResourceDefinition<S, Payload, R, Name>) => ResourceDefinition<S, Payload, R, Name>;
+  webhook: <Payload, Row extends object = never>(definition: WebhookHandler<Row, Payload>) => WebhookHandler<Row, Payload>;
+  upsert: <Row extends object>(row: Row) => ResourceMutation<Row>;
+  delete: (options: {
+    readonly key: DeleteValue;
+    readonly version: DeleteValue;
+  }) => ResourceMutation<never>;
+};
+declare const Fetch: {
+  page: <Row extends object = never, R = never>(definition: PageFetch<Row, R>) => PageFetch<Row, R>;
+  changes: <Row extends object = never, R = never>(definition: ChangesFetch<Row, R>) => ChangesFetch<Row, R>;
+};
+declare const Cursor$1: {
+  string: () => Cursor.Definition<string>;
+  number: () => Cursor.Definition<number>;
+  isoDateTime: () => Cursor.Definition<string>;
+  nowIsoDateTime: Effect.Effect<string, never, never>;
+};
+declare namespace telemetry_d_exports {
+  export { Attr, EventAttr, EventName, OtlpMetricsOptions, OtlpTracingConfig, OtlpTracingOptions, SpanName, addCurrentSpanEvent, annotateError, layer, layerConfig, layerMetricsConsoleDump, layerOtlp, layerOtlpMetrics, layerOtlpTracing };
+}
+/** Canonical span names emitted by connector-kit runtime instrumentation. */
+declare const SpanName: {
+  readonly batchProcess: "connector.batch.process";
+  readonly webhookDecode: "connector.webhook.decode";
+  readonly webhookHandle: "connector.webhook.handle";
+  readonly publish: "connector.publish";
+  readonly stateSet: "connector.state.set";
+  readonly apiFetch: "connector.api.fetch";
+};
+/** Canonical span attribute names. Keep these stable for collector queries. */
+declare const Attr: {
+  readonly connectorName: "airfoil.connector.name";
+  readonly connectorResourcesCount: "airfoil.connector.resources.count";
+  readonly resourceName: "airfoil.resource.name";
+  readonly resourceSource: "airfoil.resource.source";
+  readonly batchMutations: "airfoil.batch.mutations";
+  readonly webhookPath: "airfoil.webhook.path";
+  readonly publisherSuccess: "airfoil.publisher.success";
+  readonly stateKey: "airfoil.state.key";
+  readonly apiPath: "airfoil.api.path";
+  readonly errorPhase: "airfoil.error.phase";
+  readonly errorType: "airfoil.error.type";
+  readonly errorMessage: "airfoil.error.message";
+  readonly errorDetails: "airfoil.error.details";
+};
+/** Span event names for high-cardinality reproduction details. */
+declare const EventName: {
+  readonly batchCheckpoint: "airfoil.batch.checkpoint";
+};
+/** Event-only attributes. These are intentionally not span attributes. */
+declare const EventAttr: {
+  readonly batchCursor: "airfoil.batch.cursor";
+};
+/** Annotates the active span with phase-aware error metadata before re-failing. */
+declare const annotateError: (phase: string, error: unknown) => Effect.Effect<void, never, never>;
+/** Adds an event to the active span, or no-ops when no span is active. */
+declare const addCurrentSpanEvent: (name: string, attributes?: Record<string, unknown>) => Effect.Effect<void, never, never>;
+/** Transport configuration for OTLP trace export. All fields are direct values. */
+type OtlpTracingConfig = {
+  readonly enabled?: boolean;
+  readonly endpoint?: string;
+  readonly headers?: Record<string, string>;
+};
+/** Runtime options — not config-wrappable since RegExp cannot live in Config. */
+type OtlpTracingOptions = {
+  /** Additional connector-specific header names or regexes to redact from HTTP logs/traces. */
+  readonly redactedHeaders?: ReadonlyArray<string | RegExp>;
+};
+type OtlpMetricsOptions = {
+  readonly exportInterval?: Duration.Input;
+};
+/**
+ * Trace-only OTLP export with sensitive HTTP header redaction.
+ * Takes direct config values — no `ConfigProvider` required.
+ */
+declare const layer: (config?: OtlpTracingConfig, options?: OtlpTracingOptions) => Layer.Layer<never, Error, effect_unstable_http_HttpClient0.HttpClient>;
+/**
+ * Trace-only OTLP export with sensitive HTTP header redaction.
+ * Takes Effect Config-wrapped values — reads from `ConfigProvider`.
+ *
+ * @example
+ * Telemetry.layerConfig({
+ *   enabled: Config.boolean("MY_OTEL_ENABLED"),
+ *   endpoint: Config.string("MY_COLLECTOR_URL"),
+ * })
+ */
+declare const layerConfig: (config: Config.Wrap<OtlpTracingConfig>, options?: OtlpTracingOptions) => Layer.Layer<never, Error | Config.ConfigError, effect_unstable_http_HttpClient0.HttpClient>;
+/**
+ * Trace-only OTLP export with sensitive HTTP header redaction.
+ * Zero-config shortcut that reads the standard `OTEL_*` env var names.
+ *
+ * Reads `OTEL_ENABLED`, `OTEL_EXPORTER_OTLP_ENDPOINT`, and
+ * `OTEL_EXPORTER_OTLP_HEADERS`. Effect's OTLP resource handling reads
+ * `OTEL_SERVICE_NAME`, `OTEL_SERVICE_VERSION`, and `OTEL_RESOURCE_ATTRIBUTES`.
+ */
+declare const layerOtlpTracing: (options?: OtlpTracingOptions) => Layer.Layer<never, Error | Config.ConfigError, effect_unstable_http_HttpClient0.HttpClient>;
+declare const layerOtlpMetrics: (options?: OtlpMetricsOptions) => Layer.Layer<never, Error | Config.ConfigError, effect_unstable_http_HttpClient0.HttpClient>;
+declare const layerOtlp: (options?: OtlpTracingOptions & OtlpMetricsOptions) => Layer.Layer<never, Error | Config.ConfigError, effect_unstable_http_HttpClient0.HttpClient>;
+declare const layerMetricsConsoleDump: (interval?: Duration.Input) => Layer.Layer<never, never, never>;
+//#endregion
+//#region src/connector-app/start.d.ts
+type App = ConnectorDefinition;
+type StartOptions = {
+  readonly port: number;
+  readonly initialCutoff?: Cursor.Value;
+  readonly healthPath?: HttpRouter.PathInput;
+  readonly metricsPath?: HttpRouter.PathInput | false;
+  readonly statusPath?: HttpRouter.PathInput | false;
+  readonly disableHttpLogger?: boolean;
+};
+declare const start: (app: App, options: StartOptions) => Effect.Effect<void, ConnectorError | effect_unstable_http_HttpServerError0.ServeError, StateStore | Publisher>;
+declare namespace index_d_exports {
+  export { App, CheckOptions, CheckResult, ResourceCheckResult, StartOptions, check, start };
+}
+//#endregion
+export { telemetry_d_exports as a, Fetch as c, CheckResult as d, ResourceCheckResult as f, start as i, Resource as l, App as n, Connector as o, check as p, StartOptions as r, Cursor$1 as s, index_d_exports as t, CheckOptions as u };
+//# sourceMappingURL=index-DtJX_tic.d.ts.map

package/dist/index-J42AZaXU.d.ts

@@ -0,0 +1,38 @@
+import { t as ConnectorError } from "./index-D54ySAKn.js";
+import { l as ResourceDefinition, n as ConnectorDefinition, r as Cursor, x as WebhookRoute } from "./types-B35J5YPu.js";
+import { i as Publisher } from "./service-IE5qaf9x.js";
+import { i as StateStore } from "./index-Coh_SkBs.js";
+import { Effect } from "effect";
+import { HttpRouter, HttpServer } from "effect/unstable/http";
+
+//#region src/ingestion/engine.d.ts
+type RunBaseOptions = {
+  readonly initialCutoff?: Cursor.Value;
+};
+type RunOptions = RunBaseOptions & {
+  readonly webhook?: {
+    readonly routes: ReadonlyArray<WebhookRoute>;
+    readonly healthPath?: HttpRouter.PathInput;
+    readonly metricsPath?: HttpRouter.PathInput | false;
+    readonly statusPath?: HttpRouter.PathInput | false;
+    readonly disableHttpLogger?: boolean;
+  };
+};
+type RunNoWebhookOptions = RunBaseOptions & {
+  readonly webhook?: undefined;
+};
+type RunWebhookOptions = RunOptions & {
+  readonly webhook: NonNullable<RunOptions["webhook"]>;
+};
+/**
+ * Runs all connector ingestion loops. Callers provide the Publisher and
+ * StateStore layers; webhook mode additionally requires an HttpServer layer.
+ */
+declare function run<const Resources extends ReadonlyArray<ResourceDefinition>>(connector: ConnectorDefinition<Resources>, options?: RunNoWebhookOptions): Effect.Effect<void, ConnectorError, StateStore | Publisher>;
+declare function run<const Resources extends ReadonlyArray<ResourceDefinition>>(connector: ConnectorDefinition<Resources>, options: RunWebhookOptions): Effect.Effect<void, ConnectorError, StateStore | Publisher | HttpServer.HttpServer>;
+declare namespace index_d_exports {
+  export { RunOptions, run };
+}
+//#endregion
+export { RunOptions as n, run as r, index_d_exports as t };
+//# sourceMappingURL=index-J42AZaXU.d.ts.map

package/dist/index-fIIBVAai.d.ts

@@ -0,0 +1,25 @@
+import { C as WebhookRouteInput, S as WebhookRouteContext, c as ResourceBatch, l as ResourceDefinition, x as WebhookRoute, y as WebhookAckMode } from "./types-B35J5YPu.js";
+import { i as Publisher } from "./service-IE5qaf9x.js";
+import { Context, Queue } from "effect";
+import { HttpRouter } from "effect/unstable/http";
+import * as effect_Layer0 from "effect/Layer";
+
+//#region src/webhook/server.d.ts
+type QueuedWebhookBatch = {
+  readonly resource: string;
+  readonly batch: ResourceBatch;
+};
+declare const WebhookQueue_base: Context.ServiceClass<WebhookQueue, "@useairfoil/connector-kit/WebhookQueue", {
+  readonly queue: Queue.Queue<QueuedWebhookBatch>;
+}>;
+declare class WebhookQueue extends WebhookQueue_base {}
+declare const router: (routes: ReadonlyArray<WebhookRoute>, options: {
+  readonly connectorName: string;
+}) => effect_Layer0.Layer<never, never, HttpRouter.HttpRouter | HttpRouter.Request<"Requires", WebhookQueue> | HttpRouter.Request<"Requires", Publisher>>;
+declare namespace index_d_exports {
+  export { WebhookAckMode, WebhookRoute, WebhookRouteContext, WebhookRouteInput, route, router };
+}
+declare const route: <const Resources extends ReadonlyArray<ResourceDefinition>, Payload>(definition: WebhookRouteInput<Resources, Payload>) => WebhookRoute<Resources, Payload>;
+//#endregion
+export { route as n, router as r, index_d_exports as t };
+//# sourceMappingURL=index-fIIBVAai.d.ts.map

package/dist/index-o1-Z3n7V.d.ts

@@ -0,0 +1,55 @@
+import { FileSystem } from "effect";
+import * as effect_Types0 from "effect/Types";
+import * as effect_Cause0 from "effect/Cause";
+import * as effect_Layer0 from "effect/Layer";
+
+//#region src/runtime-config/error.d.ts
+type RuntimeConfigErrorCode = "CONFIG_PATH_MISSING" | "CONFIG_FILE_UNREADABLE" | "CONFIG_JSON_INVALID";
+declare const RuntimeConfigError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => effect_Cause0.YieldableError & {
+  readonly _tag: "RuntimeConfigError";
+} & Readonly<A>;
+/** Expected hosted-config failure with a stable code and diagnostic cause. */
+declare class RuntimeConfigError extends RuntimeConfigError_base<{
+  readonly code: RuntimeConfigErrorCode;
+  readonly message: string;
+  readonly cause: Error;
+}> {}
+//#endregion
+//#region src/runtime-config/constants.d.ts
+/** Shared runtime keys owned by Airfoil rather than an individual connector. */
+declare const PlatformRuntimeKey: {
+  readonly configPath: "AIRFOIL_CONFIG_PATH";
+  readonly connectorInstanceId: "AIRFOIL_CONNECTOR_INSTANCE_ID";
+  readonly stateTable: "AIRFOIL_STATE_TABLE";
+  readonly postgresConnectionString: "POSTGRES_CONNECTION_STRING";
+  readonly wingsHost: "WINGS_HOST";
+  readonly wingsNamespace: "WINGS_NAMESPACE";
+  readonly otelEnabled: "OTEL_ENABLED";
+  readonly otelExporterOtlpEndpoint: "OTEL_EXPORTER_OTLP_ENDPOINT";
+  readonly otelExporterOtlpHeaders: "OTEL_EXPORTER_OTLP_HEADERS";
+  readonly otelServiceName: "OTEL_SERVICE_NAME";
+  readonly otelServiceVersion: "OTEL_SERVICE_VERSION";
+  readonly otelResourceAttributes: "OTEL_RESOURCE_ATTRIBUTES";
+};
+/** Defaults for optional platform-owned runtime configuration. */
+declare const PlatformRuntimeDefault: {
+  readonly stateTable: "_airfoil_connectors_state";
+};
+//#endregion
+//#region src/runtime-config/layer.d.ts
+/**
+ * Loads the required JSON file and lets environment values override it per key.
+ * Connector field validation remains in the connector's Effect Config.
+ *
+ * @example
+ * ```ts
+ * program.pipe(Effect.provide(layerHosted()));
+ * ```
+ */
+declare const layerHosted: () => effect_Layer0.Layer<never, RuntimeConfigError, FileSystem.FileSystem>;
+declare namespace index_d_exports {
+  export { PlatformRuntimeDefault, PlatformRuntimeKey, RuntimeConfigError, RuntimeConfigErrorCode, layerHosted };
+}
+//#endregion
+export { RuntimeConfigError as a, PlatformRuntimeKey as i, layerHosted as n, RuntimeConfigErrorCode as o, PlatformRuntimeDefault as r, index_d_exports as t };
+//# sourceMappingURL=index-o1-Z3n7V.d.ts.map

package/dist/index.d.ts

@@ -1,165 +1,14 @@
-import { Context, Effect, Layer, Queue, Schema, Stream } from "effect";
-import * as Wings from "@useairfoil/wings";
-import { PartitionValue } from "@useairfoil/wings";
-import { HttpRouter, HttpServerRequest } from "effect/unstable/http";
-import * as effect_Types0 from "effect/Types";
-import * as effect_Cause0 from "effect/Cause";
-import * as Effect$1 from "effect/Effect";
-import * as effect_Layer0 from "effect/Layer";
-import * as Schema$1 from "effect/Schema";
-
-//#region src/core/errors.d.ts
-declare const ConnectorError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => effect_Cause0.YieldableError & {
-  readonly _tag: "ConnectorError";
-} & Readonly<A>;
-declare class ConnectorError extends ConnectorError_base<{
-  readonly message: string;
-  readonly cause?: unknown;
-}> {}
-//#endregion
-//#region src/core/types.d.ts
-type Cursor = string | number | bigint | Date;
-type Batch<T> = {
-  readonly cursor: Cursor;
-  readonly rows: ReadonlyArray<T>;
-};
-type StreamState<C = Cursor> = {
-  readonly cutoff: C;
-  readonly current?: C;
-};
-type IngestionState<C = Cursor> = {
-  readonly backfill: StreamState<C>;
-  readonly live: StreamState<C>;
-};
-type Transform<T> = (row: T) => Effect.Effect<T, ConnectorError>;
-type LiveStream<T> = Stream.Stream<Batch<T>, ConnectorError>;
-type BackfillStream<T> = Stream.Stream<Batch<T>, ConnectorError>;
-type WebhookStream<T> = {
-  /**
-   * The queue is used to store the batches that are received from the webhook.
-   */
-  readonly queue: Queue.Queue<Batch<T>>;
-  /**
-   * The stream is used to process the batches that are received from the webhook.
-   */
-  readonly stream: Stream.Stream<Batch<T>, ConnectorError>;
-};
-type LiveSource<T> = LiveStream<T> | WebhookStream<T>;
-/** Schema type used by connector definitions. */
-type EntitySchema = Schema.Schema<unknown>;
-/** Decoded row type produced by a schema. */
-type EntityType<S extends EntitySchema> = Schema.Schema.Type<S>;
-/** Primary key type derived from the decoded schema shape. */
-type EntityKey<S extends EntitySchema> = EntityType<S> extends Record<string, unknown> ? keyof EntityType<S> & string : never;
-/** Row type constrained to object-like shapes for ingestion. */
-type EntityRow<S extends EntitySchema> = EntityType<S> & Record<string, unknown>;
-type EntityDefinition<S extends EntitySchema> = {
-  readonly name: string;
-  readonly schema: S;
-  /**
-   * The primary key is used to identify the rows in the database.
-   */
-  readonly primaryKey: EntityKey<S>;
-  /**
-   * The live source is used to stream the live data from the database.
-   */
-  readonly live: LiveSource<EntityRow<S>>;
-  /**
-   * The backfill stream is used to stream the backfill data from the database.
-   */
-  readonly backfill: BackfillStream<EntityRow<S>>;
-  /**
-   * The transform is used to transform the rows before they are published.
-   */
-  readonly transform?: Transform<EntityRow<S>>;
-};
-type EventDefinition<S extends EntitySchema> = {
-  readonly name: string;
-  readonly schema: S;
-  /**
-   * The live source is used to stream the live data from the database.
-   */
-  readonly live: LiveSource<EntityRow<S>>;
-  /**
-   * The backfill stream is used to stream the backfill data from the database.
-   */
-  readonly backfill?: BackfillStream<EntityRow<S>>;
-  /**
-   * The transform is used to transform the rows before they are published.
-   */
-  readonly transform?: Transform<EntityRow<S>>;
-};
-type ConnectorDefinition<Entities extends ReadonlyArray<EntityDefinition<EntitySchema>> = ReadonlyArray<EntityDefinition<EntitySchema>>, Events extends ReadonlyArray<EventDefinition<EntitySchema>> = ReadonlyArray<EventDefinition<EntitySchema>>> = {
-  readonly name: string;
-  readonly entities: Entities;
-  readonly events: Events;
-};
-//#endregion
-//#region src/core/builder.d.ts
-declare const defineConnector: <const Entities extends ReadonlyArray<EntityDefinition<EntitySchema>>, const Events extends ReadonlyArray<EventDefinition<EntitySchema>>>(definition: ConnectorDefinition<Entities, Events>) => ConnectorDefinition<Entities, Events>;
-declare const defineEntity: <S extends EntitySchema>(definition: EntityDefinition<S>) => EntityDefinition<S>;
-declare const defineEvent: <S extends EntitySchema>(definition: EventDefinition<S>) => EventDefinition<S>;
-//#endregion
-//#region src/publisher/service.d.ts
-type PublishAck = {
-  readonly success: boolean;
-};
-declare const Publisher_base: Context.ServiceClass<Publisher, "Publisher", {
-  readonly publish: (options: {
-    readonly name: string;
-    readonly batch: Batch<Record<string, unknown>>;
-  }) => Effect$1.Effect<PublishAck, ConnectorError>;
-}>;
-declare class Publisher extends Publisher_base {}
-//#endregion
-//#region src/ingestion/state-store.d.ts
-declare const StateStore_base: Context.ServiceClass<StateStore, "StateStore", {
-  readonly getState: (key: string) => Effect.Effect<IngestionState<Cursor> | undefined, ConnectorError>;
-  readonly setState: (key: string, state: IngestionState<Cursor>) => Effect.Effect<void, ConnectorError>;
-}>;
-declare class StateStore extends StateStore_base {}
-declare const StateStoreInMemory: Layer.Layer<StateStore, never, never>;
-//#endregion
-//#region src/ingestion/engine.d.ts
-declare const runConnector: (connector: ConnectorDefinition, initialCutoff: Cursor) => Effect.Effect<void, ConnectorError, StateStore | Publisher>;
-//#endregion
-//#region src/publisher/wings.d.ts
-type WingsPublisherConfig = {
-  readonly connector: ConnectorDefinition;
-  /** Map of entity/event name to Wings topic. */
-  readonly topics: Record<string, Wings.Cluster.Topic.Topic>;
-  /** per-stream partition value (key is entity/event name). */
-  readonly partitionValues?: Record<string, PartitionValue>;
-};
-declare const WingsPublisherLayer: (config: WingsPublisherConfig) => Layer.Layer<Publisher, ConnectorError, Wings.WingsClient.WingsClient>;
-//#endregion
-//#region src/streams/pull-stream.d.ts
-type PullPage<T> = {
-  readonly cursor: Cursor;
-  readonly rows: ReadonlyArray<T>;
-  readonly hasMore: boolean;
-};
-type PullFetcher<T, R = never> = (cursor: Cursor | undefined) => Effect.Effect<PullPage<T>, ConnectorError, R>;
-type PullStreamOptions<T, R = never> = {
-  readonly initialCursor?: Cursor;
-  readonly fetchPage: PullFetcher<T, R>;
-};
-declare const makePullStream: <T, R = never>(options: PullStreamOptions<T, R>) => Stream.Stream<Batch<T>, ConnectorError, R>;
-//#endregion
-//#region src/streams/webhook-queue.d.ts
-declare const makeWebhookQueue: <T>(options?: {
-  readonly capacity?: number;
-}) => Effect.Effect<WebhookStream<T>, never>;
-//#endregion
-//#region src/webhook/types.d.ts
-type WebhookRoute<TPayload> = {
-  readonly path: HttpRouter.PathInput;
-  readonly schema: Schema$1.Schema<TPayload>;
-  readonly handle: (payload: TPayload, request: HttpServerRequest.HttpServerRequest, rawBody?: Uint8Array) => Effect.Effect<void, ConnectorError>;
-};
-//#endregion
-//#region src/webhook/server.d.ts
-declare const buildWebhookRouter: <TPayload>(routes: ReadonlyArray<WebhookRoute<TPayload>>) => effect_Layer0.Layer<never, never, HttpRouter.HttpRouter | HttpRouter.Request<"Requires", unknown>>;
-//#endregion
-export { type BackfillStream, type Batch, type ConnectorDefinition, ConnectorError, type Cursor, type EntityDefinition, type EntityKey, type EntityRow, type EntitySchema, type EntityType, type EventDefinition, type IngestionState, type LiveSource, type LiveStream, Publisher, StateStore, StateStoreInMemory, type StreamState, type Transform, type WebhookRoute, type WebhookStream, WingsPublisherLayer, buildWebhookRouter, defineConnector, defineEntity, defineEvent, makePullStream, makeWebhookQueue, runConnector };
-//# sourceMappingURL=index.d.ts.map
+import { t as index_d_exports } from "./index-CTHVudvQ.js";
+import { t as ConnectorError } from "./index-D54ySAKn.js";
+import { S as WebhookRouteContext, _ as ResourceState, a as FetchChangesResult, b as WebhookHandler, c as ResourceBatch, d as ResourceMutation, g as ResourceSchema, h as ResourceRows, l as ResourceDefinition, m as ResourceRow, n as ConnectorDefinition, o as FetchPageResult, p as ResourcePayload, r as Cursor$1, s as PageFetch, t as ChangesFetch, u as ResourceField, x as WebhookRoute, y as WebhookAckMode } from "./types-B35J5YPu.js";
+import { a as telemetry_d_exports, c as Fetch, l as Resource, o as Connector, s as Cursor, t as index_d_exports$1 } from "./index-DtJX_tic.js";
+import "./service-IE5qaf9x.js";
+import { t as index_d_exports$6 } from "./index-Coh_SkBs.js";
+import { t as index_d_exports$2 } from "./index-J42AZaXU.js";
+import { t as index_d_exports$3 } from "./index-CBT-JX-T.js";
+import { g as metrics_d_exports } from "./metrics-CVAk1ALR.js";
+import { t as index_d_exports$4 } from "./index-Byr0Lf0C.js";
+import { t as index_d_exports$5 } from "./index-o1-Z3n7V.js";
+import { t as index_d_exports$7 } from "./index-CTLYQ74P.js";
+import { t as index_d_exports$8 } from "./index-fIIBVAai.js";
+export { index_d_exports as Auth, ChangesFetch, Connector, index_d_exports$1 as ConnectorApp, ConnectorDefinition, ConnectorError, Cursor, Cursor$1 as CursorTypes, Fetch, FetchChangesResult, FetchPageResult, index_d_exports$2 as Ingestion, index_d_exports$3 as Manifest, metrics_d_exports as Metrics, PageFetch, index_d_exports$4 as Publisher, Resource, ResourceBatch, ResourceDefinition, ResourceField, ResourceMutation, ResourcePayload, ResourceRow, ResourceRows, ResourceSchema, ResourceState, index_d_exports$5 as RuntimeConfig, index_d_exports$6 as StateStore, index_d_exports$7 as Status, telemetry_d_exports as Telemetry, index_d_exports$8 as Webhook, WebhookAckMode, WebhookHandler, WebhookRoute, WebhookRouteContext };