_lrm

#compdef lrm
# Zsh completion script for lrm (Localization Resource Manager)
#
# Installation:
#   1. Copy this file to a directory in your $fpath (e.g., /usr/share/zsh/site-functions/_lrm)
#   2. Or add the containing directory to your fpath in ~/.zshrc:
#      fpath=(~/.zsh/completions $fpath)
#   3. Run: compinit
#   4. Restart your shell or run: exec zsh

_lrm() {
    local -a commands
    commands=(
        'init:Initialize a new localization project'
        'convert:Convert resource files between formats'
        'validate:Validate resource files for missing keys, duplicates, and empty values'
        'stats:Display statistics about resource files and translation coverage'
        'view:View details of a specific localization key'
        'add:Add a new localization key to all language files'
        'update:Update values for an existing localization key'
        'delete:Delete a localization key from all language files'
        'merge-duplicates:Merge duplicate occurrences of a key into single entries'
        'export:Export resource files to CSV or JSON format'
        'import:Import translations from CSV format'
        'edit:Launch interactive TUI editor for resource files'
        'translate:Translate missing keys using AI translation providers'
        'scan:Scan source code for localization key references'
        'check:Run validation and scan together'
        'chain:Execute multiple commands sequentially in a single invocation'
        'list-languages:List all available language resource files'
        'add-language:Add a new language resource file'
        'remove-language:Remove a language resource file'
        'config:Manage LRM configuration and API keys'
        'backup:Backup management commands for resource files'
        'web:Start web server with REST API and Blazor UI'
        'cloud:Cloud synchronization commands'
    )

    local -a global_opts
    global_opts=(
        '(-p --path)'{-p,--path}'[Path to Resources folder]:directory:_directories'
        '--backend[Resource format backend]:backend:(json resx)'
        '(-h --help)'{-h,--help}'[Show help information]'
        '(-v --version)'{-v,--version}'[Show version information]'
    )

    local -a format_opts
    format_opts=(
        'table:Table format (human-readable)'
        'json:JSON format (machine-readable)'
        'simple:Simple text format'
        'csv:CSV format (for export)'
        'tui:Terminal UI format (interactive)'
    )

    local -a provider_opts
    provider_opts=(
        'google:Google Cloud Translation API'
        'deepl:DeepL Translation API'
        'libretranslate:LibreTranslate (open-source)'
        'ollama:Ollama (local LLM)'
        'openai:OpenAI GPT models'
        'claude:Anthropic Claude'
        'azureopenai:Azure OpenAI'
        'azuretranslator:Azure AI Translator'
    )

    _arguments -C \
        '1: :->command' \
        '*:: :->args' \
        && return 0

    case $state in
        command)
            _describe -t commands 'lrm commands' commands
            _arguments $global_opts
            ;;
        args)
            case $words[1] in
                init)
                    local -a resource_format_opts
                    resource_format_opts=(
                        'json:JSON format (recommended)'
                        'resx:.NET RESX XML format'
                    )
                    _arguments \
                        '(-i --interactive)'{-i,--interactive}'[Run interactive setup wizard]' \
                        '--format[Resource format]:format:->resource_formats' \
                        '--default-lang[Default language code]:lang:(en en-US en-GB)' \
                        '--languages[Additional languages (comma-separated)]:languages' \
                        '--base-name[Base filename for resources]:basename' \
                        '(-y --yes)'{-y,--yes}'[Skip confirmation prompts]' \
                        $global_opts
                    case $state in
                        resource_formats)
                            _describe -t resource_formats 'resource formats' resource_format_opts
                            ;;
                    esac
                    ;;
                convert)
                    local -a resource_format_opts
                    resource_format_opts=(
                        'json:JSON format'
                        'resx:.NET RESX XML format'
                    )
                    _arguments \
                        '--from[Source format]:format:->resource_formats' \
                        '--to[Target format]:format:->resource_formats' \
                        '(-o --output)'{-o,--output}'[Output directory]:directory:_directories' \
                        '--nested[Convert to nested key structure (JSON only)]' \
                        '--include-comments[Preserve comments in output]' \
                        '--no-backup[Skip backup creation]' \
                        '(-y --yes)'{-y,--yes}'[Skip confirmation prompts]' \
                        $global_opts
                    case $state in
                        resource_formats)
                            _describe -t resource_formats 'resource formats' resource_format_opts
                            ;;
                    esac
                    ;;
                validate)
                    _arguments \
                        '--format[Output format]:format:->formats' \
                        '--placeholder-types[Placeholder types to validate]:placeholder types:->placeholder_types' \
                        '--no-placeholder-validation[Disable placeholder validation]' \
                        '--no-scan-code[Disable code scanning when duplicates are found]' \
                        '--source-path[Source code path to scan for duplicate key usage]:directory:_directories' \
                        $global_opts

                    local -a placeholder_type_opts
                    placeholder_type_opts=(
                        'dotnet:.NET format strings ({0}, {name})'
                        'printf:Printf-style (%s, %d, %1$s)'
                        'icu:ICU MessageFormat ({count, plural, ...})'
                        'template:Template literals (${name})'
                        'all:All placeholder types'
                    )

                    case $state in
                        formats)
                            _describe -t formats 'output formats' format_opts
                            ;;
                        placeholder_types)
                            _describe -t placeholder_types 'placeholder types' placeholder_type_opts
                            ;;
                    esac
                    ;;
                stats)
                    _arguments \
                        '--format[Output format]:format:->formats' \
                        $global_opts
                    case $state in
                        formats)
                            _describe -t formats 'output formats' format_opts
                            ;;
                    esac
                    ;;
                view)
                    _arguments \
                        '1:key name' \
                        '--show-comments[Show comments for the key]' \
                        '--format[Output format]:format:->formats' \
                        '--regex[Treat key as regex pattern]' \
                        '--sort[Sort results alphabetically]' \
                        '--no-limit[Show all matches without limit]' \
                        '--case-sensitive[Match exact key casing]' \
                        '--search-in[Search scope]:scope:->search_scopes' \
                        '--count[Show only count of matching keys]' \
                        '--status[Filter by translation status]:status:->statuses' \
                        '*--not[Exclude keys matching pattern]:pattern' \
                        '--cultures[Specific cultures to show (comma-separated)]:cultures' \
                        '--keys-only[Output only key names]' \
                        $global_opts

                    local -a search_scope_opts
                    search_scope_opts=(
                        'keys:Search in key names only'
                        'values:Search in translation values'
                        'comments:Search in comments'
                        'both:Search in keys and values'
                        'all:Search in keys, values, and comments'
                    )

                    local -a status_opts
                    status_opts=(
                        'translated:Show only translated keys'
                        'untranslated:Show only untranslated keys'
                        'empty:Show only empty keys'
                        'all:Show all keys regardless of status'
                    )

                    case $state in
                        formats)
                            _describe -t formats 'output formats' format_opts
                            ;;
                        search_scopes)
                            _describe -t search_scopes 'search scopes' search_scope_opts
                            ;;
                        statuses)
                            _describe -t statuses 'translation statuses' status_opts
                            ;;
                    esac
                    ;;
                add)
                    local -a plural_form_opts
                    plural_form_opts=(
                        'zero:Used for zero quantity'
                        'one:Used for singular (1 item)'
                        'two:Used for dual (2 items)'
                        'few:Used for few items'
                        'many:Used for many items'
                        'other:Used for all other quantities (required)'
                    )
                    _arguments \
                        '1:key name' \
                        '*'{-l,--lang}'[Language value (code:value)]:langvalue' \
                        '--comment[Add comment]:comment' \
                        '--no-backup[Skip backup creation]' \
                        '--ask-missing[Prompt for missing language values]' \
                        '--plural[Create a plural key with multiple forms (JSON only)]' \
                        '*--plural-form[Plural form value (form:value)]:pluralform:->plural_forms' \
                        '(-i --interactive)'{-i,--interactive}'[Interactive mode]' \
                        $global_opts
                    case $state in
                        plural_forms)
                            _describe -t plural_forms 'plural forms' plural_form_opts
                            ;;
                    esac
                    ;;
                update)
                    local -a plural_form_opts
                    plural_form_opts=(
                        'zero:Used for zero quantity'
                        'one:Used for singular (1 item)'
                        'two:Used for dual (2 items)'
                        'few:Used for few items'
                        'many:Used for many items'
                        'other:Used for all other quantities (required)'
                    )
                    _arguments \
                        '1:key name' \
                        '*'{-l,--lang}'[Language value (code:value)]:langvalue' \
                        '--comment[Update comment]:comment' \
                        '(-i --interactive)'{-i,--interactive}'[Interactive mode]' \
                        '(-y --yes)'{-y,--yes}'[Skip confirmation]' \
                        '--no-backup[Skip backup creation]' \
                        '*--plural-form[Update plural form value (form:value)]:pluralform:->plural_forms' \
                        $global_opts
                    case $state in
                        plural_forms)
                            _describe -t plural_forms 'plural forms' plural_form_opts
                            ;;
                    esac
                    ;;
                delete)
                    _arguments \
                        '1:key name' \
                        '(-y --yes)'{-y,--yes}'[Skip confirmation]' \
                        '--no-backup[Skip backup creation]' \
                        $global_opts
                    ;;
                merge-duplicates)
                    _arguments \
                        '1:key name' \
                        '--all[Merge all duplicate keys in the resource files]' \
                        '--auto-first[Automatically select first occurrence from each language without prompting]' \
                        '(-y --yes)'{-y,--yes}'[Skip final confirmation prompt]' \
                        '--no-backup[Skip creating backup files before merging]' \
                        $global_opts
                    ;;
                export)
                    _arguments \
                        '(-o --output)'{-o,--output}'[Output file]:file:_files' \
                        '--format[Output format]:format:->formats' \
                        '--include-status[Include validation status column]' \
                        $global_opts
                    case $state in
                        formats)
                            _describe -t formats 'output formats' format_opts
                            ;;
                    esac
                    ;;
                import)
                    _arguments \
                        '1:CSV file:_files -g "*.csv"' \
                        '--overwrite[Overwrite existing values]' \
                        '--no-backup[Skip backup creation]' \
                        $global_opts
                    ;;
                edit)
                    _arguments \
                        '--source-path[Path to source code directory for code scanning]:directory:_directories' \
                        '--no-backup[Skip backup creation]' \
                        $global_opts
                    ;;
                translate)
                    _arguments \
                        '1:key pattern' \
                        '--provider[Translation provider]:provider:->providers' \
                        '--source-language[Source language code]:lang' \
                        '--target-languages[Target languages (comma-separated)]:languages' \
                        '--only-missing[Translate only missing keys]' \
                        '--overwrite[Allow overwriting existing translations]' \
                        '--dry-run[Preview translations without saving]' \
                        '--no-cache[Disable translation cache]' \
                        '--batch-size[Batch size for translation]:size:(5 10 20 50 100)' \
                        '--no-backup[Skip creating backups before translating]' \
                        '--format[Output format]:format:->formats' \
                        '--config-file[Configuration file path]:file:_files -g "*.json"' \
                        $global_opts
                    case $state in
                        providers)
                            _describe -t providers 'translation providers' provider_opts
                            ;;
                        formats)
                            _describe -t formats 'output formats' format_opts
                            ;;
                    esac
                    ;;
                scan)
                    _arguments \
                        '--source-path[Path to source code directory]:directory:_directories' \
                        '--file[Scan a single file instead of entire codebase]:file:_files -g "*.@(cs|razor|xaml|cshtml)"' \
                        '--exclude[Glob patterns to exclude (comma-separated)]:patterns' \
                        '--strict[Strict mode - only high-confidence references]' \
                        '--show-unused[Show only unused keys]' \
                        '--show-missing[Show only missing keys]' \
                        '--show-references[Show detailed reference information]' \
                        '--resource-classes[Resource class names to detect]:classes' \
                        '--localization-methods[Localization method names to detect]:methods' \
                        '--format[Output format]:format:->formats' \
                        $global_opts
                    case $state in
                        formats)
                            _describe -t formats 'output formats' format_opts
                            ;;
                    esac
                    ;;
                check)
                    _arguments \
                        '--source-path[Path to source code directory]:directory:_directories' \
                        '--exclude[Glob patterns to exclude]:patterns' \
                        '--strict[Strict mode for scanning]' \
                        '--format[Output format]:format:->formats' \
                        $global_opts
                    case $state in
                        formats)
                            _describe -t formats 'output formats' format_opts
                            ;;
                    esac
                    ;;
                chain)
                    _arguments \
                        '1:command chain' \
                        '--continue-on-error[Continue executing commands even if one fails]' \
                        '--dry-run[Show commands without executing them]' \
                        '--help[Show help information]' \
                        '-h[Show help information]'
                    ;;
                list-languages)
                    _arguments \
                        '--format[Output format]:format:->formats' \
                        $global_opts
                    case $state in
                        formats)
                            _describe -t formats 'output formats' format_opts
                            ;;
                    esac
                    ;;
                add-language)
                    _arguments \
                        '(-c --culture)'{-c,--culture}'[Culture code]:code:(en es fr de it pt ja zh ko ru ar el tr nl pl cs sv)' \
                        '--base-name[Base resource file name]:basename' \
                        '--copy-from[Copy entries from specific language]:code:(en es fr de it pt ja zh ko ru ar el tr nl pl cs sv)' \
                        '--empty[Create empty language file]' \
                        '(-y --yes)'{-y,--yes}'[Skip confirmation prompts]' \
                        $global_opts
                    ;;
                remove-language)
                    _arguments \
                        '(-c --culture)'{-c,--culture}'[Culture code to remove]:code:(en es fr de it pt ja zh ko ru ar el tr nl pl cs sv)' \
                        '--base-name[Base resource file name]:basename' \
                        '(-y --yes)'{-y,--yes}'[Skip confirmation prompt]' \
                        '--no-backup[Skip creating backups]' \
                        $global_opts
                    ;;
                web)
                    _arguments \
                        '--source-path[Path to source code directory for code scanning]:directory:_directories' \
                        '--port[Port to bind the web server to]:port:(5000 8080 3000)' \
                        '--bind-address[Address to bind to]:address:(localhost 0.0.0.0)' \
                        '--no-open-browser[Do not automatically open browser on startup]' \
                        '--enable-https[Enable HTTPS]' \
                        '--cert-path[Path to HTTPS certificate file (.pfx)]:file:_files -g "*.pfx"' \
                        '--cert-password[Password for HTTPS certificate]:password' \
                        $global_opts
                    ;;
                config)
                    local -a config_subcommands
                    config_subcommands=(
                        'set-api-key:Store an API key in the secure credential store'
                        'get-api-key:Check where an API key is configured'
                        'delete-api-key:Remove an API key from the secure credential store'
                        'list-providers:List all translation providers and their status'
                    )

                    _arguments -C \
                        '1: :->subcommand' \
                        '*:: :->subargs' \
                        && return 0

                    case $state in
                        subcommand)
                            _describe -t config-subcommands 'config subcommands' config_subcommands
                            ;;
                        subargs)
                            case $words[1] in
                                set-api-key)
                                    _arguments \
                                        '(-p --provider)'{-p,--provider}'[Translation provider]:provider:->providers' \
                                        '(-k --key)'{-k,--key}'[API key to store]:key' \
                                        $global_opts
                                    case $state in
                                        providers)
                                            _describe -t providers 'translation providers' provider_opts
                                            ;;
                                    esac
                                    ;;
                                get-api-key)
                                    _arguments \
                                        '--provider[Translation provider]:provider:->providers' \
                                        $global_opts
                                    case $state in
                                        providers)
                                            _describe -t providers 'translation providers' provider_opts
                                            ;;
                                    esac
                                    ;;
                                delete-api-key)
                                    _arguments \
                                        '(-p --provider)'{-p,--provider}'[Translation provider]:provider:->providers' \
                                        $global_opts
                                    case $state in
                                        providers)
                                            _describe -t providers 'translation providers' provider_opts
                                            ;;
                                    esac
                                    ;;
                                list-providers)
                                    _arguments $global_opts
                                    ;;
                            esac
                            ;;
                    esac
                    ;;
                backup)
                    local -a backup_subcommands
                    backup_subcommands=(
                        'list:List all backups for resource files'
                        'create:Manually create a backup of resource files'
                        'restore:Restore resource files from a backup'
                        'diff:Show differences between backup versions'
                        'info:Display detailed information about a specific backup'
                        'prune:Remove old backups based on retention policy'
                    )

                    _arguments -C \
                        '1: :->subcommand' \
                        '*:: :->subargs' \
                        && return 0

                    case $state in
                        subcommand)
                            _describe -t backup-subcommands 'backup subcommands' backup_subcommands
                            ;;
                        subargs)
                            case $words[1] in
                                list)
                                    _arguments \
                                        '--file[Resource file name]:file:_files -g "*.resx"' \
                                        '--all[List backups for all resource files]' \
                                        '--limit[Maximum number of backups to display]:count:(10 20 50 100 0)' \
                                        '--show-details[Show detailed information]' \
                                        $global_opts
                                    ;;
                                create)
                                    _arguments \
                                        '--file[Resource file name]:file:_files -g "*.resx"' \
                                        '--all[Create backups for all resource files]' \
                                        '--operation[Operation description]:description' \
                                        $global_opts
                                    ;;
                                restore)
                                    _arguments \
                                        '1:file:_files -g "*.resx"' \
                                        '--version[Backup version to restore]:version' \
                                        '--keys[Specific keys to restore (comma-separated)]:keys' \
                                        '--preview[Preview changes without restoring]' \
                                        '(-y --yes)'{-y,--yes}'[Skip confirmation]' \
                                        '--no-backup[Skip backup creation before restore]' \
                                        $global_opts
                                    ;;
                                diff)
                                    _arguments \
                                        '1:file:_files -g "*.resx"' \
                                        '--from[Source backup version]:version' \
                                        '--to[Target backup version]:version' \
                                        '--output[Save diff to file]:file:_files' \
                                        '--show-unchanged[Include unchanged keys]' \
                                        '--format[Output format]:format:->formats' \
                                        $global_opts
                                    case $state in
                                        formats)
                                            _describe -t formats 'output formats' format_opts
                                            ;;
                                    esac
                                    ;;
                                info)
                                    _arguments \
                                        '1:file:_files -g "*.resx"' \
                                        '2:version number' \
                                        $global_opts
                                    ;;
                                prune)
                                    _arguments \
                                        '--file[Resource file name]:file:_files -g "*.resx"' \
                                        '--all[Prune backups for all files]' \
                                        '--version[Delete specific version]:version' \
                                        '--older-than[Delete backups older than N days]:days' \
                                        '--keep[Keep only N most recent backups]:count' \
                                        '--dry-run[Preview without deleting]' \
                                        '(-y --yes)'{-y,--yes}'[Skip confirmation]' \
                                        $global_opts
                                    ;;
                            esac
                            ;;
                    esac
                    ;;
                cloud)
                    local -a cloud_subcommands
                    cloud_subcommands=(
                        'init:Connect local project to cloud'
                        'clone:Clone an existing cloud project (login + link + pull)'
                        'login:Authenticate with LRM Cloud'
                        'logout:Clear stored authentication tokens'
                        'status:Show cloud sync status or account info'
                        'push:Push local changes to cloud'
                        'pull:Pull remote changes from cloud'
                        'log:Show sync history (push/revert operations)'
                        'revert:Revert a previous push (undo changes)'
                        'snapshot:Snapshot management for point-in-time backups'
                        'set-token:Manually set an authentication token'
                        'set-api-key:Store a CLI API key for cloud authentication'
                        'remote:Remote URL configuration'
                    )

                    _arguments -C \
                        '1: :->subcommand' \
                        '*:: :->subargs' \
                        && return 0

                    case $state in
                        subcommand)
                            _describe -t cloud-subcommands 'cloud subcommands' cloud_subcommands
                            ;;
                        subargs)
                            case $words[1] in
                                init)
                                    _arguments \
                                        '1:remote URL' \
                                        '(-n --name)'{-n,--name}'[Project name]:name' \
                                        '--organization[Organization slug]:org' \
                                        '(-y --yes)'{-y,--yes}'[Skip confirmation prompts]' \
                                        $global_opts
                                    ;;
                                clone)
                                    _arguments \
                                        '1:remote URL' \
                                        '2:target directory:_directories' \
                                        '--email[Email for authentication]:email' \
                                        '--password[Password (not recommended)]:password' \
                                        '--api-key[API key for authentication]:key' \
                                        '--no-pull[Do not pull resources after cloning]' \
                                        '--force[Skip confirmation prompts]' \
                                        '(-h --help)'{-h,--help}'[Show help information]'
                                    ;;
                                login)
                                    _arguments \
                                        '1:host' \
                                        '--email[Email address]:email' \
                                        '--password[Password]:password' \
                                        $global_opts
                                    ;;
                                logout)
                                    _arguments \
                                        $global_opts
                                    ;;
                                status)
                                    _arguments \
                                        '--format[Output format]:format:->formats' \
                                        '--account[Show account info instead of sync status]' \
                                        $global_opts
                                    case $state in
                                        formats)
                                            _describe -t formats 'output formats' format_opts
                                            ;;
                                    esac
                                    ;;
                                push)
                                    _arguments \
                                        '(-m --message)'{-m,--message}'[Commit message]:message' \
                                        '--dry-run[Preview changes without pushing]' \
                                        '--force[Force push even if conflicts]' \
                                        '--config-only[Push only configuration]' \
                                        '--resources-only[Push only resources]' \
                                        $global_opts
                                    ;;
                                pull)
                                    _arguments \
                                        '--dry-run[Preview changes without pulling]' \
                                        '--force[Force pull and overwrite local]' \
                                        '--no-backup[Skip backup creation]' \
                                        '--strategy[Conflict resolution]:strategy:(local remote prompt abort)' \
                                        '--config-only[Pull only configuration]' \
                                        '--resources-only[Pull only resources]' \
                                        $global_opts
                                    ;;
                                set-token)
                                    _arguments \
                                        '1:token' \
                                        '--expires[Token expiration date (ISO 8601)]:datetime' \
                                        $global_opts
                                    ;;
                                set-api-key)
                                    _arguments \
                                        '1:API key' \
                                        '--remove[Remove stored API key]' \
                                        $global_opts
                                    ;;
                                log)
                                    _arguments \
                                        '1:history ID' \
                                        '(-n --number)'{-n,--number}'[Number of entries to show]:count:(10 20 50 100)' \
                                        '--page[Page number]:page' \
                                        '--oneline[Show compact one-line format]' \
                                        '(-f --format)'{-f,--format}'[Output format]:format:->formats' \
                                        $global_opts
                                    case $state in
                                        formats)
                                            _describe -t formats 'output formats' format_opts
                                            ;;
                                    esac
                                    ;;
                                revert)
                                    _arguments \
                                        '1:history ID' \
                                        '(-m --message)'{-m,--message}'[Message describing the revert]:message' \
                                        '(-y --yes)'{-y,--yes}'[Skip confirmation prompt]' \
                                        '--dry-run[Preview without reverting]' \
                                        '(-f --format)'{-f,--format}'[Output format]:format:->formats' \
                                        $global_opts
                                    case $state in
                                        formats)
                                            _describe -t formats 'output formats' format_opts
                                            ;;
                                    esac
                                    ;;
                                snapshot)
                                    local -a snapshot_subcommands
                                    snapshot_subcommands=(
                                        'list:List all snapshots'
                                        'create:Create a new snapshot'
                                        'show:Show snapshot details'
                                        'restore:Restore to a snapshot'
                                        'delete:Delete a snapshot'
                                        'diff:Compare two snapshots'
                                    )

                                    _arguments -C \
                                        '1: :->snapshot_subcommand' \
                                        '*:: :->snapshot_subargs' \
                                        && return 0

                                    case $state in
                                        snapshot_subcommand)
                                            _describe -t snapshot-subcommands 'snapshot subcommands' snapshot_subcommands
                                            ;;
                                        snapshot_subargs)
                                            case $words[1] in
                                                list)
                                                    _arguments \
                                                        '--page[Page number]:page' \
                                                        '--page-size[Items per page]:size:(10 20 50)' \
                                                        '(-f --format)'{-f,--format}'[Output format]:format:->formats' \
                                                        $global_opts
                                                    ;;
                                                create)
                                                    _arguments \
                                                        '1:snapshot description' \
                                                        '(-f --format)'{-f,--format}'[Output format]:format:->formats' \
                                                        $global_opts
                                                    ;;
                                                show|restore|delete)
                                                    _arguments \
                                                        '1:snapshot ID' \
                                                        $global_opts
                                                    ;;
                                                diff)
                                                    _arguments \
                                                        '1:from snapshot ID' \
                                                        '2:to snapshot ID' \
                                                        $global_opts
                                                    ;;
                                            esac
                                            case $state in
                                                formats)
                                                    _describe -t formats 'output formats' format_opts
                                                    ;;
                                            esac
                                            ;;
                                    esac
                                    ;;
                                remote)
                                    local -a remote_subcommands
                                    remote_subcommands=(
                                        'set:Set the remote URL'
                                        'get:Display current remote URL'
                                        'unset:Remove remote configuration'
                                    )
                                    _describe -t remote-subcommands 'remote subcommands' remote_subcommands
                                    ;;
                            esac
                            ;;
                    esac
                    ;;
            esac
            ;;
    esac
}

_lrm "$@"