// Template's index.ts
StartTemplateWithLambda(async (i, d) => {
  // Collect user input
  const projectName = await i.text('Project name?', 'project.name', 'Enter name');
  const features = await i.checkbox('Features?', ['auth', 'api'], 'project.features', 'Select');
  const format = await i.select('Format?', ['json', 'yaml'], 'config.format', 'Choose');

  return {
    processors: [{
      name: 'myorg/my-processor',
      files: [{ root: 'templates', glob: '**/*', exclude: [], type: GlobType.Template }],
      config: {
        // This becomes input.config in processor
        projectName,
        features,
        outputFormat: format,
        additionalSettings: {
          strict: true,
          minify: false
        }
      }
    }]
  };
});

# Template's index.py
def start_template_with_lambda(i, d):
    # Collect user input
    project_name = i.text('Project name?', 'project.name', 'Enter name')
    features = i.checkbox('Features?', ['auth', 'api'], 'project.features', 'Select')
    format = i.select('Format?', ['json', 'yaml'], 'config.format', 'Choose')

    return {
        'processors': [{
            'name': 'myorg/my-processor',
            'files': [{'root': 'templates', 'glob': '**/*', 'exclude': [], 'type': GlobType.Template}],
            'config': {
                # This becomes input.config in processor
                'projectName': project_name,
                'features': features,
                'outputFormat': format,
                'additionalSettings': {
                    'strict': True,
                    'minify': False
                }
            }
        }]
    }

// Template's Index.cs
[TemplateMain]
public async Task<TemplateResult> RunAsync(IInquirer i, TemplateContext d)
{
    // Collect user input
    var projectName = await i.TextAsync("Project name?", "project.name", "Enter name");
    var features = await i.CheckboxAsync("Features?", ["auth", "api"], "project.features", "Select");
    var format = await i.SelectAsync("Format?", ["json", "yaml"], "config.format", "Choose");

    return new TemplateResult
    {
        Processors = new[]
        {
            new ProcessorConfig
            {
                Name = "myorg/my-processor",
                Files = new[] { new FileGlob { Root = "templates", Glob = "**/*", Exclude = Array.Empty<string>(), Type = GlobType.Template } },
                Config = new
                {
                    // This becomes input.config in processor
                    ProjectName = projectName,
                    Features = features,
                    OutputFormat = format,
                    AdditionalSettings = new
                    {
                        Strict = true,
                        Minify = false
                    }
                }
            }
        }
    };
}

// Processor's index.ts

// Define expected config shape
interface MyProcessorConfig {
  projectName: string;
  features: string[];
  outputFormat: 'json' | 'yaml';
  additionalSettings?: {
    strict?: boolean;
    minify?: boolean;
  };
}

StartProcessorWithLambda(async (input, fileHelper) => {
  // Cast to your type
  const config = input.config as MyProcessorConfig;

  // Use config values
  console.log('Project:', config.projectName);
  console.log('Features:', config.features);

  const files = fileHelper.resolveAll();

  files.forEach(file => {
    if (config.features.includes('auth')) {
      file.content = addAuthCode(file.content);
    }

    file.writeFile();
  });

  return { directory: input.writeDir };
});

# Processor's index.py
from dataclasses import dataclass
from typing import Optional, List

@dataclass
class AdditionalSettings:
    strict: Optional[bool] = None
    minify: Optional[bool] = None

@dataclass
class MyProcessorConfig:
    project_name: str
    features: List[str]
    output_format: str  # 'json' | 'yaml'
    additional_settings: Optional[AdditionalSettings] = None

def start_processor_with_fn(input, file_helper):
    # Cast to your type
    config = MyProcessorConfig(**input.config)

    # Use config values
    print('Project:', config.project_name)
    print('Features:', config.features)

    files = file_helper.resolve_all()

    for file in files:
        if 'auth' in config.features:
            file.content = add_auth_code(file.content)

        file.write_file()

    return {'directory': input.write_dir}

// Processor's Index.cs

// Define expected config shape
public class MyProcessorConfig
{
    public string ProjectName { get; set; }
    public List<string> Features { get; set; }
    public string OutputFormat { get; set; }  // "json" | "yaml"
    public AdditionalSettings? AdditionalSettings { get; set; }
}

public class AdditionalSettings
{
    public bool? Strict { get; set; }
    public bool? Minify { get; set; }
}

[ProcessorMain]
public async Task<ProcessorResult> RunAsync(ProcessorInput input, CyanFileHelper fileHelper)
{
    // Cast to your type
    var config = input.Config as MyProcessorConfig;

    // Use config values
    Console.WriteLine($"Project: {config.ProjectName}");
    Console.WriteLine($"Features: {string.Join(", ", config.Features)}");

    var files = fileHelper.ResolveAll();

    foreach (var file in files)
    {
        if (config.Features.Contains("auth"))
        {
            file.Content = AddAuthCode(file.Content);
        }

        file.WriteFile();
    }

    return new ProcessorResult { Directory = input.WriteDir };
}