mlform 0.1.7 → 0.1.8

package/dist/types/src/runtime/types/field.d.ts

@@ -0,0 +1,24 @@
+import { FieldDefinition as SchemaFieldDefinition, FieldStateSnapshot, FieldValidationResult, NormalizedFieldConfig } from '../../../schema';
+import { FieldDescriptor } from '../../../presentation';
+export type { AllConditions, AnyConditions, BaseFieldConfig, DeclarativeFieldCondition, FieldComparisonCondition, FieldCondition, FieldConditionContext, FieldConfig, FieldStateSnapshot, FieldStatus, FieldValidationContext, FieldValidationFnContext, FieldValidationResult, FieldValueAdapter, FieldValueCondition, FormStatusCondition, InactiveFieldPolicy, NormalizedFieldConfig, NotCondition, SelectorSubscriptionOptions, SubmitCountCondition, } from '../../../schema';
+export interface FieldHandle {
+    readonly id: string;
+    readonly kind: string;
+    readonly config: NormalizedFieldConfig;
+    readonly state: FieldStateSnapshot;
+    setValue(value: unknown): void;
+    blur(): void;
+    focus(): void;
+    validate(): Promise<FieldValidationResult>;
+    reset(): void;
+    subscribe(listener: (state: FieldStateSnapshot) => void): () => void;
+}
+export type FieldController = FieldHandle;
+export type FieldDefinition<TConfig extends import('../../../schema').FieldConfig = import('../../../schema').FieldConfig, TValue = unknown> = SchemaFieldDefinition<TConfig, TValue> & {
+    describe?: (config: NormalizedFieldConfig<TConfig>, context: {
+        fieldId: string;
+        state: FieldStateSnapshot;
+    }) => FieldDescriptor;
+    [key: string]: unknown;
+};
+export type RuntimeFieldDefinition = FieldDefinition;

package/dist/types/src/{engine → runtime}/types/form.d.ts

@@ -1,8 +1,9 @@
-import { FieldConfig, FieldController, FieldStateSnapshot, InactiveFieldPolicy, NormalizedFieldConfig, SelectorSubscriptionOptions } from './field';
-import { ExplanationConfig, ExplanationController, ExplanationStateSnapshot } from './explanation';
-import { NormalizedReportConfig, ReportConfig, ReportController, ReportStateSnapshot } from './report';
-import { AfterSubmitContext, BeforeSubmitContext, SubmitOptions, SubmitResult, Transport, TransportStreamEvent, SubmitErrorContext } from './transport';
-import { Registry } from './registry';
+import { ExplanationConfig, FieldConfig, FieldStateSnapshot, FormSchema, InactiveFieldPolicy, NormalizedFieldConfig, NormalizedReportConfig, Registry, ReportConfig, ReportStateSnapshot, SelectorSubscriptionOptions } from '../../../schema';
+import { RuntimeBehavior } from './behavior';
+import { AfterSubmitContext, BeforeSubmitContext, SubmitErrorContext, SubmitOptions, SubmitResult, Transport, TransportStreamEvent } from './transport';
+import { ExplanationController, ExplanationStateSnapshot } from './explanation';
+import { FieldController } from './field';
+import { ReportController } from './report';
 type MaybePromise<T> = T | PromiseLike<T>;
 export type FormStatus = "idle" | "editing" | "validating" | "submitting" | "success" | "error";
 export interface FormValidationResult {
@@ -81,15 +82,11 @@ export interface FormHooks {
     afterExplanation?: (context: AfterExplanationContext) => MaybePromise<void>;
     onExplanationError?: (context: ExplanationErrorContext) => MaybePromise<void>;
 }
-export interface FormSchema {
-    fields: FieldConfig[];
-    reports?: ReportConfig[];
-    explanations?: ExplanationConfig[];
-}
 export interface CreateFormConfig {
     schema: FormSchema;
     registry: Registry;
     transport: Transport;
+    behaviors?: RuntimeBehavior[];
     initialValues?: Record<string, unknown>;
     validators?: FormValidator[];
     hooks?: FormHooks;
@@ -117,4 +114,4 @@ export interface FormController {
     subscribe(listener: (state: FormState) => void): () => void;
     subscribeSelector<TSelected>(selector: (state: FormState) => TSelected, listener: (selected: TSelected, state: FormState) => void, options?: SelectorSubscriptionOptions<TSelected>): () => void;
 }
-export type { SubmitErrorContext } from './transport';
+export type { ExplanationConfig, FieldConfig, FormSchema, Registry, ReportConfig };

package/dist/types/src/runtime/types/index.d.ts

@@ -0,0 +1,9 @@
+export type MaybePromise<T> = T | PromiseLike<T>;
+export * from './behavior';
+export * from './explanation';
+export * from './field';
+export * from './form';
+export * from './pipeline';
+export * from './report';
+export * from './transport';
+export type { DeclarativeExplanationKind, DeclarativeFieldKind, DeclarativeReportKind, ExplanationDescriptor, ExplanationDescriptorContext, ExplanationPresenter, ExplanationRenderSpec, ExplanationRenderSpecContext, FieldDescriptor, FieldPresenter, FieldRenderHints, FieldRenderSpec, FieldRenderSpecContext, FieldWidget, PresentationContent, PresentationNode, PresentationSummary, PresentationTone, ReportDescriptor, ReportPresenter, ReportRenderSpec, ReportRenderSpecContext, } from '../../../presentation';

package/dist/types/src/runtime/types/registry.d.ts

@@ -0,0 +1,6 @@
+import { ExplanationDefinition, FieldDefinition, Registry as SchemaRegistry, ReportDefinition } from '../../../schema';
+export interface Registry extends Omit<SchemaRegistry, "registerExplanation" | "registerField" | "registerReport"> {
+    registerField(definition: FieldDefinition): Registry;
+    registerReport(definition: ReportDefinition): Registry;
+    registerExplanation(definition: ExplanationDefinition): Registry;
+}

package/dist/types/src/runtime/types/report.d.ts

@@ -0,0 +1,23 @@
+import { NormalizedReportConfig as SchemaNormalizedReportConfig, ReportDefinition as SchemaReportDefinition, ReportStateSnapshot } from '../../../schema';
+import { ReportDescriptor } from '../../../presentation';
+import { SubmitResult } from './transport';
+export type { BaseReportConfig, PartialReportUpdatePolicy, ReportConfig, ReportPayloadContext, ReportPayloadValidationPolicy, ReportResolveContext, ReportStateSnapshot, ReportStatus, } from '../../../schema';
+export interface ReportHandle {
+    readonly id: string;
+    readonly kind: string;
+    readonly config: SchemaNormalizedReportConfig;
+    readonly state: ReportStateSnapshot;
+    subscribe(listener: (state: ReportStateSnapshot) => void): () => void;
+}
+export type ReportController = ReportHandle;
+export type ReportDefinition<TConfig extends import('../../../schema').ReportConfig = import('../../../schema').ReportConfig> = SchemaReportDefinition<TConfig> & {
+    describe?: (config: SchemaNormalizedReportConfig<TConfig>, context: {
+        reportId: string;
+        state: ReportStateSnapshot;
+        payload: unknown;
+        result: SubmitResult | null;
+    }) => ReportDescriptor | null;
+    [key: string]: unknown;
+};
+export type NormalizedReportConfig<TConfig extends import('../../../schema').ReportConfig = import('../../../schema').ReportConfig> = SchemaNormalizedReportConfig<TConfig>;
+export type RuntimeReportDefinition = ReportDefinition;

package/dist/types/src/{engine → runtime}/utils.d.ts

@@ -1,6 +1,6 @@
 import { MaybePromise } from './types';
-export declare const slugify: (value: string) => string;
-export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+import { isRecord, slugify } from '../../shared';
+export { isRecord, slugify };
 export declare const isPromiseLike: <T>(value: MaybePromise<T>) => value is PromiseLike<T>;
 export declare const isEmptyValue: (value: unknown) => boolean;
 export declare const toDate: (value: unknown) => Date | null;

package/dist/types/src/{engine/validation/field.d.ts → runtime/validation/field-state.d.ts}

@@ -1,29 +1,13 @@
-import { EngineStore, InternalFieldState } from '../state';
-import { FieldDefinition, FieldValidationResult, FormStatus, NormalizedFieldConfig } from '../types';
+import { InternalFieldState } from '../state';
+import { FieldDefinition, FormStatus, NormalizedFieldConfig } from '../types';
 import { DerivedFieldFlags } from './conditions';
-export type FieldStateCommitter = (fieldId: string, nextState: InternalFieldState) => void;
-export type FieldValidator = {
-    abort(reason?: string): void;
-    validate(currentState: InternalFieldState, validationVersion?: number): Promise<FieldValidationResult>;
-};
 export declare const combineErrors: (state: Pick<InternalFieldState, "syncErrors" | "validationErrors" | "externalErrors">) => string[];
 export declare const toSnapshotState: (state: InternalFieldState) => InternalFieldState;
 export declare const toValidatingState: (state: InternalFieldState) => InternalFieldState;
 export declare const requiredErrors: (config: NormalizedFieldConfig, value: unknown) => string[];
-export declare const normalizeValue: (definition: FieldDefinition, config: NormalizedFieldConfig, value: unknown) => unknown;
 export declare const cloneFieldValue: (definition: FieldDefinition, config: NormalizedFieldConfig, value: unknown) => unknown;
+export declare const normalizeValue: (definition: FieldDefinition, config: NormalizedFieldConfig, value: unknown) => unknown;
 export declare const areFieldValuesEqual: (definition: FieldDefinition, config: NormalizedFieldConfig, previous: unknown, next: unknown) => boolean;
 export declare const runSyncValidation: (definition: FieldDefinition, config: NormalizedFieldConfig, value: unknown, values: Record<string, unknown>, submitCount: number) => string[];
 export declare const computeSyncErrors: (definition: FieldDefinition, config: NormalizedFieldConfig, value: unknown, values: Record<string, unknown>, submitCount: number, flags: DerivedFieldFlags) => string[];
 export declare const makeFieldState: (definition: FieldDefinition, config: NormalizedFieldConfig, initialValue: unknown, values: Record<string, unknown>, submitCount: number, formStatus: FormStatus) => InternalFieldState;
-type CreateFieldValidatorOptions = {
-    config: NormalizedFieldConfig;
-    definition: FieldDefinition;
-    store: EngineStore;
-    getValues: () => Record<string, unknown>;
-    getSubmitCount: () => number;
-    getFormStatus: () => FormStatus;
-    commitState: FieldStateCommitter;
-};
-export declare const createFieldValidator: ({ config, definition, store, getValues, getSubmitCount, getFormStatus, commitState, }: CreateFieldValidatorOptions) => FieldValidator;
-export {};

package/dist/types/src/runtime/validation/field-validator.d.ts

@@ -0,0 +1,18 @@
+import { EngineStore, InternalFieldState } from '../state';
+import { FieldDefinition, FieldValidationResult, FormStatus, NormalizedFieldConfig } from '../types';
+export type FieldStateCommitter = (fieldId: string, nextState: InternalFieldState) => void;
+export type FieldValidator = {
+    abort(reason?: string): void;
+    validate(currentState: InternalFieldState, validationVersion?: number): Promise<FieldValidationResult>;
+};
+type CreateFieldValidatorOptions = {
+    config: NormalizedFieldConfig;
+    definition: FieldDefinition;
+    store: EngineStore;
+    getValues: () => Record<string, unknown>;
+    getSubmitCount: () => number;
+    getFormStatus: () => FormStatus;
+    commitState: FieldStateCommitter;
+};
+export declare const createFieldValidator: ({ config, definition, store, getValues, getSubmitCount, getFormStatus, commitState, }: CreateFieldValidatorOptions) => FieldValidator;
+export {};

package/dist/types/src/runtime/validation/field.d.ts

@@ -0,0 +1,2 @@
+export * from './field-state';
+export * from './field-validator';

package/dist/types/src/schema/index.d.ts

@@ -0,0 +1,7 @@
+export * from './normalize';
+export * from './registry';
+export type * from './types/explanation';
+export type * from './types/field';
+export type * from './types/form';
+export type * from './types/registry';
+export type * from './types/report';

package/dist/types/src/schema/normalize.d.ts

@@ -0,0 +1,2 @@
+import { FormSchema, NormalizedFormSchema, Registry } from './index';
+export declare const normalizeSchema: (schema: FormSchema, registry: Registry) => NormalizedFormSchema;

package/dist/types/src/schema/registry.d.ts

@@ -0,0 +1,9 @@
+import { MLFormError } from '../../shared';
+import { ExplanationConfig, ExplanationDefinition, FieldConfig, FieldDefinition, Registry, ReportConfig, ReportDefinition } from './index';
+export declare class RegistryError extends MLFormError {
+    constructor(message: string);
+}
+export declare const createRegistry: () => Registry;
+export declare const defineFieldDefinition: <TConfig extends FieldConfig, TValue>(definition: FieldDefinition<TConfig, TValue>) => FieldDefinition<TConfig, TValue>;
+export declare const defineReportDefinition: <TConfig extends ReportConfig>(definition: ReportDefinition<TConfig>) => ReportDefinition<TConfig>;
+export declare const defineExplanationDefinition: <TConfig extends ExplanationConfig>(definition: ExplanationDefinition<TConfig>) => ExplanationDefinition<TConfig>;

package/dist/types/src/schema/types/explanation.d.ts

@@ -0,0 +1,43 @@
+import { ZodType } from 'zod';
+export type ExplanationStatus = "idle" | "loading" | "done" | "error";
+export interface BaseExplanationConfig {
+    id?: string;
+    kind: string;
+    label?: string;
+    description?: string;
+    [key: string]: unknown;
+}
+export type ExplanationConfig = BaseExplanationConfig;
+export type NormalizedExplanationConfig<TConfig extends ExplanationConfig = ExplanationConfig> = TConfig & {
+    id: string;
+};
+export interface ExplanationStateSnapshot {
+    status: ExplanationStatus;
+    result: unknown;
+    error: string | null;
+}
+export interface ExplanationFetchContext<TConfig extends ExplanationConfig = ExplanationConfig> {
+    config: NormalizedExplanationConfig<TConfig>;
+    explanationId: string;
+}
+export interface ExplanationFetchRequest {
+    explanationId: string;
+    backend?: string;
+    values: Record<string, unknown>;
+    fieldValues: Record<string, unknown>;
+    serializedValues: Record<string, unknown>;
+    serializedFieldValues: Record<string, unknown>;
+    reports: Record<string, unknown>;
+    meta: Record<string, unknown>;
+    raw: unknown;
+    signal?: AbortSignal;
+}
+export interface ExplanationFetchTransport {
+    submit: (request: ExplanationFetchRequest) => Promise<unknown>;
+}
+export type ExplanationFetchFactory<TConfig extends ExplanationConfig = ExplanationConfig> = (context: ExplanationFetchContext<TConfig>) => ExplanationFetchTransport;
+export interface ExplanationDefinition<TConfig extends ExplanationConfig = ExplanationConfig> {
+    kind: string;
+    schema: ZodType<TConfig>;
+    transport: (config: TConfig) => ExplanationFetchTransport;
+}

package/dist/types/src/{engine → schema}/types/field.d.ts

@@ -1,18 +1,14 @@
 import { ZodType } from 'zod';
-import { FormStatus } from './form';
-type MaybePromise<T> = T | PromiseLike<T>;
+export type MaybePromise<T> = T | PromiseLike<T>;
+export type FormStatus = "idle" | "editing" | "validating" | "submitting" | "success" | "error";
 export type FieldStatus = "idle" | "validating" | "valid" | "invalid";
 export type InactiveFieldPolicy = "include" | "omit" | "reset-on-hide";
-export interface FieldDescriptor {
-    component: string;
-    props: Record<string, unknown>;
-    meta?: Record<string, unknown>;
-}
 export interface BaseFieldConfig {
     id?: string;
     kind: string;
     label: string;
     description?: string;
+    showDescriptionInline?: boolean;
     required?: boolean;
     disabled?: boolean;
     hidden?: boolean;
@@ -108,12 +104,6 @@ export interface NotCondition {
 }
 export type DeclarativeFieldCondition = FieldValueCondition | FieldComparisonCondition | FormStatusCondition | SubmitCountCondition | AllConditions | AnyConditions | NotCondition;
 export type FieldCondition<TConfig extends FieldConfig = FieldConfig> = DeclarativeFieldCondition | ((context: FieldConditionContext<TConfig>) => boolean);
-export interface FieldDescriptorContext {
-    fieldId: string;
-    state: FieldStateSnapshot;
-}
-export type FieldWidget = "text" | "number" | "boolean" | "select" | "date" | "series";
-export type FieldRenderHints = Record<string, unknown>;
 export interface FieldValueAdapter<TConfig extends FieldConfig = FieldConfig, TValue = unknown> {
     default?: (config: TConfig) => TValue;
     normalize?: (value: unknown, config: TConfig) => TValue;
@@ -125,23 +115,6 @@ export interface FieldValidationFnContext<TConfig extends FieldConfig = FieldCon
     config: TConfig;
     value: TValue;
 }
-export interface FieldRenderSpecContext<TConfig extends FieldConfig = FieldConfig, TValue = unknown> {
-    config: TConfig;
-    fieldId: string;
-    state: FieldStateSnapshot;
-    value: TValue;
-}
-export interface FieldRenderSpec<TConfig extends FieldConfig = FieldConfig, TValue = unknown> {
-    widget: FieldWidget;
-    hints?: FieldRenderHints | ((context: FieldRenderSpecContext<TConfig, TValue>) => FieldRenderHints);
-}
-export interface DeclarativeFieldKind<TConfig extends FieldConfig = FieldConfig, TValue = unknown> {
-    kind: string;
-    schema: ZodType<TConfig>;
-    value?: FieldValueAdapter<TConfig, TValue>;
-    validate?: (context: FieldValidationFnContext<TConfig, TValue>) => MaybePromise<string[]>;
-    render: FieldRenderSpec<TConfig, TValue>;
-}
 export interface FieldDefinition<TConfig extends FieldConfig = FieldConfig, TValue = unknown> {
     kind: string;
     schema: ZodType<TConfig>;
@@ -151,23 +124,8 @@ export interface FieldDefinition<TConfig extends FieldConfig = FieldConfig, TVal
     isEqual?: (previous: TValue, next: TValue, config: TConfig) => boolean;
     serializeValue?: (value: TValue, config: TConfig) => unknown;
     validate?: (value: TValue, config: TConfig, context: FieldValidationContext<TConfig>) => MaybePromise<string[]>;
-    describe: (config: TConfig, context: FieldDescriptorContext) => FieldDescriptor;
-}
-export interface FieldController {
-    readonly id: string;
-    readonly kind: string;
-    readonly config: NormalizedFieldConfig;
-    readonly state: FieldStateSnapshot;
-    readonly descriptor: FieldDescriptor;
-    setValue(value: unknown): void;
-    blur(): void;
-    focus(): void;
-    validate(): Promise<FieldValidationResult>;
-    reset(): void;
-    subscribe(listener: (state: FieldStateSnapshot) => void): () => void;
 }
 export interface SelectorSubscriptionOptions<TSelected> {
     emitInitial?: boolean;
     equality?: (previous: TSelected, next: TSelected) => boolean;
 }
-export {};

package/dist/types/src/schema/types/form.d.ts

@@ -0,0 +1,13 @@
+import { ExplanationConfig, NormalizedExplanationConfig } from './explanation';
+import { FieldConfig, NormalizedFieldConfig } from './field';
+import { NormalizedReportConfig, ReportConfig } from './report';
+export interface FormSchema {
+    fields: FieldConfig[];
+    reports?: ReportConfig[];
+    explanations?: ExplanationConfig[];
+}
+export interface NormalizedFormSchema {
+    fields: NormalizedFieldConfig[];
+    reports: NormalizedReportConfig[];
+    explanations: NormalizedExplanationConfig[];
+}

package/dist/types/src/schema/types/report.d.ts

@@ -0,0 +1,43 @@
+import { ZodType } from 'zod';
+import { MaybePromise } from './field';
+import { SubmitResult } from '../../../runtime/types/transport';
+export type ReportStatus = "idle" | "loading" | "ready" | "error";
+export type ReportPayloadValidationPolicy = "report-error" | "fail-submit";
+export type PartialReportUpdatePolicy = "trust" | "validate" | "defer";
+export interface BaseReportConfig {
+    id?: string;
+    kind: string;
+    label?: string;
+    description?: string;
+    source?: string;
+    ui?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export type ReportConfig = BaseReportConfig;
+export type NormalizedReportConfig<TConfig extends ReportConfig = ReportConfig> = TConfig & {
+    id: string;
+    source: string;
+};
+export interface ReportStateSnapshot {
+    payload: unknown;
+    error: string | null;
+    status: ReportStatus;
+}
+export interface ReportPayloadContext<TConfig extends ReportConfig = ReportConfig> {
+    report: NormalizedReportConfig<TConfig>;
+    result: SubmitResult;
+}
+export interface ReportResolveContext<TConfig extends ReportConfig = ReportConfig> {
+    config: NormalizedReportConfig<TConfig>;
+    report: NormalizedReportConfig<TConfig>;
+    result: SubmitResult;
+}
+export interface ReportDefinition<TConfig extends ReportConfig = ReportConfig> {
+    kind: string;
+    schema: ZodType<TConfig>;
+    payloadSchema?: ZodType<unknown>;
+    payloadValidationPolicy?: ReportPayloadValidationPolicy;
+    partialUpdatePolicy?: PartialReportUpdatePolicy;
+    clonePayload?: (payload: unknown, config: TConfig) => unknown;
+    resolvePayload?: (config: TConfig, context: ReportPayloadContext<TConfig>) => MaybePromise<unknown>;
+}

package/dist/types/src/shared/index.d.ts

@@ -1 +1,3 @@
 export { MLFormError } from './errors';
+export { isRecord } from './object';
+export { slugify } from './strings';

package/dist/types/src/shared/object.d.ts

@@ -0,0 +1 @@
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;

package/dist/types/src/shared/strings.d.ts

@@ -0,0 +1 @@
+export declare const slugify: (value: string) => string;

package/dist/types/src/transport/composition/fanout-helpers.d.ts

@@ -0,0 +1,2 @@
+import { FanoutTransportFailure } from '../types';
+export declare const createFanoutFailure: (failures: readonly FanoutTransportFailure[]) => Error;

package/dist/types/src/transport/composition/fanout.d.ts

@@ -1,3 +1,2 @@
-import { FanoutTransportOptions, QuorumFanoutTransportOptions, Transport } from '../types';
+import { FanoutTransportOptions, Transport } from '../types';
 export declare const createFanoutTransport: <TTransportId extends string = string>(options: FanoutTransportOptions<TTransportId>) => Transport;
-export declare const createQuorumFanoutTransport: <TTransportId extends string = string>(options: QuorumFanoutTransportOptions<TTransportId>) => Transport;

package/dist/types/src/transport/composition/index.d.ts

@@ -1,6 +1,7 @@
 export * from './routing';
 export * from './load-balancing';
 export * from './fanout';
+export * from './quorum-fanout';
 export * from './fallback';
 export * from './pipeline';
 export * from './racing';

package/dist/types/src/transport/composition/quorum-fanout.d.ts

@@ -0,0 +1,2 @@
+import { QuorumFanoutTransportOptions, Transport } from '../types';
+export declare const createQuorumFanoutTransport: <TTransportId extends string = string>(options: QuorumFanoutTransportOptions<TTransportId>) => Transport;

package/dist/types/src/transport/internal-core.d.ts

@@ -0,0 +1,21 @@
+import { SubmitRequest, Transport, TransportCapabilities, TransportSession, TransportStreamEvent } from './types';
+export type TransportEntry = {
+    id: string | undefined;
+    index: number;
+    label: string;
+    transport: Transport;
+};
+export type StreamFactory = (request: SubmitRequest) => AsyncIterable<TransportStreamEvent> | PromiseLike<AsyncIterable<TransportStreamEvent>>;
+type SessionFactory = (request: SubmitRequest) => TransportSession | PromiseLike<TransportSession>;
+export type AsyncQueue<T> = {
+    push(value: T): void;
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+};
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+export declare const createTransport: (submit: Transport["submit"], stream?: StreamFactory, options?: {
+    openSession?: SessionFactory;
+    capabilities?: TransportCapabilities;
+}) => Transport;
+export declare const createAsyncQueue: <T>() => AsyncQueue<T>;
+export {};

package/dist/types/src/transport/internal-errors.d.ts

@@ -0,0 +1,21 @@
+import { TransportError } from './errors';
+import { Transport } from './types';
+export declare const isAbortError: (error: unknown) => boolean;
+export declare const getErrorMessage: (error: unknown) => string;
+export declare const toTransportError: (error: unknown, defaults?: {
+    source?: string;
+    status?: number;
+    code?: string;
+    retryable?: boolean;
+    response?: unknown;
+    details?: unknown;
+}) => TransportError;
+export declare const assertRetrySafe: (transport: Transport, allowUnsafeRetry?: boolean) => void;
+export declare const assertCacheSafe: (transport: Transport, allowUnsafeCache?: boolean) => void;
+export declare const assertHedgingSafe: (transport: Transport, allowUnsafeHedging?: boolean) => void;
+export declare const createAggregateFailure: (message: string, failures: readonly {
+    label: string;
+    error: unknown;
+}[]) => TransportError;
+export declare const resolveErrorMessage: (status: number, statusText: string, payload: unknown) => string;
+export declare const resolveErrorCode: (payload: unknown) => string | undefined;

package/dist/types/src/transport/internal-request.d.ts

@@ -0,0 +1,21 @@
+import { CapabilityRequirement, MaybePromise, SubmitRequest, Transport } from './types';
+export declare const mergeHeaders: (baseHeaders: HeadersInit | undefined, extraHeaders: HeadersInit | undefined) => Headers;
+export declare const resolveRequestCredentials: (optionsCredentials: RequestCredentials | undefined, request: SubmitRequest) => RequestCredentials | undefined;
+export declare const withRequestTransportContext: (request: SubmitRequest, context: NonNullable<SubmitRequest["transport"]>) => SubmitRequest;
+export declare const ensureRequestPolicyContext: (request: SubmitRequest) => SubmitRequest;
+export declare const withCapabilityRequirement: (request: SubmitRequest, requirement: CapabilityRequirement | undefined, transport: Transport, context: string) => SubmitRequest;
+export declare const normalizeRequest: (request: SubmitRequest, transport: Transport, context: string) => SubmitRequest;
+export declare const getTransportScope: (request: SubmitRequest, fallback: string) => string;
+export declare const withRequestPolicyScope: (request: SubmitRequest, scope: string, extras?: {
+    source?: string;
+    backend?: string;
+    requestId?: string;
+}) => SubmitRequest;
+export declare const defaultDedupKey: (request: SubmitRequest) => string;
+export declare const resolveGraphqlValue: <TValue>(value: TValue | ((request: SubmitRequest) => MaybePromise<TValue>), request: SubmitRequest) => Promise<TValue>;
+export declare const defaultBody: (request: Parameters<Transport["submit"]>[0]) => {
+    inputs: Record<string, unknown>;
+};
+export declare const resolveMethod: (method: string | undefined) => "POST" | "PUT" | "PATCH" | "DELETE";
+export declare const resolveSecret: (value: string | (() => MaybePromise<string>)) => Promise<string>;
+export declare const resolveTransportEntries: (transports: import('./types').TransportCollection, factoryName: string) => readonly import('./internal-core').TransportEntry[];

package/dist/types/src/transport/internal-routing.d.ts

@@ -0,0 +1,25 @@
+import { MaybePromise, SubmitRequest, TransportResponse } from './types';
+export declare const chooseWeightedTransport: <TTransportId extends string>(request: SubmitRequest, transportIds: readonly TTransportId[], weights: Partial<Record<TTransportId, number>> | ((request: SubmitRequest, transportId: TTransportId) => MaybePromise<number>), filter?: (transportId: TTransportId, request: SubmitRequest) => MaybePromise<boolean>) => Promise<TTransportId>;
+export declare const toFanoutMeta: (results: readonly {
+    id: string | undefined;
+    index: number;
+    response: TransportResponse;
+}[], failures: readonly {
+    id: string | undefined;
+    index: number;
+    error: unknown;
+}[]) => Record<string, unknown>;
+export declare const toFanoutRaw: (results: readonly {
+    id: string | undefined;
+    index: number;
+    response: TransportResponse;
+}[]) => unknown;
+export declare const mergeFanoutResponses: (results: readonly {
+    id: string | undefined;
+    index: number;
+    response: TransportResponse;
+}[], failures: readonly {
+    id: string | undefined;
+    index: number;
+    error: unknown;
+}[]) => TransportResponse;

package/dist/types/src/transport/internal-sse.d.ts

@@ -0,0 +1,14 @@
+import { TransportStreamEvent } from './types';
+export declare const parseSseBlocks: (stream: ReadableStream<Uint8Array>) => AsyncIterable<{
+    id?: string;
+    event?: string;
+    data: string;
+    retry?: number;
+}>;
+export declare const defaultDecodeSseEvent: (event: {
+    id?: string;
+    event?: string;
+    data: string;
+    retry?: number;
+}) => Promise<TransportStreamEvent>;
+export declare const defaultParse: (response: Response) => Promise<unknown>;

package/dist/types/src/transport/internal-stream.d.ts

@@ -0,0 +1,13 @@
+import { SubmitRequest, Transport, TransportResponse, TransportSessionEvent, TransportStreamEvent } from './types';
+export declare const resolveStream: (transport: Transport, request: SubmitRequest) => Promise<AsyncIterable<TransportStreamEvent>>;
+export declare const normalizeTransportResponse: (response: unknown) => TransportResponse;
+export declare const normalizeStreamEvent: (event: unknown) => TransportStreamEvent;
+export declare const combineSignals: (signals: (AbortSignal | undefined)[]) => {
+    signal: AbortSignal;
+    cleanup: () => void;
+};
+export declare const waitForDelay: (ms: number, signal?: AbortSignal) => Promise<void>;
+export declare const withEventMeta: (event: TransportStreamEvent, meta: Record<string, unknown>) => TransportStreamEvent;
+export declare const toSessionStreamEvent: (event: TransportSessionEvent) => TransportStreamEvent | null;
+export declare const createSubmitBackedStream: (transport: Transport, request: SubmitRequest) => AsyncIterable<TransportStreamEvent>;
+export declare const resolveStreamOrSubmit: (transport: Transport, request: SubmitRequest) => AsyncIterable<TransportStreamEvent> | PromiseLike<AsyncIterable<TransportStreamEvent>>;