import type { 
  IFlowContainer, 
  IFlowServiceMetadata,
  FlowServiceFactory 
} from '@codechu/flow-core-container';

// Your container implementation
class MyContainer implements IFlowContainer {
  register<T>(
    token: string | symbol,
    factory: FlowServiceFactory<T>,
    metadata?: Partial<IFlowServiceMetadata>
  ): void {
    // Implementation
  }
  
  async resolve<T>(token: string | symbol): Promise<T> {
    // Implementation
  }
  
  has(token: string | symbol): boolean {
    // Implementation
  }
  
  createScope(): IFlowContainer {
    // Implementation
  }
  
  getTokens(): ReadonlyArray<string | symbol> {
    // Implementation
  }
}

import type { IFlowServiceProvider } from '@codechu/flow-core-container';

class LazyProvider<T> implements IFlowServiceProvider<T> {
  readonly token: string | symbol;
  
  async get(): Promise<T> {
    // Lazy resolution
  }
  
  getSync(): T | undefined {
    // Synchronous access if resolved
  }
  
  isResolved(): boolean {
    // Check resolution status
  }
}

import type { 
  IFlowContainerBuilder,
  IFlowContainerModule 
} from '@codechu/flow-core-container';

const container = builder
  .singleton('Logger', async () => new ConsoleLogger())
  .transient('Request', async () => new Request())
  .scoped('Session', async () => new Session())
  .useModule(new DatabaseModule())
  .useModule(new CacheModule())
  .build();

import type { IFlowInjectable } from '@codechu/flow-core-container';

class UserService implements IFlowInjectable<IUserService> {
  readonly token = 'UserService';
  readonly dependencies = ['Database', 'Logger'];
  readonly optional = ['Cache'];
  
  async create(deps: Record<string | symbol, unknown>): Promise<IUserService> {
    return new UserServiceImpl(
      deps['Database'] as IDatabase,
      deps['Logger'] as ILogger,
      deps['Cache'] as ICache | undefined
    );
  }
}

import type { IFlowServiceResolver } from '@codechu/flow-core-container';

const resolver: IFlowServiceResolver = getResolver();

const result = await resolver.resolveWithCircularCheck('ServiceA', ['ServiceB', 'ServiceC']);
if (!result.success) {
  console.error('Circular dependency detected:', result.error.message);
}

import type { IFlowDisposable, IFlowAsyncDisposable } from '@codechu/flow-core-container';

// Standard disposal
class DatabaseConnection implements IFlowDisposable {
  isDisposed = false;
  
  async dispose(): Promise<void> {
    await this.closeConnection();
    this.isDisposed = true;
  }
}

// Modern async disposal
class ResourceManager implements IFlowAsyncDisposable {
  isDisposed = false;
  
  async [Symbol.asyncDispose](): Promise<void> {
    await this.cleanup();
    this.isDisposed = true;
  }
}

// Usage with using statement (TC39 proposal)
{
  await using resource = new ResourceManager();
  // Resource automatically disposed when scope ends
}

import type { ServiceToken, InferServiceType } from '@codechu/flow-core-container';

// Strongly typed tokens
const LoggerToken: ServiceToken<ILogger> = Symbol('Logger');
type LoggerType = InferServiceType<typeof LoggerToken>; // ILogger

// Use with container
const logger = await container.resolve<LoggerType>(LoggerToken);