import type { GenerateContext } from '../../context/GenerateContext.js';
import type { OasOperation } from '../../oas/operation/Operation.js';
import type { Identifier } from '../Identifier.js';
import type { OperationInsertable, OperationInsertableArgs } from './types.js';
import * as v from 'valibot';
/**
 * Configuration for creating a base operation class.
 *
 * Defines the structure and behavior for operation generators, including
 * identifier generation, export path resolution, and enrichment schemas.
 *
 * @template EnrichmentType - Type of enrichments to apply to generated operations
 */
export type BaseOperationConfig<EnrichmentType = undefined> = {
    /** Unique identifier for the operation generator */
    id: string;
    /** Function to generate identifiers from operations */
    toIdentifier: (operation: OasOperation) => Identifier;
    /** Function to generate export paths from operations */
    toExportPath: (operation: OasOperation) => string;
    /** Optional function to provide enrichment validation schema */
    toEnrichmentSchema?: () => v.BaseSchema<EnrichmentType, EnrichmentType, v.BaseIssue<unknown>>;
};
type ToEnrichmentsArgs = {
    operation: OasOperation;
    context: GenerateContext;
};
/**
 * Creates a base operation class constructor for generating type-safe operation artifacts.
 *
 * This factory function creates a specialized OperationBase class that implements
 * the provided configuration for identifier generation, export paths, and
 * enrichment handling. The resulting class can be instantiated to generate
 * operation artifacts from OpenAPI operations.
 *
 * @template EnrichmentType - Type of enrichments to apply to generated operations
 * @param config - Configuration defining the operation generation behavior
 * @returns Constructor function for creating operation instances
 *
 * @example Creating a TypeScript function generator
 * ```typescript
 * import { toOperationBase } from '@skmtc/core';
 *
 * const TypeScriptOperationBase = toOperationBase({
 *   id: 'typescript-functions',
 *   toIdentifier: (operation) => new Identifier(camelCase(operation.operationId)),
 *   toExportPath: (operation) => `./operations/${kebabCase(operation.operationId)}.ts`,
 *   toEnrichmentSchema: () => v.object({
 *     includeValidation: v.optional(v.boolean()),
 *     asyncMode: v.optional(v.boolean())
 *   })
 * });
 *
 * class TypeScriptOperationGenerator extends TypeScriptOperationBase {
 *   generate() {
 *     const enrichments = this.enrichments;
 *     const functionCode = generateFunction(this.operation, {
 *       async: enrichments?.asyncMode ?? true
 *     });
 *     this.register({ file: this.createFile(functionCode) });
 *   }
 * }
 * ```
 *
 * @example Creating a React hook generator
 * ```typescript
 * const ReactHookOperationBase = toOperationBase({
 *   id: 'react-hooks',
 *   toIdentifier: (operation) => new Identifier(`use${pascalCase(operation.operationId)}`),
 *   toExportPath: (operation) => `./hooks/${kebabCase(operation.operationId)}.hook.ts`
 * });
 * ```
 */
export declare const toOperationBase: <EnrichmentType = undefined>(config: BaseOperationConfig<EnrichmentType>) => {
    new (args: OperationInsertableArgs<EnrichmentType>): {
        settings: import("../ContentSettings.js").ContentSettings<EnrichmentType>;
        operation: OasOperation;
        generatorKey: import("../../mod.js").GeneratorKey;
        insertOperation<V extends import("../../mod.js").GeneratedValue, EnrichmentType_1 = undefined>(insertable: OperationInsertable<V, EnrichmentType_1>, operation: OasOperation, options?: Pick<import("../../mod.js").InsertOperationOptions<"force">, "noExport">): import("../Inserted.js").Inserted<V, "force", EnrichmentType_1>;
        insertModel<V extends import("../../mod.js").GeneratedValue, EnrichmentType_2 = undefined>(insertable: import("../model/types.js").ModelInsertable<V, EnrichmentType_2>, refName: import("../../mod.js").RefName, options?: Pick<import("../../mod.js").InsertModelOptions<"force">, "noExport">): import("../Inserted.js").Inserted<V, "force", EnrichmentType_2>;
        insertNormalizedModel<V extends import("../../mod.js").GeneratedValue, Schema extends import("../../mod.js").OasSchema | import("../../mod.js").OasRef<"schema"> | import("../../mod.js").OasVoid, EnrichmentType_3 = undefined>(insertable: import("../model/types.js").ModelInsertable<V, EnrichmentType_3>, { schema, fallbackName }: Omit<import("../../mod.js").InsertNormalisedModelArgs<Schema>, "destinationPath">, options?: Pick<import("../../mod.js").InsertModelOptions<"force">, "noExport">): import("../../mod.js").InsertNormalisedModelReturn<V, Schema>;
        defineAndRegister<V extends import("../../mod.js").GeneratedValue>({ identifier, value, noExport }: Omit<import("../../mod.js").DefineAndRegisterArgs<V>, "destinationPath">): import("../Definition.js").Definition<V>;
        register(args: import("../../mod.js").BaseRegisterArgs): void;
        context: GenerateContext;
        skipped: boolean;
    };
    id: string;
    type: "operation";
    toIdentifier: (operation: OasOperation) => Identifier;
    toExportPath: (operation: OasOperation) => string;
    toEnrichments: ({ operation, context }: ToEnrichmentsArgs) => EnrichmentType;
};
export {};
//# sourceMappingURL=toOperationBase.d.ts.map