<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def _generate_client_h(self, api):
 """Generates client base header file. For each namespace, the client will have an object field that encapsulates each route in the particular namespace."""

        self.emit_raw(stone_warning)

        self.emit('#import <Foundation/Foundation.h>')

        import_classes = [
            fmt_routes_class(ns.name, self.args.auth_type)
            for ns in api.namespaces.values()
            if ns.routes and self.namespace_to_has_routes[ns]
        ]
        import_classes.append('DBRequestErrors')
        import_classes.append('DBTasks')

        self._generate_imports_m(import_classes)
        self.emit()
        self.emit('NS_ASSUME_NONNULL_BEGIN')
        self.emit()
        self.emit('@protocol {};'.format(self.args.transport_client_name))
        self.emit()

        self.emit(comment_prefix)
        description_str = (
            'Base client object that contains an instance field for '
            'each namespace, each of which contains references to all routes within '
            'that namespace. Fully-implemented API clients will inherit this class.'
        )
        self.emit_wrapped_text(description_str, prefix=comment_prefix)
        self.emit(comment_prefix)
        with self.block_h(
                self.args.class_name,
                protected=[
                    ('transportClient',
                     'id<{}>'.format(self.args.transport_client_name))
                ]):
            self.emit()
            for namespace in api.namespaces.values():
                if namespace.routes and self.namespace_to_has_routes[namespace]:
                    class_doc = 'Routes within the `{}` namespace.'.format(
                        fmt_var(namespace.name))
                    self.emit_wrapped_text(class_doc, prefix=comment_prefix)
                    prop = '{}Routes'.format(fmt_var(namespace.name))
                    typ = '{} *'.format(
                        fmt_routes_class(namespace.name, self.args.auth_type))
                    self.emit(fmt_property_str(prop=prop, typ=typ))
                    self.emit()

            client_args = fmt_func_args_declaration(
                [('client',
                  'id<{}>'.format(self.args.transport_client_name))])

            description_str = (
                'Initializes the `{}` object with a networking client.')
            self.emit_wrapped_text(
                description_str.format(self.args.class_name),
                prefix=comment_prefix)
            init_signature = fmt_signature(
                func='initWithTransportClient',
                args=client_args,
                return_type='instancetype')
            self.emit('{};'.format(init_signature))
            self.emit()

        self.emit()
        self.emit('NS_ASSUME_NONNULL_END')