/**
 * Common schema definitions shared across AXM configuration files.
 *
 * @experimental This API is unstable and may change without notice.
 */
import * as Schema from "effect/Schema";
import * as Option from "effect/Option";
/**
 * Author information for a manifest.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const AuthorSchema: Schema.Struct<{
    readonly name: Schema.String;
    readonly email: Schema.optional<Schema.String>;
    readonly url: Schema.optional<Schema.String>;
}>;
/**
 * Author information in runtime/domain models.
 *
 * @experimental This API is unstable and may change without notice.
 */
export interface Author {
    readonly name: string;
    readonly email: Option.Option<string>;
    readonly url: Option.Option<string>;
}
/** Convert schema-decoded author shape into runtime/domain Author. */
export declare const toAuthor: (author: Schema.Schema.Type<typeof AuthorSchema>) => Author;
/**
 * Repository field for extension manifests. Accepts either a URL string
 * (or shorthand like `github:owner/repo`) or an npm-style object with
 * optional `type` and `directory` for monorepo subpaths.
 *
 * Matches the shape accepted by npm's `package.json` `repository` field.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const RepositorySchema: Schema.Union<readonly [Schema.String, Schema.Struct<{
    readonly type: Schema.optional<Schema.NonEmptyString>;
    readonly url: Schema.NonEmptyString;
    readonly directory: Schema.optional<Schema.NonEmptyString>;
}>]>;
/**
 * Inferred type for {@link RepositorySchema}.
 *
 * @experimental This API is unstable and may change without notice.
 */
export type Repository = Schema.Schema.Type<typeof RepositorySchema>;
/**
 * Bugs field for extension manifests. Accepts either a URL string or an
 * npm-style object with optional `url` and `email`.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const BugsSchema: Schema.Union<readonly [Schema.String, Schema.Struct<{
    readonly url: Schema.optional<Schema.NonEmptyString>;
    readonly email: Schema.optional<Schema.NonEmptyString>;
}>]>;
/**
 * Inferred type for {@link BugsSchema}.
 *
 * @experimental This API is unstable and may change without notice.
 */
export type Bugs = Schema.Schema.Type<typeof BugsSchema>;
/**
 * License field for extension manifests.
 *
 * Accepts valid SPDX license expressions plus the npm-compatible
 * `UNLICENSED` literal for proprietary code that grants no license.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const LicenseSchema: Schema.String;
/** How an extension type is distributed. All current types are registry-distributed. */
export type ExtensionDistribution = "registry";
/**
 * Where an extension type's installed artifacts live: in per-agent locations
 * AXM can collide with, in workspace-owned locations, or nowhere of its own
 * (container types like pack).
 */
export type ExtensionPlacement = "per-agent" | "workspace" | "container";
/** What a governing standard covers for a type, when one exists. */
export type StandardGoverns = "package-body" | "runtime-protocol" | "host-file";
/** Workspace-level capability a type participates in. */
export type WorkspaceCapabilityKey = "instructions";
/**
 * One extension type's naming and capability-axis row. Every CONDITIONAL
 * parity obligation is a predicate over the five axis columns.
 */
interface ExtensionTypeRow {
    readonly plural: string;
    readonly label: string;
    readonly pluralLabel: string;
    readonly sentenceLabel: string;
    readonly pluralSentenceLabel: string;
    readonly distribution: ExtensionDistribution;
    readonly placement: ExtensionPlacement;
    readonly governs: StandardGoverns | null;
    readonly installInputs: boolean;
    readonly workspaceCapability: WorkspaceCapabilityKey | null;
}
/**
 * Single source of truth for extension type naming. Row order is the canonical
 * display order. Every other type-naming export in this module derives from
 * this table, so a new extension type is exactly one row here: a missing
 * column is TS2741, an excess column is TS2353, and every downstream
 * `satisfies Record<ExtensionType, _>` table fails until the new type is
 * decided everywhere.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const EXTENSION_TYPE_TABLE: {
    readonly skill: {
        readonly plural: "skills";
        readonly label: "Skill";
        readonly pluralLabel: "Skills";
        readonly sentenceLabel: "skill";
        readonly pluralSentenceLabel: "skills";
        readonly distribution: "registry";
        readonly placement: "per-agent";
        readonly governs: "package-body";
        readonly installInputs: false;
        readonly workspaceCapability: null;
    };
    readonly "mcp-server": {
        readonly plural: "mcps";
        readonly label: "MCP Server";
        readonly pluralLabel: "MCP Servers";
        readonly sentenceLabel: "MCP server";
        readonly pluralSentenceLabel: "MCP servers";
        readonly distribution: "registry";
        readonly placement: "per-agent";
        readonly governs: "runtime-protocol";
        readonly installInputs: true;
        readonly workspaceCapability: null;
    };
    readonly subagent: {
        readonly plural: "subagents";
        readonly label: "Subagent";
        readonly pluralLabel: "Subagents";
        readonly sentenceLabel: "subagent";
        readonly pluralSentenceLabel: "subagents";
        readonly distribution: "registry";
        readonly placement: "per-agent";
        readonly governs: null;
        readonly installInputs: false;
        readonly workspaceCapability: null;
    };
    readonly rule: {
        readonly plural: "rules";
        readonly label: "Rule";
        readonly pluralLabel: "Rules";
        readonly sentenceLabel: "rule";
        readonly pluralSentenceLabel: "rules";
        readonly distribution: "registry";
        readonly placement: "workspace";
        readonly governs: "host-file";
        readonly installInputs: false;
        readonly workspaceCapability: "instructions";
    };
    readonly hook: {
        readonly plural: "hooks";
        readonly label: "Hook";
        readonly pluralLabel: "Hooks";
        readonly sentenceLabel: "hook";
        readonly pluralSentenceLabel: "hooks";
        readonly distribution: "registry";
        readonly placement: "per-agent";
        readonly governs: null;
        readonly installInputs: false;
        readonly workspaceCapability: null;
    };
    readonly knowledge: {
        readonly plural: "knowledge";
        readonly label: "Knowledge";
        readonly pluralLabel: "Knowledge";
        readonly sentenceLabel: "knowledge bundle";
        readonly pluralSentenceLabel: "knowledge bundles";
        readonly distribution: "registry";
        readonly placement: "workspace";
        readonly governs: "package-body";
        readonly installInputs: false;
        readonly workspaceCapability: null;
    };
    readonly pack: {
        readonly plural: "packs";
        readonly label: "Pack";
        readonly pluralLabel: "Packs";
        readonly sentenceLabel: "pack";
        readonly pluralSentenceLabel: "packs";
        readonly distribution: "registry";
        readonly placement: "container";
        readonly governs: null;
        readonly installInputs: false;
        readonly workspaceCapability: null;
    };
};
export type ExtensionType = keyof typeof EXTENSION_TYPE_TABLE;
export type ExtensionTypePlural = (typeof EXTENSION_TYPE_TABLE)[ExtensionType]["plural"];
export declare const extensionTypes: ReadonlyArray<ExtensionType>;
export declare const extensionTypePluralSegments: ReadonlyArray<ExtensionTypePlural>;
export declare const isExtensionType: (value: string | undefined) => value is ExtensionType;
export declare const isExtensionTypePlural: (value: string | undefined) => value is ExtensionTypePlural;
export declare const extensionTypeFromPlural: Record<ExtensionTypePlural, ExtensionType>;
export declare const extensionTypeToPlural: Record<ExtensionType, ExtensionTypePlural>;
export declare const toExtensionType: (segment: ExtensionTypePlural) => ExtensionType;
export declare const toExtensionTypePlural: (type: ExtensionType) => ExtensionTypePlural;
export declare const extensionTypeLabels: Record<ExtensionType, string>;
export declare const extensionTypePluralLabels: Record<ExtensionTypePlural, string>;
export declare const extensionTypeSentenceLabels: Record<ExtensionType, string>;
export declare const extensionTypePluralSentenceLabels: Record<ExtensionTypePlural, string>;
/**
 * Plural extension-type segments that may appear as dependency keys —
 * everything except `packs`. Packs cannot depend on other packs.
 *
 * @experimental This API is unstable and may change without notice.
 */
export type NonPackExtensionTypePlural = Exclude<ExtensionTypePlural, "packs">;
export declare const nonPackExtensionTypePluralSegments: ReadonlyArray<NonPackExtensionTypePlural>;
type ExtensionTypeRows = typeof EXTENSION_TYPE_TABLE;
/**
 * Extension types whose table row matches an axis value. Derived, never
 * hand-written: an axis change on a row updates every union below, and the
 * exact-membership pins in extension-type-table.type-test.ts fail compile in
 * both directions if a union gains or loses a member.
 */
type TypesWhere<Axis extends keyof ExtensionTypeRow, Value> = {
    [Key in ExtensionType]: ExtensionTypeRows[Key][Axis] extends Value ? Key : never;
}[ExtensionType];
/** Extension types materialized into agent-owned locations. */
export type PerAgentType = TypesWhere<"placement", "per-agent">;
/** Extension types materialized into workspace-owned locations. */
export type WorkspaceType = TypesWhere<"placement", "workspace">;
/** Extension types that coordinate other extensions instead of projecting directly. */
export type ContainerType = TypesWhere<"placement", "container">;
/** Registry-distributed non-container extension types. */
export type RegistryType = PerAgentType | WorkspaceType;
/** Extension types whose installs accept user-provided inputs. */
export type InputType = TypesWhere<"installInputs", true>;
/** Extension types whose governing standard covers the package body. */
export type BodyGovernedType = TypesWhere<"governs", "package-body">;
/**
 * Extension types a standard governs at all. The agent catalog records a
 * standards-compliance grade for exactly these, so the grade is never
 * hand-applied per capability schema.
 */
export type SpecTrackedType = TypesWhere<"governs", StandardGoverns>;
/**
 * Extension types that double as a workspace-level capability toggle. These
 * carry workspace configuration of their own, so surfaces that split extension
 * management from workspace management group them with the workspace.
 */
export type WorkspaceCapabilityType = TypesWhere<"workspaceCapability", WorkspaceCapabilityKey>;
export declare const PER_AGENT_EXTENSION_TYPES: ReadonlyArray<PerAgentType>;
export declare const WORKSPACE_EXTENSION_TYPES: ReadonlyArray<WorkspaceType>;
export declare const CONTAINER_EXTENSION_TYPES: ReadonlyArray<ContainerType>;
export declare const REGISTRY_EXTENSION_TYPES: ReadonlyArray<RegistryType>;
export declare const INPUT_EXTENSION_TYPES: ReadonlyArray<InputType>;
export declare const BODY_GOVERNED_EXTENSION_TYPES: ReadonlyArray<BodyGovernedType>;
export declare const SPEC_TRACKED_EXTENSION_TYPES: ReadonlyArray<SpecTrackedType>;
export declare const WORKSPACE_CAPABILITY_EXTENSION_TYPES: ReadonlyArray<WorkspaceCapabilityType>;
/** Extension types managed purely as extensions, with no workspace capability. */
export declare const EXTENSION_ONLY_TYPES: ReadonlyArray<Exclude<ExtensionType, WorkspaceCapabilityType>>;
/**
 * Fully qualified name regex: `@<handle>/<type>/<name>` where handle and name
 * use the canonical handle, plural extension type, and extension name grammar.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const FQN_PATTERN: RegExp;
/**
 * Fully qualified name regex restricted to non-pack extension types. Matches
 * `@<handle>/<type>/<name>` where `<type>` is any plural extension type other
 * than `packs`.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const NON_PACK_FQN_PATTERN: RegExp;
/**
 * Fully qualified name regex restricted to the pack extension type. Matches
 * `@<handle>/packs/<name>`.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const PACK_FQN_PATTERN: RegExp;
/**
 * Canonical extension short name regex.
 */
export declare const EXTENSION_NAME_PATTERN: RegExp;
/**
 * Canonical extension short name schema shared by generic extension surfaces.
 */
export declare const ExtensionNameSchema: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
export type ExtensionName = Schema.Schema.Type<typeof ExtensionNameSchema>;
export declare const decodeExtensionNameSync: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"ExtensionName">;
/**
 * Extension type enumeration.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const ExtensionTypeSchema: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack")[]>;
/**
 * Plural extension-type segment enumeration used by route/FQN surfaces.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const ExtensionTypePluralSchema: Schema.Literals<readonly ("skills" | "mcps" | "subagents" | "rules" | "hooks" | "knowledge" | "packs")[]>;
/**
 * Structured FQN parts schema composed from the canonical handle, type, and name schemas.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const ExtensionFqnPartsSchema: Schema.Struct<{
    readonly owner: Schema.brand<Schema.String, "Handle">;
    readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack")[]>;
    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
}>;
/**
 * Inferred type for parsed FQN parts.
 *
 * @experimental This API is unstable and may change without notice.
 */
export type ExtensionFqnParts = Schema.Schema.Type<typeof ExtensionFqnPartsSchema>;
/**
 * Parse a fully qualified name string into validated structured parts.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const parseExtensionFqnParts: (input: string) => ExtensionFqnParts | undefined;
/**
 * Parse an extension spec string (with optional version constraint) into parts.
 * Strips the version constraint suffix and returns the validated FQN parts.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const parseExtensionSpecParts: (input: string) => ExtensionFqnParts | undefined;
/**
 * Fully qualified name string schema validated against the composed handle,
 * type, and name patterns. Annotated so JSON Schema generation surfaces a
 * `pattern` and a top-level `ExtensionFqn` definition that `Schema.Record`
 * keys can reference via `propertyNames`.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const ExtensionFqnSchema: Schema.String;
/**
 * Inferred type for ExtensionFqn schema.
 *
 * @experimental This API is unstable and may change without notice.
 */
export type ExtensionFqn = Schema.Schema.Type<typeof ExtensionFqnSchema>;
/**
 * Fully qualified name string schema restricted to non-pack extension types.
 * Used wherever pack-typed FQNs are not permitted, like the keys of a pack
 * manifest's `dependencies` map.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const NonPackExtensionFqnSchema: Schema.String;
/**
 * Inferred type for NonPackExtensionFqn schema.
 *
 * @experimental This API is unstable and may change without notice.
 */
export type NonPackExtensionFqn = Schema.Schema.Type<typeof NonPackExtensionFqnSchema>;
/**
 * Fully qualified name string schema restricted to the pack extension type.
 * Used wherever only pack-typed FQNs are permitted, like the items of a
 * non-pack manifest's `recommendedPacks` list.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const PackFqnSchema: Schema.String;
/**
 * Inferred type for PackFqn schema.
 *
 * @experimental This API is unstable and may change without notice.
 */
export type PackFqn = Schema.Schema.Type<typeof PackFqnSchema>;
/**
 * Extension spec — fully qualified extension name with an optional version
 * constraint suffix. Accepts `@owner/type/name` or `@owner/type/name@constraint`
 * where the FQN portion validates through ExtensionFqnSchema and the optional
 * constraint validates as a semver VersionRange.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const ExtensionSpecSchema: Schema.brand<Schema.NonEmptyString, "ExtensionSpec">;
/**
 * Inferred type for ExtensionSpec schema.
 *
 * @experimental This API is unstable and may change without notice.
 */
export type ExtensionSpec = Schema.Schema.Type<typeof ExtensionSpecSchema>;
/**
 * Pack spec — fully qualified pack name with an optional version constraint
 * suffix. Accepts `@owner/packs/name` or `@owner/packs/name@constraint` where
 * the FQN portion validates through PackFqnSchema and the optional constraint
 * validates as a semver VersionRange.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const PackSpecSchema: Schema.brand<Schema.NonEmptyString, "PackSpec">;
/**
 * Inferred type for PackSpec schema.
 *
 * @experimental This API is unstable and may change without notice.
 */
export type PackSpec = Schema.Schema.Type<typeof PackSpecSchema>;
/**
 * Map of fully-qualified extension names to semver constraints.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const ExtensionDependencyConstraintMapSchema: Schema.$Record<Schema.String, Schema.brand<Schema.NonEmptyString, "VersionRange">>;
/**
 * Inferred type for extension dependency constraint maps.
 *
 * @experimental This API is unstable and may change without notice.
 */
export type ExtensionDependencyConstraintMap = Schema.Schema.Type<typeof ExtensionDependencyConstraintMapSchema>;
/**
 * Map of non-pack fully-qualified extension names to semver constraints.
 * Used for pack manifest `dependencies`, which cannot include other packs.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const NonPackExtensionDependencyConstraintMapSchema: Schema.$Record<Schema.String, Schema.brand<Schema.NonEmptyString, "VersionRange">>;
/**
 * Inferred type for non-pack extension dependency constraint maps.
 *
 * @experimental This API is unstable and may change without notice.
 */
export type NonPackExtensionDependencyConstraintMap = Schema.Schema.Type<typeof NonPackExtensionDependencyConstraintMapSchema>;
/**
 * Publish-time packaging options.
 *
 * Declared in the manifest rather than in workspace settings so the policy
 * travels with the package: whoever publishes a checkout produces the same
 * archive. Absent means every file under the package directory is published,
 * which is the default and the only behavior before this field existed.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const ExtensionVisibilitySchema: Schema.Literals<readonly ["public", "private"]>;
/** @experimental This API is unstable and may change without notice. */
export type ExtensionVisibility = Schema.Schema.Type<typeof ExtensionVisibilitySchema>;
export declare const PublishOptionsSchema: Schema.Struct<{
    readonly visibility: Schema.optional<Schema.Literals<readonly ["public", "private"]>>;
    readonly ignore: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
}>;
/** @experimental This API is unstable and may change without notice. */
export type PublishOptions = Schema.Schema.Type<typeof PublishOptionsSchema>;
/**
 * Common base fields shared across manifest types.
 * Type-specific manifests provide their own `type` and `name` fields explicitly.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const CommonManifestBaseFields: {
    publish: Schema.optional<Schema.Struct<{
        readonly visibility: Schema.optional<Schema.Literals<readonly ["public", "private"]>>;
        readonly ignore: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
    }>>;
    metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
    owner: Schema.brand<Schema.String, "Handle">;
    version: Schema.brand<Schema.String, "Version">;
    description: Schema.optional<Schema.String>;
    keywords: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
    repository: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
        readonly type: Schema.optional<Schema.NonEmptyString>;
        readonly url: Schema.NonEmptyString;
        readonly directory: Schema.optional<Schema.NonEmptyString>;
    }>]>>;
    homepage: Schema.optional<Schema.String>;
    license: Schema.optional<Schema.String>;
    bugs: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
        readonly url: Schema.optional<Schema.NonEmptyString>;
        readonly email: Schema.optional<Schema.NonEmptyString>;
    }>]>>;
    authors: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly name: Schema.String;
        readonly email: Schema.optional<Schema.String>;
        readonly url: Schema.optional<Schema.String>;
    }>>>;
    packages: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly purl: Schema.brand<Schema.NonEmptyString, "PackageIdentityPurl">;
        readonly versionRange: Schema.optional<Schema.brand<Schema.decodeTo<Schema.toType<Schema.Struct<{
            readonly raw: Schema.NonEmptyString;
            readonly scheme: Schema.NonEmptyString;
            readonly constraints: Schema.$Array<Schema.Struct<{
                readonly comparator: Schema.Literals<readonly ["=", "!=", "<", "<=", ">", ">="]>;
                readonly version: Schema.NonEmptyString;
            }>>;
        }>>, Schema.NonEmptyString, never, never>, "VersRange">>;
    }>>>;
};
/**
 * Fields shared across non-pack extension manifests. These describe how an
 * extension relates to packs.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const NonPackManifestFields: {
    enhances: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
    requires: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
    fallback: Schema.optional<Schema.Literals<readonly ["auto", "none"]>>;
    recommendedPacks: Schema.optional<Schema.$Array<Schema.brand<Schema.NonEmptyString, "PackSpec">>>;
    standalone: Schema.optional<Schema.Boolean>;
};
/**
 * Agent identifier enumeration for supported coding agents.
 *
 * Derived from `AGENT_IDS` in agents/types.ts — compile-time enforced,
 * no manual sync required.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const AgentIdSchema: Schema.Literals<readonly ["adal", "aider-desk", "amp", "antigravity", "antigravity-cli", "augment", "claude-code", "cline", "codearts-agent", "codebuddy", "codemaker", "codestudio", "codex", "command-code", "continue", "cortex", "crush", "cursor", "deepagents", "devin", "dexto", "droid", "firebender", "forgecode", "gemini-cli", "github-copilot-cli", "goose", "grok-cli", "hermes", "ibm-bob", "iflow-cli", "junie", "lingma", "kilo", "kimi-cli", "kiro-cli", "kode", "mcpjam", "minimax-code", "mistral-vibe", "mux", "neovate", "openclaw", "opencode", "openhands", "ona", "pi", "pochi", "qoder", "qoder-cn", "qwen-code", "replit", "roo", "rovodev", "tabnine-cli", "trae-cn", "trae", "warp", "windsurf", "zencoder", "zed", "zenflow", "universal"]>;
/**
 * Agent identifiers users may persist in `axm.json`.
 *
 * Synthetic materialization targets such as `universal` are known agents, but
 * they are injected by repository code rather than configured by users.
 *
 * @experimental This API is unstable and may change without notice.
 */
export declare const ConfigurableAgentIdSchema: Schema.Literals<readonly ["adal", "aider-desk", "amp", "antigravity", "antigravity-cli", "augment", "claude-code", "cline", "codearts-agent", "codebuddy", "codemaker", "codestudio", "codex", "command-code", "continue", "cortex", "crush", "cursor", "deepagents", "devin", "dexto", "droid", "firebender", "forgecode", "gemini-cli", "github-copilot-cli", "goose", "grok-cli", "hermes", "ibm-bob", "iflow-cli", "junie", "lingma", "kilo", "kimi-cli", "kiro-cli", "kode", "mcpjam", "minimax-code", "mistral-vibe", "mux", "neovate", "openclaw", "opencode", "openhands", "ona", "pi", "pochi", "qoder", "qoder-cn", "qwen-code", "replit", "roo", "rovodev", "tabnine-cli", "trae-cn", "trae", "warp", "windsurf", "zencoder", "zed", "zenflow"]>;
/**
 * Inferred type for AgentId schema.
 *
 * @experimental This API is unstable and may change without notice.
 */
export type AgentId = Schema.Schema.Type<typeof AgentIdSchema>;
/** @experimental This API is unstable and may change without notice. */
export type ConfigurableAgentId = Schema.Schema.Type<typeof ConfigurableAgentIdSchema>;
export {};
//# sourceMappingURL=common.d.ts.map