use super::CompletionSpec;

pub(super) fn specs() -> Vec<CompletionSpec> {
    vec![
        (
            "fetch.path",
            "Fetch local path",
            "fetch.path(${1:path})",
            "#{ path: String, hash: String, cached: Bool }",
        ),
        (
            "fetch.pathWithHash",
            "Fetch local path with hash",
            "fetch.pathWithHash(${1:path}, ${2:hash})",
            "#{ path: String, hash: String, cached: Bool }",
        ),
        (
            "fetch.url",
            "Fetch URL",
            "fetch.url(${1:url})",
            "#{ path: String, hash: String, cached: Bool }",
        ),
        (
            "fetch.urlWithHash",
            "Fetch URL with hash",
            "fetch.urlWithHash(${1:url}, ${2:hash})",
            "#{ path: String, hash: String, cached: Bool }",
        ),
        (
            "fetch.git",
            "Fetch git revision",
            "fetch.git(${1:url}, ${2:rev})",
            "#{ path: String, hash: String, cached: Bool }",
        ),
        (
            "fetch.gitWithHash",
            "Fetch git revision with hash",
            "fetch.gitWithHash(${1:url}, ${2:rev}, ${3:hash})",
            "#{ path: String, hash: String, cached: Bool }",
        ),
        ("Map.empty", "Empty map", "Map.empty", "Map[K, V]"),
        (
            "Map.singleton",
            "Singleton map",
            "Map.singleton(${1:key}, ${2:value})",
            "Map[K, V]",
        ),
        (
            "Map.fromList",
            "Map from pairs",
            "Map.fromList(${1:items})",
            "Map[K, V]",
        ),
        (
            "Map.get",
            "Lookup map value",
            "Map.get(${1:key}, ${2:map})",
            "Option[V]",
        ),
        (
            "Map.getWithDefault",
            "Lookup map value with default",
            "Map.getWithDefault(${1:key}, ${2:default}, ${3:map})",
            "V",
        ),
        (
            "Map.contains",
            "Check map key presence",
            "Map.contains(${1:key}, ${2:map})",
            "Bool",
        ),
        ("Map.size", "Map size", "Map.size(${1:map})", "Int"),
        (
            "Map.isEmpty",
            "Check if map is empty",
            "Map.isEmpty(${1:map})",
            "Bool",
        ),
        (
            "Map.values",
            "Map values",
            "Map.values(${1:map})",
            "List[V]",
        ),
        (
            "Map.insert",
            "Insert map entry",
            "Map.insert(${1:key}, ${2:value}, ${3:map})",
            "Map[K, V]",
        ),
        (
            "Map.remove",
            "Remove map entry",
            "Map.remove(${1:key}, ${2:map})",
            "Map[K, V]",
        ),
        (
            "Map.union",
            "Union of maps",
            "Map.union(${1:left}, ${2:right})",
            "Map[K, V]",
        ),
        (
            "Map.intersection",
            "Intersection of maps",
            "Map.intersection(${1:left}, ${2:right})",
            "Map[K, V]",
        ),
        (
            "Map.difference",
            "Difference of maps",
            "Map.difference(${1:left}, ${2:right})",
            "Map[K, V]",
        ),
        ("Set.empty", "Empty set", "Set.empty", "Set[A]"),
        (
            "Set.singleton",
            "Singleton set",
            "Set.singleton(${1:value})",
            "Set[A]",
        ),
        (
            "Set.fromList",
            "Set from list",
            "Set.fromList(${1:items})",
            "Set[A]",
        ),
        (
            "Set.contains",
            "Check set membership",
            "Set.contains(${1:value}, ${2:set})",
            "Bool",
        ),
        ("Set.size", "Set size", "Set.size(${1:set})", "Int"),
        (
            "Set.isEmpty",
            "Check if set is empty",
            "Set.isEmpty(${1:set})",
            "Bool",
        ),
        (
            "Set.insert",
            "Insert into set",
            "Set.insert(${1:value}, ${2:set})",
            "Set[A]",
        ),
        (
            "Set.remove",
            "Remove from set",
            "Set.remove(${1:value}, ${2:set})",
            "Set[A]",
        ),
        (
            "Set.union",
            "Union of sets",
            "Set.union(${1:left}, ${2:right})",
            "Set[A]",
        ),
        (
            "Set.intersection",
            "Intersection of sets",
            "Set.intersection(${1:left}, ${2:right})",
            "Set[A]",
        ),
        (
            "Set.difference",
            "Difference of sets",
            "Set.difference(${1:left}, ${2:right})",
            "Set[A]",
        ),
        (
            "Set.symmetricDifference",
            "Symmetric difference of sets",
            "Set.symmetricDifference(${1:left}, ${2:right})",
            "Set[A]",
        ),
        (
            "Set.isSubset",
            "Check subset relation",
            "Set.isSubset(${1:left}, ${2:right})",
            "Bool",
        ),
        (
            "Set.isSuperset",
            "Check superset relation",
            "Set.isSuperset(${1:left}, ${2:right})",
            "Bool",
        ),
        (
            "Set.isDisjoint",
            "Check disjoint sets",
            "Set.isDisjoint(${1:left}, ${2:right})",
            "Bool",
        ),
    ]
}
