@skmtc/core 0.0.785 → 0.0.787

package/script/dsl/Import.d.ts

@@ -1,21 +1,242 @@
+/**
+ * Constructor arguments for {@link Import}.
+ */
 type ConstructorArgs = {
+    /** The module path to import from */
     module: string;
+    /** Array of import names (can be strings or alias objects) */
     importNames: ImportNameArg[];
 };
+/**
+ * Represents a TypeScript import statement in the SKMTC DSL system.
+ *
+ * The `Import` class generates properly formatted import statements for TypeScript
+ * files, handling named imports with optional aliases. It's used throughout the
+ * code generation pipeline to manage module dependencies.
+ *
+ * This class supports both simple string imports and aliased imports, making it
+ * easy to avoid naming conflicts and provide cleaner import statements.
+ *
+ * @example Basic named imports
+ * ```typescript
+ * import { Import } from '@skmtc/core';
+ *
+ * const basicImport = new Import({
+ *   module: './types',
+ *   importNames: ['User', 'Product', 'Order']
+ * });
+ *
+ * console.log(basicImport.toString());
+ * // import { User, Product, Order } from './types'
+ * ```
+ *
+ * @example Imports with aliases
+ * ```typescript
+ * const aliasedImport = new Import({
+ *   module: 'react',
+ *   importNames: [
+ *     'useState',
+ *     'useEffect',
+ *     { 'default': 'React' } // Import default as React
+ *   ]
+ * });
+ *
+ * console.log(aliasedImport.toString());
+ * // import { useState, useEffect, default as React } from 'react'
+ * ```
+ *
+ * @example Mixed imports
+ * ```typescript
+ * const mixedImport = new Import({
+ *   module: './api/client',
+ *   importNames: [
+ *     'ApiClient',
+ *     { 'RequestOptions': 'Options' }, // Alias to avoid conflicts
+ *     'ResponseType'
+ *   ]
+ * });
+ *
+ * console.log(mixedImport.toString());
+ * // import { ApiClient, RequestOptions as Options, ResponseType } from './api/client'
+ * ```
+ *
+ * @example Using in File generation
+ * ```typescript
+ * import { File, Import } from '@skmtc/core';
+ *
+ * const file = new File({ path: './generated.ts', settings: undefined });
+ *
+ * // Add import to file
+ * file.imports.set('./types', new Set(['User', 'Product']));
+ *
+ * // Or create Import directly for more control
+ * const customImport = new Import({
+ *   module: './helpers',
+ *   importNames: [{ 'validateEmail': 'emailValidator' }]
+ * });
+ * ```
+ */
 export declare class Import {
+    /** The module path to import from */
     module: string;
+    /** Array of parsed import names with potential aliases */
     importNames: ImportName[];
+    /**
+     * Creates a new Import instance.
+     *
+     * @param args - Import configuration
+     * @param args.module - The module path to import from (e.g., './types', 'react')
+     * @param args.importNames - Array of import names, can be strings or alias objects
+     *
+     * @example
+     * ```typescript
+     * const importStatement = new Import({
+     *   module: './models/User',
+     *   importNames: [
+     *     'User',                           // Simple import
+     *     { 'UserType': 'IUser' },         // Aliased import
+     *     'createUser'                     // Another simple import
+     *   ]
+     * });
+     * ```
+     */
     constructor({ module, importNames }: ConstructorArgs);
+    /**
+     * Converts the import to a record format.
+     *
+     * This method creates a record representation where the module path is the key
+     * and the import names are the value. Useful for serialization or when working
+     * with import maps.
+     *
+     * @returns A record with module as key and import names as value
+     *
+     * @example
+     * ```typescript
+     * const importStatement = new Import({
+     *   module: './types',
+     *   importNames: ['User', { 'Product': 'IProduct' }]
+     * });
+     *
+     * const record = importStatement.toRecord();
+     * console.log(record);
+     * // {
+     * //   './types': ['User', { 'Product': 'IProduct' }]
+     * // }
+     * ```
+     */
     toRecord(): Record<string, ImportNameArg[]>;
+    /**
+     * Generates the TypeScript import statement string.
+     *
+     * This method produces a properly formatted ES6 import statement that can be
+     * written directly to a TypeScript file. It handles both simple and aliased
+     * imports correctly.
+     *
+     * @returns The formatted import statement string
+     *
+     * @example
+     * ```typescript
+     * const basicImport = new Import({
+     *   module: './utils',
+     *   importNames: ['formatDate', 'parseJson']
+     * });
+     *
+     * console.log(basicImport.toString());
+     * // import { formatDate, parseJson } from './utils'
+     *
+     * const aliasedImport = new Import({
+     *   module: 'lodash',
+     *   importNames: [{ 'isEqual': 'deepEqual' }, 'cloneDeep']
+     * });
+     *
+     * console.log(aliasedImport.toString());
+     * // import { isEqual as deepEqual, cloneDeep } from 'lodash'
+     * ```
+     *
+     * @todo Move syntax to typescript package to enable language-agnostic use
+     */
     toString(): string;
 }
+/**
+ * Argument type for import names - can be a simple string or an alias object.
+ *
+ * @example String import
+ * ```typescript
+ * const simpleImport: ImportNameArg = 'User';
+ * ```
+ *
+ * @example Aliased import
+ * ```typescript
+ * const aliasedImport: ImportNameArg = { 'User': 'IUser' };
+ * // This creates: User as IUser
+ * ```
+ */
 export type ImportNameArg = string | {
     [name: string]: string;
 };
+/**
+ * Represents a single import name with optional aliasing.
+ *
+ * This class handles the parsing and formatting of individual import specifiers,
+ * supporting both simple imports and aliased imports. It's used internally by
+ * the {@link Import} class to manage import statement components.
+ *
+ * @example Simple import name
+ * ```typescript
+ * const simple = new ImportName('useState');
+ * console.log(simple.toString()); // 'useState'
+ * ```
+ *
+ * @example Aliased import name
+ * ```typescript
+ * const aliased = new ImportName({ 'React': 'ReactLib' });
+ * console.log(aliased.toString()); // 'React as ReactLib'
+ * ```
+ */
 export declare class ImportName {
+    /** The original name being imported */
     name: string;
+    /** The alias to use (if any) */
     alias?: string;
+    /**
+     * Creates a new ImportName instance.
+     *
+     * @param name - Either a string for simple imports or an object for aliased imports
+     *
+     * @example Simple import
+     * ```typescript
+     * const importName = new ImportName('User');
+     * // Results in: User
+     * ```
+     *
+     * @example Aliased import
+     * ```typescript
+     * const importName = new ImportName({ 'UserInterface': 'IUser' });
+     * // Results in: UserInterface as IUser
+     * ```
+     */
     constructor(name: ImportNameArg);
+    /**
+     * Generates the string representation of the import name.
+     *
+     * This method creates the appropriate import specifier syntax,
+     * either a simple name or an aliased import using TypeScript's
+     * 'as' keyword.
+     *
+     * @returns The formatted import specifier string
+     *
+     * @example Simple import
+     * ```typescript
+     * const simple = new ImportName('useState');
+     * console.log(simple.toString()); // 'useState'
+     * ```
+     *
+     * @example Aliased import
+     * ```typescript
+     * const aliased = new ImportName({ 'Component': 'ReactComponent' });
+     * console.log(aliased.toString()); // 'Component as ReactComponent'
+     * ```
+     */
     toString(): string;
 }
 export {};

package/script/dsl/Import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Import.d.ts","sourceRoot":"","sources":["../../src/dsl/Import.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,aAAa,EAAE,CAAA;CAC7B,CAAA;AAED,qBAAa,MAAM;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,UAAU,EAAE,CAAA;gBAEb,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,eAAe;IAKpD,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,aAAa,EAAE,CAAC;IAQ3C,QAAQ,IAAI,MAAM;CAKnB;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAA;AAE/D,qBAAa,UAAU;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;gBAEF,IAAI,EAAE,aAAa;IAW/B,QAAQ,IAAI,MAAM;CAGnB"}
+{"version":3,"file":"Import.d.ts","sourceRoot":"","sources":["../../src/dsl/Import.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,KAAK,eAAe,GAAG;IACrB,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAA;IACd,8DAA8D;IAC9D,WAAW,EAAE,aAAa,EAAE,CAAA;CAC7B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,qBAAa,MAAM;IACjB,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAA;IAEd,0DAA0D;IAC1D,WAAW,EAAE,UAAU,EAAE,CAAA;IAEzB;;;;;;;;;;;;;;;;;;OAkBG;gBACS,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,eAAe;IAKpD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,aAAa,EAAE,CAAC;IAQ3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,QAAQ,IAAI,MAAM;CAKnB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAA;AAE/D;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,UAAU;IACrB,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAA;IAEZ,gCAAgC;IAChC,KAAK,CAAC,EAAE,MAAM,CAAA;IAEd;;;;;;;;;;;;;;;;OAgBG;gBACS,IAAI,EAAE,aAAa;IAW/B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,IAAI,MAAM;CAGnB"}

package/script/dsl/Import.js

@@ -1,14 +1,104 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImportName = exports.Import = void 0;
+/**
+ * Represents a TypeScript import statement in the SKMTC DSL system.
+ *
+ * The `Import` class generates properly formatted import statements for TypeScript
+ * files, handling named imports with optional aliases. It's used throughout the
+ * code generation pipeline to manage module dependencies.
+ *
+ * This class supports both simple string imports and aliased imports, making it
+ * easy to avoid naming conflicts and provide cleaner import statements.
+ *
+ * @example Basic named imports
+ * ```typescript
+ * import { Import } from '@skmtc/core';
+ *
+ * const basicImport = new Import({
+ *   module: './types',
+ *   importNames: ['User', 'Product', 'Order']
+ * });
+ *
+ * console.log(basicImport.toString());
+ * // import { User, Product, Order } from './types'
+ * ```
+ *
+ * @example Imports with aliases
+ * ```typescript
+ * const aliasedImport = new Import({
+ *   module: 'react',
+ *   importNames: [
+ *     'useState',
+ *     'useEffect',
+ *     { 'default': 'React' } // Import default as React
+ *   ]
+ * });
+ *
+ * console.log(aliasedImport.toString());
+ * // import { useState, useEffect, default as React } from 'react'
+ * ```
+ *
+ * @example Mixed imports
+ * ```typescript
+ * const mixedImport = new Import({
+ *   module: './api/client',
+ *   importNames: [
+ *     'ApiClient',
+ *     { 'RequestOptions': 'Options' }, // Alias to avoid conflicts
+ *     'ResponseType'
+ *   ]
+ * });
+ *
+ * console.log(mixedImport.toString());
+ * // import { ApiClient, RequestOptions as Options, ResponseType } from './api/client'
+ * ```
+ *
+ * @example Using in File generation
+ * ```typescript
+ * import { File, Import } from '@skmtc/core';
+ *
+ * const file = new File({ path: './generated.ts', settings: undefined });
+ *
+ * // Add import to file
+ * file.imports.set('./types', new Set(['User', 'Product']));
+ *
+ * // Or create Import directly for more control
+ * const customImport = new Import({
+ *   module: './helpers',
+ *   importNames: [{ 'validateEmail': 'emailValidator' }]
+ * });
+ * ```
+ */
 class Import {
+    /**
+     * Creates a new Import instance.
+     *
+     * @param args - Import configuration
+     * @param args.module - The module path to import from (e.g., './types', 'react')
+     * @param args.importNames - Array of import names, can be strings or alias objects
+     *
+     * @example
+     * ```typescript
+     * const importStatement = new Import({
+     *   module: './models/User',
+     *   importNames: [
+     *     'User',                           // Simple import
+     *     { 'UserType': 'IUser' },         // Aliased import
+     *     'createUser'                     // Another simple import
+     *   ]
+     * });
+     * ```
+     */
     constructor({ module, importNames }) {
+        /** The module path to import from */
         Object.defineProperty(this, "module", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /** Array of parsed import names with potential aliases */
         Object.defineProperty(this, "importNames", {
             enumerable: true,
             configurable: true,
@@ -18,11 +108,64 @@ class Import {
         this.module = module;
         this.importNames = importNames.map(importName => new ImportName(importName));
     }
+    /**
+     * Converts the import to a record format.
+     *
+     * This method creates a record representation where the module path is the key
+     * and the import names are the value. Useful for serialization or when working
+     * with import maps.
+     *
+     * @returns A record with module as key and import names as value
+     *
+     * @example
+     * ```typescript
+     * const importStatement = new Import({
+     *   module: './types',
+     *   importNames: ['User', { 'Product': 'IProduct' }]
+     * });
+     *
+     * const record = importStatement.toRecord();
+     * console.log(record);
+     * // {
+     * //   './types': ['User', { 'Product': 'IProduct' }]
+     * // }
+     * ```
+     */
     toRecord() {
         return {
             [this.module]: this.importNames.map(({ name, alias }) => alias ? { [name]: alias } : name)
         };
     }
+    /**
+     * Generates the TypeScript import statement string.
+     *
+     * This method produces a properly formatted ES6 import statement that can be
+     * written directly to a TypeScript file. It handles both simple and aliased
+     * imports correctly.
+     *
+     * @returns The formatted import statement string
+     *
+     * @example
+     * ```typescript
+     * const basicImport = new Import({
+     *   module: './utils',
+     *   importNames: ['formatDate', 'parseJson']
+     * });
+     *
+     * console.log(basicImport.toString());
+     * // import { formatDate, parseJson } from './utils'
+     *
+     * const aliasedImport = new Import({
+     *   module: 'lodash',
+     *   importNames: [{ 'isEqual': 'deepEqual' }, 'cloneDeep']
+     * });
+     *
+     * console.log(aliasedImport.toString());
+     * // import { isEqual as deepEqual, cloneDeep } from 'lodash'
+     * ```
+     *
+     * @todo Move syntax to typescript package to enable language-agnostic use
+     */
     toString() {
         // @TODO move syntax to typescript package to enable
         // language agnostic use
@@ -30,14 +173,52 @@ class Import {
     }
 }
 exports.Import = Import;
+/**
+ * Represents a single import name with optional aliasing.
+ *
+ * This class handles the parsing and formatting of individual import specifiers,
+ * supporting both simple imports and aliased imports. It's used internally by
+ * the {@link Import} class to manage import statement components.
+ *
+ * @example Simple import name
+ * ```typescript
+ * const simple = new ImportName('useState');
+ * console.log(simple.toString()); // 'useState'
+ * ```
+ *
+ * @example Aliased import name
+ * ```typescript
+ * const aliased = new ImportName({ 'React': 'ReactLib' });
+ * console.log(aliased.toString()); // 'React as ReactLib'
+ * ```
+ */
 class ImportName {
+    /**
+     * Creates a new ImportName instance.
+     *
+     * @param name - Either a string for simple imports or an object for aliased imports
+     *
+     * @example Simple import
+     * ```typescript
+     * const importName = new ImportName('User');
+     * // Results in: User
+     * ```
+     *
+     * @example Aliased import
+     * ```typescript
+     * const importName = new ImportName({ 'UserInterface': 'IUser' });
+     * // Results in: UserInterface as IUser
+     * ```
+     */
     constructor(name) {
+        /** The original name being imported */
         Object.defineProperty(this, "name", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /** The alias to use (if any) */
         Object.defineProperty(this, "alias", {
             enumerable: true,
             configurable: true,
@@ -53,6 +234,27 @@ class ImportName {
             this.alias = alias;
         }
     }
+    /**
+     * Generates the string representation of the import name.
+     *
+     * This method creates the appropriate import specifier syntax,
+     * either a simple name or an aliased import using TypeScript's
+     * 'as' keyword.
+     *
+     * @returns The formatted import specifier string
+     *
+     * @example Simple import
+     * ```typescript
+     * const simple = new ImportName('useState');
+     * console.log(simple.toString()); // 'useState'
+     * ```
+     *
+     * @example Aliased import
+     * ```typescript
+     * const aliased = new ImportName({ 'Component': 'ReactComponent' });
+     * console.log(aliased.toString()); // 'Component as ReactComponent'
+     * ```
+     */
     toString() {
         return this.alias ? `${this.name} as ${this.alias}` : this.name;
     }

package/script/dsl/operation/OperationBase.d.ts

@@ -199,10 +199,190 @@ export declare class OperationBase<EnrichmentType = undefined> extends ContentBa
      * ```
      */
     insertOperation<V extends GeneratedValue, EnrichmentType = undefined>(insertable: OperationInsertable<V, EnrichmentType>, operation: OasOperation, options?: Pick<InsertOperationOptions<'force'>, 'noExport'>): Inserted<V, 'force', EnrichmentType>;
+    /**
+     * Inserts a related model with forced generation.
+     *
+     * This method adds a model to the current generation context, typically used
+     * for request/response models or other types related to the operation. The model
+     * will be generated and can be referenced in the operation code.
+     *
+     * @template V - Type of generated value returned by the insertable
+     * @template EnrichmentType - Type of enrichment data for the insertable
+     * @param insertable - The model generator to insert
+     * @param refName - Reference name for the inserted model
+     * @param options - Insertion options
+     * @param options.noExport - Whether to skip exporting the inserted model
+     * @returns Inserted model reference with generated value
+     *
+     * @example Inserting request/response models
+     * ```typescript
+     * class ApiOperation extends OperationBase {
+     *   toDefinition(): Definition {
+     *     // Insert request model
+     *     const requestModel = this.insertModel(
+     *       new RequestModel({ ... }),
+     *       'CreateUserRequest'
+     *     );
+     *
+     *     // Insert response model
+     *     const responseModel = this.insertModel(
+     *       new ResponseModel({ ... }),
+     *       'CreateUserResponse'
+     *     );
+     *
+     *     return new Definition({
+     *       name: this.operation.operationId,
+     *       content: `async ${this.operation.operationId}(data: ${requestModel.value}): Promise<${responseModel.value}> {
+     *         return this.request('${this.operation.method}', '${this.operation.path}', data);
+     *       }`
+     *     });
+     *   }
+     * }
+     * ```
+     */
     insertModel<V extends GeneratedValue, EnrichmentType = undefined>(insertable: ModelInsertable<V, EnrichmentType>, refName: RefName, options?: Pick<InsertModelOptions<'force'>, 'noExport'>): Inserted<V, 'force', EnrichmentType>;
+    /**
+     * Inserts a related model with automatic schema normalization and reference resolution.
+     *
+     * This method intelligently handles schema references from operation request/response
+     * bodies, automatically resolving schema references to appropriate model names.
+     * This is particularly useful for operations with complex request/response schemas.
+     *
+     * @template V - Type of generated value returned by the insertable
+     * @template Schema - Type of OpenAPI schema (schema object, reference, or void)
+     * @template EnrichmentType - Type of enrichment data for the insertable
+     * @param insertable - The model generator to insert
+     * @param args - Schema normalization arguments
+     * @param args.schema - The OpenAPI schema to normalize (from request/response)
+     * @param args.fallbackName - Name to use if schema is not a reference
+     * @param options - Insertion options
+     * @param options.noExport - Whether to skip exporting the inserted model
+     * @returns Inserted model reference with normalized name and generated value
+     *
+     * @example Handling operation request/response schemas
+     * ```typescript
+     * class RestApiOperation extends OperationBase {
+     *   toDefinition(): Definition {
+     *     const operation = this.operation;
+     *
+     *     // Handle request body schema
+     *     let requestType = 'void';
+     *     const requestSchema = operation.requestBody?.content?.['application/json']?.schema;
+     *     if (requestSchema) {
+     *       const requestModel = this.insertNormalizedModel(
+     *         new TypeScriptInterface({ ... }),
+     *         {
+     *           schema: requestSchema,
+     *           fallbackName: `${operation.operationId}Request`
+     *         }
+     *       );
+     *       requestType = requestModel.value;
+     *     }
+     *
+     *     // Handle response schema
+     *     const responseSchema = operation.responses?.['200']?.content?.['application/json']?.schema;
+     *     const responseModel = this.insertNormalizedModel(
+     *       new TypeScriptInterface({ ... }),
+     *       {
+     *         schema: responseSchema,
+     *         fallbackName: `${operation.operationId}Response`
+     *       }
+     *     );
+     *
+     *     return new Definition({
+     *       name: operation.operationId,
+     *       content: `async ${operation.operationId}(data: ${requestType}): Promise<${responseModel.value}>`
+     *     });
+     *   }
+     * }
+     * ```
+     */
     insertNormalizedModel<V extends GeneratedValue, Schema extends OasSchema | OasRef<'schema'> | OasVoid, EnrichmentType = undefined>(insertable: ModelInsertable<V, EnrichmentType>, { schema, fallbackName }: Omit<InsertNormalisedModelArgs<Schema>, 'destinationPath'>, options?: Pick<InsertModelOptions<'force'>, 'noExport'>): InsertNormalisedModelReturn<V, Schema>;
-    /** @experimental */
+    /**
+     * Defines and registers a new definition in the generation context.
+     *
+     * This is an experimental method that allows creating and registering
+     * definitions directly without going through the standard insertion flow.
+     * Use with caution as the API may change in future versions.
+     *
+     * @experimental This method's API may change in future versions
+     * @template V - Type of generated value
+     * @param args - Definition arguments
+     * @param args.identifier - Unique identifier for the definition
+     * @param args.value - The generated value to associate with the definition
+     * @param args.noExport - Whether to skip exporting the definition
+     * @returns The created and registered definition
+     *
+     * @example Creating inline definitions
+     * ```typescript
+     * class InlineHelperOperation extends OperationBase {
+     *   toDefinition(): Definition {
+     *     // Create an inline helper function
+     *     const helper = this.defineAndRegister({
+     *       identifier: 'validateRequest',
+     *       value: 'function validateRequest(data: any) { ... }',
+     *       noExport: true
+     *     });
+     *
+     *     return new Definition({
+     *       name: this.operation.operationId,
+     *       content: `async ${this.operation.operationId}(data: any) {
+     *         ${helper.value}(data);
+     *         return this.request('${this.operation.method}', '${this.operation.path}', data);
+     *       }`
+     *     });
+     *   }
+     * }
+     * ```
+     */
     defineAndRegister<V extends GeneratedValue>({ identifier, value, noExport }: Omit<DefineAndRegisterArgs<V>, 'destinationPath'>): Definition<V>;
+    /**
+     * Registers a file-level artifact with the generation context.
+     *
+     * This method allows the operation generator to register additional content
+     * (like imports, exports, or file-level definitions) that should be included
+     * in the generated file. The registration is automatically scoped to this
+     * operation's export path.
+     *
+     * @param args - Registration arguments
+     * @param args.content - The content to register (import, export, etc.)
+     * @param args.phase - When to register the content ('pre' or 'post')
+     *
+     * @example Registering API client imports
+     * ```typescript
+     * class HttpOperation extends OperationBase {
+     *   toDefinition(): Definition {
+     *     // Register imports needed for HTTP operations
+     *     this.register({
+     *       content: "import { ApiClient } from './client';",
+     *       phase: 'pre'
+     *     });
+     *
+     *     this.register({
+     *       content: "import { RequestOptions } from './types';",
+     *       phase: 'pre'
+     *     });
+     *
+     *     return new Definition({ ... });
+     *   }
+     * }
+     * ```
+     *
+     * @example Registering utility exports
+     * ```typescript
+     * class ApiOperationGroup extends OperationBase {
+     *   toDefinition(): Definition {
+     *     // Register a utility export after all operations
+     *     this.register({
+     *       content: "export const API_VERSION = '1.0';",
+     *       phase: 'post'
+     *     });
+     *
+     *     return new Definition({ ... });
+     *   }
+     * }
+     * ```
+     */
     register(args: BaseRegisterArgs): void;
 }
 //# sourceMappingURL=OperationBase.d.ts.map