@crossdelta/cloudevents 0.6.2 → 0.6.4

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import { Context } from 'hono';
 import { CloudEventV1 } from 'cloudevents';
 import { ZodTypeAny, z } from 'zod';
+import { ChangeResult, FlowContext, FsContextMixin, GenerationContextMixin, FlowStep } from '@crossdelta/flowcore';
+import { PfPlugin } from '@crossdelta/platform-sdk';
 import { ConsumerMessages, Subscription } from 'nats';
 
 /**
@@ -46,6 +48,355 @@ interface CloudEventParseResult {
  */
 declare const parseEventFromContext: (context: Context) => Promise<CloudEventParseResult>;
 
+/**
+ * Domain Effects
+ *
+ * Effects are pure DATA describing side effects that need to happen.
+ * They are produced by domain flows and consumed by runtime handlers.
+ *
+ * This enables:
+ * - Clean separation between domain logic (cloudevents) and runtime integration (pf)
+ * - Testability: flows return data, no side effects
+ * - MCP compatibility: effects can be returned to AI agents
+ *
+ * Naming Convention:
+ * - Kind: `<noun>.<past-participle>` (e.g., `stream.wired`, `contract.created`)
+ * - Type: `<Noun><PastParticiple>Effect` (e.g., `StreamWiredEffect`)
+ * - Factory: `<noun><PastParticiple>` (e.g., `streamWired()`)
+ */
+/**
+ * Effect: Stream was wired to a service
+ *
+ * Signals that a service should be configured to consume from a stream.
+ * Runtime handler will modify the service's entry point (index.ts/main.ts).
+ */
+interface StreamWiredEffect {
+    readonly kind: 'stream.wired';
+    readonly stream: string;
+    readonly servicePath: string;
+}
+/**
+ * Effect: Contract was created
+ *
+ * Signals that a new contract file was created.
+ * Runtime may need to invalidate caches or trigger rebuilds.
+ */
+interface ContractCreatedEffect {
+    readonly kind: 'contract.created';
+    readonly path: string;
+    readonly eventType: string;
+}
+/**
+ * Effect: Handler was created
+ *
+ * Signals that a new handler file was created.
+ * Runtime may need to update service configuration.
+ */
+interface HandlerCreatedEffect {
+    readonly kind: 'handler.created';
+    readonly path: string;
+    readonly eventType: string;
+    readonly servicePath: string;
+}
+/**
+ * Union of all domain effects
+ *
+ * Add new effect types here as the system grows.
+ * Effects are a discriminated union on `kind`.
+ */
+type DomainEffect = StreamWiredEffect | ContractCreatedEffect | HandlerCreatedEffect;
+/**
+ * Create a stream.wired effect
+ */
+declare const streamWired: (stream: string, servicePath: string) => StreamWiredEffect;
+/**
+ * Create a contract.created effect
+ */
+declare const contractCreated: (path: string, eventType: string) => ContractCreatedEffect;
+/**
+ * Create a handler.created effect
+ */
+declare const handlerCreated: (path: string, eventType: string, servicePath: string) => HandlerCreatedEffect;
+
+/**
+ * Generator Types
+ *
+ * Interfaces for file system abstraction and generator options
+ */
+/**
+ * File system abstraction for testing
+ */
+interface FileSystem {
+    readFile(path: string): string | null;
+    writeFile(path: string, content: string): void;
+    exists(path: string): boolean;
+    mkdir(path: string): void;
+}
+/**
+ * In-memory file system for testing
+ */
+declare const createMemoryFileSystem: (initialFiles?: Record<string, string>) => FileSystem & {
+    files: Record<string, string>;
+};
+/**
+ * Schema field definition for contract generation
+ */
+interface SchemaField {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'date' | 'datetime' | 'array' | 'object';
+    optional?: boolean;
+}
+/**
+ * Options for contract generation
+ */
+interface GenerateContractOptions {
+    /** Event type (e.g., 'order.created') */
+    eventType: string;
+    /** Schema fields */
+    fields?: SchemaField[];
+    /** Base path for contracts (e.g., 'packages/contracts/src') */
+    basePath: string;
+    /** Package scope for imports (e.g., '@crossdelta') */
+    scope?: string;
+    /** Force overwrite existing files */
+    force?: boolean;
+}
+/**
+ * Options for event handler generation
+ */
+interface GenerateEventHandlerOptions {
+    /** Event type (e.g., 'order.created') */
+    eventType: string;
+    /** Base path for service (e.g., 'services/orders/src') */
+    basePath: string;
+    /** Contract package name (e.g., '@crossdelta/contracts') */
+    contractsPackage?: string;
+    /** Force overwrite existing files */
+    force?: boolean;
+}
+/**
+ * Options for mock generation
+ */
+interface GenerateMockOptions {
+    /** Event type (e.g., 'order.created') */
+    eventType: string;
+    /** Base path for mocks (e.g., 'packages/contracts/src/__mocks__') */
+    basePath: string;
+    /** Schema fields to generate mock data for */
+    fields?: SchemaField[];
+    /** Force overwrite existing files */
+    force?: boolean;
+}
+
+/**
+ * Contract Generator
+ *
+ * Pure function for generating event contract files
+ */
+
+/**
+ * Generate contract file content
+ */
+declare const generateContractContent: (options: GenerateContractOptions) => string;
+/**
+ * Get the full path for a contract file
+ */
+declare const getContractFilePath: (eventType: string, basePath: string) => string;
+/**
+ * Generate a contract file
+ *
+ * Returns ChangeResult indicating if file was created, updated, or skipped.
+ *
+ * @example
+ * generateContract({
+ *   eventType: 'order.created',
+ *   basePath: 'packages/contracts/src',
+ *   fields: [
+ *     { name: 'orderId', type: 'string' },
+ *     { name: 'total', type: 'number' },
+ *   ],
+ * })
+ */
+declare const generateContract: (options: GenerateContractOptions, fs?: FileSystem) => ChangeResult<string>;
+
+/**
+ * Handler Generator
+ *
+ * Pure function for generating event handler files
+ */
+
+/**
+ * Generate handler file content
+ */
+declare const generateEventHandlerContent: (options: GenerateEventHandlerOptions) => string;
+/**
+ * Get the full path for a handler file
+ */
+declare const getHandlerFilePath: (eventType: string, basePath: string) => string;
+/**
+ * Generate an event handler file
+ *
+ * @example
+ * generateEventHandler({
+ *   eventType: 'order.created',
+ *   basePath: 'services/orders/src',
+ *   contractsPackage: '@my-org/contracts',
+ * })
+ */
+declare const generateEventHandler: (options: GenerateEventHandlerOptions, fs?: FileSystem) => ChangeResult<string>;
+
+/**
+ * Mock Generator
+ *
+ * Pure functions for generating event mock files (TypeScript and JSON formats).
+ * Supports optional @faker-js/faker for realistic mock data.
+ */
+
+interface JsonMockData {
+    eventName: string;
+    description: string;
+    data: Record<string, unknown>;
+    faker?: Record<string, string>;
+}
+/**
+ * Initialize faker (call once at startup if you want faker support)
+ */
+declare const initFaker: () => Promise<boolean>;
+/**
+ * Generate mock file content
+ */
+declare const generateMockContent: (options: GenerateMockOptions) => string;
+/**
+ * Get the full path for a mock file
+ */
+declare const getMockFilePath: (eventType: string, basePath: string) => string;
+/**
+ * Generate a mock file
+ *
+ * @example
+ * generateMock({
+ *   eventType: 'order.created',
+ *   basePath: 'packages/contracts/src/__mocks__',
+ *   fields: [
+ *     { name: 'orderId', type: 'string' },
+ *     { name: 'total', type: 'number' },
+ *   ],
+ * })
+ */
+declare const generateMock: (options: GenerateMockOptions, fs?: FileSystem) => ChangeResult<string>;
+/**
+ * Get the JSON mock file path for an event type
+ */
+declare const getJsonMockPath: (eventType: string, contractsPath: string) => string;
+/**
+ * Check if a JSON mock file exists
+ */
+declare const jsonMockExists: (eventType: string, contractsPath: string, fs?: FileSystem) => boolean;
+/**
+ * Load JSON mock data for an event type
+ */
+declare const loadJsonMock: (eventType: string, contractsPath: string, fs?: FileSystem) => JsonMockData | null;
+/**
+ * Generate and save a JSON mock file for an event type
+ */
+declare const generateJsonMock: (options: {
+    eventType: string;
+    contractsPath: string;
+    fields?: SchemaField[];
+    force?: boolean;
+    /** Use @faker-js/faker for realistic data */
+    useFaker?: boolean;
+}, fs?: FileSystem) => ChangeResult<string>;
+/**
+ * Generate JSON mock from existing contract file
+ */
+declare const generateJsonMockFromContract: (eventType: string, contractsPath: string, options?: {
+    useFaker?: boolean;
+}, fs?: FileSystem) => ChangeResult<string> | null;
+
+/**
+ * Simple options for creating an event
+ */
+interface CreateEventOptions {
+    /** Schema fields as string (e.g., 'orderId:string,total:number') or array */
+    fields?: string | SchemaField[];
+    /** Service path for handler (e.g., 'services/orders') */
+    service?: string;
+    /** Base path for contracts (default: 'packages/contracts/src') */
+    contractsPath?: string;
+    /** Base path for mocks (optional) */
+    mocksPath?: string;
+    /** Overwrite existing files */
+    force?: boolean;
+}
+/**
+ * Create an event contract (and optionally handler + mock)
+ *
+ * @example
+ * ```typescript
+ * import { createEvent } from '@crossdelta/cloudevents'
+ *
+ * // Simple: just the event type (interactive)
+ * await createEvent('order.created')
+ *
+ * // With fields
+ * await createEvent('order.created', {
+ *   fields: 'orderId:string,total:number,customerId:string'
+ * })
+ *
+ * // With handler
+ * await createEvent('order.created', {
+ *   fields: 'orderId:string,total:number',
+ *   service: 'services/orders'
+ * })
+ * ```
+ */
+declare const createEvent: (eventType: string, options?: CreateEventOptions) => Promise<{
+    created: string[];
+    skipped: string[];
+    effects: DomainEffect[];
+}>;
+/**
+ * List all event types in the workspace
+ *
+ * @example
+ * ```typescript
+ * import { listEvents } from '@crossdelta/cloudevents'
+ *
+ * // List all
+ * const events = await listEvents()
+ * // ['order.created', 'order.updated', 'customer.created']
+ *
+ * // Filter by pattern
+ * const orderEvents = await listEvents({ pattern: 'order' })
+ * // ['order.created', 'order.updated']
+ * ```
+ */
+declare const listEvents: (options?: {
+    pattern?: string;
+    contractsPath?: string;
+}) => Promise<string[]>;
+/**
+ * Publish an event to NATS
+ *
+ * @example
+ * ```typescript
+ * import { publishEvent } from '@crossdelta/cloudevents'
+ *
+ * await publishEvent('order.created', {
+ *   orderId: 'ord_123',
+ *   total: 99.99,
+ *   customerId: 'cus_456'
+ * })
+ * ```
+ */
+declare const publishEvent: (eventType: string, data: Record<string, unknown>, options?: {
+    natsUrl?: string;
+    contractsPath?: string;
+}) => Promise<{
+    success: boolean;
+}>;
+
 /**
  * Domain Types
  *
@@ -254,6 +605,185 @@ declare function eventSchema<T extends Record<string, ZodTypeAny>>(schema: T & {
     type: ZodTypeAny;
 } extends infer T_1 ? { -readonly [P in keyof T_1]: T_1[P]; } : never, z.core.$strip>;
 
+/**
+ * Pluralization Utilities
+ *
+ * Re-exports from the 'pluralize' library for consistent pluralization.
+ * Used by both cloudevents (subject derivation) and platform-sdk (contract generation).
+ */
+/**
+ * Convert singular word to plural
+ *
+ * @example pluralize('order') => 'orders'
+ * @example pluralize('policy') => 'policies'
+ * @example pluralize('max') => 'maxes'
+ * @example pluralize('batch') => 'batches'
+ * @example pluralize('bus') => 'buses'
+ * @example pluralize('products') => 'products' (already plural)
+ */
+declare const pluralize: (word: string) => string;
+/**
+ * Convert plural word to singular
+ *
+ * @example singularize('orders') => 'order'
+ * @example singularize('policies') => 'policy'
+ * @example singularize('maxes') => 'max'
+ * @example singularize('batches') => 'batch'
+ */
+declare const singularize: (word: string) => string;
+
+/**
+ * Event Naming Domain
+ *
+ * Central authority for all event naming conventions:
+ * - Event type format and validation
+ * - Pluralization rules for streams/domains
+ * - Name derivation (schema, contract, handler, etc.)
+ * - Path structure for contracts and handlers
+ */
+
+/**
+ * Derived names from an event type
+ */
+interface EventNames {
+    /** Original event type (e.g., 'order.created') */
+    eventType: string;
+    /** Event type in kebab-case (e.g., 'order-created') */
+    kebab: string;
+    /** Event type in PascalCase (e.g., 'OrderCreated') */
+    pascal: string;
+    /** Schema name - singular PascalCase (e.g., 'OrderCreatedSchema') */
+    schemaName: string;
+    /** Type name - singular PascalCase (e.g., 'OrderCreatedData') */
+    typeName: string;
+    /** Contract name - plural PascalCase (e.g., 'OrdersCreatedContract') */
+    contractName: string;
+    /** Handler filename (e.g., 'order-created.handler.ts') */
+    handlerFile: string;
+    /** Stream name - uppercase plural (e.g., 'ORDERS') */
+    streamName: string;
+    /** Domain folder - lowercase plural (e.g., 'customers') */
+    domain: string;
+    /** Event action part (e.g., 'created' from 'order.created') */
+    action: string;
+    /** Namespace part - singular (e.g., 'order' from 'order.created') */
+    namespace: string;
+}
+/**
+ * Event type validation result
+ */
+interface EventTypeValidation {
+    valid: boolean;
+    errors: string[];
+}
+/**
+ * Contract file path structure
+ */
+interface ContractPaths {
+    /** Relative path from contracts root (e.g., 'events/orders/created.ts') */
+    relativePath: string;
+    /** Domain folder (e.g., 'orders') */
+    folder: string;
+    /** Filename without extension (e.g., 'created') */
+    filename: string;
+}
+/**
+ * Convert string to kebab-case
+ * Handles dots as separators
+ */
+declare const toKebabCase: (str: string) => string;
+/**
+ * Convert string to PascalCase
+ * Handles dots and dashes as word separators
+ */
+declare const toPascalCase: (str: string) => string;
+/**
+ * Validate an event type string
+ *
+ * Rules:
+ * - Must contain at least one dot (namespace.action)
+ * - Must be lowercase
+ * - Must not start/end with dots
+ * - Namespace must be singular (will be pluralized for domain)
+ */
+declare const validateEventType: (eventType: string) => EventTypeValidation;
+/**
+ * Check if an event type is valid
+ */
+declare const isValidEventType: (eventType: string) => boolean;
+/**
+ * Derive all names from an event type
+ *
+ * @example
+ * deriveEventNames('order.created')
+ * // {
+ * //   eventType: 'order.created',
+ * //   kebab: 'order-created',
+ * //   pascal: 'OrderCreated',
+ * //   schemaName: 'OrderCreatedSchema',
+ * //   typeName: 'OrderCreatedData',
+ * //   contractName: 'OrdersCreatedContract',
+ * //   handlerFile: 'order-created.handler.ts',
+ * //   streamName: 'ORDERS',
+ * //   domain: 'orders',
+ * //   action: 'created',
+ * //   namespace: 'order',
+ * // }
+ */
+declare const deriveEventNames: (eventType: string) => EventNames;
+/**
+ * Get contract file paths from an event type
+ *
+ * @example
+ * getContractPaths('order.created')
+ * // {
+ * //   relativePath: 'events/orders/created.ts',
+ * //   folder: 'orders',
+ * //   filename: 'created',
+ * // }
+ */
+declare const getContractPaths: (eventType: string) => ContractPaths;
+/**
+ * Get handler file path from an event type
+ *
+ * @example
+ * getHandlerPath('order.created')
+ * // 'events/order-created.handler.ts'
+ */
+declare const getHandlerPath: (eventType: string) => string;
+/**
+ * Get stream name from an event type
+ *
+ * @example
+ * getStreamName('order.created') // 'ORDERS'
+ * getStreamName('customer.updated') // 'CUSTOMERS'
+ */
+declare const getStreamName: (eventType: string) => string;
+/**
+ * Parse an event type from a handler filename
+ *
+ * @example
+ * parseEventTypeFromHandler('order-created.handler.ts') // 'order.created'
+ * parseEventTypeFromHandler('customer-profile-updated.handler.ts') // 'customer-profile.updated'
+ */
+declare const parseEventTypeFromHandler: (filename: string) => string | null;
+/**
+ * Parse an event type from a contract filename
+ *
+ * @example
+ * parseEventTypeFromContract('orders/created.ts') // 'order.created'
+ * parseEventTypeFromContract('customers/profile-updated.ts') // 'customer.profile-updated'
+ */
+declare const parseEventTypeFromContract: (path: string) => string | null;
+/**
+ * Normalize subject from event type
+ * Used for NATS subject derivation
+ *
+ * @example
+ * normalizeSubject('order.created') // 'orders.created'
+ */
+declare const normalizeSubject: (eventType: string) => string;
+
 /**
  * Domain Validation
  *
@@ -269,6 +799,150 @@ declare function eventSchema<T extends Record<string, ZodTypeAny>>(schema: T & {
  */
 declare const extractTypeFromSchema: (schema: ZodTypeAny) => string | undefined;
 
+/**
+ * Create Event Flow
+ *
+ * Interactive flow for creating event contracts, handlers, and mocks
+ */
+
+/**
+ * Configuration for event flows
+ */
+interface FlowConfig$2 {
+    /** Base path for contracts (e.g., 'packages/contracts/src') */
+    contractsPath: string;
+    /** Base path for mocks (e.g., 'packages/contracts/src/__mocks__') */
+    mocksPath?: string;
+    /** Contracts package name (e.g., '@my-platform/contracts') */
+    contractsPackage?: string;
+    /** File system abstraction (defaults to node fs) */
+    fs?: FileSystem;
+}
+/**
+ * Context for create event flow
+ *
+ * Flow-specific fields (user-provided):
+ * - eventType: Event name like "order.created"
+ * - servicePath: Optional service for handler creation
+ * - fieldsInput: Raw input string from user (internal)
+ * - fields: Parsed schema fields
+ * - availableServices: Services available for handler creation
+ * - force: Overwrite existing files
+ * - config: Flow configuration (paths, fs)
+ *
+ * Infrastructure fields (auto-initialized by ensure() steps):
+ * - _fs: Filesystem abstraction (lazy-init via flow.ensure())
+ * - _generation: Generation tracker (lazy-init via flow.ensure())
+ *
+ * @see FsContextMixin for _fs details
+ * @see GenerationContextMixin for _generation details
+ */
+interface CreateEventContext extends FlowContext, FsContextMixin, GenerationContextMixin<DomainEffect> {
+    /** Event type (e.g., 'order.created') */
+    eventType: string;
+    /** Service path for handler generation */
+    servicePath?: string;
+    /** Schema fields as comma-separated string */
+    fieldsInput?: string;
+    /** Parsed schema fields */
+    fields?: Array<{
+        name: string;
+        type: string;
+        optional?: boolean;
+    }>;
+    /** Available services for selection */
+    availableServices?: string[];
+    /** Force overwrite existing files */
+    force?: boolean;
+    /** Flow configuration */
+    config: FlowConfig$2;
+    /** Internal filesystem (lazy-initialized) */
+    _fs?: FileSystem;
+}
+declare const parseFieldsInput: (input: string) => SchemaField[];
+/**
+ * Complete flow for creating event contracts
+ *
+ * Steps:
+ * 1. Initialize infrastructure (_fs, _generation)
+ * 2. Get event type (e.g., "order.created")
+ * 3. Get schema fields (optional)
+ * 4. Select service for handler (optional)
+ * 5. Generate files (contract, mock, handler, exports)
+ * 6. Print summary
+ */
+declare const createEventFlowSteps: FlowStep<CreateEventContext>[];
+
+/**
+ * List Events Flow
+ *
+ * Flow for discovering and listing event types in the workspace
+ */
+
+/**
+ * Configuration for event flows
+ */
+interface FlowConfig$1 {
+    /** Base path for contracts (e.g., 'packages/contracts/src') */
+    contractsPath: string;
+    /** Base path for mocks (e.g., 'packages/contracts/src/__mocks__') */
+    mocksPath?: string;
+    /** Contracts package name (e.g., '@my-platform/contracts') */
+    contractsPackage?: string;
+}
+/**
+ * Context for list events flow
+ */
+interface ListEventsContext extends FlowContext {
+    /** Filter pattern for event types */
+    pattern?: string;
+    /** Discovered event types */
+    eventTypes?: string[];
+    /** Flow configuration */
+    config: FlowConfig$1;
+}
+declare const discoverEventTypes: (contractsPath: string, pattern?: string) => string[];
+declare const listEventsFlowSteps: FlowStep<ListEventsContext>[];
+
+/**
+ * Publish Event Flow
+ *
+ * Flow for publishing events to NATS
+ */
+
+/**
+ * Configuration for event flows
+ */
+interface FlowConfig {
+    /** Base path for contracts (e.g., 'packages/contracts/src') */
+    contractsPath: string;
+    /** NATS connection URL */
+    natsUrl?: string;
+}
+/**
+ * Context for publish event flow
+ */
+interface PublishEventContext extends FlowContext {
+    /** Event type to publish */
+    eventType: string;
+    /** Event data as JSON string */
+    dataInput?: string;
+    /** Parsed event data */
+    data?: Record<string, unknown>;
+    /** NATS connection URL */
+    natsUrl?: string;
+    /** Whether publish was successful */
+    published?: boolean;
+    /** Whether mock data was used */
+    usedMock?: boolean;
+    /** Flow configuration */
+    config: FlowConfig & {
+        natsUrl?: string;
+    };
+}
+declare const parseDataInput: (input: string) => Record<string, unknown> | null;
+declare const publishEventFlowSteps: FlowStep<PublishEventContext>[];
+
 /**
  * Handler Cache Management
  * Immutable cache operations for CloudEvents handlers
@@ -502,12 +1176,42 @@ interface CloudEventsOptions {
  */
 declare function cloudEvents(options?: CloudEventsOptions): (ctx: Context, next: () => Promise<void>) => Promise<void | Response>;
 
+/**
+ * PfPlugin Adapter
+ *
+ * Exposes cloudevents functionality as a pf plugin.
+ * Architectural rules:
+ * - cloudevents IMPORTS Pf* interfaces from platform-sdk
+ * - Uses flows for all commands (CLI + MCP)
+ * - Returns effects for workspace mutations
+ */
+
+interface CloudEventsPfPluginOptions {
+    contractsPath?: string;
+    contractsPackage?: string;
+    mocksPath?: string;
+    availableServices?: string[];
+    natsUrl?: string;
+}
+declare const createPfPlugin: (options?: CloudEventsPfPluginOptions) => PfPlugin;
+
 interface PublishNatsEventOptions {
     servers?: string;
     source?: string;
     subject?: string;
     tenantId?: string;
+    /** Close connection after publishing (for CLI tools) */
+    closeAfterPublish?: boolean;
 }
+/**
+ * Close the NATS connection and reset state
+ */
+declare const closeConnection: () => Promise<void>;
+/**
+ * Reset publisher state (for testing only)
+ * @internal
+ */
+declare const __resetNatsPublisher: () => Promise<void>;
 declare const deriveSubjectFromType: (eventType: string, config?: RoutingConfig) => string;
 declare const deriveStreamFromType: (eventType: string, config?: RoutingConfig) => string | undefined;
 declare const publishNatsRawEvent: (subjectName: string, eventType: string, eventData: unknown, options?: PublishNatsEventOptions) => Promise<string>;
@@ -518,7 +1222,6 @@ declare const publish: (eventTypeOrContract: string | {
         subject?: string;
     };
 }, eventData: unknown, options?: PublishNatsEventOptions) => Promise<string>;
-declare const __resetNatsPublisher: () => void;
 
 interface PublishEventOptions {
     projectId?: string;
@@ -527,26 +1230,6 @@ interface PublishEventOptions {
     subject?: string;
     attributes?: Record<string, string>;
 }
-/**
- * Publishes an event using a Zod schema for validation and type extraction.
- * Automatically extracts the event type from the schema and creates a CloudEvent.
- *
- * @param topicName - PubSub topic name
- * @param schema - Zod schema that defines the event structure and type
- * @param eventData - Event data that must match the schema
- * @param options - Optional PubSub configuration
- * @returns Promise resolving to the published message ID
- *
- * @example
- * ```typescript
- * await publishEvent(
- *   'customer-events',
- *   CustomerCreatedSchema,
- *   { customer: { id: '123', email: 'test@example.com' } }
- * )
- * ```
- */
-declare function publishEvent<T extends ZodTypeAny>(topicName: string, schema: T, eventData: unknown, options?: PublishEventOptions): Promise<string>;
 /**
  * Raw event publisher - bypasses schema validation.
  * Use this when you need direct control over the event type and data.
@@ -809,34 +1492,4 @@ interface NatsConsumerOptions extends Pick<CloudEventsOptions, 'quarantineTopic'
  */
 declare function consumeNatsEvents(options: NatsConsumerOptions): Promise<Subscription>;
 
-/**
- * Pluralization Utilities
- *
- * Central place for English pluralization rules.
- * Used by both cloudevents (subject derivation) and platform-sdk (contract generation).
- *
- * Rules follow standard English grammar:
- * - consonant + y → ies (policy → policies)
- * - s, sh, ch, x → +es (max → maxes, batch → batches)
- * - all other → +s (order → orders)
- */
-/**
- * Convert singular word to plural
- *
- * @example pluralize('order') => 'orders'
- * @example pluralize('policy') => 'policies'
- * @example pluralize('max') => 'maxes'
- * @example pluralize('batch') => 'batches'
- */
-declare const pluralize: (word: string) => string;
-/**
- * Convert plural word to singular (inverse of pluralize)
- *
- * @example singularize('orders') => 'order'
- * @example singularize('policies') => 'policy'
- * @example singularize('maxes') => 'max'
- * @example singularize('batches') => 'batch'
- */
-declare const singularize: (word: string) => string;
-
-export { type ChannelConfig, type ChannelMetadata, type EnrichedEvent, type EventContext, type HandleEventOptions, type IdempotencyStore, type InferEventData, type JetStreamConsumerOptions, type JetStreamStreamOptions, type JetStreamStreamsConsumerOptions, type JetStreamStreamsOptions, type PublishEventOptions, type PublishNatsEventOptions, type RoutingConfig, type StreamConfig, type StreamDefinition, __resetNatsPublisher, checkAndMarkProcessed, clearHandlerCache, cloudEvents, consumeJetStreamEvents, consumeJetStreamStreams, consumeJetStreams, consumeNatsEvents, createContract, createInMemoryIdempotencyStore, deriveStreamFromType, deriveSubjectFromType, ensureJetStreamStream, ensureJetStreamStreams, ensureJetStreams, eventSchema, extractTypeFromSchema, getDefaultIdempotencyStore, handleEvent, parseEventFromContext, pluralize, publish, publishEvent, publishNatsEvent, publishNatsRawEvent, publishRawEvent, resetDefaultIdempotencyStore, singularize };
+export { type ChannelConfig, type ChannelMetadata, type CloudEventsPfPluginOptions, type ContractCreatedEffect, type ContractPaths, type CreateEventContext, type CreateEventOptions, type DomainEffect, type EnrichedEvent, type EventContext, type EventNames, type EventTypeValidation, type FileSystem, type HandleEventOptions, type HandlerCreatedEffect, type IdempotencyStore, type InferEventData, type JetStreamConsumerOptions, type JetStreamStreamOptions, type JetStreamStreamsConsumerOptions, type JetStreamStreamsOptions, type ListEventsContext, type PublishEventContext, type PublishEventOptions, type PublishNatsEventOptions, type RoutingConfig, type SchemaField, type StreamConfig, type StreamDefinition, type StreamWiredEffect, __resetNatsPublisher, checkAndMarkProcessed, clearHandlerCache, closeConnection, cloudEvents, consumeJetStreamEvents, consumeJetStreamStreams, consumeJetStreams, consumeNatsEvents, contractCreated, createContract, createEvent, createEventFlowSteps, createInMemoryIdempotencyStore, createMemoryFileSystem, createPfPlugin, deriveEventNames, deriveStreamFromType, deriveSubjectFromType, discoverEventTypes, ensureJetStreamStream, ensureJetStreamStreams, ensureJetStreams, eventSchema, extractTypeFromSchema, generateContract, generateContractContent, generateEventHandler, generateEventHandlerContent, generateJsonMock, generateJsonMockFromContract, generateMock, generateMockContent, getContractFilePath, getContractPaths, getDefaultIdempotencyStore, getHandlerFilePath, getHandlerPath, getJsonMockPath, getMockFilePath, getStreamName, handleEvent, handlerCreated, initFaker, isValidEventType, jsonMockExists, listEvents, listEventsFlowSteps, loadJsonMock, normalizeSubject, parseDataInput, parseEventFromContext, parseEventTypeFromContract, parseEventTypeFromHandler, parseFieldsInput, pluralize, publish, publishEvent, publishEventFlowSteps, publishNatsEvent, publishNatsRawEvent, publishRawEvent, resetDefaultIdempotencyStore, singularize, streamWired, toKebabCase, toPascalCase, validateEventType };