@adaas/a-frame 0.1.1 → 0.1.2

package/dist/node/A-FrameChannel.component-C0O3TaRD.d.ts

@@ -0,0 +1,679 @@
+import { A_TYPES__Ctor, A_Component, A_Fragment, A_Container, A_TYPES__Entity_Serialized, A_Entity } from '@adaas/a-concept';
+import { I as IA_Frame_Channel, c as A_FrameChannelRequest, s as A_Frame_GenerateResponse, m as A_FrameEmbedOptions, r as A_Frame_EmbedResponse, q as A_Frame_CredentialResponse } from './A-FrameChannel.types-DD2B11rf.js';
+import { A_FrameEnv } from './env.js';
+import { A as A_FrameDefinition } from './A-FrameDefinition.entity-C0kzaGJ0.js';
+import { A as A_FrameNamespace } from './A-FrameNamespace.entity-HDXcLGcS.js';
+import { o as A_FrameDynamicPatch_Serialized, m as A_FrameDynamicPatch, f as A_FrameDynamicContent, i as A_FrameDynamicContentOperation } from './A-FrameDynamicContentOperation.context-C_aH1gEn.js';
+import { A as A_FrameSegment } from './A-FrameSegment.entity-C0izuOmC.js';
+import { A as A_FrameCompletion } from './A-FrameCompletion.entity-Brx11JMp.js';
+import { A as A_FrameSchema } from './A-FrameSchema.entity-DjYIhsoj.js';
+
+declare const A_FrameDynamicStructureFeatures: {
+    readonly Load: "_A_FRAME_DYNAMIC_STRUCTURE_LOAD";
+    readonly Patch: "_A_FRAME_DYNAMIC_STRUCTURE_PATCH";
+    readonly Generate: "_A_FRAME_DYNAMIC_STRUCTURE_GENERATE";
+    readonly Map: "_A_FRAME_DYNAMIC_STRUCTURE_MAP";
+};
+declare const A_FrameDynamicStructureEvents: {
+    readonly Updated: "_A_FRAME_DYNAMIC_STRUCTURE_UPDATED";
+};
+
+type DynamicStructureDefaultBasesNames = 'A_Component' | 'A_Container' | 'A_Fragment';
+type BaseClassName = DynamicStructureDefaultBasesNames | A_TYPES__Ctor<A_Component | A_Fragment | A_Container>;
+type A_FrameDynamicStructureOptions = {
+    /**
+     * Which AI model to use for structure generation and patching.
+     * Defaults to `A_FRAME_MODELS.PULSAR` — the architecture model.
+     */
+    model?: string;
+    /** Context hint passed to the AI to scope the expected architecture style. */
+    context?: string;
+    /** Free-form hint about meta/prop requirements for component selection. */
+    metaHint?: string;
+    /**
+     * Only include elements whose base class is in this list.
+     * Accepts class name strings (e.g. `'A_Component'`) or constructors.
+     */
+    includeBases?: Array<string | A_TYPES__Ctor<A_Component | A_Fragment | A_Container>>;
+    /**
+     * Exclude elements whose base class is in this list.
+     */
+    excludeBases?: Array<string | A_TYPES__Ctor<A_Component | A_Fragment | A_Container>>;
+    /**
+     * Explicit allowlist of component/fragment/entity names for the AI to pick from.
+     */
+    enabledComponents?: Array<string | A_TYPES__Ctor<A_Component | A_Fragment | A_Container>>;
+};
+type A_FrameComponentMapOptions = {
+    /**
+     * Minimum cosine-similarity score (0–1) required for a generated element to
+     * be considered matched to a registered component in the local index.
+     * Default: `0.7`
+     */
+    minScore?: number;
+    /**
+     * How many times the mapper will invoke the server's select/suggest endpoint
+     * for unmatched elements before giving up and recording a `matchError`.
+     * Default: `3`
+     */
+    maxRetries?: number;
+    /**
+     * Number of top-scoring candidates to pull from the local index and send to
+     * the AI on each retry.  Larger values give the AI more choices but increase
+     * the request payload size.
+     * Default: `5`
+     */
+    candidateCount?: number;
+};
+type A_FrameDynamicStructure_Init = {
+    /** Goal or description driving structure generation. */
+    prompt: string;
+    /** Optional generation / filtering options. */
+    options?: Partial<A_FrameDynamicStructureOptions & A_FrameComponentMapOptions>;
+};
+type A_FrameDynamicStructure_Serialized = {
+    name: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+    history: Array<A_FrameDynamicPatch_Serialized>;
+} & A_TYPES__Entity_Serialized;
+type A_FrameDynamicStructureFeatureNames = typeof A_FrameDynamicStructureFeatures[keyof typeof A_FrameDynamicStructureFeatures];
+/**
+ * A single architectural element in the generated structure as returned by the
+ * server. The `prompt` is a one-sentence description of its purpose and
+ * responsibilities. `embedding` is the server-computed search vector — present
+ * immediately after generate/patch, and used by the mapper for cosine search.
+ */
+type A_FrameDynamicStructureDefinitionEntity = {
+    prompt: string;
+    /** Why this element is needed — the requirement or concern that justifies its inclusion. */
+    role?: string;
+    class?: string;
+    /** @internal Server-computed search vector; consumed during mapping. */
+    embedding?: number[];
+};
+/**
+ * Single element in the component-map result. Carries the original prompt/class
+ * from the definition plus the match outcome from the A_FrameComponentMapper.
+ */
+type A_FrameComponentMapEntry = {
+    prompt: string;
+    /** Why this element is needed — the requirement or concern that justifies its inclusion. */
+    role?: string;
+    class?: string;
+    /** Name of the registered class matched to this element, or `null` if unmatched. */
+    matchedClass: string | null;
+    /** Cosine-similarity score of the best found candidate (0–1). */
+    matchScore: number;
+    /** Populated when the element could not be matched after all retries. */
+    matchError?: {
+        title: string;
+        description: string;
+    } | null;
+};
+/**
+ * Full architecture definition produced by `generate()` or `patch()`.
+ */
+type A_FrameDynamicStructureDefinition = {
+    /**
+     * Infrastructure/runtime hosts (HTTP server, worker process, database, etc.).
+     * Each container lists the components, fragments and entities that belong to it.
+     */
+    containers: Array<A_FrameDynamicStructureDefinitionEntity & {
+        components: Array<A_FrameDynamicStructureDefinitionEntity>;
+        fragments: Array<A_FrameDynamicStructureDefinitionEntity>;
+        entities: Array<A_FrameDynamicStructureDefinitionEntity>;
+    }>;
+    /** Stateless logic units with methods and features (controllers, services, renderers, etc.). */
+    components: Array<A_FrameDynamicStructureDefinitionEntity>;
+    /** Stateful context objects shared across components (session, config, state store, etc.). */
+    fragments: Array<A_FrameDynamicStructureDefinitionEntity>;
+    /** Domain data models with unique identities (User, Article, Order, etc.). */
+    entities: Array<A_FrameDynamicStructureDefinitionEntity>;
+};
+/**
+ * Result produced by `map()` after matching all definition elements against the
+ * local A_FrameIndex. Mirrors the definition's shape but uses
+ * `A_FrameComponentMapEntry` nodes (match outcome) instead of raw definition
+ * nodes (embeddings).
+ */
+type A_FrameComponentMapResult = {
+    containers: Array<A_FrameComponentMapEntry & {
+        components: Array<A_FrameComponentMapEntry>;
+        fragments: Array<A_FrameComponentMapEntry>;
+        entities: Array<A_FrameComponentMapEntry>;
+    }>;
+    components: Array<A_FrameComponentMapEntry>;
+    fragments: Array<A_FrameComponentMapEntry>;
+    entities: Array<A_FrameComponentMapEntry>;
+};
+interface A_FrameStructureGenerateResponse {
+    definition: A_FrameDynamicStructureDefinition;
+    model: string;
+    date: string;
+    meta: {
+        server_version: string;
+    };
+}
+interface A_FrameStructureSelectCandidate {
+    name: string;
+    description?: string;
+}
+interface A_FrameStructureSelectElement {
+    prompt: string;
+    role?: string;
+    candidates: A_FrameStructureSelectCandidate[];
+}
+type A_FrameStructureSelectResolutionType = 'select' | 'suggest' | 'none';
+interface A_FrameStructureSelectResolution {
+    elementPrompt: string;
+    type: A_FrameStructureSelectResolutionType;
+    /** Present when type === 'select' */
+    selectedClass?: string;
+    /** Present when type === 'suggest' */
+    suggestion?: {
+        prompt: string;
+        role?: string;
+        /** Server-computed embedding ready for immediate local re-search. */
+        embedding?: number[];
+    };
+}
+interface A_FrameStructureSelectRequest {
+    originalPrompt: string;
+    elements: A_FrameStructureSelectElement[];
+    model?: string;
+}
+interface A_FrameStructureSelectResponse {
+    resolutions: A_FrameStructureSelectResolution[];
+    model: string;
+    date: string;
+    meta: {
+        server_version: string;
+    };
+}
+interface A_FrameStructurePatchResponse {
+    patchSummary: string;
+    definition: A_FrameDynamicStructureDefinition;
+    model: string;
+    date: string;
+    meta: {
+        server_version: string;
+    };
+}
+interface A_FrameStructurePatchResponse {
+    patchSummary: string;
+    definition: A_FrameDynamicStructureDefinition;
+    model: string;
+    date: string;
+    meta: {
+        server_version: string;
+    };
+}
+
+declare class A_FrameDynamicStructure extends A_Entity<A_FrameDynamicStructure_Init, A_FrameDynamicStructure_Serialized> {
+    static get concept(): string;
+    prompt: string;
+    createdAt: number;
+    private model;
+    private _context;
+    private _metaHint;
+    private _includeBases;
+    private _excludeBases;
+    private _enabledComponents;
+    private _minScore;
+    private _maxRetries;
+    private _candidateCount;
+    private _definition;
+    private _mapResult;
+    private _history;
+    private _version;
+    fromNew(options: A_FrameDynamicStructure_Init): void;
+    /** The AI model name used for generation / patching. */
+    get modelName(): string;
+    /** Context hint forwarded to the AI for scoping architecture style. */
+    get contextHint(): string;
+    /** Meta/prop hint forwarded to the AI for component selection. */
+    get metaHintValue(): string;
+    /** Base-class allowlist (string names). */
+    get includedBases(): string[];
+    /** Base-class denylist (string names). */
+    get excludedBases(): string[];
+    /** Explicit component allowlist (string names). */
+    get enabledComponentsList(): string[];
+    /** Minimum cosine-similarity score (0–1) required for a component match. */
+    get minScore(): number;
+    /** Max server refinement retries per unmatched element. */
+    get maxRetries(): number;
+    /** Number of top candidates to send to the AI on each retry. */
+    get candidateCount(): number;
+    /** Current architecture definition as a raw object, or null before first generate(). */
+    get definition(): A_FrameDynamicStructureDefinition | null;
+    /**
+     * Current architecture definition serialised to a formatted JSON string,
+     * with server embeddings stripped for readability.
+     * Returns an empty-definition JSON before generate() is called.
+     */
+    get structure(): string;
+    /** Component-mapping result produced by map(), or null before map() is called. */
+    get mapResult(): A_FrameComponentMapResult | null;
+    /** Immutable patch history. */
+    get history(): ReadonlyArray<A_FrameDynamicPatch>;
+    /** Current definition version (increments with each patch). */
+    get version(): number;
+    /**
+     * Generate the architecture definition from the entity's prompt.
+     * Calls the server's /api/v1/structure/generate endpoint via the A_FrameChannel feature.
+     */
+    generate(): Promise<void>;
+    /**
+     * Apply a natural-language patch instruction to the current definition.
+     * Calls the server's /api/v1/structure/patch endpoint via the A_FrameChannel feature.
+     */
+    patch(instruction: string): Promise<void>;
+    /**
+     * Match every element in the current definition against the local A_FrameIndex.
+     * Retries unmatched elements via server-side refinement patches.
+     *
+     * Results are stored separately from the raw definition and are available
+     * via `mapResult` after this call completes.
+     */
+    map(): Promise<void>;
+    /**
+     * Populate the definition from a server generate response.
+     * Creates the first history entry.
+     */
+    hydrateFromGeneration(definition: A_FrameDynamicStructureDefinition, meta: {
+        model: string;
+        serverVersion: string;
+    }): void;
+    /**
+     * Replace the current definition with a patched version from the server.
+     * Increments the version and records a history entry.
+     */
+    hydrateFromPatch(definition: A_FrameDynamicStructureDefinition, patchSummary: string, meta: {
+        model: string;
+        serverVersion: string;
+    }): void;
+    /**
+     * Store the component-mapping result produced by `A_FrameComponentMapper`.
+     * Called by the mapper after it finishes matching all elements.
+     */
+    hydrateFromMap(result: A_FrameComponentMapResult): void;
+    toJSON(): A_FrameDynamicStructure_Serialized;
+    private _countElements;
+    /** Return a copy of the definition with all `embedding` arrays removed. */
+    private _stripEmbeddings;
+}
+
+declare class A_FrameDynamicStructureOperation<_InputParams = any> extends A_Fragment {
+    protected _meta: Map<string, any>;
+    constructor(params?: _InputParams);
+    get params(): _InputParams;
+    get(key: string): any;
+    set(key: string, value: any): void;
+}
+
+declare const A_FrameDynamicFeatureFeatures: {
+    readonly Generate: "_A_FRAME_DYNAMIC_FEATURE_GENERATE";
+    readonly Patch: "_A_FRAME_DYNAMIC_FEATURE_PATCH";
+    readonly Map: "_A_FRAME_DYNAMIC_FEATURE_MAP";
+};
+
+type A_FrameDynamicFeatureOptions = {
+    /**
+     * Which AI model to use for workflow generation.
+     * Defaults to `A_FRAME_MODELS.PULSAR` — the architecture model.
+     */
+    model?: string;
+    /**
+     * Additional context hint forwarded to the AI — e.g. "microservices",
+     * "monolith", "event-driven".
+     */
+    context?: string;
+    /**
+     * Only consider methods whose owning class's base is in this allowlist.
+     * Accepts string names or constructors.
+     */
+    includeBases?: Array<string | A_TYPES__Ctor<A_Component | A_Fragment>>;
+    /**
+     * Exclude methods whose owning class's base is in this denylist.
+     */
+    excludeBases?: Array<string | A_TYPES__Ctor<A_Component | A_Fragment>>;
+    /**
+     * Explicit allowlist of component/fragment names the AI may reference.
+     */
+    enabledComponents?: Array<string | A_TYPES__Ctor<A_Component | A_Fragment>>;
+    /**
+     * Minimum cosine-similarity score (0–1) for a workflow step to be matched
+     * to a registered method.  Default: `0.7`
+     */
+    minScore?: number;
+    /**
+     * How many server refinement retries before a step is marked unmatched.
+     * Default: `3`
+     */
+    maxRetries?: number;
+};
+type A_FrameDynamicFeature_Init = {
+    /** Goal or capability driving workflow generation. */
+    prompt: string;
+    /** Optional generation / filtering options. */
+    options?: Partial<A_FrameDynamicFeatureOptions>;
+};
+type A_FrameDynamicFeature_Serialized = {
+    name: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+    history: Array<A_FrameDynamicPatch_Serialized>;
+} & A_TYPES__Entity_Serialized;
+type A_FrameDynamicFeatureFeatureNames = typeof A_FrameDynamicFeatureFeatures[keyof typeof A_FrameDynamicFeatureFeatures];
+/**
+ * A single parameter in a workflow step — describes what the caller should
+ * provide or what the step will produce.
+ */
+type A_FrameDynamicFeatureParam = {
+    /** Parameter name (camelCase). */
+    name: string;
+    /** TypeScript type string, e.g. `"string"`, `"number"`, `"UserEntity"`. */
+    type: string;
+    /** Human-readable purpose of this parameter. */
+    description: string;
+    /** Whether this parameter must be provided (`true`) or is optional. */
+    required: boolean;
+};
+/**
+ * A single step in the generated workflow definition.
+ * Each step corresponds to one method call on a component or fragment.
+ */
+type A_FrameDynamicFeatureStep = {
+    /**
+     * One-sentence description of this step's purpose — used as the primary
+     * key for semantic matching against the A_FrameIndex.
+     */
+    prompt: string;
+    /** Ordered list of input parameters for this step. */
+    inputs: A_FrameDynamicFeatureParam[];
+    /** Ordered list of output values produced by this step. */
+    outputs: A_FrameDynamicFeatureParam[];
+    /** @internal Server-computed search vector (consumed during mapping). */
+    embedding?: number[];
+};
+/**
+ * Full workflow definition produced by `generate()` or `patch()`.
+ */
+type A_FrameDynamicFeatureDefinition = {
+    /**
+     * Short title for the workflow, e.g. "User Registration".
+     */
+    title: string;
+    /**
+     * Description of what the workflow accomplishes end-to-end,
+     * what the caller must supply, and what will be returned.
+     */
+    description: string;
+    /** Ordered sequence of steps that make up the workflow. */
+    steps: A_FrameDynamicFeatureStep[];
+    /**
+     * Supporting components (stateless services / controllers) whose methods
+     * are used in the steps.  No container grouping — workflows are
+     * cross-cutting by nature.
+     */
+    components: Array<{
+        prompt: string;
+        embedding?: number[];
+    }>;
+    /** Supporting fragments (stateful context objects) referenced in the steps. */
+    fragments: Array<{
+        prompt: string;
+        embedding?: number[];
+    }>;
+    /** Supporting entities / domain models referenced in step parameters. */
+    entities: Array<{
+        prompt: string;
+        embedding?: number[];
+        parameters?: A_FrameDynamicFeatureParam[];
+    }>;
+};
+/**
+ * Result of matching one workflow step against the A_FrameIndex.
+ */
+type A_FrameDynamicFeatureStepMapEntry = {
+    prompt: string;
+    inputs: A_FrameDynamicFeatureParam[];
+    outputs: A_FrameDynamicFeatureParam[];
+    /** Matched class name, or `null` if unresolved. */
+    matchedClass: string | null;
+    /** Matched method name, or `null` if unresolved. */
+    matchedMethod: string | null;
+    /** Cosine-similarity score of the best match (0–1). */
+    matchScore: number;
+    /** Error details when matching failed after all retries. */
+    matchError?: {
+        title: string;
+        description: string;
+    } | null;
+};
+/**
+ * Result of matching a supporting element (component / fragment / entity)
+ * against the A_FrameIndex.
+ */
+type A_FrameDynamicFeatureElementMapEntry = {
+    prompt: string;
+    matchedClass: string | null;
+    matchScore: number;
+    matchError?: {
+        title: string;
+        description: string;
+    } | null;
+};
+/**
+ * Full map result produced by `map()` after matching every element against
+ * the local A_FrameIndex.
+ */
+type A_FrameDynamicFeatureMapResult = {
+    steps: A_FrameDynamicFeatureStepMapEntry[];
+    components: A_FrameDynamicFeatureElementMapEntry[];
+    fragments: A_FrameDynamicFeatureElementMapEntry[];
+    entities: A_FrameDynamicFeatureElementMapEntry[];
+};
+interface A_FrameFeatureGenerateResponse {
+    definition: A_FrameDynamicFeatureDefinition;
+    model: string;
+    date: string;
+    meta: {
+        server_version: string;
+    };
+}
+interface A_FrameFeaturePatchResponse {
+    patchSummary: string;
+    definition: A_FrameDynamicFeatureDefinition;
+    model: string;
+    date: string;
+    meta: {
+        server_version: string;
+    };
+}
+
+declare class A_FrameDynamicFeature extends A_Entity<A_FrameDynamicFeature_Init, A_FrameDynamicFeature_Serialized> {
+    static get concept(): string;
+    prompt: string;
+    createdAt: number;
+    private _model;
+    private _context;
+    private _includeBases;
+    private _excludeBases;
+    private _enabledComponents;
+    private _minScore;
+    private _maxRetries;
+    private _definition;
+    private _mapResult;
+    private _history;
+    private _version;
+    fromNew(options: A_FrameDynamicFeature_Init): void;
+    get modelName(): string;
+    get contextHint(): string;
+    get includedBases(): string[];
+    get excludedBases(): string[];
+    get enabledComponentsList(): string[];
+    get minScore(): number;
+    get maxRetries(): number;
+    /** Current workflow definition, or `null` before first `generate()`. */
+    get definition(): A_FrameDynamicFeatureDefinition | null;
+    /**
+     * Serialised workflow definition (no embedding arrays) — safe to
+     * log or persist.  Returns an empty shell before `generate()` is called.
+     */
+    get workflow(): string;
+    /** Component-mapping result produced by `map()`, or `null` before that call. */
+    get mapResult(): A_FrameDynamicFeatureMapResult | null;
+    /** Immutable patch history. */
+    get history(): ReadonlyArray<A_FrameDynamicPatch>;
+    /** Version counter — increments with each `patch()` call. */
+    get version(): number;
+    /**
+     * Generate the workflow definition from the entity's prompt.
+     *
+     * Calls the server's `/api/v1/feature/generate` endpoint.  The server
+     * returns an ordered list of steps (with embeddings), a list of supporting
+     * components/fragments/entities, and a human-readable title + description
+     * of the workflow.
+     *
+     * After this call succeeds, invoke `map()` to match each element to a
+     * registered class/method in the local A_FrameIndex.
+     */
+    generate(): Promise<void>;
+    /**
+     * Apply a natural-language patch instruction to refine the current workflow.
+     *
+     * Calls the server's `/api/v1/feature/patch` endpoint.  Increments the
+     * version and records a history entry.  A previous `map()` result is
+     * invalidated — call `map()` again after patching.
+     */
+    patch(instruction: string): Promise<void>;
+    /**
+     * Match every step and supporting element in the current workflow definition
+     * against the local A_FrameIndex.
+     *
+     * Steps are matched to registered *methods* (via embedded method-level
+     * definitions indexed with `@A_Frame.Define`).  Supporting components,
+     * fragments, and entities are matched to registered classes.
+     *
+     * Unmatched steps are retried via server-side refinement patches (up to
+     * `maxRetries` times) before being marked with a `matchError`.
+     *
+     * Results are stored in `mapResult` after this call completes.
+     */
+    map(): Promise<void>;
+    hydrateFromGeneration(definition: A_FrameDynamicFeatureDefinition, meta: {
+        model: string;
+        serverVersion: string;
+    }): void;
+    hydrateFromPatch(definition: A_FrameDynamicFeatureDefinition, patchSummary: string, meta: {
+        model: string;
+        serverVersion: string;
+    }): void;
+    hydrateFromMap(result: A_FrameDynamicFeatureMapResult): void;
+    toJSON(): A_FrameDynamicFeature_Serialized;
+    private _stripEmbeddings;
+}
+
+/**
+ * Thin context fragment that carries parameters for a single DynamicFeature
+ * operation (generate or patch).  Injected into the feature execution scope and
+ * resolved by channel feature-extension handlers via `@A_Inject`.
+ */
+declare class A_FrameDynamicFeatureOperation<_InputParams = any> extends A_Fragment {
+    protected _meta: Map<string, any>;
+    constructor(params?: _InputParams);
+    get params(): _InputParams;
+    get(key: string): any;
+    set(key: string, value: any): void;
+}
+
+/**
+ * A_FrameChannel — Node.js environment
+ *
+ * HTTP client for the embed-server API.
+ * Configuration is resolved from process.env via A_FrameEnv injected at
+ * feature execution time — no state is stored on the component itself.
+ *
+ * Uses the global fetch (available in Node 18+; no extra dependency needed).
+ */
+declare class A_FrameChannel extends A_Component implements IA_Frame_Channel {
+    generate(prompt: string): Promise<A_FrameChannelRequest<A_Frame_GenerateResponse>>;
+    embed(input: string | string[], options?: A_FrameEmbedOptions): Promise<A_FrameChannelRequest<A_Frame_EmbedResponse>>;
+    getCredentials(): Promise<A_FrameChannelRequest<A_Frame_CredentialResponse>>;
+    ping(): Promise<A_FrameChannelRequest<boolean>>;
+    embedDefinition(definition: A_FrameDefinition, env: A_FrameEnv): Promise<void>;
+    embedNamespace(namespace: A_FrameNamespace, env: A_FrameEnv): Promise<void>;
+    embedSegment(segment: A_FrameSegment, env: A_FrameEnv): Promise<void>;
+    /**
+     * Feature implementation for A_FrameDynamicStructure.generate().
+     *
+     * Calls POST /api/v1/structure/generate — the server returns element
+     * descriptions with embeddings.  The raw definition (embeddings included) is
+     * stored on the entity so the separate `map()` phase can use them later.
+     */
+    generateDynamicStructure(structure: A_FrameDynamicStructure, operation: A_FrameDynamicStructureOperation): Promise<void>;
+    /**
+     * Feature implementation for A_FrameDynamicStructure.patch().
+     *
+     * Calls POST /api/v1/structure/patch — the server returns an updated
+     * definition with fresh embeddings.  The raw definition is stored on the
+     * entity; run `map()` afterwards to update the component-mapping result.
+     */
+    patchDynamicStructure(structure: A_FrameDynamicStructure, operation: A_FrameDynamicStructureOperation): Promise<void>;
+    /**
+     * Strip embedding arrays and any client-side match fields from a definition
+     * before sending it to the server (the server does not need embeddings back).
+     */
+    private _stripStructureEmbeddings;
+    /**
+     * Feature implementation for A_FrameDynamicFeature.generate().
+     *
+     * Calls POST /api/v1/feature/generate — the server decomposes the prompt
+     * into an ordered workflow: title, description, steps (with embeddings),
+     * and supporting components/fragments/entities.
+     */
+    generateDynamicFeature(feature: A_FrameDynamicFeature, operation: A_FrameDynamicFeatureOperation): Promise<void>;
+    /**
+     * Feature implementation for A_FrameDynamicFeature.patch().
+     *
+     * Calls POST /api/v1/feature/patch — the server returns an updated workflow
+     * definition with fresh embeddings on all steps and elements.
+     */
+    patchDynamicFeature(feature: A_FrameDynamicFeature, operation: A_FrameDynamicFeatureOperation): Promise<void>;
+    private _stripFeatureEmbeddings;
+    /**
+     * Feature implementation for A_FrameDynamicContent.generate().
+     *
+     * Calls POST /api/v1/content/generate on the server and hydrates the
+     * content entity from the returned piece list.
+     */
+    generateDynamicContent(content: A_FrameDynamicContent, operation: A_FrameDynamicContentOperation): Promise<void>;
+    /**
+     * Feature implementation for A_FrameDynamicContent.patch().
+     *
+     * Sends the current piece list and a patch instruction to the server,
+     * then applies the returned operations to the content entity.
+     */
+    patchDynamicContent(content: A_FrameDynamicContent, operation: A_FrameDynamicContentOperation): Promise<void>;
+    /**
+     * Feature implementation for A_FrameCompletion.generate().
+     *
+     * Calls POST /api/v1/completions/generate on the server, which performs a
+     * text completion followed by an embedding of the result in a single
+     * round-trip, then hydrates the entity with both values.
+     */
+    generateCompletion(completion: A_FrameCompletion, env: A_FrameEnv): Promise<void>;
+    /**
+     * Calls POST /api/v1/schema/extract on the server.
+     *
+     * Sends the prompt and schema descriptor to the Nova model, which returns
+     * a structured JSON object matching the schema.  Hydrates the entity with
+     * the extracted data and provenance metadata.
+     */
+    extractSchema<T extends Record<string, unknown>>(scheme: A_FrameSchema<T>, env: A_FrameEnv): Promise<void>;
+}
+
+export { type A_FrameDynamicFeatureStepMapEntry as A, type A_FrameDynamicStructure_Serialized as B, type A_FrameStructureGenerateResponse as C, type A_FrameStructurePatchResponse as D, type A_FrameStructureSelectCandidate as E, type A_FrameStructureSelectElement as F, type A_FrameStructureSelectRequest as G, type A_FrameStructureSelectResolution as H, type A_FrameStructureSelectResolutionType as I, type A_FrameStructureSelectResponse as J, type BaseClassName as K, type DynamicStructureDefaultBasesNames as L, type A_FrameDynamicFeatureElementMapEntry as a, type A_FrameDynamicFeatureDefinition as b, type A_FrameDynamicFeatureMapResult as c, A_FrameDynamicFeature as d, A_FrameChannel as e, type A_FrameDynamicFeatureFeatureNames as f, A_FrameDynamicFeatureFeatures as g, A_FrameDynamicFeatureOperation as h, type A_FrameDynamicFeatureOptions as i, type A_FrameDynamicFeatureParam as j, type A_FrameDynamicFeatureStep as k, type A_FrameDynamicFeature_Init as l, type A_FrameDynamicFeature_Serialized as m, type A_FrameFeatureGenerateResponse as n, type A_FrameFeaturePatchResponse as o, type A_FrameComponentMapEntry as p, type A_FrameDynamicStructureDefinition as q, type A_FrameComponentMapResult as r, A_FrameDynamicStructure as s, type A_FrameComponentMapOptions as t, type A_FrameDynamicStructureDefinitionEntity as u, A_FrameDynamicStructureEvents as v, type A_FrameDynamicStructureFeatureNames as w, A_FrameDynamicStructureFeatures as x, type A_FrameDynamicStructureOptions as y, type A_FrameDynamicStructure_Init as z };