globalFunctions static method

Map<String, NativeFunctionImpl> globalFunctions()

Returns a map of global function names to their native implementations.

Implementation

static Map<String, NativeFunctionImpl> globalFunctions() {
  return {
    'findBridgePortForWorkspace': (visitor, positional, named, typeArgs) {
      D4.requireMinArgs(positional, 1, 'findBridgePortForWorkspace');
      final name = D4.getRequiredArg<String>(
        positional,
        0,
        'name',
        'findBridgePortForWorkspace',
      );
      final host = D4.getNamedArgWithDefault<String>(
        named,
        'host',
        '127.0.0.1',
      );
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        return $tom_vscode_scripting_api_11.findBridgePortForWorkspace(
          name,
          host: host,
        );
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'findBridgePortForWorkspace',
        );
        return $tom_vscode_scripting_api_11.findBridgePortForWorkspace(
          name,
          host: host,
          minPort: minPort,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'findBridgePortForWorkspace',
        );
        return $tom_vscode_scripting_api_11.findBridgePortForWorkspace(
          name,
          host: host,
          maxPort: maxPort,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'findBridgePortForWorkspace',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'findBridgePortForWorkspace',
        );
        return $tom_vscode_scripting_api_11.findBridgePortForWorkspace(
          name,
          host: host,
          minPort: minPort,
          maxPort: maxPort,
        );
      }
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortForWorkspace(
          name,
          host: host,
          probe: probe,
        );
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'findBridgePortForWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortForWorkspace(
          name,
          host: host,
          minPort: minPort,
          probe: probe,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'findBridgePortForWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortForWorkspace(
          name,
          host: host,
          maxPort: maxPort,
          probe: probe,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'findBridgePortForWorkspace',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'findBridgePortForWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortForWorkspace(
          name,
          host: host,
          minPort: minPort,
          maxPort: maxPort,
          probe: probe,
        );
      }
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortForWorkspace(
          name,
          host: host,
          fetchIdentity: fetchIdentity,
        );
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'findBridgePortForWorkspace',
        );
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortForWorkspace(
          name,
          host: host,
          minPort: minPort,
          fetchIdentity: fetchIdentity,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'findBridgePortForWorkspace',
        );
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortForWorkspace(
          name,
          host: host,
          maxPort: maxPort,
          fetchIdentity: fetchIdentity,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'findBridgePortForWorkspace',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'findBridgePortForWorkspace',
        );
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortForWorkspace(
          name,
          host: host,
          minPort: minPort,
          maxPort: maxPort,
          fetchIdentity: fetchIdentity,
        );
      }
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortForWorkspace(
          name,
          host: host,
          probe: probe,
          fetchIdentity: fetchIdentity,
        );
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'findBridgePortForWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortForWorkspace(
          name,
          host: host,
          minPort: minPort,
          probe: probe,
          fetchIdentity: fetchIdentity,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'findBridgePortForWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortForWorkspace(
          name,
          host: host,
          maxPort: maxPort,
          probe: probe,
          fetchIdentity: fetchIdentity,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'findBridgePortForWorkspace',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'findBridgePortForWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortForWorkspace(
          name,
          host: host,
          minPort: minPort,
          maxPort: maxPort,
          probe: probe,
          fetchIdentity: fetchIdentity,
        );
      }
      throw StateError(
        'Unreachable: all named parameter combinations should be covered',
      );
    },
    'findBridgePortsForWorkspace': (visitor, positional, named, typeArgs) {
      D4.requireMinArgs(positional, 1, 'findBridgePortsForWorkspace');
      final name = D4.getRequiredArg<String>(
        positional,
        0,
        'name',
        'findBridgePortsForWorkspace',
      );
      final host = D4.getNamedArgWithDefault<String>(
        named,
        'host',
        '127.0.0.1',
      );
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        return $tom_vscode_scripting_api_11.findBridgePortsForWorkspace(
          name,
          host: host,
        );
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'findBridgePortsForWorkspace',
        );
        return $tom_vscode_scripting_api_11.findBridgePortsForWorkspace(
          name,
          host: host,
          minPort: minPort,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'findBridgePortsForWorkspace',
        );
        return $tom_vscode_scripting_api_11.findBridgePortsForWorkspace(
          name,
          host: host,
          maxPort: maxPort,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'findBridgePortsForWorkspace',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'findBridgePortsForWorkspace',
        );
        return $tom_vscode_scripting_api_11.findBridgePortsForWorkspace(
          name,
          host: host,
          minPort: minPort,
          maxPort: maxPort,
        );
      }
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortsForWorkspace(
          name,
          host: host,
          probe: probe,
        );
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'findBridgePortsForWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortsForWorkspace(
          name,
          host: host,
          minPort: minPort,
          probe: probe,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'findBridgePortsForWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortsForWorkspace(
          name,
          host: host,
          maxPort: maxPort,
          probe: probe,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'findBridgePortsForWorkspace',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'findBridgePortsForWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortsForWorkspace(
          name,
          host: host,
          minPort: minPort,
          maxPort: maxPort,
          probe: probe,
        );
      }
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortsForWorkspace(
          name,
          host: host,
          fetchIdentity: fetchIdentity,
        );
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'findBridgePortsForWorkspace',
        );
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortsForWorkspace(
          name,
          host: host,
          minPort: minPort,
          fetchIdentity: fetchIdentity,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'findBridgePortsForWorkspace',
        );
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortsForWorkspace(
          name,
          host: host,
          maxPort: maxPort,
          fetchIdentity: fetchIdentity,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'findBridgePortsForWorkspace',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'findBridgePortsForWorkspace',
        );
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortsForWorkspace(
          name,
          host: host,
          minPort: minPort,
          maxPort: maxPort,
          fetchIdentity: fetchIdentity,
        );
      }
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortsForWorkspace(
          name,
          host: host,
          probe: probe,
          fetchIdentity: fetchIdentity,
        );
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'findBridgePortsForWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortsForWorkspace(
          name,
          host: host,
          minPort: minPort,
          probe: probe,
          fetchIdentity: fetchIdentity,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'findBridgePortsForWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortsForWorkspace(
          name,
          host: host,
          maxPort: maxPort,
          probe: probe,
          fetchIdentity: fetchIdentity,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'findBridgePortsForWorkspace',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'findBridgePortsForWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.findBridgePortsForWorkspace(
          name,
          host: host,
          minPort: minPort,
          maxPort: maxPort,
          probe: probe,
          fetchIdentity: fetchIdentity,
        );
      }
      throw StateError(
        'Unreachable: all named parameter combinations should be covered',
      );
    },
    'scanBridgePorts': (visitor, positional, named, typeArgs) {
      final host = D4.getNamedArgWithDefault<String>(
        named,
        'host',
        '127.0.0.1',
      );
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        return $tom_vscode_scripting_api_11.scanBridgePorts(host: host);
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'scanBridgePorts',
        );
        return $tom_vscode_scripting_api_11.scanBridgePorts(
          host: host,
          minPort: minPort,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'scanBridgePorts',
        );
        return $tom_vscode_scripting_api_11.scanBridgePorts(
          host: host,
          maxPort: maxPort,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'scanBridgePorts',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'scanBridgePorts',
        );
        return $tom_vscode_scripting_api_11.scanBridgePorts(
          host: host,
          minPort: minPort,
          maxPort: maxPort,
        );
      }
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        return $tom_vscode_scripting_api_11.scanBridgePorts(
          host: host,
          probe: probe,
        );
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'scanBridgePorts',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        return $tom_vscode_scripting_api_11.scanBridgePorts(
          host: host,
          minPort: minPort,
          probe: probe,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'scanBridgePorts',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        return $tom_vscode_scripting_api_11.scanBridgePorts(
          host: host,
          maxPort: maxPort,
          probe: probe,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'scanBridgePorts',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'scanBridgePorts',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        return $tom_vscode_scripting_api_11.scanBridgePorts(
          host: host,
          minPort: minPort,
          maxPort: maxPort,
          probe: probe,
        );
      }
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.scanBridgePorts(
          host: host,
          fetchIdentity: fetchIdentity,
        );
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'scanBridgePorts',
        );
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.scanBridgePorts(
          host: host,
          minPort: minPort,
          fetchIdentity: fetchIdentity,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'scanBridgePorts',
        );
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.scanBridgePorts(
          host: host,
          maxPort: maxPort,
          fetchIdentity: fetchIdentity,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'scanBridgePorts',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'scanBridgePorts',
        );
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.scanBridgePorts(
          host: host,
          minPort: minPort,
          maxPort: maxPort,
          fetchIdentity: fetchIdentity,
        );
      }
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.scanBridgePorts(
          host: host,
          probe: probe,
          fetchIdentity: fetchIdentity,
        );
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'scanBridgePorts',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.scanBridgePorts(
          host: host,
          minPort: minPort,
          probe: probe,
          fetchIdentity: fetchIdentity,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'scanBridgePorts',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.scanBridgePorts(
          host: host,
          maxPort: maxPort,
          probe: probe,
          fetchIdentity: fetchIdentity,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'scanBridgePorts',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'scanBridgePorts',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.scanBridgePorts(
          host: host,
          minPort: minPort,
          maxPort: maxPort,
          probe: probe,
          fetchIdentity: fetchIdentity,
        );
      }
      throw StateError(
        'Unreachable: all named parameter combinations should be covered',
      );
    },
    'connectToWorkspace': (visitor, positional, named, typeArgs) {
      D4.requireMinArgs(positional, 1, 'connectToWorkspace');
      final name = D4.getRequiredArg<String>(
        positional,
        0,
        'name',
        'connectToWorkspace',
      );
      final host = D4.getNamedArgWithDefault<String>(
        named,
        'host',
        '127.0.0.1',
      );
      final initializeVSCode = D4.getNamedArgWithDefault<bool>(
        named,
        'initializeVSCode',
        false,
      );
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity') &&
          !named.containsKey('adapterFactory')) {
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
        );
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity') &&
          !named.containsKey('adapterFactory')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'connectToWorkspace',
        );
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          minPort: minPort,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity') &&
          !named.containsKey('adapterFactory')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'connectToWorkspace',
        );
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          maxPort: maxPort,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity') &&
          !named.containsKey('adapterFactory')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'connectToWorkspace',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'connectToWorkspace',
        );
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          minPort: minPort,
          maxPort: maxPort,
        );
      }
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity') &&
          !named.containsKey('adapterFactory')) {
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          probe: probe,
        );
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity') &&
          !named.containsKey('adapterFactory')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'connectToWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          minPort: minPort,
          probe: probe,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity') &&
          !named.containsKey('adapterFactory')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'connectToWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          maxPort: maxPort,
          probe: probe,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity') &&
          !named.containsKey('adapterFactory')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'connectToWorkspace',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'connectToWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          minPort: minPort,
          maxPort: maxPort,
          probe: probe,
        );
      }
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity') &&
          !named.containsKey('adapterFactory')) {
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          fetchIdentity: fetchIdentity,
        );
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity') &&
          !named.containsKey('adapterFactory')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'connectToWorkspace',
        );
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          minPort: minPort,
          fetchIdentity: fetchIdentity,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity') &&
          !named.containsKey('adapterFactory')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'connectToWorkspace',
        );
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          maxPort: maxPort,
          fetchIdentity: fetchIdentity,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity') &&
          !named.containsKey('adapterFactory')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'connectToWorkspace',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'connectToWorkspace',
        );
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          minPort: minPort,
          maxPort: maxPort,
          fetchIdentity: fetchIdentity,
        );
      }
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity') &&
          !named.containsKey('adapterFactory')) {
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          probe: probe,
          fetchIdentity: fetchIdentity,
        );
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity') &&
          !named.containsKey('adapterFactory')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'connectToWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          minPort: minPort,
          probe: probe,
          fetchIdentity: fetchIdentity,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity') &&
          !named.containsKey('adapterFactory')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'connectToWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          maxPort: maxPort,
          probe: probe,
          fetchIdentity: fetchIdentity,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity') &&
          !named.containsKey('adapterFactory')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'connectToWorkspace',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'connectToWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          minPort: minPort,
          maxPort: maxPort,
          probe: probe,
          fetchIdentity: fetchIdentity,
        );
      }
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity') &&
          named.containsKey('adapterFactory')) {
        final adapterFactoryRaw = named['adapterFactory'];
        final adapterFactory =
            ((String p0, int p1) {
                  return D4.extractBridgedArg<
                        $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                      >(
                        D4.callInterpreterCallback(
                          visitor!,
                          adapterFactoryRaw,
                          [p0, p1],
                        ),
                        'callback',
                        visitor,
                      )
                      as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter;
                })
                as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          adapterFactory: adapterFactory,
        );
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity') &&
          named.containsKey('adapterFactory')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'connectToWorkspace',
        );
        final adapterFactoryRaw = named['adapterFactory'];
        final adapterFactory =
            ((String p0, int p1) {
                  return D4.extractBridgedArg<
                        $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                      >(
                        D4.callInterpreterCallback(
                          visitor!,
                          adapterFactoryRaw,
                          [p0, p1],
                        ),
                        'callback',
                        visitor,
                      )
                      as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter;
                })
                as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          minPort: minPort,
          adapterFactory: adapterFactory,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity') &&
          named.containsKey('adapterFactory')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'connectToWorkspace',
        );
        final adapterFactoryRaw = named['adapterFactory'];
        final adapterFactory =
            ((String p0, int p1) {
                  return D4.extractBridgedArg<
                        $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                      >(
                        D4.callInterpreterCallback(
                          visitor!,
                          adapterFactoryRaw,
                          [p0, p1],
                        ),
                        'callback',
                        visitor,
                      )
                      as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter;
                })
                as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          maxPort: maxPort,
          adapterFactory: adapterFactory,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          !named.containsKey('fetchIdentity') &&
          named.containsKey('adapterFactory')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'connectToWorkspace',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'connectToWorkspace',
        );
        final adapterFactoryRaw = named['adapterFactory'];
        final adapterFactory =
            ((String p0, int p1) {
                  return D4.extractBridgedArg<
                        $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                      >(
                        D4.callInterpreterCallback(
                          visitor!,
                          adapterFactoryRaw,
                          [p0, p1],
                        ),
                        'callback',
                        visitor,
                      )
                      as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter;
                })
                as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          minPort: minPort,
          maxPort: maxPort,
          adapterFactory: adapterFactory,
        );
      }
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity') &&
          named.containsKey('adapterFactory')) {
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final adapterFactoryRaw = named['adapterFactory'];
        final adapterFactory =
            ((String p0, int p1) {
                  return D4.extractBridgedArg<
                        $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                      >(
                        D4.callInterpreterCallback(
                          visitor!,
                          adapterFactoryRaw,
                          [p0, p1],
                        ),
                        'callback',
                        visitor,
                      )
                      as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter;
                })
                as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          probe: probe,
          adapterFactory: adapterFactory,
        );
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity') &&
          named.containsKey('adapterFactory')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'connectToWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final adapterFactoryRaw = named['adapterFactory'];
        final adapterFactory =
            ((String p0, int p1) {
                  return D4.extractBridgedArg<
                        $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                      >(
                        D4.callInterpreterCallback(
                          visitor!,
                          adapterFactoryRaw,
                          [p0, p1],
                        ),
                        'callback',
                        visitor,
                      )
                      as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter;
                })
                as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          minPort: minPort,
          probe: probe,
          adapterFactory: adapterFactory,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity') &&
          named.containsKey('adapterFactory')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'connectToWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final adapterFactoryRaw = named['adapterFactory'];
        final adapterFactory =
            ((String p0, int p1) {
                  return D4.extractBridgedArg<
                        $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                      >(
                        D4.callInterpreterCallback(
                          visitor!,
                          adapterFactoryRaw,
                          [p0, p1],
                        ),
                        'callback',
                        visitor,
                      )
                      as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter;
                })
                as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          maxPort: maxPort,
          probe: probe,
          adapterFactory: adapterFactory,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          !named.containsKey('fetchIdentity') &&
          named.containsKey('adapterFactory')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'connectToWorkspace',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'connectToWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final adapterFactoryRaw = named['adapterFactory'];
        final adapterFactory =
            ((String p0, int p1) {
                  return D4.extractBridgedArg<
                        $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                      >(
                        D4.callInterpreterCallback(
                          visitor!,
                          adapterFactoryRaw,
                          [p0, p1],
                        ),
                        'callback',
                        visitor,
                      )
                      as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter;
                })
                as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          minPort: minPort,
          maxPort: maxPort,
          probe: probe,
          adapterFactory: adapterFactory,
        );
      }
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity') &&
          named.containsKey('adapterFactory')) {
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        final adapterFactoryRaw = named['adapterFactory'];
        final adapterFactory =
            ((String p0, int p1) {
                  return D4.extractBridgedArg<
                        $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                      >(
                        D4.callInterpreterCallback(
                          visitor!,
                          adapterFactoryRaw,
                          [p0, p1],
                        ),
                        'callback',
                        visitor,
                      )
                      as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter;
                })
                as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          fetchIdentity: fetchIdentity,
          adapterFactory: adapterFactory,
        );
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity') &&
          named.containsKey('adapterFactory')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'connectToWorkspace',
        );
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        final adapterFactoryRaw = named['adapterFactory'];
        final adapterFactory =
            ((String p0, int p1) {
                  return D4.extractBridgedArg<
                        $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                      >(
                        D4.callInterpreterCallback(
                          visitor!,
                          adapterFactoryRaw,
                          [p0, p1],
                        ),
                        'callback',
                        visitor,
                      )
                      as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter;
                })
                as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          minPort: minPort,
          fetchIdentity: fetchIdentity,
          adapterFactory: adapterFactory,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity') &&
          named.containsKey('adapterFactory')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'connectToWorkspace',
        );
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        final adapterFactoryRaw = named['adapterFactory'];
        final adapterFactory =
            ((String p0, int p1) {
                  return D4.extractBridgedArg<
                        $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                      >(
                        D4.callInterpreterCallback(
                          visitor!,
                          adapterFactoryRaw,
                          [p0, p1],
                        ),
                        'callback',
                        visitor,
                      )
                      as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter;
                })
                as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          maxPort: maxPort,
          fetchIdentity: fetchIdentity,
          adapterFactory: adapterFactory,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          !named.containsKey('probe') &&
          named.containsKey('fetchIdentity') &&
          named.containsKey('adapterFactory')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'connectToWorkspace',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'connectToWorkspace',
        );
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        final adapterFactoryRaw = named['adapterFactory'];
        final adapterFactory =
            ((String p0, int p1) {
                  return D4.extractBridgedArg<
                        $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                      >(
                        D4.callInterpreterCallback(
                          visitor!,
                          adapterFactoryRaw,
                          [p0, p1],
                        ),
                        'callback',
                        visitor,
                      )
                      as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter;
                })
                as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          minPort: minPort,
          maxPort: maxPort,
          fetchIdentity: fetchIdentity,
          adapterFactory: adapterFactory,
        );
      }
      if (!named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity') &&
          named.containsKey('adapterFactory')) {
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        final adapterFactoryRaw = named['adapterFactory'];
        final adapterFactory =
            ((String p0, int p1) {
                  return D4.extractBridgedArg<
                        $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                      >(
                        D4.callInterpreterCallback(
                          visitor!,
                          adapterFactoryRaw,
                          [p0, p1],
                        ),
                        'callback',
                        visitor,
                      )
                      as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter;
                })
                as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          probe: probe,
          fetchIdentity: fetchIdentity,
          adapterFactory: adapterFactory,
        );
      }
      if (named.containsKey('minPort') &&
          !named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity') &&
          named.containsKey('adapterFactory')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'connectToWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        final adapterFactoryRaw = named['adapterFactory'];
        final adapterFactory =
            ((String p0, int p1) {
                  return D4.extractBridgedArg<
                        $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                      >(
                        D4.callInterpreterCallback(
                          visitor!,
                          adapterFactoryRaw,
                          [p0, p1],
                        ),
                        'callback',
                        visitor,
                      )
                      as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter;
                })
                as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          minPort: minPort,
          probe: probe,
          fetchIdentity: fetchIdentity,
          adapterFactory: adapterFactory,
        );
      }
      if (!named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity') &&
          named.containsKey('adapterFactory')) {
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'connectToWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        final adapterFactoryRaw = named['adapterFactory'];
        final adapterFactory =
            ((String p0, int p1) {
                  return D4.extractBridgedArg<
                        $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                      >(
                        D4.callInterpreterCallback(
                          visitor!,
                          adapterFactoryRaw,
                          [p0, p1],
                        ),
                        'callback',
                        visitor,
                      )
                      as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter;
                })
                as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          maxPort: maxPort,
          probe: probe,
          fetchIdentity: fetchIdentity,
          adapterFactory: adapterFactory,
        );
      }
      if (named.containsKey('minPort') &&
          named.containsKey('maxPort') &&
          named.containsKey('probe') &&
          named.containsKey('fetchIdentity') &&
          named.containsKey('adapterFactory')) {
        final minPort = D4.getRequiredNamedArg<int>(
          named,
          'minPort',
          'connectToWorkspace',
        );
        final maxPort = D4.getRequiredNamedArg<int>(
          named,
          'maxPort',
          'connectToWorkspace',
        );
        final probeRaw = named['probe'];
        final probe =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, probeRaw, [p0, p1]),
                  ).then((v) => v as bool);
                })
                as Future<bool> Function(String, int);
        final fetchIdentityRaw = named['fetchIdentity'];
        final fetchIdentity =
            ((String p0, int p1) {
                  return Future.value(
                    D4.callInterpreterCallback(visitor!, fetchIdentityRaw, [
                      p0,
                      p1,
                    ]),
                  ).then((v) => v as String?);
                })
                as Future<String?> Function(String, int);
        final adapterFactoryRaw = named['adapterFactory'];
        final adapterFactory =
            ((String p0, int p1) {
                  return D4.extractBridgedArg<
                        $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                      >(
                        D4.callInterpreterCallback(
                          visitor!,
                          adapterFactoryRaw,
                          [p0, p1],
                        ),
                        'callback',
                        visitor,
                      )
                      as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter;
                })
                as $tom_vscode_scripting_api_22.LazyVSCodeBridgeAdapter
                Function(String, int);
        return $tom_vscode_scripting_api_11.connectToWorkspace(
          name,
          host: host,
          initializeVSCode: initializeVSCode,
          minPort: minPort,
          maxPort: maxPort,
          probe: probe,
          fetchIdentity: fetchIdentity,
          adapterFactory: adapterFactory,
        );
      }
      throw StateError(
        'Unreachable: all named parameter combinations should be covered',
      );
    },
    'fetchBridgeWorkspaceName': (visitor, positional, named, typeArgs) {
      D4.requireMinArgs(positional, 2, 'fetchBridgeWorkspaceName');
      final host = D4.getRequiredArg<String>(
        positional,
        0,
        'host',
        'fetchBridgeWorkspaceName',
      );
      final port = D4.getRequiredArg<int>(
        positional,
        1,
        'port',
        'fetchBridgeWorkspaceName',
      );
      return $tom_vscode_scripting_api_11.fetchBridgeWorkspaceName(
        host,
        port,
      );
    },
    'normalizeWorkspaceName': (visitor, positional, named, typeArgs) {
      D4.requireMinArgs(positional, 1, 'normalizeWorkspaceName');
      final value = D4.getRequiredArg<String>(
        positional,
        0,
        'value',
        'normalizeWorkspaceName',
      );
      return $tom_vscode_scripting_api_11.normalizeWorkspaceName(value);
    },
    'dispatchCanUseTool': (visitor, positional, named, typeArgs) {
      D4.requireMinArgs(positional, 2, 'dispatchCanUseTool');
      if (positional.isEmpty) {
        throw ArgumentError(
          'dispatchCanUseTool: Missing required argument "callback" at position 0',
        );
      }
      final callbackRaw = positional[0];
      final callback =
          ((
                String p0,
                Map<String, dynamic> p1,
                $tom_vscode_scripting_api_6.CanUseToolContext p2,
              ) {
                return Future.value(
                  D4.callInterpreterCallback(visitor!, callbackRaw, [
                    p0,
                    p1,
                    p2,
                  ]),
                ).then(
                  (v) => v as $tom_vscode_scripting_api_6.PermissionResult,
                );
              })
              as Future<$tom_vscode_scripting_api_6.PermissionResult>
              Function(
                String,
                Map<String, dynamic>,
                $tom_vscode_scripting_api_6.CanUseToolContext,
              );
      final params = D4.getRequiredArg<Map<String, dynamic>>(
        positional,
        1,
        'params',
        'dispatchCanUseTool',
      );
      return $tom_vscode_scripting_api_5.dispatchCanUseTool(callback, params);
    },
  };
}