@ahoo-wang/wow-generator 9.2.0-rc.0

package/dist/pipeline/codeGenerator.d.cts

@@ -0,0 +1,61 @@
+import { GenerationResult, GeneratorOptions } from '../api/options.cjs';
+/**
+ * Main code generator class that orchestrates the generation of TypeScript code from OpenAPI specifications.
+ * This class handles the entire code generation process, including parsing OpenAPI specs,
+ * resolving aggregates, generating models and clients, and formatting the output.
+ *
+ * @example
+ * ```typescript
+ * const generator = new CodeGenerator({
+ *   inputPath: './openapi.yaml',
+ *   outputDir: './generated',
+ *   tsConfigFilePath: './tsconfig.json',
+ *   logger: new ConsoleLogger({ level: 'verbose' }),
+ * });
+ * const { files } = await generator.generate();
+ * ```
+ */
+export declare class CodeGenerator {
+    private readonly options;
+    private readonly project;
+    private readonly logger;
+    private readonly signal?;
+    /** The output of the last run, whose files the next run starts without. */
+    private output?;
+    /**
+     * Creates a new CodeGenerator instance with the specified options.
+     *
+     * @param options - Input, output, configuration and logging of the run.
+     * @throws GeneratorError of kind `configuration` if the TypeScript
+     * configuration cannot be read.
+     */
+    constructor(options: GeneratorOptions);
+    /**
+     * Generates TypeScript code from the OpenAPI specification:
+     *
+     * 1. reads the generator configuration, then the document, which it checks
+     *    for dangling references;
+     * 2. reads the document's Wow model: bounded contexts and aggregates;
+     * 3. decides what the document generates (`analysis/`);
+     * 4. writes every module once (`emitters/`), then the index files;
+     * 5. formats, organises and types the imports, and checks the output
+     *    compiles (`finalize/`);
+     * 6. writes the files, removes the stale ones of the last run and records
+     *    the manifest (`output/`).
+     *
+     * Every warning is logged as it arises, and counted.
+     *
+     * @returns The files written, the configuration read and how many warnings
+     * the run logged.
+     * @throws GeneratorError when the document or the configuration cannot be
+     * read or understood, the document describes code that cannot compile, or
+     * the output cannot be written. A configuration is only optional at
+     * `DEFAULT_CONFIG_PATH`; one the caller named has to exist.
+     *
+     * @example
+     * ```typescript
+     * await generator.generate();
+     * ```
+     */
+    generate(): Promise<GenerationResult>;
+}

package/dist/pipeline/codeGenerator.d.ts

@@ -0,0 +1,61 @@
+import { GenerationResult, GeneratorOptions } from '../api/options.js';
+/**
+ * Main code generator class that orchestrates the generation of TypeScript code from OpenAPI specifications.
+ * This class handles the entire code generation process, including parsing OpenAPI specs,
+ * resolving aggregates, generating models and clients, and formatting the output.
+ *
+ * @example
+ * ```typescript
+ * const generator = new CodeGenerator({
+ *   inputPath: './openapi.yaml',
+ *   outputDir: './generated',
+ *   tsConfigFilePath: './tsconfig.json',
+ *   logger: new ConsoleLogger({ level: 'verbose' }),
+ * });
+ * const { files } = await generator.generate();
+ * ```
+ */
+export declare class CodeGenerator {
+    private readonly options;
+    private readonly project;
+    private readonly logger;
+    private readonly signal?;
+    /** The output of the last run, whose files the next run starts without. */
+    private output?;
+    /**
+     * Creates a new CodeGenerator instance with the specified options.
+     *
+     * @param options - Input, output, configuration and logging of the run.
+     * @throws GeneratorError of kind `configuration` if the TypeScript
+     * configuration cannot be read.
+     */
+    constructor(options: GeneratorOptions);
+    /**
+     * Generates TypeScript code from the OpenAPI specification:
+     *
+     * 1. reads the generator configuration, then the document, which it checks
+     *    for dangling references;
+     * 2. reads the document's Wow model: bounded contexts and aggregates;
+     * 3. decides what the document generates (`analysis/`);
+     * 4. writes every module once (`emitters/`), then the index files;
+     * 5. formats, organises and types the imports, and checks the output
+     *    compiles (`finalize/`);
+     * 6. writes the files, removes the stale ones of the last run and records
+     *    the manifest (`output/`).
+     *
+     * Every warning is logged as it arises, and counted.
+     *
+     * @returns The files written, the configuration read and how many warnings
+     * the run logged.
+     * @throws GeneratorError when the document or the configuration cannot be
+     * read or understood, the document describes code that cannot compile, or
+     * the output cannot be written. A configuration is only optional at
+     * `DEFAULT_CONFIG_PATH`; one the caller named has to exist.
+     *
+     * @example
+     * ```typescript
+     * await generator.generate();
+     * ```
+     */
+    generate(): Promise<GenerationResult>;
+}

package/dist/pipeline/seams.d.cts

@@ -0,0 +1,29 @@
+import { Project } from 'ts-morph';
+import { GeneratorOptions } from '../api/options.cjs';
+/**
+ * Test seam: an option under this key hands a generator the ts-morph project
+ * to write into, such as an in-memory one, instead of one it reads from
+ * `tsConfigFilePath`. A symbol the package does not export, so it is no part
+ * of the public options. It lives apart from `CodeGenerator`, whose
+ * declaration therefore names neither it nor ts-morph, whose major version it
+ * would follow.
+ */
+export declare const PROJECT_SEAM: unique symbol;
+/**
+ * The CLI's seam: an option under this key stops a run when it aborts, as
+ * Ctrl-C does. A run stops at its next step; once it writes, it finishes
+ * writing its files and then stops without removing anything or recording
+ * the files in the manifest.
+ */
+export declare const SIGNAL_SEAM: unique symbol;
+/**
+ * What the package itself may hand a generator beyond its public options,
+ * each under a symbol it does not export.
+ */
+export interface Seams {
+    readonly [PROJECT_SEAM]?: Project;
+    readonly [SIGNAL_SEAM]?: AbortSignal;
+}
+/** The options, with the {@link Seams} the package may add. */
+export interface SeamOptions extends GeneratorOptions, Seams {
+}

package/dist/pipeline/seams.d.ts

@@ -0,0 +1,29 @@
+import { Project } from 'ts-morph';
+import { GeneratorOptions } from '../api/options.js';
+/**
+ * Test seam: an option under this key hands a generator the ts-morph project
+ * to write into, such as an in-memory one, instead of one it reads from
+ * `tsConfigFilePath`. A symbol the package does not export, so it is no part
+ * of the public options. It lives apart from `CodeGenerator`, whose
+ * declaration therefore names neither it nor ts-morph, whose major version it
+ * would follow.
+ */
+export declare const PROJECT_SEAM: unique symbol;
+/**
+ * The CLI's seam: an option under this key stops a run when it aborts, as
+ * Ctrl-C does. A run stops at its next step; once it writes, it finishes
+ * writing its files and then stops without removing anything or recording
+ * the files in the manifest.
+ */
+export declare const SIGNAL_SEAM: unique symbol;
+/**
+ * What the package itself may hand a generator beyond its public options,
+ * each under a symbol it does not export.
+ */
+export interface Seams {
+    readonly [PROJECT_SEAM]?: Project;
+    readonly [SIGNAL_SEAM]?: AbortSignal;
+}
+/** The options, with the {@link Seams} the package may add. */
+export interface SeamOptions extends GeneratorOptions, Seams {
+}

package/dist/types/typeResolver.d.cts

@@ -0,0 +1,124 @@
+import { Components, Reference, Schema } from '@ahoo-wang/fetcher-openapi';
+import { ModelInfo } from '../naming/modelInfo.cjs';
+import { MapSchema } from '../openapi/schemas.cjs';
+/**
+ * Schema → TypeScript type expression, as pure functions.
+ *
+ * Every entry point takes a schema and a {@link TypeScope} - where the type
+ * is written - and returns a {@link ResolvedType}: the type's text, and the
+ * imports the module needs for it. Nothing is written; the caller applies the
+ * imports to its module (`ImportRegistry.apply`) before it resolves the next
+ * type, so a later reference sees the names and aliases an earlier one took.
+ */
+/** An import a resolved type needs: a name, and the alias it goes by. */
+export interface ImportRequest {
+    readonly moduleSpecifier: string;
+    readonly name: string;
+    readonly alias?: string;
+}
+/** A type expression, and the imports it needs. */
+export interface ResolvedType {
+    readonly text: string;
+    readonly imports: readonly ImportRequest[];
+}
+/** The imports a module already holds, as the resolver reads them. */
+export interface ImportLookup {
+    entries(): readonly ImportRequest[];
+}
+/**
+ * What stays the same for every type of one document: its components, how a
+ * component names its model, and the model names declared at each path.
+ */
+export interface TypeContext {
+    readonly components?: Components;
+    /** The model a reference names. */
+    modelOf(reference: Reference): ModelInfo;
+    /** The models declared at a path, with their `EnumText` companions. */
+    namesAt(path: string): readonly string[];
+}
+/**
+ * How a document's component keys name models: `resolveModelInfo` and
+ * `resolveReferenceModelInfo` of `analysis/modelInfo.ts`.
+ */
+export interface ModelNaming {
+    ofKey(key: string): ModelInfo;
+    ofReference(reference: Reference, components?: Components): ModelInfo;
+}
+/**
+ * Builds the context of a document. The model names of each path are read
+ * once, on first use, rather than from every component for every reference.
+ */
+export declare function createTypeContext(components: Components | undefined, naming: ModelNaming): TypeContext;
+/** Where a type is written. */
+export interface TypeScope {
+    readonly context: TypeContext;
+    /**
+     * The declaration the type belongs to. An import never takes its name.
+     * With a `path`, it is a model: the models of that path are declared beside
+     * it, so a reference to one needs no import, and an import takes none of
+     * their names. Without, every referenced model is imported.
+     */
+    readonly owner: {
+        readonly name: string;
+        readonly path?: string;
+    };
+    /** The specifier the module imports a model by. */
+    specifierOf(model: ModelInfo): string;
+    /** The imports the module holds. */
+    readonly imports: ImportLookup;
+}
+/**
+ * Global names generated code relies on. A model imported under one of these
+ * names would shadow the global, so the import is aliased instead: a model
+ * named `Response` must not turn `Promise<Response>` into a promise of the
+ * model.
+ */
+export declare const GLOBAL_TYPE_NAMES: readonly string[];
+/**
+ * Chooses the intersection representation over an interface with an index
+ * signature.
+ *
+ * An interface may only carry a named property whose type is assignable to
+ * its index signature (TS2411). Every generated property is required, so
+ * only a clash that can be PROVEN off the schemas moves one - see
+ * {@link clashesWithIndexSignature}. Anything undecided keeps the interface,
+ * which is the only form that can reference itself through an index
+ * signature: an alias reaching itself through `Record` is circular (TS2456),
+ * which is what a dictionary of its own type would generate.
+ *
+ * @param schema - The object schema to represent
+ * @param components - The components a reference resolves against
+ * @returns True when the schema needs the intersection form
+ */
+export declare function requiresAdditionalPropertiesIntersection(schema: Schema, components?: Components): boolean;
+/**
+ * Renders a JSON value as a TypeScript literal type: a string in single
+ * quotes, escaped as ts-morph's printer escapes it, an array as a tuple, an
+ * object as an object type that no array matches.
+ *
+ * @param value - The value from the document
+ * @returns The literal type
+ */
+export declare function resolveLiteral(value: unknown): string;
+/**
+ * The type a schema generates.
+ *
+ * @param schema - The schema, or a reference to a component
+ * @param scope - Where the type is written
+ * @returns The type expression and the imports it needs
+ */
+export declare function resolveType(schema: Schema | Reference, scope: TypeScope): ResolvedType;
+/**
+ * The index signature an object schema's additional properties generate, as
+ * `[key: string]: T`, or `''` when it admits none beyond the ones it names.
+ */
+export declare function resolveAdditionalProperties(schema: Schema, scope: TypeScope): ResolvedType;
+/** The type of an object schema's additional properties; `any` when open. */
+export declare function resolveAdditionalPropertyType(schema: Schema, scope: TypeScope): ResolvedType;
+/**
+ * The type of a property an object schema requires without declaring it: its
+ * additional-property type, `never` when it admits none, else any JSON value.
+ */
+export declare function resolveRequiredAdditionalPropertyType(schema: Schema, scope: TypeScope): ResolvedType;
+/** The value type of a map schema; `any` when its values are open. */
+export declare function resolveMapValueType(schema: MapSchema, scope: TypeScope): ResolvedType;

package/dist/types/typeResolver.d.ts

@@ -0,0 +1,124 @@
+import { Components, Reference, Schema } from '@ahoo-wang/fetcher-openapi';
+import { ModelInfo } from '../naming/modelInfo.js';
+import { MapSchema } from '../openapi/schemas.js';
+/**
+ * Schema → TypeScript type expression, as pure functions.
+ *
+ * Every entry point takes a schema and a {@link TypeScope} - where the type
+ * is written - and returns a {@link ResolvedType}: the type's text, and the
+ * imports the module needs for it. Nothing is written; the caller applies the
+ * imports to its module (`ImportRegistry.apply`) before it resolves the next
+ * type, so a later reference sees the names and aliases an earlier one took.
+ */
+/** An import a resolved type needs: a name, and the alias it goes by. */
+export interface ImportRequest {
+    readonly moduleSpecifier: string;
+    readonly name: string;
+    readonly alias?: string;
+}
+/** A type expression, and the imports it needs. */
+export interface ResolvedType {
+    readonly text: string;
+    readonly imports: readonly ImportRequest[];
+}
+/** The imports a module already holds, as the resolver reads them. */
+export interface ImportLookup {
+    entries(): readonly ImportRequest[];
+}
+/**
+ * What stays the same for every type of one document: its components, how a
+ * component names its model, and the model names declared at each path.
+ */
+export interface TypeContext {
+    readonly components?: Components;
+    /** The model a reference names. */
+    modelOf(reference: Reference): ModelInfo;
+    /** The models declared at a path, with their `EnumText` companions. */
+    namesAt(path: string): readonly string[];
+}
+/**
+ * How a document's component keys name models: `resolveModelInfo` and
+ * `resolveReferenceModelInfo` of `analysis/modelInfo.ts`.
+ */
+export interface ModelNaming {
+    ofKey(key: string): ModelInfo;
+    ofReference(reference: Reference, components?: Components): ModelInfo;
+}
+/**
+ * Builds the context of a document. The model names of each path are read
+ * once, on first use, rather than from every component for every reference.
+ */
+export declare function createTypeContext(components: Components | undefined, naming: ModelNaming): TypeContext;
+/** Where a type is written. */
+export interface TypeScope {
+    readonly context: TypeContext;
+    /**
+     * The declaration the type belongs to. An import never takes its name.
+     * With a `path`, it is a model: the models of that path are declared beside
+     * it, so a reference to one needs no import, and an import takes none of
+     * their names. Without, every referenced model is imported.
+     */
+    readonly owner: {
+        readonly name: string;
+        readonly path?: string;
+    };
+    /** The specifier the module imports a model by. */
+    specifierOf(model: ModelInfo): string;
+    /** The imports the module holds. */
+    readonly imports: ImportLookup;
+}
+/**
+ * Global names generated code relies on. A model imported under one of these
+ * names would shadow the global, so the import is aliased instead: a model
+ * named `Response` must not turn `Promise<Response>` into a promise of the
+ * model.
+ */
+export declare const GLOBAL_TYPE_NAMES: readonly string[];
+/**
+ * Chooses the intersection representation over an interface with an index
+ * signature.
+ *
+ * An interface may only carry a named property whose type is assignable to
+ * its index signature (TS2411). Every generated property is required, so
+ * only a clash that can be PROVEN off the schemas moves one - see
+ * {@link clashesWithIndexSignature}. Anything undecided keeps the interface,
+ * which is the only form that can reference itself through an index
+ * signature: an alias reaching itself through `Record` is circular (TS2456),
+ * which is what a dictionary of its own type would generate.
+ *
+ * @param schema - The object schema to represent
+ * @param components - The components a reference resolves against
+ * @returns True when the schema needs the intersection form
+ */
+export declare function requiresAdditionalPropertiesIntersection(schema: Schema, components?: Components): boolean;
+/**
+ * Renders a JSON value as a TypeScript literal type: a string in single
+ * quotes, escaped as ts-morph's printer escapes it, an array as a tuple, an
+ * object as an object type that no array matches.
+ *
+ * @param value - The value from the document
+ * @returns The literal type
+ */
+export declare function resolveLiteral(value: unknown): string;
+/**
+ * The type a schema generates.
+ *
+ * @param schema - The schema, or a reference to a component
+ * @param scope - Where the type is written
+ * @returns The type expression and the imports it needs
+ */
+export declare function resolveType(schema: Schema | Reference, scope: TypeScope): ResolvedType;
+/**
+ * The index signature an object schema's additional properties generate, as
+ * `[key: string]: T`, or `''` when it admits none beyond the ones it names.
+ */
+export declare function resolveAdditionalProperties(schema: Schema, scope: TypeScope): ResolvedType;
+/** The type of an object schema's additional properties; `any` when open. */
+export declare function resolveAdditionalPropertyType(schema: Schema, scope: TypeScope): ResolvedType;
+/**
+ * The type of a property an object schema requires without declaring it: its
+ * additional-property type, `never` when it admits none, else any JSON value.
+ */
+export declare function resolveRequiredAdditionalPropertyType(schema: Schema, scope: TypeScope): ResolvedType;
+/** The value type of a map schema; `any` when its values are open. */
+export declare function resolveMapValueType(schema: MapSchema, scope: TypeScope): ResolvedType;

package/dist/version.d.cts

@@ -0,0 +1,2 @@
+/** The version of this package, as its package.json named it at build time. */
+export declare const VERSION: string;

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+/** The version of this package, as its package.json named it at build time. */
+export declare const VERSION: string;

package/dist/wow/conventions.d.cts

@@ -0,0 +1,154 @@
+import { OpenAPI, Tag } from '@ahoo-wang/fetcher-openapi';
+import { AggregateDefinition, TagAliasAggregate } from './model.cjs';
+/** The oldest Wow server whose OpenAPI metadata the generator reads fully. */
+export declare const MINIMUM_WOW_VERSION = "8.10";
+/** The `info` extension naming the bounded context the document serves. */
+export declare const CONTEXT_ALIAS_EXTENSION = "x-wow-context-alias";
+/** The bounded context a document names, if it is a Wow service's. */
+export declare function contextAliasOf(openAPI: OpenAPI): string | undefined;
+/**
+ * Reads an aggregate off a tag named `<contextAlias>.<aggregateName>`.
+ *
+ * @param tagName - The tag name
+ * @returns `[contextAlias, aggregateName]`, or null when the tag names no aggregate
+ */
+export declare function isAliasAggregate(tagName: string): [string, string] | null;
+/**
+ * The aggregate a tag names, or null when it names none.
+ *
+ * @param tag - The tag
+ */
+export declare function tagToAggregate(tag: Tag): TagAliasAggregate | null;
+/**
+ * The command an operation sends, read off its id
+ * `<contextAlias>.<aggregateName>.<command>`.
+ *
+ * @param operationId - The operation id
+ * @returns The command name, or null when the id has another shape
+ */
+export declare function operationIdToCommandName(operationId?: string): string | null;
+/** The operation that sends any command; it belongs to no aggregate. */
+export declare const SEND_COMMAND_OPERATION_ID = "wow.command.send";
+/** The response every command operation answers with. */
+export declare const COMMAND_OK_RESPONSE_REF = "#/components/responses/wow.CommandOk";
+/** The operation id suffix of the operation that loads an aggregate's state. */
+export declare const STATE_OPERATION_SUFFIX = ".snapshot_state.single";
+/** The operation id suffix of the operation that lists an aggregate's events. */
+export declare const EVENTS_OPERATION_SUFFIX = ".event.list_query";
+/** The operation id suffix of the operation that counts snapshots by a condition. */
+export declare const FIELDS_OPERATION_SUFFIX = ".snapshot.count";
+/** The request body extension naming an aggregate's query fields (Wow 8.11.1+). */
+export declare const QUERY_FIELDS_EXTENSION = "x-wow-query-fields";
+/**
+ * The route segment of an aggregate, read off one of its snapshot routes:
+ * `/tenant/{tenantId}/owner/{ownerId}/sales-order/snapshot/count` →
+ * `sales-order`. It differs from the aggregate name when the aggregate sets
+ * a resource name (`@AggregateRoute(resourceName = "sales-order")`).
+ */
+export declare const SNAPSHOT_ROUTE: RegExp;
+/**
+ * The suffixes of the types Wow derives from an aggregate's state; the
+ * wow-client generics stand for them, so they generate no model.
+ */
+export declare const AGGREGATED_SCHEMA_SUFFIXES: readonly string[];
+/**
+ * The names of the types Wow derives from an aggregate's state model.
+ *
+ * @param stateName - The name of the state model
+ */
+export declare function aggregatedTypeNames(stateName: string): string[];
+/**
+ * Tells whether a schema is Wow's own, which wow-client already declares, so
+ * it generates no model: every `wow.` schema but the paged lists and operator
+ * maps of the query API, the aggregated query and event stream types, and
+ * the types derived from an aggregate's state.
+ *
+ * @param schemaKey - The schema's component key
+ * @param modelName - The name of the model the schema would generate, read
+ *   only when the key alone does not decide
+ * @param aggregatedNames - The names of the types derived from the aggregates' states
+ */
+export declare function isWowSchema(schemaKey: string, modelName: () => string, aggregatedNames: ReadonlySet<string>): boolean;
+/** Import path for the WOW framework types */
+export declare const IMPORT_WOW_PATH = "@ahoo-wang/wow-client";
+/**
+ * Import path for the deprecated Condition query model, which
+ * `@ahoo-wang/wow-client` keeps on its `/legacy` subpath for Wow 8.10 servers.
+ */
+export declare const IMPORT_WOW_LEGACY_PATH = "@ahoo-wang/wow-client/legacy";
+/** The mapped type names that `IMPORT_WOW_LEGACY_PATH` exports. */
+export declare const WOW_LEGACY_TYPES: ReadonlySet<string>;
+/** Mapping of OpenAPI schema keys to WOW framework types */
+export declare const WOW_TYPE_MAPPING: {
+    'wow.command.CommandResult': string;
+    'wow.command.CommandResultArray': string;
+    'wow.MessageHeaderSqlType': string;
+    'wow.api.BindingError': string;
+    'wow.api.DefaultErrorInfo': string;
+    'wow.api.RecoverableType': string;
+    'wow.api.command.DefaultDeleteAggregate': string;
+    'wow.api.command.DefaultRecoverAggregate': string;
+    'wow.api.abac.DefaultApplyResourceTags': string;
+    'wow.api.messaging.FunctionInfoData': string;
+    'wow.api.messaging.FunctionKind': string;
+    'wow.api.modeling.AggregateId': string;
+    'wow.api.query.Condition': string;
+    'wow.api.query.ConditionOptions': string;
+    'wow.api.query.ListQuery': string;
+    'wow.api.query.Operator': string;
+    'wow.api.query.PagedQuery': string;
+    'wow.api.query.Pagination': string;
+    'wow.api.query.Projection': string;
+    'wow.api.query.Sort': string;
+    'wow.api.query.Sort.Direction': string;
+    'wow.api.query.DynamicDocument': string;
+    'wow.api.query.DynamicDocumentArray': string;
+    'wow.command.CommandStage': string;
+    'wow.command.SimpleWaitSignal': string;
+    'wow.configuration.Aggregate': string;
+    'wow.configuration.BoundedContext': string;
+    'wow.configuration.WowMetadata': string;
+    'wow.modeling.DomainEvent': string;
+    'wow.openapi.BatchResult': string;
+    'wow.messaging.CompensationTarget': string;
+};
+/**
+ * The wow-client type a schema maps to, and the module that exports it.
+ *
+ * @param schemaKey - The schema's component key
+ * @param properties - The schema's properties, if the caller has the schema:
+ * a ListQuery or PagedQuery that carries `filter` is the filter model's
+ * @returns The type, or undefined when the schema is not one of Wow's own
+ */
+export declare function wowTypeOf(schemaKey: string, properties?: Record<string, unknown>): {
+    name: string;
+    path: string;
+} | undefined;
+/**
+ * Tags whose operations generate no API client: Wow's own endpoints and
+ * Spring's actuator. The tags of aggregates are left out as well; their
+ * operations go to the command and query clients.
+ */
+export declare const IGNORED_API_CLIENT_TAGS: ReadonlySet<string>;
+/**
+ * The resource-attribution path parameters Wow's CoSec interceptor fills,
+ * which generated clients therefore leave out.
+ */
+export declare const RESOURCE_ATTRIBUTION_PATH_PARAMETERS: readonly string[];
+/** The route prefix of a tenant's resources (wow-client `ResourceAttributionPathSpec.TENANT`). */
+export declare const TENANT_PATH_PREFIX = "/tenant/{tenantId}";
+/** The route prefix of an owner's resources (wow-client `ResourceAttributionPathSpec.OWNER`). */
+export declare const OWNER_PATH_PREFIX = "/owner/{ownerId}";
+/**
+ * The resource attribution a query client of an aggregate uses, as the
+ * `ResourceAttributionPathSpec` member it generates: the prefix most of the
+ * aggregate's command routes start with, owner on a tie, none when no route
+ * starts with either.
+ *
+ * @example
+ * ```typescript
+ * // commands at /tenant/{tenantId}/users, /tenant/{tenantId}/orders and /owner/{ownerId}/profile
+ * inferPathSpecType(aggregate); // 'ResourceAttributionPathSpec.TENANT'
+ * ```
+ */
+export declare function inferPathSpecType(aggregateDefinition: Pick<AggregateDefinition, 'commands'>): string;