from peewee import *
from playhouse.postgres_ext import *

database = PostgresqlDatabase('gitlabhq_production', **{'host': '/var/opt/gitlab/postgresql', 'user': 'gitlab'})

class UnknownField(object):
    def __init__(self, *_, **__): pass

class BaseModel(Model):
    class Meta:
        database = database

class AbuseReports(BaseModel):
    cached_markdown_version = IntegerField(null=True)
    created_at = DateTimeField(null=True)
    message = TextField(null=True)
    message_html = TextField(null=True)
    reporter = IntegerField(db_column='reporter_id', null=True)
    updated_at = DateTimeField(null=True)
    user = IntegerField(db_column='user_id', index=True, null=True)

    class Meta:
        db_table = 'abuse_reports'

class ApplicationSettingTerms(BaseModel):
    cached_markdown_version = IntegerField(null=True)
    terms = TextField()
    terms_html = TextField(null=True)

    class Meta:
        db_table = 'application_setting_terms'

# Possible reference cycle: users
class Shards(BaseModel):
    name = CharField(unique=True)

    class Meta:
        db_table = 'shards'

# Possible reference cycle: projects
class PoolRepositories(BaseModel):
    disk_path = CharField(null=True, unique=True)
    id = BigIntegerField(primary_key=True)
    shard = ForeignKeyField(db_column='shard_id', rel_model=Shards, to_field='id')
    source_project = ForeignKeyField(db_column='source_project_id', null=True, rel_model=Projects, to_field='id')
    state = CharField(null=True)

    class Meta:
        db_table = 'pool_repositories'
        indexes = (
            (('shard', 'source_project'), True),
        )

# Possible reference cycle: namespaces
class Projects(BaseModel):
    approvals_before_merge = IntegerField()
    archived = BooleanField()
    auto_cancel_pending_pipelines = IntegerField()
    autoclose_referenced_issues = BooleanField(null=True)
    avatar = CharField(null=True)
    bfg_object_map = CharField(null=True)
    build_allow_git_fetch = BooleanField()
    build_coverage_regex = CharField(null=True)
    build_timeout = IntegerField()
    cached_markdown_version = IntegerField(null=True)
    ci_config_path = CharField(null=True)
    container_registry_enabled = BooleanField(null=True)
    created_at = DateTimeField(null=True)
    creator = IntegerField(db_column='creator_id', null=True)
    delete_error = TextField(null=True)
    description = TextField(index=True, null=True)
    description_html = TextField(null=True)
    detected_repository_languages = BooleanField(null=True)
    disable_overriding_approvers_per_merge_request = BooleanField(null=True)
    emails_disabled = BooleanField(null=True)
    external_authorization_classification_label = CharField(null=True)
    external_webhook_token = CharField(null=True)
    has_external_issue_tracker = BooleanField(null=True)
    has_external_wiki = BooleanField(null=True)
    import_source = CharField(null=True)
    import_type = CharField(null=True)
    import_url = CharField(null=True)
    issues_template = TextField(null=True)
    jobs_cache_index = IntegerField(null=True)
    last_activity_at = DateTimeField(null=True)
    last_repository_check_at = DateTimeField(index=True, null=True)
    last_repository_check_failed = BooleanField(index=True, null=True)
    last_repository_updated_at = DateTimeField(index=True, null=True)
    lfs_enabled = BooleanField(null=True)
    marked_for_deletion_at = DateField(index=True, null=True)
    marked_for_deletion_by_user = ForeignKeyField(db_column='marked_for_deletion_by_user_id', null=True, rel_model=Users, to_field='id')
    max_artifacts_size = IntegerField(null=True)
    max_pages_size = IntegerField(null=True)
    merge_requests_author_approval = BooleanField(null=True)
    merge_requests_disable_committers_approval = BooleanField(null=True)
    merge_requests_ff_only_enabled = BooleanField(null=True)
    merge_requests_rebase_enabled = BooleanField(null=True)
    merge_requests_template = TextField(null=True)
    mirror = BooleanField()
    mirror_last_successful_update_at = DateTimeField(index=True, null=True)
    mirror_last_update_at = DateTimeField(null=True)
    mirror_overwrites_diverged_branches = BooleanField(null=True)
    mirror_trigger_builds = BooleanField()
    mirror_user = IntegerField(db_column='mirror_user_id', index=True, null=True)
    name = CharField(index=True, null=True)
    namespace = ForeignKeyField(db_column='namespace_id', rel_model=Namespaces, to_field='id')
    only_allow_merge_if_all_discussions_are_resolved = BooleanField(null=True)
    only_allow_merge_if_pipeline_succeeds = BooleanField()
    only_mirror_protected_branches = BooleanField(null=True)
    packages_enabled = BooleanField(null=True)
    pages_https_only = BooleanField(null=True)
    path = CharField(index=True, null=True)
    pending_delete = BooleanField(index=True, null=True)
    pool_repository = ForeignKeyField(db_column='pool_repository_id', null=True, rel_model=PoolRepositories, to_field='id')
    printing_merge_request_link_enabled = BooleanField()
    public_builds = BooleanField()
    pull_mirror_available_overridden = BooleanField(null=True)
    pull_mirror_branch_prefix = CharField(null=True)
    remote_mirror_available_overridden = BooleanField(null=True)
    remove_source_branch_after_merge = BooleanField(null=True)
    repository_read_only = BooleanField(null=True)
    repository_size_limit = BigIntegerField(null=True)
    repository_storage = CharField(index=True)
    request_access_enabled = BooleanField()
    require_password_to_approve = BooleanField(null=True)
    reset_approvals_on_push = BooleanField(null=True)
    resolve_outdated_diff_discussions = BooleanField(null=True)
    runners_token = CharField(index=True, null=True)
    runners_token_encrypted = CharField(index=True, null=True)
    service_desk_enabled = BooleanField(null=True)
    shared_runners_enabled = BooleanField()
    star_count = IntegerField(index=True)
    storage_version = IntegerField(null=True)
    suggestion_commit_message = CharField(null=True)
    updated_at = DateTimeField(null=True)
    visibility_level = IntegerField()

    class Meta:
        db_table = 'projects'
        indexes = (
            (('created_at', 'creator'), False),
            (('created_at', 'id'), False),
            (('created_at', 'id'), False),
            (('created_at', 'id'), False),
            (('created_at', 'id'), False),
            (('created_at', 'id'), False),
            (('creator', 'created_at', 'id'), False),
            (('creator', 'id'), False),
            (('id', 'created_at'), False),
            (('id', 'created_at'), False),
            (('id', 'created_at'), False),
            (('id', 'creator', 'created_at'), False),
            (('id', 'last_activity_at'), False),
            (('id', 'name'), False),
            (('id', 'path'), False),
            (('last_activity_at', 'id'), False),
            (('last_activity_at', 'id'), False),
            (('last_repository_updated_at', 'repository_storage', 'id'), False),
            (('name', 'id'), False),
            (('name', 'id'), False),
            (('namespace', 'id'), False),
            (('path', 'id'), False),
            (('path', 'id'), False),
            (('repository_storage', 'created_at'), False),
            (('updated_at', 'id'), False),
            (('updated_at', 'id'), False),
            (('updated_at', 'id'), False),
        )

class PushRules(BaseModel):
    author_email_regex = CharField(null=True)
    branch_name_regex = CharField(null=True)
    commit_committer_check = BooleanField(null=True)
    commit_message_negative_regex = CharField(null=True)
    commit_message_regex = CharField(null=True)
    created_at = DateTimeField(null=True)
    delete_branch_regex = CharField(null=True)
    deny_delete_tag = BooleanField(null=True)
    file_name_regex = CharField(null=True)
    force_push_regex = CharField(null=True)
    is_sample = BooleanField(index=True, null=True)
    max_file_size = IntegerField()
    member_check = BooleanField()
    prevent_secrets = BooleanField()
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    regexp_uses_re2 = BooleanField(null=True)
    reject_unsigned_commits = BooleanField(null=True)
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'push_rules'

class Namespaces(BaseModel):
    allow_descendants_override_disabled_shared_runners = BooleanField()
    auto_devops_enabled = BooleanField(null=True)
    avatar = CharField(null=True)
    cached_markdown_version = IntegerField(null=True)
    created_at = DateTimeField(index=True, null=True)
    custom_project_templates_group = ForeignKeyField(db_column='custom_project_templates_group_id', null=True, rel_model='self', to_field='id')
    default_branch_protection = IntegerField(null=True)
    delayed_project_removal = BooleanField()
    description = CharField()
    description_html = TextField(null=True)
    emails_disabled = BooleanField(null=True)
    extra_shared_runners_minutes_limit = IntegerField(null=True)
    file_template_project = ForeignKeyField(db_column='file_template_project_id', null=True, rel_model=Projects, to_field='id')
    last_ci_minutes_notification_at = DateTimeField(null=True)
    last_ci_minutes_usage_notification_level = IntegerField(null=True)
    ldap_sync_error = CharField(null=True)
    ldap_sync_last_successful_update_at = DateTimeField(index=True, null=True)
    ldap_sync_last_sync_at = DateTimeField(null=True)
    ldap_sync_last_update_at = DateTimeField(index=True, null=True)
    ldap_sync_status = CharField()
    lfs_enabled = BooleanField(null=True)
    max_artifacts_size = IntegerField(null=True)
    max_pages_size = IntegerField(null=True)
    max_personal_access_token_lifetime = IntegerField(null=True)
    membership_lock = BooleanField(null=True)
    mentions_disabled = BooleanField(null=True)
    name = CharField(index=True)
    owner = IntegerField(db_column='owner_id', index=True, null=True)
    parent = IntegerField(db_column='parent_id', null=True)
    path = CharField(index=True)
    project_creation_level = IntegerField(null=True)
    push_rule = ForeignKeyField(db_column='push_rule_id', null=True, rel_model=PushRules, to_field='id', unique=True)
    repository_size_limit = BigIntegerField(null=True)
    request_access_enabled = BooleanField()
    require_two_factor_authentication = BooleanField(index=True)
    runners_token = CharField(null=True, unique=True)
    runners_token_encrypted = CharField(null=True, unique=True)
    saml_discovery_token = CharField(null=True)
    share_with_group_lock = BooleanField(null=True)
    shared_runners_enabled = BooleanField()
    shared_runners_minutes_limit = IntegerField(null=True)
    subgroup_creation_level = IntegerField(null=True)
    traversal_ids = UnknownField()  # ARRAY
    two_factor_grace_period = IntegerField()
    type = CharField(index=True, null=True)
    unlock_membership_to_ldap = BooleanField(null=True)
    updated_at = DateTimeField(null=True)
    visibility_level = IntegerField()

    class Meta:
        db_table = 'namespaces'
        indexes = (
            (('extra_shared_runners_minutes_limit', 'shared_runners_minutes_limit'), False),
            (('id', 'parent'), True),
            (('name', 'parent'), True),
            (('type', 'custom_project_templates_group'), False),
        )

class Users(BaseModel):
    accepted_term = ForeignKeyField(db_column='accepted_term_id', null=True, rel_model=ApplicationSettingTerms, to_field='id')
    admin = BooleanField(index=True)
    admin_email_unsubscribed_at = DateTimeField(null=True)
    auditor = BooleanField()
    avatar = CharField(null=True)
    bio = CharField(null=True)
    can_create_group = BooleanField()
    can_create_team = BooleanField()
    color_scheme = IntegerField(db_column='color_scheme_id')
    commit_email = CharField(null=True)
    confirmation_sent_at = DateTimeField(null=True)
    confirmation_token = CharField(null=True, unique=True)
    confirmed_at = DateTimeField(null=True)
    consumed_timestep = IntegerField(null=True)
    created_at = DateTimeField(index=True, null=True)
    created_by = IntegerField(db_column='created_by_id', null=True)
    current_sign_in_at = DateTimeField(null=True)
    current_sign_in_ip = CharField(null=True)
    dashboard = IntegerField(null=True)
    email = CharField(index=True)
    email_opted_in = BooleanField(null=True)
    email_opted_in_at = DateTimeField(null=True)
    email_opted_in_ip = CharField(null=True)
    email_opted_in_source = IntegerField(db_column='email_opted_in_source_id', null=True)
    encrypted_otp_secret = CharField(null=True)
    encrypted_otp_secret_iv = CharField(null=True)
    encrypted_otp_secret_salt = CharField(null=True)
    encrypted_password = CharField()
    external = BooleanField(null=True)
    failed_attempts = IntegerField(null=True)
    feed_token = CharField(index=True, null=True)
    first_name = CharField(null=True)
    group_view = IntegerField(index=True, null=True)
    hide_no_password = BooleanField(null=True)
    hide_no_ssh_key = BooleanField(null=True)
    hide_project_limit = BooleanField(null=True)
    include_private_contributions = BooleanField(null=True)
    incoming_email_token = CharField(index=True, null=True)
    last_activity_on = DateField(null=True)
    last_credential_check_at = DateTimeField(null=True)
    last_name = CharField(null=True)
    last_sign_in_at = DateTimeField(null=True)
    last_sign_in_ip = CharField(null=True)
    layout = IntegerField(null=True)
    linkedin = CharField()
    location = CharField(null=True)
    locked_at = DateTimeField(null=True)
    managing_group = ForeignKeyField(db_column='managing_group_id', null=True, rel_model=Namespaces, to_field='id')
    name = CharField(index=True, null=True)
    note = TextField(null=True)
    notification_email = CharField(null=True)
    notified_of_own_activity = BooleanField(null=True)
    organization = CharField(null=True)
    otp_backup_codes = TextField(null=True)
    otp_grace_period_started_at = DateTimeField(null=True)
    otp_required_for_login = BooleanField()
    password_automatically_set = BooleanField(null=True)
    password_expires_at = DateTimeField(null=True)
    preferred_language = CharField(null=True)
    private_profile = BooleanField()
    project_view = IntegerField(null=True)
    projects_limit = IntegerField()
    public_email = CharField(index=True)
    remember_created_at = DateTimeField(null=True)
    require_two_factor_authentication_from_group = BooleanField()
    reset_password_sent_at = DateTimeField(null=True)
    reset_password_token = CharField(null=True, unique=True)
    roadmap_layout = IntegerField(null=True)
    role = IntegerField(null=True)
    sign_in_count = IntegerField(null=True)
    skype = CharField()
    state = CharField(index=True, null=True)
    static_object_token = CharField(null=True, unique=True)
    theme = IntegerField(db_column='theme_id', null=True)
    twitter = CharField()
    two_factor_grace_period = IntegerField()
    unconfirmed_email = CharField(index=True, null=True)
    unlock_token = CharField(null=True, unique=True)
    updated_at = DateTimeField(null=True)
    user_type = IntegerField(index=True, null=True)
    username = CharField(index=True, null=True)
    website_url = CharField()

    class Meta:
        db_table = 'users'
        indexes = (
            (('user_type', 'state'), False),
        )

class Sprints(BaseModel):
    cached_markdown_version = IntegerField(null=True)
    created_at = DateTimeField()
    description = TextField(index=True, null=True)
    description_html = TextField(null=True)
    due_date = DateField(index=True, null=True)
    group = ForeignKeyField(db_column='group_id', null=True, rel_model=Namespaces, to_field='id')
    id = BigIntegerField(primary_key=True)
    iid = IntegerField()
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    start_date = DateField(null=True)
    state_enum = IntegerField()
    title = TextField(index=True)
    title_html = TextField(null=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'sprints'
        indexes = (
            (('group', 'title'), True),
            (('project', 'iid'), True),
            (('project', 'title'), True),
        )

class Milestones(BaseModel):
    cached_markdown_version = IntegerField(null=True)
    created_at = DateTimeField(null=True)
    description = TextField(index=True, null=True)
    description_html = TextField(null=True)
    due_date = DateField(index=True, null=True)
    group = ForeignKeyField(db_column='group_id', null=True, rel_model=Namespaces, to_field='id')
    iid = IntegerField(null=True)
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    start_date = DateField(null=True)
    state = CharField(null=True)
    title = CharField(index=True)
    title_html = TextField(null=True)
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'milestones'
        indexes = (
            (('project', 'iid'), True),
        )

class Epics(BaseModel):
    assignee = ForeignKeyField(db_column='assignee_id', null=True, rel_model=Users, to_field='id')
    author = ForeignKeyField(db_column='author_id', rel_model=Users, related_name='users_author_set', to_field='id')
    cached_markdown_version = IntegerField(null=True)
    closed_at = DateTimeField(null=True)
    closed_by = ForeignKeyField(db_column='closed_by_id', null=True, rel_model=Users, related_name='users_closed_by_set', to_field='id')
    confidential = BooleanField(index=True)
    created_at = DateTimeField()
    description = TextField(null=True)
    description_html = TextField(null=True)
    due_date_fixed = DateField(null=True)
    due_date_is_fixed = BooleanField(null=True)
    due_date_sourcing_epic = ForeignKeyField(db_column='due_date_sourcing_epic_id', null=True, rel_model='self', to_field='id')
    due_date_sourcing_milestone = ForeignKeyField(db_column='due_date_sourcing_milestone_id', null=True, rel_model=Milestones, to_field='id')
    end_date = DateField(index=True, null=True)
    external_key = CharField(null=True)
    group = ForeignKeyField(db_column='group_id', rel_model=Namespaces, to_field='id')
    iid = IntegerField(index=True)
    last_edited_at = DateTimeField(null=True)
    last_edited_by = IntegerField(db_column='last_edited_by_id', index=True, null=True)
    lock_version = IntegerField(null=True)
    parent = ForeignKeyField(db_column='parent_id', null=True, rel_model='self', related_name='epics_parent_set', to_field='id')
    relative_position = IntegerField(null=True)
    start_date = DateField(index=True, null=True)
    start_date_fixed = DateField(null=True)
    start_date_is_fixed = BooleanField(null=True)
    start_date_sourcing_epic = ForeignKeyField(db_column='start_date_sourcing_epic_id', null=True, rel_model='self', related_name='epics_start_date_sourcing_epic_set', to_field='id')
    start_date_sourcing_milestone = ForeignKeyField(db_column='start_date_sourcing_milestone_id', null=True, rel_model=Milestones, related_name='milestones_start_date_sourcing_milestone_set', to_field='id')
    state = IntegerField(db_column='state_id')
    title = CharField()
    title_html = CharField()
    updated_at = DateTimeField()
    updated_by = IntegerField(db_column='updated_by_id', null=True)

    class Meta:
        db_table = 'epics'
        indexes = (
            (('external_key', 'group'), True),
        )

class Issues(BaseModel):
    author = ForeignKeyField(db_column='author_id', null=True, rel_model=Users, to_field='id')
    blocking_issues_count = IntegerField()
    cached_markdown_version = IntegerField(null=True)
    closed_at = DateTimeField(null=True)
    closed_by = ForeignKeyField(db_column='closed_by_id', null=True, rel_model=Users, related_name='users_closed_by_set', to_field='id')
    confidential = BooleanField(index=True)
    created_at = DateTimeField(null=True)
    description = TextField(index=True, null=True)
    description_html = TextField(null=True)
    discussion_locked = BooleanField(null=True)
    due_date = DateField(null=True)
    duplicated_to = ForeignKeyField(db_column='duplicated_to_id', null=True, rel_model='self', to_field='id')
    external_key = CharField(null=True)
    health_status = IntegerField(index=True, null=True)
    iid = IntegerField(null=True)
    issue_type = IntegerField(index=True)
    last_edited_at = DateTimeField(null=True)
    last_edited_by = IntegerField(db_column='last_edited_by_id', index=True, null=True)
    lock_version = IntegerField(null=True)
    milestone = ForeignKeyField(db_column='milestone_id', null=True, rel_model=Milestones, to_field='id')
    moved_to = ForeignKeyField(db_column='moved_to_id', null=True, rel_model='self', related_name='issues_moved_to_set', to_field='id')
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    promoted_to_epic = ForeignKeyField(db_column='promoted_to_epic_id', null=True, rel_model=Epics, to_field='id')
    relative_position = IntegerField(index=True, null=True)
    service_desk_reply_to = CharField(null=True)
    sprint = ForeignKeyField(db_column='sprint_id', null=True, rel_model=Sprints, to_field='id')
    state = IntegerField(db_column='state_id', index=True)
    time_estimate = IntegerField(null=True)
    title = CharField(index=True, null=True)
    title_html = TextField(null=True)
    updated_at = DateTimeField(index=True, null=True)
    updated_by = ForeignKeyField(db_column='updated_by_id', null=True, rel_model=Users, related_name='users_updated_by_set', to_field='id')
    weight = IntegerField(null=True)

    class Meta:
        db_table = 'issues'
        indexes = (
            (('created_at', 'author', 'id'), False),
            (('id', 'state', 'relative_position', 'project'), False),
            (('project', 'external_key'), True),
            (('project', 'iid'), True),
            (('project', 'state', 'blocking_issues_count'), False),
            (('project', 'state', 'created_at', 'id'), False),
            (('project', 'state', 'id', 'updated_at'), False),
            (('state', 'due_date', 'project', 'id'), False),
        )

class Environments(BaseModel):
    auto_stop_at = DateTimeField(index=True, null=True)
    created_at = DateTimeField(null=True)
    environment_type = CharField(null=True)
    external_url = CharField(null=True)
    name = CharField(index=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    slug = CharField()
    state = CharField()
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'environments'
        indexes = (
            (('project', 'environment_type', 'state'), False),
            (('project', 'name'), True),
            (('slug', 'project'), True),
            (('state', 'auto_stop_at'), False),
        )

class PrometheusMetrics(BaseModel):
    common = BooleanField(index=True)
    created_at = DateTimeField()
    dashboard_path = TextField(null=True)
    group = IntegerField(index=True)
    identifier = CharField(null=True, unique=True)
    legend = CharField(null=True)
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    query = CharField()
    title = CharField()
    unit = CharField()
    updated_at = DateTimeField()
    y_label = CharField()

    class Meta:
        db_table = 'prometheus_metrics'
        indexes = (
            (('project', 'identifier'), True),
        )

class PrometheusAlerts(BaseModel):
    created_at = DateTimeField()
    environment = ForeignKeyField(db_column='environment_id', rel_model=Environments, to_field='id')
    operator = IntegerField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    prometheus_metric = ForeignKeyField(db_column='prometheus_metric_id', rel_model=PrometheusMetrics, to_field='id')
    runbook_url = TextField(null=True)
    threshold = FloatField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'prometheus_alerts'
        indexes = (
            (('environment', 'project', 'prometheus_metric'), True),
        )

class AlertManagementAlerts(BaseModel):
    created_at = DateTimeField()
    description = TextField(null=True)
    ended_at = DateTimeField(null=True)
    environment = ForeignKeyField(db_column='environment_id', null=True, rel_model=Environments, to_field='id')
    events = IntegerField()
    fingerprint = BlobField(null=True)
    hosts = UnknownField()  # ARRAY
    id = BigIntegerField(primary_key=True)
    iid = IntegerField()
    issue = ForeignKeyField(db_column='issue_id', null=True, rel_model=Issues, to_field='id')
    monitoring_tool = TextField(null=True)
    payload = JSONField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    prometheus_alert = ForeignKeyField(db_column='prometheus_alert_id', null=True, rel_model=PrometheusAlerts, to_field='id')
    service = TextField(null=True)
    severity = IntegerField()
    started_at = DateTimeField()
    status = IntegerField()
    title = TextField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'alert_management_alerts'
        indexes = (
            (('project', 'fingerprint'), True),
            (('project', 'iid'), True),
        )

class AlertManagementAlertAssignees(BaseModel):
    alert = ForeignKeyField(db_column='alert_id', rel_model=AlertManagementAlerts, to_field='id')
    id = BigIntegerField(primary_key=True)
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'alert_management_alert_assignees'
        indexes = (
            (('user', 'alert'), True),
        )

# Possible reference cycle: merge_requests
class MergeRequestDiffs(BaseModel):
    base_commit_sha = CharField(null=True)
    commits_count = IntegerField(null=True)
    created_at = DateTimeField(null=True)
    external_diff = CharField(null=True)
    external_diff_store = IntegerField(index=True, null=True)
    files_count = IntegerField(null=True)
    head_commit_sha = CharField(null=True)
    merge_request = ForeignKeyField(db_column='merge_request_id', rel_model=MergeRequests, to_field='id')
    real_size = CharField(null=True)
    start_commit_sha = CharField(null=True)
    state = CharField(null=True)
    stored_externally = BooleanField(null=True)
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'merge_request_diffs'
        indexes = (
            (('id', 'merge_request'), False),
        )

class ExternalPullRequests(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    pull_request_iid = IntegerField()
    source_branch = CharField()
    source_repository = CharField()
    source_sha = BlobField()
    status = IntegerField()
    target_branch = CharField()
    target_repository = CharField()
    target_sha = BlobField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'external_pull_requests'
        indexes = (
            (('project', 'source_branch', 'target_branch'), True),
        )

class CiPipelineSchedules(BaseModel):
    active = BooleanField(null=True)
    created_at = DateTimeField(null=True)
    cron = CharField(null=True)
    cron_timezone = CharField(null=True)
    description = CharField(null=True)
    next_run_at = DateTimeField(null=True)
    owner = ForeignKeyField(db_column='owner_id', null=True, rel_model=Users, to_field='id')
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    ref = CharField(null=True)
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'ci_pipeline_schedules'
        indexes = (
            (('next_run_at', 'active'), False),
        )

# Possible reference cycle: merge_requests
class CiRefs(BaseModel):
    id = BigIntegerField(primary_key=True)
    lock_version = IntegerField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    ref_path = TextField()
    status = IntegerField()

    class Meta:
        db_table = 'ci_refs'
        indexes = (
            (('project', 'ref_path'), True),
        )

class CiPipelines(BaseModel):
    auto_canceled_by = ForeignKeyField(db_column='auto_canceled_by_id', null=True, rel_model='self', to_field='id')
    before_sha = CharField(null=True)
    ci_ref = ForeignKeyField(db_column='ci_ref_id', null=True, rel_model=CiRefs, to_field='id')
    committed_at = DateTimeField(null=True)
    config_source = IntegerField(null=True)
    created_at = DateTimeField(null=True)
    duration = IntegerField(null=True)
    external_pull_request = ForeignKeyField(db_column='external_pull_request_id', null=True, rel_model=ExternalPullRequests, to_field='id')
    failure_reason = IntegerField(null=True)
    finished_at = DateTimeField(null=True)
    iid = IntegerField(null=True)
    lock_version = IntegerField(null=True)
    locked = IntegerField()
    merge_request = ForeignKeyField(db_column='merge_request_id', null=True, rel_model=MergeRequests, to_field='id')
    pipeline_schedule = ForeignKeyField(db_column='pipeline_schedule_id', null=True, rel_model=CiPipelineSchedules, to_field='id')
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    protected = BooleanField(null=True)
    ref = CharField(null=True)
    sha = CharField(null=True)
    source = IntegerField(null=True)
    source_sha = BlobField(null=True)
    started_at = DateTimeField(null=True)
    status = CharField(index=True, null=True)
    tag = BooleanField(null=True)
    target_sha = BlobField(null=True)
    updated_at = DateTimeField(null=True)
    user = IntegerField(db_column='user_id', null=True)
    yaml_errors = TextField(null=True)

    class Meta:
        db_table = 'ci_pipelines'
        indexes = (
            (('ci_ref', 'id'), False),
            (('config_source', 'status', 'project'), False),
            (('created_at', 'project'), False),
            (('id', 'project'), False),
            (('id', 'project', 'ref'), False),
            (('iid', 'project'), True),
            (('project', 'status', 'ref', 'id'), False),
            (('project', 'user', 'status', 'ref'), False),
            (('sha', 'project'), False),
            (('source', 'project'), False),
            (('updated_at', 'status', 'project'), False),
            (('user', 'config_source', 'created_at'), False),
            (('user', 'source', 'created_at'), False),
        )

class MergeRequests(BaseModel):
    allow_maintainer_to_push = BooleanField(null=True)
    approvals_before_merge = IntegerField(null=True)
    assignee = ForeignKeyField(db_column='assignee_id', null=True, rel_model=Users, to_field='id')
    author = ForeignKeyField(db_column='author_id', null=True, rel_model=Users, related_name='users_author_set', to_field='id')
    cached_markdown_version = IntegerField(null=True)
    created_at = DateTimeField(index=True, null=True)
    description = TextField(index=True, null=True)
    description_html = TextField(null=True)
    discussion_locked = BooleanField(null=True)
    head_pipeline = ForeignKeyField(db_column='head_pipeline_id', null=True, rel_model=CiPipelines, to_field='id')
    iid = IntegerField(null=True)
    in_progress_merge_commit_sha = CharField(null=True)
    last_edited_at = DateTimeField(null=True)
    last_edited_by = IntegerField(db_column='last_edited_by_id', null=True)
    latest_merge_request_diff = ForeignKeyField(db_column='latest_merge_request_diff_id', null=True, rel_model=MergeRequestDiffs, to_field='id')
    lock_version = IntegerField(null=True)
    merge_commit_sha = CharField(null=True)
    merge_error = TextField(null=True)
    merge_jid = CharField(null=True)
    merge_params = TextField(null=True)
    merge_status = CharField()
    merge_user = ForeignKeyField(db_column='merge_user_id', null=True, rel_model=Users, related_name='users_merge_user_set', to_field='id')
    merge_when_pipeline_succeeds = BooleanField()
    milestone = ForeignKeyField(db_column='milestone_id', null=True, rel_model=Milestones, to_field='id')
    rebase_commit_sha = CharField(null=True)
    rebase_jid = CharField(null=True)
    source_branch = CharField(index=True)
    source_project = ForeignKeyField(db_column='source_project_id', null=True, rel_model=Projects, to_field='id')
    sprint = ForeignKeyField(db_column='sprint_id', null=True, rel_model=Sprints, to_field='id')
    squash = BooleanField()
    squash_commit_sha = BlobField(null=True)
    state = IntegerField(db_column='state_id')
    target_branch = CharField(index=True)
    target_project = ForeignKeyField(db_column='target_project_id', rel_model=Projects, related_name='projects_target_project_set', to_field='id')
    time_estimate = IntegerField(null=True)
    title = CharField(index=True, null=True)
    title_html = TextField(null=True)
    updated_at = DateTimeField(null=True)
    updated_by = ForeignKeyField(db_column='updated_by_id', null=True, rel_model=Users, related_name='users_updated_by_set', to_field='id')

    class Meta:
        db_table = 'merge_requests'
        indexes = (
            (('created_at', 'target_project'), False),
            (('id', 'merge_commit_sha', 'target_project'), False),
            (('id', 'merge_jid'), False),
            (('iid', 'target_project'), True),
            (('source_branch', 'source_project'), False),
            (('source_project', 'source_branch'), False),
            (('state', 'merge_status'), False),
            (('target_branch', 'target_project'), False),
            (('target_project', 'iid'), False),
        )

class Reviews(BaseModel):
    author = ForeignKeyField(db_column='author_id', null=True, rel_model=Users, to_field='id')
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    merge_request = ForeignKeyField(db_column='merge_request_id', rel_model=MergeRequests, to_field='id')
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')

    class Meta:
        db_table = 'reviews'

class Notes(BaseModel):
    attachment = CharField(null=True)
    author = IntegerField(db_column='author_id', null=True)
    cached_markdown_version = IntegerField(null=True)
    change_position = TextField(null=True)
    commit = CharField(db_column='commit_id', index=True, null=True)
    confidential = BooleanField(null=True)
    created_at = DateTimeField(index=True, null=True)
    discussion = CharField(db_column='discussion_id', index=True, null=True)
    line_code = CharField(index=True, null=True)
    note = TextField(index=True, null=True)
    note_html = TextField(null=True)
    noteable = IntegerField(db_column='noteable_id', null=True)
    noteable_type = CharField(null=True)
    original_position = TextField(null=True)
    position = TextField(null=True)
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    resolved_at = DateTimeField(null=True)
    resolved_by = IntegerField(db_column='resolved_by_id', null=True)
    resolved_by_push = BooleanField(null=True)
    review = ForeignKeyField(db_column='review_id', null=True, rel_model=Reviews, to_field='id')
    st_diff = TextField(null=True)
    system = BooleanField()
    type = CharField(null=True)
    updated_at = DateTimeField(null=True)
    updated_by = IntegerField(db_column='updated_by_id', null=True)

    class Meta:
        db_table = 'notes'
        indexes = (
            (('created_at', 'author', 'id'), False),
            (('noteable_type', 'id'), False),
            (('noteable_type', 'noteable'), False),
            (('noteable_type', 'project'), False),
            (('project', 'id'), False),
        )

class AlertManagementAlertUserMentions(BaseModel):
    alert_management_alert = ForeignKeyField(db_column='alert_management_alert_id', rel_model=AlertManagementAlerts, to_field='id', unique=True)
    id = BigIntegerField(primary_key=True)
    mentioned_groups_ids = UnknownField(null=True)  # ARRAY
    mentioned_projects_ids = UnknownField(null=True)  # ARRAY
    mentioned_users_ids = UnknownField(null=True)  # ARRAY
    note = ForeignKeyField(db_column='note_id', null=True, rel_model=Notes, to_field='id', unique=True)

    class Meta:
        db_table = 'alert_management_alert_user_mentions'
        indexes = (
            (('alert_management_alert', 'note'), True),
        )

class Services(BaseModel):
    active = BooleanField()
    alert_events = BooleanField(null=True)
    category = CharField()
    comment_detail = IntegerField(null=True)
    comment_on_event_enabled = BooleanField()
    commit_events = BooleanField()
    confidential_issues_events = BooleanField()
    confidential_note_events = BooleanField(null=True)
    created_at = DateTimeField(null=True)
    default = BooleanField(null=True)
    deployment_events = BooleanField()
    group = ForeignKeyField(db_column='group_id', null=True, rel_model=Namespaces, to_field='id')
    inherit_from = ForeignKeyField(db_column='inherit_from_id', null=True, rel_model='self', to_field='id')
    instance = BooleanField()
    issues_events = BooleanField(null=True)
    job_events = BooleanField()
    merge_requests_events = BooleanField(null=True)
    note_events = BooleanField()
    pipeline_events = BooleanField()
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    properties = TextField(null=True)
    push_events = BooleanField(null=True)
    tag_push_events = BooleanField(null=True)
    template = BooleanField(index=True, null=True)
    type = CharField(index=True, null=True)
    updated_at = DateTimeField(null=True)
    wiki_page_events = BooleanField(null=True)

    class Meta:
        db_table = 'services'
        indexes = (
            (('instance', 'type'), True),
            (('type', 'group'), True),
            (('type', 'id'), False),
            (('type', 'project'), False),
            (('type', 'template'), True),
        )

class AlertsServiceData(BaseModel):
    created_at = DateTimeField()
    encrypted_token = CharField(null=True)
    encrypted_token_iv = CharField(null=True)
    id = BigIntegerField(primary_key=True)
    service = ForeignKeyField(db_column='service_id', rel_model=Services, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'alerts_service_data'

class AllowedEmailDomains(BaseModel):
    created_at = DateTimeField()
    domain = CharField()
    group = ForeignKeyField(db_column='group_id', rel_model=Namespaces, to_field='id')
    id = BigIntegerField(primary_key=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'allowed_email_domains'

class AnalyticsCycleAnalyticsGroupValueStreams(BaseModel):
    created_at = DateTimeField()
    group = ForeignKeyField(db_column='group_id', rel_model=Namespaces, to_field='id')
    id = BigIntegerField(primary_key=True)
    name = TextField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'analytics_cycle_analytics_group_value_streams'
        indexes = (
            (('group', 'name'), True),
        )

class Labels(BaseModel):
    cached_markdown_version = IntegerField(null=True)
    color = CharField(null=True)
    created_at = DateTimeField(null=True)
    description = CharField(null=True)
    description_html = TextField(null=True)
    group = ForeignKeyField(db_column='group_id', null=True, rel_model=Namespaces, related_name='namespaces_group_set', to_field='id')
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, related_name='projects_project_set', to_field='id')
    template = BooleanField(index=True, null=True)
    title = CharField(index=True, null=True)
    type = CharField(null=True)
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'labels'
        indexes = (
            (('project', 'type'), False),
            (('title', 'group'), False),
            (('title', 'group', 'project'), True),
            (('title', 'project'), True),
        )

class AnalyticsCycleAnalyticsGroupStages(BaseModel):
    created_at = DateTimeField()
    custom = BooleanField()
    end_event_identifier = IntegerField()
    end_event_label = ForeignKeyField(db_column='end_event_label_id', null=True, rel_model=Labels, to_field='id')
    group = ForeignKeyField(db_column='group_id', rel_model=Namespaces, to_field='id')
    group_value_stream = ForeignKeyField(db_column='group_value_stream_id', rel_model=AnalyticsCycleAnalyticsGroupValueStreams, to_field='id')
    hidden = BooleanField()
    id = BigIntegerField(primary_key=True)
    name = CharField()
    relative_position = IntegerField(index=True, null=True)
    start_event_identifier = IntegerField()
    start_event_label = ForeignKeyField(db_column='start_event_label_id', null=True, rel_model=Labels, related_name='labels_start_event_label_set', to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'analytics_cycle_analytics_group_stages'
        indexes = (
            (('name', 'group_value_stream', 'group'), True),
        )

class AnalyticsCycleAnalyticsProjectStages(BaseModel):
    created_at = DateTimeField()
    custom = BooleanField()
    end_event_identifier = IntegerField()
    end_event_label = ForeignKeyField(db_column='end_event_label_id', null=True, rel_model=Labels, to_field='id')
    hidden = BooleanField()
    id = BigIntegerField(primary_key=True)
    name = CharField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    relative_position = IntegerField(index=True, null=True)
    start_event_identifier = IntegerField()
    start_event_label = ForeignKeyField(db_column='start_event_label_id', null=True, rel_model=Labels, related_name='labels_start_event_label_set', to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'analytics_cycle_analytics_project_stages'
        indexes = (
            (('project', 'name'), True),
        )

class ProgrammingLanguages(BaseModel):
    color = CharField()
    created_at = DateTimeField()
    name = CharField(unique=True)

    class Meta:
        db_table = 'programming_languages'

class AnalyticsLanguageTrendRepositoryLanguages(BaseModel):
    bytes = IntegerField()
    file_count = IntegerField()
    loc = IntegerField()
    percentage = IntegerField()
    programming_language = ForeignKeyField(db_column='programming_language_id', rel_model=ProgrammingLanguages, to_field='id')
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    snapshot_date = DateField()

    class Meta:
        db_table = 'analytics_language_trend_repository_languages'
        indexes = (
            (('programming_language', 'project', 'snapshot_date'), True),
        )

class Appearances(BaseModel):
    cached_markdown_version = IntegerField(null=True)
    created_at = DateTimeField()
    description = TextField()
    description_html = TextField(null=True)
    email_header_and_footer_enabled = BooleanField()
    favicon = CharField(null=True)
    footer_message = TextField(null=True)
    footer_message_html = TextField(null=True)
    header_logo = CharField(null=True)
    header_message = TextField(null=True)
    header_message_html = TextField(null=True)
    logo = CharField(null=True)
    message_background_color = TextField(null=True)
    message_font_color = TextField(null=True)
    new_project_guidelines = TextField(null=True)
    new_project_guidelines_html = TextField(null=True)
    profile_image_guidelines = TextField(null=True)
    profile_image_guidelines_html = TextField(null=True)
    title = CharField()
    updated_at = DateTimeField()
    updated_by = IntegerField(null=True)

    class Meta:
        db_table = 'appearances'

class ApplicationSettings(BaseModel):
    admin_notification_email = CharField(null=True)
    after_sign_out_path = CharField(null=True)
    after_sign_up_text = TextField(null=True)
    after_sign_up_text_html = TextField(null=True)
    akismet_enabled = BooleanField(null=True)
    allow_group_owners_to_manage_ldap = BooleanField()
    allow_local_requests_from_system_hooks = BooleanField()
    allow_local_requests_from_web_hooks_and_services = BooleanField()
    archive_builds_in_seconds = IntegerField(null=True)
    asset_proxy_enabled = BooleanField()
    asset_proxy_url = CharField(null=True)
    asset_proxy_whitelist = TextField(null=True)
    authorized_keys_enabled = BooleanField()
    auto_devops_domain = CharField(null=True)
    auto_devops_enabled = BooleanField()
    cached_markdown_version = IntegerField(null=True)
    check_namespace_plan = BooleanField()
    commit_email_hostname = CharField(null=True)
    compliance_frameworks = UnknownField()  # ARRAY
    container_expiration_policies_enable_historic_entries = BooleanField()
    container_registry_features = UnknownField()  # ARRAY
    container_registry_token_expire_delay = IntegerField(null=True)
    container_registry_vendor = TextField()
    container_registry_version = TextField()
    created_at = DateTimeField(null=True)
    custom_http_clone_url_root = CharField(null=True)
    custom_project_templates_group = ForeignKeyField(db_column='custom_project_templates_group_id', null=True, rel_model=Namespaces, to_field='id')
    default_artifacts_expire_in = CharField()
    default_branch_name = TextField(null=True)
    default_branch_protection = IntegerField(null=True)
    default_ci_config_path = CharField(null=True)
    default_group_visibility = IntegerField(null=True)
    default_project_creation = IntegerField()
    default_project_deletion_protection = BooleanField()
    default_project_visibility = IntegerField()
    default_projects_limit = IntegerField(null=True)
    default_snippet_visibility = IntegerField()
    deletion_adjourned_period = IntegerField()
    diff_max_patch_bytes = IntegerField()
    disable_overriding_approvers_per_merge_request = BooleanField()
    disabled_oauth_sign_in_sources = TextField(null=True)
    dns_rebinding_protection_enabled = BooleanField()
    domain_blacklist = TextField(null=True)
    domain_blacklist_enabled = BooleanField(null=True)
    domain_whitelist = TextField(null=True)
    dsa_key_restriction = IntegerField()
    ecdsa_key_restriction = IntegerField()
    ed25519_key_restriction = IntegerField()
    eks_access_key = CharField(db_column='eks_access_key_id', null=True)
    eks_account = CharField(db_column='eks_account_id', null=True)
    eks_integration_enabled = BooleanField()
    elasticsearch_aws = BooleanField()
    elasticsearch_aws_access_key = CharField(null=True)
    elasticsearch_aws_region = CharField(null=True)
    elasticsearch_indexed_field_length_limit = IntegerField()
    elasticsearch_indexed_file_size_limit_kb = IntegerField()
    elasticsearch_indexing = BooleanField()
    elasticsearch_limit_indexing = BooleanField()
    elasticsearch_max_bulk_concurrency = IntegerField()
    elasticsearch_max_bulk_size_mb = IntegerField()
    elasticsearch_pause_indexing = BooleanField()
    elasticsearch_replicas = IntegerField()
    elasticsearch_search = BooleanField()
    elasticsearch_shards = IntegerField()
    elasticsearch_url = CharField(null=True)
    email_additional_text = CharField(null=True)
    email_author_in_body = BooleanField(null=True)
    email_restrictions = TextField(null=True)
    email_restrictions_enabled = BooleanField()
    enabled_git_access_protocol = CharField(null=True)
    encrypted_akismet_api_key = TextField(null=True)
    encrypted_akismet_api_key_iv = CharField(null=True)
    encrypted_asset_proxy_secret_key = TextField(null=True)
    encrypted_asset_proxy_secret_key_iv = CharField(null=True)
    encrypted_eks_secret_access_key = TextField(null=True)
    encrypted_eks_secret_access_key_iv = CharField(null=True)
    encrypted_elasticsearch_aws_secret_access_key = TextField(null=True)
    encrypted_elasticsearch_aws_secret_access_key_iv = CharField(null=True)
    encrypted_external_auth_client_key = TextField(null=True)
    encrypted_external_auth_client_key_iv = CharField(null=True)
    encrypted_external_auth_client_key_pass = CharField(null=True)
    encrypted_external_auth_client_key_pass_iv = CharField(null=True)
    encrypted_lets_encrypt_private_key = TextField(null=True)
    encrypted_lets_encrypt_private_key_iv = TextField(null=True)
    encrypted_recaptcha_private_key = TextField(null=True)
    encrypted_recaptcha_private_key_iv = CharField(null=True)
    encrypted_recaptcha_site_key = TextField(null=True)
    encrypted_recaptcha_site_key_iv = CharField(null=True)
    encrypted_slack_app_secret = TextField(null=True)
    encrypted_slack_app_secret_iv = CharField(null=True)
    encrypted_slack_app_verification_token = TextField(null=True)
    encrypted_slack_app_verification_token_iv = CharField(null=True)
    enforce_namespace_storage_limit = BooleanField()
    enforce_pat_expiration = BooleanField()
    enforce_terms = BooleanField(null=True)
    external_auth_client_cert = TextField(null=True)
    external_authorization_service_default_label = CharField(null=True)
    external_authorization_service_enabled = BooleanField()
    external_authorization_service_timeout = FloatField(null=True)
    external_authorization_service_url = CharField(null=True)
    file_template_project = ForeignKeyField(db_column='file_template_project_id', null=True, rel_model=Projects, to_field='id')
    first_day_of_week = IntegerField()
    force_pages_access_control = BooleanField()
    geo_node_allowed_ips = CharField(null=True)
    geo_status_timeout = IntegerField(null=True)
    gitaly_timeout_default = IntegerField()
    gitaly_timeout_fast = IntegerField()
    gitaly_timeout_medium = IntegerField()
    grafana_enabled = BooleanField()
    grafana_url = CharField()
    gravatar_enabled = BooleanField(null=True)
    group_download_export_limit = IntegerField()
    group_export_limit = IntegerField()
    group_import_limit = IntegerField()
    group_owners_can_manage_default_branch_protection = BooleanField()
    hashed_storage_enabled = BooleanField()
    health_check_access_token = CharField(null=True)
    help_page_hide_commercial_content = BooleanField(null=True)
    help_page_support_url = CharField(null=True)
    help_page_text = TextField(null=True)
    help_page_text_html = TextField(null=True)
    help_text = TextField(null=True)
    hide_third_party_offers = BooleanField()
    home_page_url = CharField(null=True)
    housekeeping_bitmaps_enabled = BooleanField()
    housekeeping_enabled = BooleanField()
    housekeeping_full_repack_period = IntegerField()
    housekeeping_gc_period = IntegerField()
    housekeeping_incremental_repack_period = IntegerField()
    html_emails_enabled = BooleanField(null=True)
    import_sources = TextField(null=True)
    instance_administration_project = ForeignKeyField(db_column='instance_administration_project_id', null=True, rel_model=Projects, related_name='projects_instance_administration_project_set', to_field='id')
    instance_administrators_group = ForeignKeyField(db_column='instance_administrators_group_id', null=True, rel_model=Namespaces, related_name='namespaces_instance_administrators_group_set', to_field='id')
    instance_statistics_visibility_private = BooleanField()
    issues_create_limit = IntegerField()
    lets_encrypt_notification_email = CharField(null=True)
    lets_encrypt_terms_of_service_accepted = BooleanField()
    license_trial_ends_on = DateField(null=True)
    local_markdown_version = IntegerField()
    lock_memberships_to_ldap = BooleanField()
    login_recaptcha_protection_enabled = BooleanField()
    maintenance_mode = BooleanField()
    maintenance_mode_message = TextField(null=True)
    max_artifacts_size = IntegerField()
    max_attachment_size = IntegerField()
    max_import_size = IntegerField()
    max_pages_size = IntegerField()
    max_personal_access_token_lifetime = IntegerField(null=True)
    metrics_enabled = BooleanField(null=True)
    metrics_host = CharField(null=True)
    metrics_method_call_threshold = IntegerField(null=True)
    metrics_packet_size = IntegerField(null=True)
    metrics_pool_size = IntegerField(null=True)
    metrics_port = IntegerField(null=True)
    metrics_sample_interval = IntegerField(null=True)
    metrics_timeout = IntegerField(null=True)
    minimum_password_length = IntegerField()
    mirror_available = BooleanField()
    mirror_capacity_threshold = IntegerField()
    mirror_max_capacity = IntegerField()
    mirror_max_delay = IntegerField()
    namespace_storage_size_limit = BigIntegerField()
    notify_on_unknown_sign_in = BooleanField()
    npm_package_requests_forwarding = BooleanField()
    outbound_local_requests_whitelist = UnknownField()  # ARRAY
    pages_domain_verification_enabled = BooleanField()
    password_authentication_enabled_for_git = BooleanField()
    password_authentication_enabled_for_web = BooleanField(null=True)
    performance_bar_allowed_group = IntegerField(db_column='performance_bar_allowed_group_id', null=True)
    plantuml_enabled = BooleanField(null=True)
    plantuml_url = CharField(null=True)
    polling_interval_multiplier = DecimalField()
    prevent_merge_requests_author_approval = BooleanField()
    prevent_merge_requests_committers_approval = BooleanField()
    productivity_analytics_start_date = DateTimeField(null=True)
    project_download_export_limit = IntegerField()
    project_export_enabled = BooleanField()
    project_export_limit = IntegerField()
    project_import_limit = IntegerField()
    prometheus_metrics_enabled = BooleanField()
    protected_ci_variables = BooleanField()
    protected_paths = UnknownField(null=True)  # ARRAY
    pseudonymizer_enabled = BooleanField()
    push_event_activities_limit = IntegerField()
    push_event_hooks_limit = IntegerField()
    push_rule = ForeignKeyField(db_column='push_rule_id', null=True, rel_model=PushRules, to_field='id', unique=True)
    raw_blob_request_limit = IntegerField()
    recaptcha_enabled = BooleanField(null=True)
    receive_max_input_size = IntegerField(null=True)
    repository_checks_enabled = BooleanField(null=True)
    repository_size_limit = BigIntegerField(null=True)
    repository_storages = CharField(null=True)
    repository_storages_weighted = JSONField()
    require_two_factor_authentication = BooleanField(null=True)
    required_instance_ci_template = CharField(null=True)
    restricted_visibility_levels = TextField(null=True)
    rsa_key_restriction = IntegerField()
    runners_registration_token = CharField(null=True)
    runners_registration_token_encrypted = CharField(null=True)
    seat_link_enabled = BooleanField()
    send_user_confirmation_email = BooleanField(null=True)
    session_expire_delay = IntegerField()
    shared_runners_enabled = BooleanField()
    shared_runners_minutes = IntegerField()
    shared_runners_text = TextField(null=True)
    shared_runners_text_html = TextField(null=True)
    sign_in_text = TextField(null=True)
    sign_in_text_html = TextField(null=True)
    signup_enabled = BooleanField(null=True)
    slack_app_enabled = BooleanField(null=True)
    slack_app = CharField(db_column='slack_app_id', null=True)
    snippet_size_limit = BigIntegerField()
    snowplow_app = CharField(db_column='snowplow_app_id', null=True)
    snowplow_collector_hostname = CharField(null=True)
    snowplow_cookie_domain = CharField(null=True)
    snowplow_enabled = BooleanField()
    snowplow_iglu_registry_url = CharField(null=True)
    sourcegraph_enabled = BooleanField()
    sourcegraph_public_only = BooleanField()
    sourcegraph_url = CharField(null=True)
    spam_check_endpoint_enabled = BooleanField()
    spam_check_endpoint_url = TextField(null=True)
    static_objects_external_storage_auth_token = CharField(null=True)
    static_objects_external_storage_url = CharField(null=True)
    terminal_max_session_time = IntegerField()
    throttle_authenticated_api_enabled = BooleanField()
    throttle_authenticated_api_period_in_seconds = IntegerField()
    throttle_authenticated_api_requests_per_period = IntegerField()
    throttle_authenticated_web_enabled = BooleanField()
    throttle_authenticated_web_period_in_seconds = IntegerField()
    throttle_authenticated_web_requests_per_period = IntegerField()
    throttle_incident_management_notification_enabled = BooleanField()
    throttle_incident_management_notification_per_period = IntegerField(null=True)
    throttle_incident_management_notification_period_in_seconds = IntegerField(null=True)
    throttle_protected_paths_enabled = BooleanField()
    throttle_protected_paths_period_in_seconds = IntegerField()
    throttle_protected_paths_requests_per_period = IntegerField()
    throttle_unauthenticated_enabled = BooleanField()
    throttle_unauthenticated_period_in_seconds = IntegerField()
    throttle_unauthenticated_requests_per_period = IntegerField()
    time_tracking_limit_to_hours = BooleanField()
    two_factor_grace_period = IntegerField(null=True)
    unique_ips_limit_enabled = BooleanField()
    unique_ips_limit_per_user = IntegerField(null=True)
    unique_ips_limit_time_window = IntegerField(null=True)
    updated_at = DateTimeField(null=True)
    updating_name_disabled_for_users = BooleanField()
    usage_ping_enabled = BooleanField()
    usage_stats_set_by_user = ForeignKeyField(db_column='usage_stats_set_by_user_id', null=True, rel_model=Users, to_field='id')
    user_default_external = BooleanField()
    user_default_internal_regex = CharField(null=True)
    user_oauth_applications = BooleanField(null=True)
    user_show_add_ssh_key_message = BooleanField()
    uuid = CharField(null=True)
    version_check_enabled = BooleanField(null=True)
    web_ide_clientside_preview_enabled = BooleanField()
    wiki_page_max_content_bytes = BigIntegerField()

    class Meta:
        db_table = 'application_settings'

class ApprovalProjectRules(BaseModel):
    approvals_required = IntegerField()
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    name = CharField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    rule_type = IntegerField(index=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'approval_project_rules'

class ApprovalMergeRequestRules(BaseModel):
    approvals_required = IntegerField()
    code_owner = BooleanField()
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    merge_request = ForeignKeyField(db_column='merge_request_id', rel_model=MergeRequests, to_field='id')
    name = CharField()
    report_type = IntegerField(null=True)
    rule_type = IntegerField()
    section = TextField(null=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'approval_merge_request_rules'
        indexes = (
            (('code_owner', 'merge_request'), False),
            (('merge_request', 'name'), True),
            (('merge_request', 'section', 'name'), True),
            (('name', 'merge_request', 'code_owner'), True),
            (('rule_type', 'merge_request'), True),
        )

class ApprovalMergeRequestRuleSources(BaseModel):
    approval_merge_request_rule = ForeignKeyField(db_column='approval_merge_request_rule_id', rel_model=ApprovalMergeRequestRules, to_field='id', unique=True)
    approval_project_rule = ForeignKeyField(db_column='approval_project_rule_id', rel_model=ApprovalProjectRules, to_field='id')
    id = BigIntegerField(primary_key=True)

    class Meta:
        db_table = 'approval_merge_request_rule_sources'

class ApprovalMergeRequestRulesApprovedApprovers(BaseModel):
    approval_merge_request_rule = ForeignKeyField(db_column='approval_merge_request_rule_id', rel_model=ApprovalMergeRequestRules, to_field='id')
    id = BigIntegerField(primary_key=True)
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'approval_merge_request_rules_approved_approvers'
        indexes = (
            (('approval_merge_request_rule', 'user'), True),
        )

class ApprovalMergeRequestRulesGroups(BaseModel):
    approval_merge_request_rule = ForeignKeyField(db_column='approval_merge_request_rule_id', rel_model=ApprovalMergeRequestRules, to_field='id')
    group = ForeignKeyField(db_column='group_id', rel_model=Namespaces, to_field='id')
    id = BigIntegerField(primary_key=True)

    class Meta:
        db_table = 'approval_merge_request_rules_groups'
        indexes = (
            (('approval_merge_request_rule', 'group'), True),
        )

class ApprovalMergeRequestRulesUsers(BaseModel):
    approval_merge_request_rule = ForeignKeyField(db_column='approval_merge_request_rule_id', rel_model=ApprovalMergeRequestRules, to_field='id')
    id = BigIntegerField(primary_key=True)
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'approval_merge_request_rules_users'
        indexes = (
            (('approval_merge_request_rule', 'user'), True),
        )

class ApprovalProjectRulesGroups(BaseModel):
    approval_project_rule = ForeignKeyField(db_column='approval_project_rule_id', rel_model=ApprovalProjectRules, to_field='id')
    group = ForeignKeyField(db_column='group_id', rel_model=Namespaces, to_field='id')
    id = BigIntegerField(primary_key=True)

    class Meta:
        db_table = 'approval_project_rules_groups'
        indexes = (
            (('approval_project_rule', 'group'), True),
        )

class ProtectedBranches(BaseModel):
    code_owner_approval_required = BooleanField()
    created_at = DateTimeField(null=True)
    name = CharField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'protected_branches'
        indexes = (
            (('project', 'code_owner_approval_required'), False),
        )

class ApprovalProjectRulesProtectedBranches(BaseModel):
    approval_project_rule = ForeignKeyField(db_column='approval_project_rule_id', rel_model=ApprovalProjectRules, to_field='id')
    protected_branch = ForeignKeyField(db_column='protected_branch_id', rel_model=ProtectedBranches, to_field='id')

    class Meta:
        db_table = 'approval_project_rules_protected_branches'
        indexes = (
            (('approval_project_rule', 'protected_branch'), True),
        )

class ApprovalProjectRulesUsers(BaseModel):
    approval_project_rule = ForeignKeyField(db_column='approval_project_rule_id', rel_model=ApprovalProjectRules, to_field='id')
    id = BigIntegerField(primary_key=True)
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'approval_project_rules_users'
        indexes = (
            (('approval_project_rule', 'user'), True),
        )

class Approvals(BaseModel):
    created_at = DateTimeField(null=True)
    merge_request = ForeignKeyField(db_column='merge_request_id', rel_model=MergeRequests, to_field='id')
    updated_at = DateTimeField(null=True)
    user = IntegerField(db_column='user_id')

    class Meta:
        db_table = 'approvals'
        indexes = (
            (('merge_request', 'user'), True),
        )

class ApproverGroups(BaseModel):
    created_at = DateTimeField(null=True)
    group = ForeignKeyField(db_column='group_id', rel_model=Namespaces, to_field='id')
    target = IntegerField(db_column='target_id')
    target_type = CharField()
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'approver_groups'
        indexes = (
            (('target', 'target_type'), False),
        )

class Approvers(BaseModel):
    created_at = DateTimeField(null=True)
    target = IntegerField(db_column='target_id')
    target_type = CharField(null=True)
    updated_at = DateTimeField(null=True)
    user = IntegerField(db_column='user_id', index=True)

    class Meta:
        db_table = 'approvers'
        indexes = (
            (('target', 'target_type'), False),
        )

class ArInternalMetadata(BaseModel):
    created_at = DateTimeField()
    key = CharField(primary_key=True)
    updated_at = DateTimeField()
    value = CharField(null=True)

    class Meta:
        db_table = 'ar_internal_metadata'

class AuditEvents(BaseModel):
    author = IntegerField(db_column='author_id')
    author_name = TextField(null=True)
    created_at = DateTimeField(null=True)
    details = TextField(null=True)
    entity = IntegerField(db_column='entity_id')
    entity_path = TextField(null=True)
    entity_type = CharField()
    ip_address = UnknownField(null=True)  # inet
    target_details = TextField(null=True)
    target_type = TextField(null=True)
    type = CharField(null=True)

    class Meta:
        db_table = 'audit_events'
        indexes = (
            (('author', 'created_at'), False),
            (('id', 'entity_type', 'author', 'entity'), False),
        )

class AuditEventsPart5Fc467Ac26(BaseModel):
    author = IntegerField(db_column='author_id')
    author_name = TextField(null=True)
    created_at = DateTimeField()
    details = TextField(null=True)
    entity = IntegerField(db_column='entity_id')
    entity_path = TextField(null=True)
    entity_type = CharField()
    id = BigIntegerField()
    ip_address = UnknownField(null=True)  # inet
    target_details = TextField(null=True)
    target_type = TextField(null=True)
    type = CharField(null=True)

    class Meta:
        db_table = 'audit_events_part_5fc467ac26'
        primary_key = CompositeKey('created_at', 'id')

class AwardEmoji(BaseModel):
    awardable = IntegerField(db_column='awardable_id', null=True)
    awardable_type = CharField(null=True)
    created_at = DateTimeField(null=True)
    name = CharField(null=True)
    updated_at = DateTimeField(null=True)
    user = IntegerField(db_column='user_id', null=True)

    class Meta:
        db_table = 'award_emoji'
        indexes = (
            (('awardable', 'awardable_type'), False),
            (('name', 'user'), False),
        )

class AwsRoles(BaseModel):
    created_at = DateTimeField()
    role_arn = CharField(null=True)
    role_external = CharField(db_column='role_external_id', unique=True)
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', primary_key=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'aws_roles'

class BackgroundMigrationJobs(BaseModel):
    arguments = JSONField()
    class_name = TextField()
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    status = IntegerField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'background_migration_jobs'
        indexes = (
            (('class_name', 'arguments'), False),
            (('status', 'class_name', 'id'), False),
        )

class BackupLabels(BaseModel):
    cached_markdown_version = IntegerField(null=True)
    color = CharField(null=True)
    created_at = DateTimeField(null=True)
    description = CharField(null=True)
    description_html = TextField(null=True)
    group = ForeignKeyField(db_column='group_id', null=True, rel_model=Namespaces, related_name='namespaces_group_set', to_field='id')
    new_title = CharField(null=True)
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, related_name='projects_project_set', to_field='id')
    restore_action = IntegerField(null=True)
    template = BooleanField(index=True, null=True)
    title = CharField(index=True, null=True)
    type = CharField(null=True)
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'backup_labels'
        indexes = (
            (('project', 'type'), False),
            (('title', 'group'), False),
            (('title', 'group', 'project'), True),
            (('title', 'project'), True),
        )

class Badges(BaseModel):
    created_at = DateTimeField()
    group = ForeignKeyField(db_column='group_id', null=True, rel_model=Namespaces, to_field='id')
    image_url = CharField()
    link_url = CharField()
    name = CharField(null=True)
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    type = CharField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'badges'

class Boards(BaseModel):
    created_at = DateTimeField()
    group = ForeignKeyField(db_column='group_id', null=True, rel_model=Namespaces, to_field='id')
    hide_backlog_list = BooleanField()
    hide_closed_list = BooleanField()
    milestone = IntegerField(db_column='milestone_id', index=True, null=True)
    name = CharField()
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    updated_at = DateTimeField()
    weight = IntegerField(null=True)

    class Meta:
        db_table = 'boards'

class BoardAssignees(BaseModel):
    assignee = ForeignKeyField(db_column='assignee_id', rel_model=Users, to_field='id')
    board = ForeignKeyField(db_column='board_id', rel_model=Boards, to_field='id')

    class Meta:
        db_table = 'board_assignees'
        indexes = (
            (('board', 'assignee'), True),
        )

class BoardGroupRecentVisits(BaseModel):
    board = ForeignKeyField(db_column='board_id', null=True, rel_model=Boards, to_field='id')
    created_at = DateTimeField()
    group = ForeignKeyField(db_column='group_id', null=True, rel_model=Namespaces, to_field='id')
    id = BigIntegerField(primary_key=True)
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', null=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'board_group_recent_visits'
        indexes = (
            (('user', 'board', 'group'), True),
        )

class BoardLabels(BaseModel):
    board = ForeignKeyField(db_column='board_id', rel_model=Boards, to_field='id')
    label = ForeignKeyField(db_column='label_id', rel_model=Labels, to_field='id')

    class Meta:
        db_table = 'board_labels'
        indexes = (
            (('board', 'label'), True),
        )

class BoardProjectRecentVisits(BaseModel):
    board = ForeignKeyField(db_column='board_id', null=True, rel_model=Boards, to_field='id')
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', null=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'board_project_recent_visits'
        indexes = (
            (('project', 'board', 'user'), True),
        )

class BoardUserPreferences(BaseModel):
    board = ForeignKeyField(db_column='board_id', rel_model=Boards, to_field='id')
    created_at = DateTimeField()
    hide_labels = BooleanField(null=True)
    id = BigIntegerField(primary_key=True)
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'board_user_preferences'
        indexes = (
            (('user', 'board'), True),
        )

class BroadcastMessages(BaseModel):
    broadcast_type = IntegerField()
    cached_markdown_version = IntegerField(null=True)
    color = CharField(null=True)
    created_at = DateTimeField()
    dismissable = BooleanField(null=True)
    ends_at = DateTimeField()
    font = CharField(null=True)
    message = TextField()
    message_html = TextField()
    starts_at = DateTimeField()
    target_path = CharField(null=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'broadcast_messages'
        indexes = (
            (('id', 'ends_at', 'broadcast_type'), False),
        )

class ChatNames(BaseModel):
    chat = CharField(db_column='chat_id')
    chat_name = CharField(null=True)
    created_at = DateTimeField()
    last_used_at = DateTimeField(null=True)
    service = ForeignKeyField(db_column='service_id', rel_model=Services, to_field='id')
    team_domain = CharField(null=True)
    team = CharField(db_column='team_id')
    updated_at = DateTimeField()
    user = IntegerField(db_column='user_id')

    class Meta:
        db_table = 'chat_names'
        indexes = (
            (('service', 'team', 'chat'), True),
            (('user', 'service'), True),
        )

class ChatTeams(BaseModel):
    created_at = DateTimeField()
    name = CharField(null=True)
    namespace = ForeignKeyField(db_column='namespace_id', rel_model=Namespaces, to_field='id', unique=True)
    team = CharField(db_column='team_id', null=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'chat_teams'

class CiStages(BaseModel):
    created_at = DateTimeField(null=True)
    lock_version = IntegerField(null=True)
    name = CharField(null=True)
    pipeline = ForeignKeyField(db_column='pipeline_id', null=True, rel_model=CiPipelines, to_field='id')
    position = IntegerField(null=True)
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    status = IntegerField(null=True)
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'ci_stages'
        indexes = (
            (('pipeline', 'name'), True),
            (('pipeline', 'position'), False),
        )

class CiResourceGroups(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    key = CharField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'ci_resource_groups'
        indexes = (
            (('project', 'key'), True),
        )

class CiBuilds(BaseModel):
    allow_failure = BooleanField()
    artifacts_expire_at = DateTimeField(index=True, null=True)
    artifacts_file = TextField(null=True)
    artifacts_file_store = IntegerField(null=True)
    artifacts_metadata = TextField(null=True)
    artifacts_metadata_store = IntegerField(null=True)
    artifacts_size = BigIntegerField(null=True)
    auto_canceled_by = ForeignKeyField(db_column='auto_canceled_by_id', null=True, rel_model=CiPipelines, to_field='id')
    commands = TextField(null=True)
    commit = ForeignKeyField(db_column='commit_id', null=True, rel_model=CiPipelines, related_name='ci_pipelines_commit_set', to_field='id')
    coverage = FloatField(null=True)
    coverage_regex = CharField(null=True)
    created_at = DateTimeField(null=True)
    description = CharField(null=True)
    environment = CharField(null=True)
    erased_at = DateTimeField(null=True)
    erased_by = IntegerField(db_column='erased_by_id', null=True)
    failure_reason = IntegerField(null=True)
    finished_at = DateTimeField(null=True)
    lock_version = IntegerField(null=True)
    name = CharField(null=True)
    options = TextField(null=True)
    processed = BooleanField(null=True)
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    protected = BooleanField(index=True, null=True)
    queued_at = DateTimeField(index=True, null=True)
    ref = CharField(null=True)
    resource_group = ForeignKeyField(db_column='resource_group_id', null=True, rel_model=CiResourceGroups, to_field='id')
    retried = BooleanField(null=True)
    runner = IntegerField(db_column='runner_id', index=True, null=True)
    scheduled_at = DateTimeField(index=True, null=True)
    scheduling_type = IntegerField(null=True)
    stage = CharField(null=True)
    stage_id = ForeignKeyField(db_column='stage_id', null=True, rel_model=CiStages, to_field='id')
    stage_idx = IntegerField(null=True)
    started_at = DateTimeField(null=True)
    status = CharField(null=True)
    tag = BooleanField(null=True)
    target_url = CharField(null=True)
    token = CharField(null=True, unique=True)
    token_encrypted = CharField(null=True, unique=True)
    trace = TextField(null=True)
    trigger_request = IntegerField(db_column='trigger_request_id', null=True)
    type = CharField(null=True)
    updated_at = DateTimeField(index=True, null=True)
    upstream_pipeline = ForeignKeyField(db_column='upstream_pipeline_id', null=True, rel_model=CiPipelines, related_name='ci_pipelines_upstream_pipeline_set', to_field='id')
    user = IntegerField(db_column='user_id', index=True, null=True)
    waiting_for_resource_at = DateTimeField(null=True)
    when = CharField(null=True)
    yaml_variables = TextField(null=True)

    class Meta:
        db_table = 'ci_builds'
        indexes = (
            (('commit', 'artifacts_expire_at', 'id'), False),
            (('commit', 'ref', 'type', 'name'), False),
            (('created_at', 'stage_idx', 'commit'), False),
            (('id', 'name'), False),
            (('name', 'ref', 'project'), False),
            (('project', 'id'), False),
            (('project', 'status'), False),
            (('ref', 'type', 'commit'), False),
            (('resource_group', 'id'), False),
            (('stage_id', 'stage_idx'), False),
            (('status', 'created_at', 'project'), False),
            (('status', 'type', 'commit'), False),
            (('status', 'type', 'runner'), False),
            (('user', 'created_at'), False),
            (('user', 'created_at'), False),
        )

class CiBuildNeeds(BaseModel):
    artifacts = BooleanField()
    build = ForeignKeyField(db_column='build_id', rel_model=CiBuilds, to_field='id')
    name = TextField()

    class Meta:
        db_table = 'ci_build_needs'
        indexes = (
            (('build', 'name'), True),
        )

class CiBuildReportResults(BaseModel):
    build = ForeignKeyField(db_column='build_id', primary_key=True, rel_model=CiBuilds, to_field='id')
    data = JSONField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')

    class Meta:
        db_table = 'ci_build_report_results'

class CiBuildTraceChunks(BaseModel):
    build = ForeignKeyField(db_column='build_id', rel_model=CiBuilds, to_field='id')
    chunk_index = IntegerField()
    data_store = IntegerField()
    id = BigIntegerField(primary_key=True)
    raw_data = BlobField(null=True)

    class Meta:
        db_table = 'ci_build_trace_chunks'
        indexes = (
            (('build', 'chunk_index'), True),
        )

class CiBuildTraceSectionNames(BaseModel):
    name = CharField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')

    class Meta:
        db_table = 'ci_build_trace_section_names'
        indexes = (
            (('project', 'name'), True),
        )

class CiBuildTraceSections(BaseModel):
    build = ForeignKeyField(db_column='build_id', rel_model=CiBuilds, to_field='id')
    byte_end = BigIntegerField()
    byte_start = BigIntegerField()
    date_end = DateTimeField()
    date_start = DateTimeField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    section_name = ForeignKeyField(db_column='section_name_id', rel_model=CiBuildTraceSectionNames, to_field='id')

    class Meta:
        db_table = 'ci_build_trace_sections'
        indexes = (
            (('build', 'section_name'), True),
        )

class CiBuildsMetadata(BaseModel):
    build = ForeignKeyField(db_column='build_id', rel_model=CiBuilds, to_field='id')
    config_options = JSONField(null=True)
    config_variables = JSONField(null=True)
    environment_auto_stop_in = CharField(null=True)
    expanded_environment_name = CharField(null=True)
    has_exposed_artifacts = BooleanField(null=True)
    interruptible = BooleanField(null=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    secrets = JSONField()
    timeout = IntegerField(null=True)
    timeout_source = IntegerField()

    class Meta:
        db_table = 'ci_builds_metadata'

class CiBuildsRunnerSession(BaseModel):
    authorization = CharField(null=True)
    build = ForeignKeyField(db_column='build_id', rel_model=CiBuilds, to_field='id', unique=True)
    certificate = CharField(null=True)
    id = BigIntegerField(primary_key=True)
    url = CharField()

    class Meta:
        db_table = 'ci_builds_runner_session'

class CiDailyBuildGroupReportResults(BaseModel):
    data = JSONField()
    date = DateField()
    group_name = TextField()
    id = BigIntegerField(primary_key=True)
    last_pipeline = ForeignKeyField(db_column='last_pipeline_id', rel_model=CiPipelines, to_field='id')
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    ref_path = TextField()

    class Meta:
        db_table = 'ci_daily_build_group_report_results'
        indexes = (
            (('date', 'project', 'ref_path', 'group_name'), True),
        )

class CiFreezePeriods(BaseModel):
    created_at = DateTimeField()
    cron_timezone = CharField()
    freeze_end = CharField()
    freeze_start = CharField()
    id = BigIntegerField(primary_key=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'ci_freeze_periods'

class CiGroupVariables(BaseModel):
    created_at = DateTimeField()
    encrypted_value = TextField(null=True)
    encrypted_value_iv = CharField(null=True)
    encrypted_value_salt = CharField(null=True)
    group = ForeignKeyField(db_column='group_id', rel_model=Namespaces, to_field='id')
    key = CharField()
    masked = BooleanField()
    protected = BooleanField()
    updated_at = DateTimeField()
    value = TextField(null=True)
    variable_type = IntegerField()

    class Meta:
        db_table = 'ci_group_variables'
        indexes = (
            (('key', 'group'), True),
        )

class CiInstanceVariables(BaseModel):
    encrypted_value = TextField(null=True)
    encrypted_value_iv = TextField(null=True)
    id = BigIntegerField(primary_key=True)
    key = TextField(unique=True)
    masked = BooleanField(null=True)
    protected = BooleanField(null=True)
    variable_type = IntegerField()

    class Meta:
        db_table = 'ci_instance_variables'

class CiJobArtifacts(BaseModel):
    created_at = DateTimeField()
    expire_at = DateTimeField(null=True)
    file = CharField(null=True)
    file_format = IntegerField(null=True)
    file_location = IntegerField(null=True)
    file_sha256 = BlobField(null=True)
    file_store = IntegerField(index=True, null=True)
    file_type = IntegerField()
    job = ForeignKeyField(db_column='job_id', rel_model=CiBuilds, to_field='id')
    locked = BooleanField(null=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    size = BigIntegerField(null=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'ci_job_artifacts'
        indexes = (
            (('file_type', 'job'), False),
            (('file_type', 'job'), True),
            (('id', 'project'), False),
            (('job', 'expire_at'), False),
        )

class CiJobVariables(BaseModel):
    encrypted_value = TextField(null=True)
    encrypted_value_iv = CharField(null=True)
    id = BigIntegerField(primary_key=True)
    job = ForeignKeyField(db_column='job_id', rel_model=CiBuilds, to_field='id')
    key = CharField()
    source = IntegerField()
    variable_type = IntegerField()

    class Meta:
        db_table = 'ci_job_variables'
        indexes = (
            (('key', 'job'), True),
        )

class CiPipelineArtifacts(BaseModel):
    created_at = DateTimeField()
    expire_at = DateTimeField(null=True)
    file = TextField(null=True)
    file_format = IntegerField()
    file_store = IntegerField()
    file_type = IntegerField()
    id = BigIntegerField(primary_key=True)
    pipeline = ForeignKeyField(db_column='pipeline_id', rel_model=CiPipelines, to_field='id')
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    size = IntegerField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'ci_pipeline_artifacts'
        indexes = (
            (('pipeline', 'file_type'), True),
        )

class CiPipelineChatData(BaseModel):
    chat_name = ForeignKeyField(db_column='chat_name_id', rel_model=ChatNames, to_field='id')
    id = BigIntegerField(primary_key=True)
    pipeline = ForeignKeyField(db_column='pipeline_id', rel_model=CiPipelines, to_field='id', unique=True)
    response_url = TextField()

    class Meta:
        db_table = 'ci_pipeline_chat_data'

class CiPipelineMessages(BaseModel):
    content = TextField()
    id = BigIntegerField(primary_key=True)
    pipeline = ForeignKeyField(db_column='pipeline_id', rel_model=CiPipelines, to_field='id')
    severity = IntegerField()

    class Meta:
        db_table = 'ci_pipeline_messages'

class CiPipelineScheduleVariables(BaseModel):
    created_at = DateTimeField(null=True)
    encrypted_value = TextField(null=True)
    encrypted_value_iv = CharField(null=True)
    encrypted_value_salt = CharField(null=True)
    key = CharField()
    pipeline_schedule = ForeignKeyField(db_column='pipeline_schedule_id', rel_model=CiPipelineSchedules, to_field='id')
    updated_at = DateTimeField(null=True)
    value = TextField(null=True)
    variable_type = IntegerField()

    class Meta:
        db_table = 'ci_pipeline_schedule_variables'
        indexes = (
            (('key', 'pipeline_schedule'), True),
        )

class CiPipelineVariables(BaseModel):
    encrypted_value = TextField(null=True)
    encrypted_value_iv = CharField(null=True)
    encrypted_value_salt = CharField(null=True)
    key = CharField()
    pipeline = ForeignKeyField(db_column='pipeline_id', rel_model=CiPipelines, to_field='id')
    value = TextField(null=True)
    variable_type = IntegerField()

    class Meta:
        db_table = 'ci_pipeline_variables'
        indexes = (
            (('key', 'pipeline'), True),
        )

class CiPipelinesConfig(BaseModel):
    content = TextField()
    pipeline = ForeignKeyField(db_column='pipeline_id', primary_key=True, rel_model=CiPipelines, to_field='id')

    class Meta:
        db_table = 'ci_pipelines_config'

class CiResources(BaseModel):
    build = ForeignKeyField(db_column='build_id', null=True, rel_model=CiBuilds, to_field='id')
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    resource_group = ForeignKeyField(db_column='resource_group_id', rel_model=CiResourceGroups, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'ci_resources'
        indexes = (
            (('resource_group', 'build'), True),
        )

class CiRunners(BaseModel):
    access_level = IntegerField()
    active = BooleanField()
    architecture = CharField(null=True)
    contacted_at = DateTimeField(index=True, null=True)
    created_at = DateTimeField(null=True)
    description = CharField(null=True)
    ip_address = CharField(null=True)
    is_shared = BooleanField(index=True, null=True)
    locked = BooleanField(index=True)
    maximum_timeout = IntegerField(null=True)
    name = CharField(null=True)
    platform = CharField(null=True)
    private_projects_minutes_cost_factor = FloatField()
    public_projects_minutes_cost_factor = FloatField()
    revision = CharField(null=True)
    run_untagged = BooleanField()
    runner_type = IntegerField(index=True)
    token = CharField(index=True, null=True)
    token_encrypted = CharField(index=True, null=True)
    updated_at = DateTimeField(null=True)
    version = CharField(null=True)

    class Meta:
        db_table = 'ci_runners'

class CiRunnerNamespaces(BaseModel):
    namespace = ForeignKeyField(db_column='namespace_id', null=True, rel_model=Namespaces, to_field='id')
    runner = ForeignKeyField(db_column='runner_id', null=True, rel_model=CiRunners, to_field='id')

    class Meta:
        db_table = 'ci_runner_namespaces'
        indexes = (
            (('runner', 'namespace'), True),
        )

class CiRunnerProjects(BaseModel):
    created_at = DateTimeField(null=True)
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    runner = IntegerField(db_column='runner_id', index=True)
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'ci_runner_projects'

class CiSourcesPipelines(BaseModel):
    pipeline = ForeignKeyField(db_column='pipeline_id', null=True, rel_model=CiPipelines, to_field='id')
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    source_job = ForeignKeyField(db_column='source_job_id', null=True, rel_model=CiBuilds, to_field='id')
    source_pipeline = ForeignKeyField(db_column='source_pipeline_id', null=True, rel_model=CiPipelines, related_name='ci_pipelines_source_pipeline_set', to_field='id')
    source_project = ForeignKeyField(db_column='source_project_id', null=True, rel_model=Projects, related_name='projects_source_project_set', to_field='id')

    class Meta:
        db_table = 'ci_sources_pipelines'

class CiSourcesProjects(BaseModel):
    id = BigIntegerField(primary_key=True)
    pipeline = ForeignKeyField(db_column='pipeline_id', rel_model=CiPipelines, to_field='id')
    source_project = ForeignKeyField(db_column='source_project_id', rel_model=Projects, to_field='id')

    class Meta:
        db_table = 'ci_sources_projects'
        indexes = (
            (('pipeline', 'source_project'), True),
        )

class CiSubscriptionsProjects(BaseModel):
    downstream_project = ForeignKeyField(db_column='downstream_project_id', rel_model=Projects, to_field='id')
    id = BigIntegerField(primary_key=True)
    upstream_project = ForeignKeyField(db_column='upstream_project_id', rel_model=Projects, related_name='projects_upstream_project_set', to_field='id')

    class Meta:
        db_table = 'ci_subscriptions_projects'
        indexes = (
            (('downstream_project', 'upstream_project'), True),
        )

class CiTriggers(BaseModel):
    created_at = DateTimeField(null=True)
    description = CharField(null=True)
    owner = ForeignKeyField(db_column='owner_id', rel_model=Users, to_field='id')
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    ref = CharField(null=True)
    token = CharField(null=True)
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'ci_triggers'

class CiTriggerRequests(BaseModel):
    commit = IntegerField(db_column='commit_id', index=True, null=True)
    created_at = DateTimeField(null=True)
    trigger = ForeignKeyField(db_column='trigger_id', rel_model=CiTriggers, to_field='id')
    updated_at = DateTimeField(null=True)
    variables = TextField(null=True)

    class Meta:
        db_table = 'ci_trigger_requests'
        indexes = (
            (('id', 'trigger'), False),
        )

class CiVariables(BaseModel):
    encrypted_value = TextField(null=True)
    encrypted_value_iv = CharField(null=True)
    encrypted_value_salt = CharField(null=True)
    environment_scope = CharField()
    key = CharField()
    masked = BooleanField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    protected = BooleanField()
    value = TextField(null=True)
    variable_type = IntegerField()

    class Meta:
        db_table = 'ci_variables'
        indexes = (
            (('key', 'project', 'environment_scope'), True),
        )

class ClusterAgents(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    name = TextField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'cluster_agents'
        indexes = (
            (('project', 'name'), True),
        )

class ClusterAgentTokens(BaseModel):
    agent = ForeignKeyField(db_column='agent_id', rel_model=ClusterAgents, to_field='id')
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    token_encrypted = TextField(unique=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'cluster_agent_tokens'

class Clusters(BaseModel):
    cleanup_status = IntegerField()
    cleanup_status_reason = TextField(null=True)
    cluster_type = IntegerField()
    created_at = DateTimeField()
    domain = CharField(null=True)
    enabled = BooleanField(null=True)
    environment_scope = CharField()
    managed = BooleanField()
    management_project = ForeignKeyField(db_column='management_project_id', null=True, rel_model=Projects, to_field='id')
    name = CharField()
    namespace_per_environment = BooleanField()
    platform_type = IntegerField(null=True)
    provider_type = IntegerField(null=True)
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', null=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'clusters'
        indexes = (
            (('enabled', 'id', 'created_at', 'cluster_type'), False),
            (('enabled', 'provider_type', 'id'), False),
        )

class ClusterGroups(BaseModel):
    cluster = ForeignKeyField(db_column='cluster_id', rel_model=Clusters, to_field='id')
    group = ForeignKeyField(db_column='group_id', rel_model=Namespaces, to_field='id')

    class Meta:
        db_table = 'cluster_groups'
        indexes = (
            (('cluster', 'group'), True),
        )

class ClusterPlatformsKubernetes(BaseModel):
    api_url = TextField(null=True)
    authorization_type = IntegerField(null=True)
    ca_cert = TextField(null=True)
    cluster = ForeignKeyField(db_column='cluster_id', rel_model=Clusters, to_field='id', unique=True)
    created_at = DateTimeField()
    encrypted_password = TextField(null=True)
    encrypted_password_iv = CharField(null=True)
    encrypted_token = TextField(null=True)
    encrypted_token_iv = CharField(null=True)
    namespace = CharField(null=True)
    updated_at = DateTimeField()
    username = CharField(null=True)

    class Meta:
        db_table = 'cluster_platforms_kubernetes'

class ClusterProjects(BaseModel):
    cluster = ForeignKeyField(db_column='cluster_id', rel_model=Clusters, to_field='id')
    created_at = DateTimeField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'cluster_projects'

class ClusterProvidersAws(BaseModel):
    access_key = CharField(db_column='access_key_id', null=True)
    cluster = ForeignKeyField(db_column='cluster_id', rel_model=Clusters, to_field='id', unique=True)
    created_at = DateTimeField()
    created_by_user = ForeignKeyField(db_column='created_by_user_id', null=True, rel_model=Users, to_field='id')
    encrypted_secret_access_key = TextField(null=True)
    encrypted_secret_access_key_iv = CharField(null=True)
    id = BigIntegerField(primary_key=True)
    instance_type = CharField()
    key_name = CharField()
    num_nodes = IntegerField()
    region = CharField()
    role_arn = CharField()
    security_group = CharField(db_column='security_group_id')
    session_token = TextField(null=True)
    status = IntegerField()
    status_reason = TextField(null=True)
    subnet_ids = UnknownField()  # ARRAY
    updated_at = DateTimeField()
    vpc = CharField(db_column='vpc_id')

    class Meta:
        db_table = 'cluster_providers_aws'
        indexes = (
            (('cluster', 'status'), False),
        )

class ClusterProvidersGcp(BaseModel):
    cloud_run = BooleanField(index=True)
    cluster = ForeignKeyField(db_column='cluster_id', rel_model=Clusters, to_field='id', unique=True)
    created_at = DateTimeField()
    encrypted_access_token = TextField(null=True)
    encrypted_access_token_iv = CharField(null=True)
    endpoint = CharField(null=True)
    gcp_project = CharField(db_column='gcp_project_id')
    legacy_abac = BooleanField()
    machine_type = CharField(null=True)
    num_nodes = IntegerField()
    operation = CharField(db_column='operation_id', null=True)
    status = IntegerField(null=True)
    status_reason = TextField(null=True)
    updated_at = DateTimeField()
    zone = CharField()

    class Meta:
        db_table = 'cluster_providers_gcp'

class ClustersApplicationsCertManagers(BaseModel):
    cluster = ForeignKeyField(db_column='cluster_id', rel_model=Clusters, to_field='id', unique=True)
    created_at = DateTimeField()
    email = CharField()
    status = IntegerField()
    status_reason = TextField(null=True)
    updated_at = DateTimeField()
    version = CharField()

    class Meta:
        db_table = 'clusters_applications_cert_managers'

class ClustersApplicationsCilium(BaseModel):
    cluster = ForeignKeyField(db_column='cluster_id', rel_model=Clusters, to_field='id', unique=True)
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    status = IntegerField()
    status_reason = TextField(null=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'clusters_applications_cilium'

class ClustersApplicationsCrossplane(BaseModel):
    cluster = ForeignKeyField(db_column='cluster_id', rel_model=Clusters, to_field='id', unique=True)
    created_at = DateTimeField()
    stack = CharField()
    status = IntegerField()
    status_reason = TextField(null=True)
    updated_at = DateTimeField()
    version = CharField()

    class Meta:
        db_table = 'clusters_applications_crossplane'

class ClustersApplicationsElasticStacks(BaseModel):
    cluster = ForeignKeyField(db_column='cluster_id', rel_model=Clusters, to_field='id', unique=True)
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    status = IntegerField()
    status_reason = TextField(null=True)
    updated_at = DateTimeField()
    version = CharField()

    class Meta:
        db_table = 'clusters_applications_elastic_stacks'

class ClustersApplicationsFluentd(BaseModel):
    cilium_log_enabled = BooleanField()
    cluster = ForeignKeyField(db_column='cluster_id', rel_model=Clusters, to_field='id', unique=True)
    created_at = DateTimeField()
    host = CharField()
    id = BigIntegerField(primary_key=True)
    port = IntegerField()
    protocol = IntegerField()
    status = IntegerField()
    status_reason = TextField(null=True)
    updated_at = DateTimeField()
    version = CharField()
    waf_log_enabled = BooleanField()

    class Meta:
        db_table = 'clusters_applications_fluentd'

class ClustersApplicationsHelm(BaseModel):
    ca_cert = TextField(null=True)
    cluster = ForeignKeyField(db_column='cluster_id', rel_model=Clusters, to_field='id', unique=True)
    created_at = DateTimeField()
    encrypted_ca_key = TextField(null=True)
    encrypted_ca_key_iv = TextField(null=True)
    status = IntegerField()
    status_reason = TextField(null=True)
    updated_at = DateTimeField()
    version = CharField()

    class Meta:
        db_table = 'clusters_applications_helm'

class ClustersApplicationsIngress(BaseModel):
    cluster = ForeignKeyField(db_column='cluster_id', rel_model=Clusters, to_field='id', unique=True)
    cluster_ip = CharField(null=True)
    created_at = DateTimeField()
    external_hostname = CharField(null=True)
    external_ip = CharField(null=True)
    ingress_type = IntegerField()
    modsecurity_enabled = BooleanField(null=True)
    modsecurity_mode = IntegerField()
    status = IntegerField()
    status_reason = TextField(null=True)
    updated_at = DateTimeField()
    version = CharField()

    class Meta:
        db_table = 'clusters_applications_ingress'
        indexes = (
            (('cluster', 'modsecurity_enabled', 'modsecurity_mode'), False),
        )

class OauthApplications(BaseModel):
    confidential = BooleanField()
    created_at = DateTimeField(null=True)
    name = CharField()
    owner = IntegerField(db_column='owner_id', null=True)
    owner_type = CharField(null=True)
    redirect_uri = TextField()
    scopes = CharField()
    secret = CharField()
    trusted = BooleanField()
    uid = CharField(unique=True)
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'oauth_applications'
        indexes = (
            (('owner', 'owner_type'), False),
        )

class ClustersApplicationsJupyter(BaseModel):
    cluster = ForeignKeyField(db_column='cluster_id', rel_model=Clusters, to_field='id', unique=True)
    created_at = DateTimeField()
    hostname = CharField(null=True)
    oauth_application = ForeignKeyField(db_column='oauth_application_id', null=True, rel_model=OauthApplications, to_field='id')
    status = IntegerField()
    status_reason = TextField(null=True)
    updated_at = DateTimeField()
    version = CharField()

    class Meta:
        db_table = 'clusters_applications_jupyter'

class ClustersApplicationsKnative(BaseModel):
    cluster = ForeignKeyField(db_column='cluster_id', rel_model=Clusters, to_field='id', unique=True)
    created_at = DateTimeField()
    external_hostname = CharField(null=True)
    external_ip = CharField(null=True)
    hostname = CharField(null=True)
    status = IntegerField()
    status_reason = TextField(null=True)
    updated_at = DateTimeField()
    version = CharField()

    class Meta:
        db_table = 'clusters_applications_knative'

class ClustersApplicationsPrometheus(BaseModel):
    cluster = ForeignKeyField(db_column='cluster_id', rel_model=Clusters, to_field='id', unique=True)
    created_at = DateTimeField()
    encrypted_alert_manager_token = CharField(null=True)
    encrypted_alert_manager_token_iv = CharField(null=True)
    healthy = BooleanField(null=True)
    last_update_started_at = DateTimeField(null=True)
    status = IntegerField()
    status_reason = TextField(null=True)
    updated_at = DateTimeField()
    version = CharField()

    class Meta:
        db_table = 'clusters_applications_prometheus'

class ClustersApplicationsRunners(BaseModel):
    cluster = ForeignKeyField(db_column='cluster_id', rel_model=Clusters, to_field='id', unique=True)
    created_at = DateTimeField()
    privileged = BooleanField()
    runner = ForeignKeyField(db_column='runner_id', null=True, rel_model=CiRunners, to_field='id')
    status = IntegerField()
    status_reason = TextField(null=True)
    updated_at = DateTimeField()
    version = CharField()

    class Meta:
        db_table = 'clusters_applications_runners'

class ClustersKubernetesNamespaces(BaseModel):
    cluster = ForeignKeyField(db_column='cluster_id', rel_model=Clusters, to_field='id')
    cluster_project = ForeignKeyField(db_column='cluster_project_id', null=True, rel_model=ClusterProjects, to_field='id')
    created_at = DateTimeField()
    encrypted_service_account_token = TextField(null=True)
    encrypted_service_account_token_iv = CharField(null=True)
    environment = ForeignKeyField(db_column='environment_id', null=True, rel_model=Environments, to_field='id')
    id = BigIntegerField(primary_key=True)
    namespace = CharField()
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    service_account_name = CharField(null=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'clusters_kubernetes_namespaces'
        indexes = (
            (('cluster', 'namespace'), True),
            (('environment', 'cluster', 'project'), True),
        )

class CommitUserMentions(BaseModel):
    commit = CharField(db_column='commit_id')
    id = BigIntegerField(primary_key=True)
    mentioned_groups_ids = UnknownField(null=True)  # ARRAY
    mentioned_projects_ids = UnknownField(null=True)  # ARRAY
    mentioned_users_ids = UnknownField(null=True)  # ARRAY
    note = ForeignKeyField(db_column='note_id', rel_model=Notes, to_field='id', unique=True)

    class Meta:
        db_table = 'commit_user_mentions'
        indexes = (
            (('note', 'commit'), False),
        )

class ContainerExpirationPolicies(BaseModel):
    cadence = CharField()
    created_at = DateTimeField()
    enabled = BooleanField()
    keep_n = IntegerField(null=True)
    name_regex = CharField(null=True)
    name_regex_keep = TextField(null=True)
    next_run_at = DateTimeField(null=True)
    older_than = CharField(null=True)
    project = ForeignKeyField(db_column='project_id', primary_key=True, rel_model=Projects, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'container_expiration_policies'
        indexes = (
            (('next_run_at', 'enabled'), False),
        )

class ContainerRepositories(BaseModel):
    created_at = DateTimeField()
    name = CharField(index=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    status = IntegerField(null=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'container_repositories'
        indexes = (
            (('project', 'name'), True),
        )

class ConversationalDevelopmentIndexMetrics(BaseModel):
    created_at = DateTimeField()
    instance_boards = FloatField()
    instance_ci_pipelines = FloatField()
    instance_deployments = FloatField()
    instance_environments = FloatField()
    instance_issues = FloatField()
    instance_merge_requests = FloatField()
    instance_milestones = FloatField()
    instance_notes = FloatField()
    instance_projects_prometheus_active = FloatField()
    instance_service_desk_issues = FloatField()
    leader_boards = FloatField()
    leader_ci_pipelines = FloatField()
    leader_deployments = FloatField()
    leader_environments = FloatField()
    leader_issues = FloatField()
    leader_merge_requests = FloatField()
    leader_milestones = FloatField()
    leader_notes = FloatField()
    leader_projects_prometheus_active = FloatField()
    leader_service_desk_issues = FloatField()
    percentage_boards = FloatField()
    percentage_ci_pipelines = FloatField()
    percentage_deployments = FloatField()
    percentage_environments = FloatField()
    percentage_issues = FloatField()
    percentage_merge_requests = FloatField()
    percentage_milestones = FloatField()
    percentage_notes = FloatField()
    percentage_projects_prometheus_active = FloatField()
    percentage_service_desk_issues = FloatField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'conversational_development_index_metrics'

class CustomEmoji(BaseModel):
    created_at = DateTimeField()
    external = BooleanField()
    file = TextField()
    id = BigIntegerField(primary_key=True)
    name = TextField()
    namespace = ForeignKeyField(db_column='namespace_id', rel_model=Namespaces, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'custom_emoji'
        indexes = (
            (('namespace', 'name'), True),
        )

class DastScannerProfiles(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    name = TextField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    spider_timeout = IntegerField(null=True)
    target_timeout = IntegerField(null=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'dast_scanner_profiles'
        indexes = (
            (('project', 'name'), True),
        )

class DastSites(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()
    url = TextField()

    class Meta:
        db_table = 'dast_sites'
        indexes = (
            (('project', 'url'), True),
        )

class DastSiteProfiles(BaseModel):
    created_at = DateTimeField()
    dast_site = ForeignKeyField(db_column='dast_site_id', rel_model=DastSites, to_field='id')
    id = BigIntegerField(primary_key=True)
    name = TextField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'dast_site_profiles'
        indexes = (
            (('project', 'name'), True),
        )

class DependencyProxyBlobs(BaseModel):
    created_at = DateTimeField()
    file = TextField()
    file_name = CharField()
    file_store = IntegerField(null=True)
    group = ForeignKeyField(db_column='group_id', rel_model=Namespaces, to_field='id')
    size = BigIntegerField(null=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'dependency_proxy_blobs'
        indexes = (
            (('group', 'file_name'), False),
        )

class DependencyProxyGroupSettings(BaseModel):
    created_at = DateTimeField()
    enabled = BooleanField()
    group = ForeignKeyField(db_column='group_id', rel_model=Namespaces, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'dependency_proxy_group_settings'

class DeployKeysProjects(BaseModel):
    can_push = BooleanField()
    created_at = DateTimeField(null=True)
    deploy_key = IntegerField(db_column='deploy_key_id', index=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'deploy_keys_projects'

class DeployTokens(BaseModel):
    created_at = DateTimeField()
    deploy_token_type = IntegerField()
    expires_at = DateTimeField()
    name = CharField()
    read_package_registry = BooleanField()
    read_registry = BooleanField()
    read_repository = BooleanField()
    revoked = BooleanField(null=True)
    token = CharField(null=True, unique=True)
    token_encrypted = CharField(null=True, unique=True)
    username = CharField(null=True)
    write_package_registry = BooleanField()
    write_registry = BooleanField()

    class Meta:
        db_table = 'deploy_tokens'
        indexes = (
            (('id', 'expires_at', 'token'), False),
        )

class Deployments(BaseModel):
    cluster = ForeignKeyField(db_column='cluster_id', null=True, rel_model=Clusters, to_field='id')
    created_at = DateTimeField(index=True, null=True)
    deployable = IntegerField(db_column='deployable_id', null=True)
    deployable_type = CharField(null=True)
    environment = IntegerField(db_column='environment_id')
    finished_at = DateTimeField(null=True)
    iid = IntegerField()
    on_stop = CharField(null=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    ref = CharField()
    sha = CharField()
    status = IntegerField()
    tag = BooleanField()
    updated_at = DateTimeField(null=True)
    user = IntegerField(db_column='user_id', null=True)

    class Meta:
        db_table = 'deployments'
        indexes = (
            (('cluster', 'environment'), False),
            (('created_at', 'status', 'project'), False),
            (('created_at', 'status', 'user'), False),
            (('deployable', 'deployable_type'), False),
            (('environment', 'project', 'iid'), False),
            (('environment', 'status'), False),
            (('id', 'environment'), False),
            (('id', 'project'), False),
            (('iid', 'project'), True),
            (('project', 'ref'), False),
            (('project', 'updated_at', 'id'), False),
            (('status', 'cluster'), False),
            (('status', 'created_at', 'id'), False),
            (('status', 'project'), False),
        )

class DeploymentClusters(BaseModel):
    cluster = ForeignKeyField(db_column='cluster_id', rel_model=Clusters, to_field='id')
    deployment = ForeignKeyField(db_column='deployment_id', primary_key=True, rel_model=Deployments, to_field='id')
    kubernetes_namespace = CharField(null=True)

    class Meta:
        db_table = 'deployment_clusters'
        indexes = (
            (('cluster', 'kubernetes_namespace'), False),
            (('deployment', 'cluster'), True),
        )

class DeploymentMergeRequests(BaseModel):
    deployment = ForeignKeyField(db_column='deployment_id', rel_model=Deployments, to_field='id')
    environment = ForeignKeyField(db_column='environment_id', null=True, rel_model=Environments, to_field='id')
    merge_request = ForeignKeyField(db_column='merge_request_id', rel_model=MergeRequests, to_field='id')

    class Meta:
        db_table = 'deployment_merge_requests'
        indexes = (
            (('deployment', 'merge_request'), True),
            (('merge_request', 'environment'), True),
        )

class DescriptionVersions(BaseModel):
    created_at = DateTimeField()
    deleted_at = DateTimeField(null=True)
    description = TextField(null=True)
    epic = ForeignKeyField(db_column='epic_id', null=True, rel_model=Epics, to_field='id')
    id = BigIntegerField(primary_key=True)
    issue = ForeignKeyField(db_column='issue_id', null=True, rel_model=Issues, to_field='id')
    merge_request = ForeignKeyField(db_column='merge_request_id', null=True, rel_model=MergeRequests, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'description_versions'

class DesignManagementDesigns(BaseModel):
    filename = CharField()
    id = BigIntegerField(primary_key=True)
    issue = ForeignKeyField(db_column='issue_id', null=True, rel_model=Issues, to_field='id')
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    relative_position = IntegerField(null=True)

    class Meta:
        db_table = 'design_management_designs'
        indexes = (
            (('id', 'issue', 'relative_position'), False),
            (('issue', 'filename'), True),
        )

class DesignManagementVersions(BaseModel):
    author = ForeignKeyField(db_column='author_id', null=True, rel_model=Users, to_field='id')
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    issue = ForeignKeyField(db_column='issue_id', null=True, rel_model=Issues, to_field='id')
    sha = BlobField()

    class Meta:
        db_table = 'design_management_versions'
        indexes = (
            (('sha', 'issue'), True),
        )

class DesignManagementDesignsVersions(BaseModel):
    design = ForeignKeyField(db_column='design_id', rel_model=DesignManagementDesigns, to_field='id')
    event = IntegerField(index=True)
    id = BigIntegerField(primary_key=True)
    image_v432x230 = CharField(null=True)
    version = ForeignKeyField(db_column='version_id', rel_model=DesignManagementVersions, to_field='id')

    class Meta:
        db_table = 'design_management_designs_versions'
        indexes = (
            (('design', 'version'), True),
        )

class DesignUserMentions(BaseModel):
    design = ForeignKeyField(db_column='design_id', rel_model=DesignManagementDesigns, to_field='id')
    id = BigIntegerField(primary_key=True)
    mentioned_groups_ids = UnknownField(null=True)  # ARRAY
    mentioned_projects_ids = UnknownField(null=True)  # ARRAY
    mentioned_users_ids = UnknownField(null=True)  # ARRAY
    note = ForeignKeyField(db_column='note_id', rel_model=Notes, to_field='id', unique=True)

    class Meta:
        db_table = 'design_user_mentions'
        indexes = (
            (('design', 'note'), False),
        )

class DiffNotePositions(BaseModel):
    base_sha = BlobField()
    diff_content_type = IntegerField()
    diff_type = IntegerField()
    head_sha = BlobField()
    id = BigIntegerField(primary_key=True)
    line_code = CharField()
    new_line = IntegerField(null=True)
    new_path = TextField()
    note = ForeignKeyField(db_column='note_id', rel_model=Notes, to_field='id')
    old_line = IntegerField(null=True)
    old_path = TextField()
    start_sha = BlobField()

    class Meta:
        db_table = 'diff_note_positions'
        indexes = (
            (('note', 'diff_type'), True),
        )

class DraftNotes(BaseModel):
    author = ForeignKeyField(db_column='author_id', rel_model=Users, to_field='id')
    change_position = TextField(null=True)
    commit = BlobField(db_column='commit_id', null=True)
    discussion = CharField(db_column='discussion_id', index=True, null=True)
    id = BigIntegerField(primary_key=True)
    merge_request = ForeignKeyField(db_column='merge_request_id', rel_model=MergeRequests, to_field='id')
    note = TextField()
    original_position = TextField(null=True)
    position = TextField(null=True)
    resolve_discussion = BooleanField()

    class Meta:
        db_table = 'draft_notes'

class ElasticReindexingTasks(BaseModel):
    created_at = DateTimeField()
    delete_original_index_at = DateTimeField(null=True)
    documents_count = IntegerField(null=True)
    documents_count_target = IntegerField(null=True)
    elastic_task = TextField(null=True)
    error_message = TextField(null=True)
    id = BigIntegerField(primary_key=True)
    in_progress = BooleanField(unique=True)
    index_name_from = TextField(null=True)
    index_name_to = TextField(null=True)
    state = IntegerField(index=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'elastic_reindexing_tasks'

class ElasticsearchIndexedNamespaces(BaseModel):
    created_at = DateTimeField(index=True)
    namespace = ForeignKeyField(db_column='namespace_id', null=True, rel_model=Namespaces, to_field='id', unique=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'elasticsearch_indexed_namespaces'

class ElasticsearchIndexedProjects(BaseModel):
    created_at = DateTimeField()
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id', unique=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'elasticsearch_indexed_projects'

class Emails(BaseModel):
    confirmation_sent_at = DateTimeField(null=True)
    confirmation_token = CharField(null=True, unique=True)
    confirmed_at = DateTimeField(null=True)
    created_at = DateTimeField(null=True)
    email = CharField(unique=True)
    updated_at = DateTimeField(null=True)
    user = IntegerField(db_column='user_id', index=True)

    class Meta:
        db_table = 'emails'

class EpicIssues(BaseModel):
    epic = ForeignKeyField(db_column='epic_id', rel_model=Epics, to_field='id')
    issue = ForeignKeyField(db_column='issue_id', rel_model=Issues, to_field='id', unique=True)
    relative_position = IntegerField(null=True)

    class Meta:
        db_table = 'epic_issues'

class EpicMetrics(BaseModel):
    created_at = DateTimeField()
    epic = ForeignKeyField(db_column='epic_id', rel_model=Epics, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'epic_metrics'

class EpicUserMentions(BaseModel):
    epic = ForeignKeyField(db_column='epic_id', rel_model=Epics, to_field='id', unique=True)
    id = BigIntegerField(primary_key=True)
    mentioned_groups_ids = UnknownField(null=True)  # ARRAY
    mentioned_projects_ids = UnknownField(null=True)  # ARRAY
    mentioned_users_ids = UnknownField(null=True)  # ARRAY
    note = ForeignKeyField(db_column='note_id', null=True, rel_model=Notes, to_field='id', unique=True)

    class Meta:
        db_table = 'epic_user_mentions'
        indexes = (
            (('epic', 'note'), True),
        )

class Events(BaseModel):
    action = IntegerField(index=True)
    author = ForeignKeyField(db_column='author_id', rel_model=Users, to_field='id')
    created_at = DateTimeField()
    fingerprint = BlobField(null=True)
    group = ForeignKeyField(db_column='group_id', null=True, rel_model=Namespaces, to_field='id')
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    target = IntegerField(db_column='target_id', null=True)
    target_type = CharField(null=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'events'
        indexes = (
            (('author', 'created_at'), False),
            (('created_at', 'author'), False),
            (('created_at', 'author'), False),
            (('id', 'project'), False),
            (('id', 'project'), False),
            (('project', 'author'), False),
            (('project', 'created_at'), False),
            (('target', 'target_type'), False),
            (('target_type', 'fingerprint', 'target'), True),
        )

class Releases(BaseModel):
    author = ForeignKeyField(db_column='author_id', null=True, rel_model=Users, to_field='id')
    cached_markdown_version = IntegerField(null=True)
    created_at = DateTimeField()
    description = TextField(null=True)
    description_html = TextField(null=True)
    name = CharField(null=True)
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    released_at = DateTimeField()
    sha = CharField(null=True)
    tag = CharField(null=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'releases'
        indexes = (
            (('tag', 'project'), False),
        )

class Evidences(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    release = ForeignKeyField(db_column='release_id', rel_model=Releases, to_field='id')
    summary = JSONField()
    summary_sha = BlobField(null=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'evidences'

class Experiments(BaseModel):
    id = BigIntegerField(primary_key=True)
    name = TextField(unique=True)

    class Meta:
        db_table = 'experiments'

class ExperimentUsers(BaseModel):
    created_at = DateTimeField()
    experiment = ForeignKeyField(db_column='experiment_id', rel_model=Experiments, to_field='id')
    group_type = IntegerField()
    id = BigIntegerField(primary_key=True)
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'experiment_users'

class FeatureGates(BaseModel):
    created_at = DateTimeField()
    feature_key = CharField()
    key = CharField()
    updated_at = DateTimeField()
    value = CharField(null=True)

    class Meta:
        db_table = 'feature_gates'
        indexes = (
            (('feature_key', 'key', 'value'), True),
        )

class Features(BaseModel):
    created_at = DateTimeField()
    key = CharField(unique=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'features'

class ForkNetworks(BaseModel):
    deleted_root_project_name = CharField(null=True)
    root_project = ForeignKeyField(db_column='root_project_id', null=True, rel_model=Projects, to_field='id', unique=True)

    class Meta:
        db_table = 'fork_networks'

class ForkNetworkMembers(BaseModel):
    fork_network = ForeignKeyField(db_column='fork_network_id', rel_model=ForkNetworks, to_field='id')
    forked_from_project = ForeignKeyField(db_column='forked_from_project_id', null=True, rel_model=Projects, to_field='id')
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, related_name='projects_project_set', to_field='id', unique=True)

    class Meta:
        db_table = 'fork_network_members'

class GeoCacheInvalidationEvents(BaseModel):
    id = BigIntegerField(primary_key=True)
    key = CharField()

    class Meta:
        db_table = 'geo_cache_invalidation_events'

class GeoContainerRepositoryUpdatedEvents(BaseModel):
    container_repository = ForeignKeyField(db_column='container_repository_id', rel_model=ContainerRepositories, to_field='id')
    id = BigIntegerField(primary_key=True)

    class Meta:
        db_table = 'geo_container_repository_updated_events'

class GeoJobArtifactDeletedEvents(BaseModel):
    file_path = CharField()
    id = BigIntegerField(primary_key=True)
    job_artifact = IntegerField(db_column='job_artifact_id', index=True)

    class Meta:
        db_table = 'geo_job_artifact_deleted_events'

class GeoHashedStorageMigratedEvents(BaseModel):
    id = BigIntegerField(primary_key=True)
    new_design_disk_path = TextField(null=True)
    new_disk_path = TextField()
    new_storage_version = IntegerField()
    new_wiki_disk_path = TextField()
    old_design_disk_path = TextField(null=True)
    old_disk_path = TextField()
    old_storage_version = IntegerField(null=True)
    old_wiki_disk_path = TextField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    repository_storage_name = TextField()

    class Meta:
        db_table = 'geo_hashed_storage_migrated_events'

class GeoNodes(BaseModel):
    access_key = CharField(index=True, null=True)
    clone_url_prefix = CharField(null=True)
    container_repositories_max_capacity = IntegerField()
    created_at = DateTimeField(null=True)
    enabled = BooleanField()
    encrypted_secret_access_key = CharField(null=True)
    encrypted_secret_access_key_iv = CharField(null=True)
    files_max_capacity = IntegerField()
    internal_url = CharField(null=True)
    minimum_reverification_interval = IntegerField()
    name = CharField(unique=True)
    oauth_application = IntegerField(db_column='oauth_application_id', null=True)
    primary = BooleanField(index=True)
    repos_max_capacity = IntegerField()
    selective_sync_shards = TextField(null=True)
    selective_sync_type = CharField(null=True)
    sync_object_storage = BooleanField()
    updated_at = DateTimeField(null=True)
    url = CharField()
    verification_max_capacity = IntegerField()

    class Meta:
        db_table = 'geo_nodes'

class GeoRepositoriesChangedEvents(BaseModel):
    geo_node = ForeignKeyField(db_column='geo_node_id', rel_model=GeoNodes, to_field='id')
    id = BigIntegerField(primary_key=True)

    class Meta:
        db_table = 'geo_repositories_changed_events'

class GeoRepositoryUpdatedEvents(BaseModel):
    branches_affected = IntegerField()
    id = BigIntegerField(primary_key=True)
    new_branch = BooleanField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    ref = TextField(null=True)
    remove_branch = BooleanField()
    source = IntegerField(index=True)
    tags_affected = IntegerField()

    class Meta:
        db_table = 'geo_repository_updated_events'

class GeoRepositoryRenamedEvents(BaseModel):
    id = BigIntegerField(primary_key=True)
    new_path = TextField()
    new_path_with_namespace = TextField()
    new_wiki_path_with_namespace = TextField()
    old_path = TextField()
    old_path_with_namespace = TextField()
    old_wiki_path_with_namespace = TextField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    repository_storage_name = TextField()

    class Meta:
        db_table = 'geo_repository_renamed_events'

class GeoRepositoryCreatedEvents(BaseModel):
    id = BigIntegerField(primary_key=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    project_name = TextField()
    repo_path = TextField()
    repository_storage_name = TextField()
    wiki_path = TextField(null=True)

    class Meta:
        db_table = 'geo_repository_created_events'

class GeoUploadDeletedEvents(BaseModel):
    file_path = CharField()
    id = BigIntegerField(primary_key=True)
    model = IntegerField(db_column='model_id')
    model_type = CharField()
    upload = IntegerField(db_column='upload_id', index=True)
    uploader = CharField()

    class Meta:
        db_table = 'geo_upload_deleted_events'

class GeoRepositoryDeletedEvents(BaseModel):
    deleted_path = TextField()
    deleted_project_name = TextField()
    deleted_wiki_path = TextField(null=True)
    id = BigIntegerField(primary_key=True)
    project = IntegerField(db_column='project_id', index=True)
    repository_storage_name = TextField()

    class Meta:
        db_table = 'geo_repository_deleted_events'

class GeoResetChecksumEvents(BaseModel):
    id = BigIntegerField(primary_key=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')

    class Meta:
        db_table = 'geo_reset_checksum_events'

class GeoLfsObjectDeletedEvents(BaseModel):
    file_path = CharField()
    id = BigIntegerField(primary_key=True)
    lfs_object = IntegerField(db_column='lfs_object_id', index=True)
    oid = CharField()

    class Meta:
        db_table = 'geo_lfs_object_deleted_events'

class GeoEvents(BaseModel):
    created_at = DateTimeField()
    event_name = CharField()
    id = BigIntegerField(primary_key=True)
    payload = JSONField()
    replicable_name = CharField()

    class Meta:
        db_table = 'geo_events'

class GeoEventLog(BaseModel):
    cache_invalidation_event = ForeignKeyField(db_column='cache_invalidation_event_id', null=True, rel_model=GeoCacheInvalidationEvents, to_field='id')
    container_repository_updated_event = ForeignKeyField(db_column='container_repository_updated_event_id', null=True, rel_model=GeoContainerRepositoryUpdatedEvents, to_field='id')
    created_at = DateTimeField()
    geo_event = ForeignKeyField(db_column='geo_event_id', null=True, rel_model=GeoEvents, to_field='id')
    hashed_storage_attachments_event = BigIntegerField(db_column='hashed_storage_attachments_event_id', index=True, null=True)
    hashed_storage_migrated_event = ForeignKeyField(db_column='hashed_storage_migrated_event_id', null=True, rel_model=GeoHashedStorageMigratedEvents, to_field='id')
    id = BigIntegerField(primary_key=True)
    job_artifact_deleted_event = ForeignKeyField(db_column='job_artifact_deleted_event_id', null=True, rel_model=GeoJobArtifactDeletedEvents, to_field='id')
    lfs_object_deleted_event = ForeignKeyField(db_column='lfs_object_deleted_event_id', null=True, rel_model=GeoLfsObjectDeletedEvents, to_field='id')
    repositories_changed_event = ForeignKeyField(db_column='repositories_changed_event_id', null=True, rel_model=GeoRepositoriesChangedEvents, to_field='id')
    repository_created_event = ForeignKeyField(db_column='repository_created_event_id', null=True, rel_model=GeoRepositoryCreatedEvents, to_field='id')
    repository_deleted_event = ForeignKeyField(db_column='repository_deleted_event_id', null=True, rel_model=GeoRepositoryDeletedEvents, to_field='id')
    repository_renamed_event = ForeignKeyField(db_column='repository_renamed_event_id', null=True, rel_model=GeoRepositoryRenamedEvents, to_field='id')
    repository_updated_event = ForeignKeyField(db_column='repository_updated_event_id', null=True, rel_model=GeoRepositoryUpdatedEvents, to_field='id')
    reset_checksum_event = ForeignKeyField(db_column='reset_checksum_event_id', null=True, rel_model=GeoResetChecksumEvents, to_field='id')
    upload_deleted_event = ForeignKeyField(db_column='upload_deleted_event_id', null=True, rel_model=GeoUploadDeletedEvents, to_field='id')

    class Meta:
        db_table = 'geo_event_log'

class GeoHashedStorageAttachmentsEvents(BaseModel):
    id = BigIntegerField(primary_key=True)
    new_attachments_path = TextField()
    old_attachments_path = TextField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')

    class Meta:
        db_table = 'geo_hashed_storage_attachments_events'

class GeoNodeNamespaceLinks(BaseModel):
    created_at = DateTimeField()
    geo_node = ForeignKeyField(db_column='geo_node_id', rel_model=GeoNodes, to_field='id')
    namespace = ForeignKeyField(db_column='namespace_id', rel_model=Namespaces, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'geo_node_namespace_links'
        indexes = (
            (('geo_node', 'namespace'), True),
        )

class GeoNodeStatuses(BaseModel):
    attachments_count = IntegerField(null=True)
    attachments_failed_count = IntegerField(null=True)
    attachments_synced_count = IntegerField(null=True)
    attachments_synced_missing_on_primary_count = IntegerField(null=True)
    container_repositories_count = IntegerField(null=True)
    container_repositories_failed_count = IntegerField(null=True)
    container_repositories_registry_count = IntegerField(null=True)
    container_repositories_synced_count = IntegerField(null=True)
    created_at = DateTimeField()
    cursor_last_event_date = DateTimeField(null=True)
    cursor_last_event = IntegerField(db_column='cursor_last_event_id', null=True)
    db_replication_lag_seconds = IntegerField(null=True)
    design_repositories_count = IntegerField(null=True)
    design_repositories_failed_count = IntegerField(null=True)
    design_repositories_registry_count = IntegerField(null=True)
    design_repositories_synced_count = IntegerField(null=True)
    geo_node = ForeignKeyField(db_column='geo_node_id', rel_model=GeoNodes, to_field='id', unique=True)
    job_artifacts_count = IntegerField(null=True)
    job_artifacts_failed_count = IntegerField(null=True)
    job_artifacts_synced_count = IntegerField(null=True)
    job_artifacts_synced_missing_on_primary_count = IntegerField(null=True)
    last_event_date = DateTimeField(null=True)
    last_event = IntegerField(db_column='last_event_id', null=True)
    last_successful_status_check_at = DateTimeField(null=True)
    lfs_objects_count = IntegerField(null=True)
    lfs_objects_failed_count = IntegerField(null=True)
    lfs_objects_synced_count = IntegerField(null=True)
    lfs_objects_synced_missing_on_primary_count = IntegerField(null=True)
    projects_count = IntegerField(null=True)
    replication_slots_count = IntegerField(null=True)
    replication_slots_max_retained_wal_bytes = BigIntegerField(null=True)
    replication_slots_used_count = IntegerField(null=True)
    repositories_checksum_failed_count = IntegerField(null=True)
    repositories_checksum_mismatch_count = IntegerField(null=True)
    repositories_checksummed_count = IntegerField(null=True)
    repositories_failed_count = IntegerField(null=True)
    repositories_retrying_verification_count = IntegerField(null=True)
    repositories_synced_count = IntegerField(null=True)
    repositories_verification_failed_count = IntegerField(null=True)
    repositories_verified_count = IntegerField(null=True)
    revision = CharField(null=True)
    status = JSONField()
    status_message = CharField(null=True)
    storage_configuration_digest = BlobField(null=True)
    updated_at = DateTimeField()
    version = CharField(null=True)
    wikis_checksum_failed_count = IntegerField(null=True)
    wikis_checksum_mismatch_count = IntegerField(null=True)
    wikis_checksummed_count = IntegerField(null=True)
    wikis_failed_count = IntegerField(null=True)
    wikis_retrying_verification_count = IntegerField(null=True)
    wikis_synced_count = IntegerField(null=True)
    wikis_verification_failed_count = IntegerField(null=True)
    wikis_verified_count = IntegerField(null=True)

    class Meta:
        db_table = 'geo_node_statuses'

class GitlabSubscriptionHistories(BaseModel):
    auto_renew = BooleanField(null=True)
    change_type = IntegerField(null=True)
    created_at = DateTimeField(null=True)
    end_date = DateField(null=True)
    gitlab_subscription_created_at = DateTimeField(null=True)
    gitlab_subscription = BigIntegerField(db_column='gitlab_subscription_id', index=True)
    gitlab_subscription_updated_at = DateTimeField(null=True)
    hosted_plan = IntegerField(db_column='hosted_plan_id', null=True)
    id = BigIntegerField(primary_key=True)
    max_seats_used = IntegerField(null=True)
    namespace = IntegerField(db_column='namespace_id', null=True)
    seats = IntegerField(null=True)
    start_date = DateField(null=True)
    trial = BooleanField(null=True)
    trial_ends_on = DateField(null=True)
    trial_starts_on = DateField(null=True)

    class Meta:
        db_table = 'gitlab_subscription_histories'

class Plans(BaseModel):
    created_at = DateTimeField()
    name = CharField(null=True, unique=True)
    title = CharField(null=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'plans'

class GitlabSubscriptions(BaseModel):
    auto_renew = BooleanField(null=True)
    created_at = DateTimeField()
    end_date = DateField(null=True)
    hosted_plan = ForeignKeyField(db_column='hosted_plan_id', null=True, rel_model=Plans, to_field='id')
    id = BigIntegerField(primary_key=True)
    max_seats_used = IntegerField(null=True)
    namespace = ForeignKeyField(db_column='namespace_id', null=True, rel_model=Namespaces, to_field='id', unique=True)
    seats = IntegerField(null=True)
    start_date = DateField(null=True)
    trial = BooleanField(null=True)
    trial_ends_on = DateField(null=True)
    trial_starts_on = DateField(null=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'gitlab_subscriptions'
        indexes = (
            (('end_date', 'namespace'), False),
        )

class GpgKeys(BaseModel):
    created_at = DateTimeField()
    fingerprint = BlobField(null=True, unique=True)
    key = TextField(null=True)
    primary_keyid = BlobField(null=True, unique=True)
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', null=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'gpg_keys'

class GpgKeySubkeys(BaseModel):
    fingerprint = BlobField(null=True, unique=True)
    gpg_key = ForeignKeyField(db_column='gpg_key_id', rel_model=GpgKeys, to_field='id')
    keyid = BlobField(null=True, unique=True)

    class Meta:
        db_table = 'gpg_key_subkeys'

class GpgSignatures(BaseModel):
    commit_sha = BlobField(null=True, unique=True)
    created_at = DateTimeField()
    gpg_key = ForeignKeyField(db_column='gpg_key_id', null=True, rel_model=GpgKeys, to_field='id')
    gpg_key_primary_keyid = BlobField(index=True, null=True)
    gpg_key_subkey = ForeignKeyField(db_column='gpg_key_subkey_id', null=True, rel_model=GpgKeySubkeys, to_field='id')
    gpg_key_user_email = TextField(null=True)
    gpg_key_user_name = TextField(null=True)
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    updated_at = DateTimeField()
    verification_status = IntegerField()

    class Meta:
        db_table = 'gpg_signatures'

class GrafanaIntegrations(BaseModel):
    created_at = DateTimeField()
    enabled = BooleanField(index=True)
    encrypted_token = CharField()
    encrypted_token_iv = CharField()
    grafana_url = CharField()
    id = BigIntegerField(primary_key=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'grafana_integrations'

class GroupCustomAttributes(BaseModel):
    created_at = DateTimeField()
    group = ForeignKeyField(db_column='group_id', rel_model=Namespaces, to_field='id')
    key = CharField()
    updated_at = DateTimeField()
    value = CharField()

    class Meta:
        db_table = 'group_custom_attributes'
        indexes = (
            (('group', 'key'), True),
            (('key', 'value'), False),
        )

class GroupDeletionSchedules(BaseModel):
    group = ForeignKeyField(db_column='group_id', primary_key=True, rel_model=Namespaces, to_field='id')
    marked_for_deletion_on = DateField(index=True)
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'group_deletion_schedules'

class GroupDeployKeys(BaseModel):
    created_at = DateTimeField()
    expires_at = DateTimeField(null=True)
    fingerprint = TextField(unique=True)
    fingerprint_sha256 = BlobField(index=True, null=True)
    id = BigIntegerField(primary_key=True)
    key = TextField()
    last_used_at = DateTimeField(null=True)
    title = TextField(null=True)
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', null=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'group_deploy_keys'

class GroupDeployKeysGroups(BaseModel):
    can_push = BooleanField()
    created_at = DateTimeField()
    group_deploy_key = ForeignKeyField(db_column='group_deploy_key_id', rel_model=GroupDeployKeys, to_field='id')
    group = ForeignKeyField(db_column='group_id', rel_model=Namespaces, to_field='id')
    id = BigIntegerField(primary_key=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'group_deploy_keys_groups'
        indexes = (
            (('group', 'group_deploy_key'), True),
        )

class GroupDeployTokens(BaseModel):
    created_at = DateTimeField()
    deploy_token = ForeignKeyField(db_column='deploy_token_id', rel_model=DeployTokens, to_field='id')
    group = ForeignKeyField(db_column='group_id', rel_model=Namespaces, to_field='id')
    id = BigIntegerField(primary_key=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'group_deploy_tokens'
        indexes = (
            (('group', 'deploy_token'), True),
        )

class GroupGroupLinks(BaseModel):
    created_at = DateTimeField()
    expires_at = DateField(null=True)
    group_access = IntegerField()
    id = BigIntegerField(primary_key=True)
    shared_group = ForeignKeyField(db_column='shared_group_id', rel_model=Namespaces, to_field='id')
    shared_with_group = ForeignKeyField(db_column='shared_with_group_id', rel_model=Namespaces, related_name='namespaces_shared_with_group_set', to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'group_group_links'
        indexes = (
            (('shared_group', 'shared_with_group'), True),
        )

class GroupImportStates(BaseModel):
    created_at = DateTimeField()
    group = ForeignKeyField(db_column='group_id', primary_key=True, rel_model=Namespaces, to_field='id')
    jid = TextField(null=True)
    last_error = TextField(null=True)
    status = IntegerField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'group_import_states'

class GroupWikiRepositories(BaseModel):
    disk_path = TextField(unique=True)
    group = ForeignKeyField(db_column='group_id', primary_key=True, rel_model=Namespaces, to_field='id')
    shard = ForeignKeyField(db_column='shard_id', rel_model=Shards, to_field='id')

    class Meta:
        db_table = 'group_wiki_repositories'

class HistoricalData(BaseModel):
    active_user_count = IntegerField(null=True)
    created_at = DateTimeField(null=True)
    date = DateField()
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'historical_data'

class SamlProviders(BaseModel):
    certificate_fingerprint = CharField()
    default_membership_role = IntegerField()
    enabled = BooleanField()
    enforced_group_managed_accounts = BooleanField()
    enforced_sso = BooleanField()
    group = ForeignKeyField(db_column='group_id', rel_model=Namespaces, to_field='id')
    prohibited_outer_forks = BooleanField()
    sso_url = CharField()

    class Meta:
        db_table = 'saml_providers'

class Identities(BaseModel):
    created_at = DateTimeField(null=True)
    extern_uid = CharField(null=True)
    provider = CharField(index=True, null=True)
    saml_provider = ForeignKeyField(db_column='saml_provider_id', null=True, rel_model=SamlProviders, to_field='id')
    secondary_extern_uid = CharField(null=True)
    updated_at = DateTimeField(null=True)
    user = IntegerField(db_column='user_id', index=True, null=True)

    class Meta:
        db_table = 'identities'

class ImportExportUploads(BaseModel):
    export_file = TextField(null=True)
    group = ForeignKeyField(db_column='group_id', null=True, rel_model=Namespaces, to_field='id', unique=True)
    import_file = TextField(null=True)
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    updated_at = DateTimeField(index=True)

    class Meta:
        db_table = 'import_export_uploads'

class ImportFailures(BaseModel):
    correlation_id_value = CharField(index=True, null=True)
    created_at = DateTimeField()
    exception_class = CharField(null=True)
    exception_message = CharField(null=True)
    group = ForeignKeyField(db_column='group_id', null=True, rel_model=Namespaces, to_field='id')
    id = BigIntegerField(primary_key=True)
    project = BigIntegerField(db_column='project_id', index=True, null=True)
    relation_index = IntegerField(null=True)
    relation_key = CharField(null=True)
    retry_count = IntegerField(null=True)
    source = CharField(null=True)

    class Meta:
        db_table = 'import_failures'
        indexes = (
            (('project', 'correlation_id_value'), False),
        )

class IndexStatuses(BaseModel):
    created_at = DateTimeField()
    indexed_at = DateTimeField(null=True)
    last_commit = CharField(null=True)
    last_wiki_commit = BlobField(null=True)
    note = TextField(null=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id', unique=True)
    updated_at = DateTimeField()
    wiki_indexed_at = DateTimeField(null=True)

    class Meta:
        db_table = 'index_statuses'

class Insights(BaseModel):
    namespace = ForeignKeyField(db_column='namespace_id', rel_model=Namespaces, to_field='id')
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')

    class Meta:
        db_table = 'insights'

class InternalIds(BaseModel):
    id = BigIntegerField(primary_key=True)
    last_value = IntegerField()
    namespace = ForeignKeyField(db_column='namespace_id', null=True, rel_model=Namespaces, to_field='id')
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    usage = IntegerField()

    class Meta:
        db_table = 'internal_ids'
        indexes = (
            (('namespace', 'usage'), True),
            (('project', 'usage'), True),
        )

class IpRestrictions(BaseModel):
    group = ForeignKeyField(db_column='group_id', rel_model=Namespaces, to_field='id')
    id = BigIntegerField(primary_key=True)
    range = CharField()

    class Meta:
        db_table = 'ip_restrictions'

class IssueAssignees(BaseModel):
    issue = ForeignKeyField(db_column='issue_id', rel_model=Issues, to_field='id')
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'issue_assignees'
        indexes = (
            (('user', 'issue'), True),
        )

class IssueLinks(BaseModel):
    created_at = DateTimeField(null=True)
    link_type = IntegerField()
    source = ForeignKeyField(db_column='source_id', rel_model=Issues, to_field='id')
    target = ForeignKeyField(db_column='target_id', rel_model=Issues, related_name='issues_target_set', to_field='id')
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'issue_links'
        indexes = (
            (('source', 'target'), True),
        )

class IssueMetrics(BaseModel):
    created_at = DateTimeField()
    first_added_to_board_at = DateTimeField(null=True)
    first_associated_with_milestone_at = DateTimeField(null=True)
    first_mentioned_in_commit_at = DateTimeField(null=True)
    issue = ForeignKeyField(db_column='issue_id', rel_model=Issues, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'issue_metrics'
        indexes = (
            (('issue', 'first_mentioned_in_commit_at', 'first_associated_with_milestone_at', 'first_added_to_board_at'), False),
        )

class IssueTrackerData(BaseModel):
    created_at = DateTimeField()
    encrypted_issues_url = CharField(null=True)
    encrypted_issues_url_iv = CharField(null=True)
    encrypted_new_issue_url = CharField(null=True)
    encrypted_new_issue_url_iv = CharField(null=True)
    encrypted_project_url = CharField(null=True)
    encrypted_project_url_iv = CharField(null=True)
    id = BigIntegerField(primary_key=True)
    service = ForeignKeyField(db_column='service_id', rel_model=Services, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'issue_tracker_data'

class IssueUserMentions(BaseModel):
    id = BigIntegerField(primary_key=True)
    issue = ForeignKeyField(db_column='issue_id', rel_model=Issues, to_field='id', unique=True)
    mentioned_groups_ids = UnknownField(null=True)  # ARRAY
    mentioned_projects_ids = UnknownField(null=True)  # ARRAY
    mentioned_users_ids = UnknownField(null=True)  # ARRAY
    note = ForeignKeyField(db_column='note_id', null=True, rel_model=Notes, to_field='id', unique=True)

    class Meta:
        db_table = 'issue_user_mentions'
        indexes = (
            (('issue', 'note'), True),
        )

class PrometheusAlertEvents(BaseModel):
    ended_at = DateTimeField(null=True)
    id = BigIntegerField(primary_key=True)
    payload_key = CharField(null=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    prometheus_alert = ForeignKeyField(db_column='prometheus_alert_id', rel_model=PrometheusAlerts, to_field='id')
    started_at = DateTimeField()
    status = IntegerField(null=True)

    class Meta:
        db_table = 'prometheus_alert_events'
        indexes = (
            (('project', 'status'), False),
            (('prometheus_alert', 'payload_key'), True),
        )

class IssuesPrometheusAlertEvents(BaseModel):
    created_at = DateTimeField()
    issue = ForeignKeyField(db_column='issue_id', rel_model=Issues, to_field='id')
    prometheus_alert_event = ForeignKeyField(db_column='prometheus_alert_event_id', rel_model=PrometheusAlertEvents, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'issues_prometheus_alert_events'
        indexes = (
            (('issue', 'prometheus_alert_event'), True),
        )

class SelfManagedPrometheusAlertEvents(BaseModel):
    ended_at = DateTimeField(null=True)
    environment = ForeignKeyField(db_column='environment_id', null=True, rel_model=Environments, to_field='id')
    id = BigIntegerField(primary_key=True)
    payload_key = CharField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    query_expression = CharField(null=True)
    started_at = DateTimeField()
    status = IntegerField()
    title = CharField()

    class Meta:
        db_table = 'self_managed_prometheus_alert_events'
        indexes = (
            (('project', 'payload_key'), True),
        )

class IssuesSelfManagedPrometheusAlertEvents(BaseModel):
    created_at = DateTimeField()
    issue = ForeignKeyField(db_column='issue_id', rel_model=Issues, to_field='id')
    self_managed_prometheus_alert_event = ForeignKeyField(db_column='self_managed_prometheus_alert_event_id', rel_model=SelfManagedPrometheusAlertEvents, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'issues_self_managed_prometheus_alert_events'
        indexes = (
            (('issue', 'self_managed_prometheus_alert_event'), True),
        )

class JiraConnectInstallations(BaseModel):
    base_url = CharField(null=True)
    client_key = CharField(null=True, unique=True)
    encrypted_shared_secret = CharField(null=True)
    encrypted_shared_secret_iv = CharField(null=True)
    id = BigIntegerField(primary_key=True)

    class Meta:
        db_table = 'jira_connect_installations'

class JiraConnectSubscriptions(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    jira_connect_installation = ForeignKeyField(db_column='jira_connect_installation_id', rel_model=JiraConnectInstallations, to_field='id')
    namespace = ForeignKeyField(db_column='namespace_id', rel_model=Namespaces, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'jira_connect_subscriptions'
        indexes = (
            (('jira_connect_installation', 'namespace'), True),
        )

class JiraImports(BaseModel):
    created_at = DateTimeField()
    error_message = TextField(null=True)
    failed_to_import_count = IntegerField()
    finished_at = DateTimeField(null=True)
    id = BigIntegerField(primary_key=True)
    imported_issues_count = IntegerField()
    jid = CharField(null=True)
    jira_project_key = CharField()
    jira_project_name = CharField()
    jira_project_xid = BigIntegerField()
    label = ForeignKeyField(db_column='label_id', null=True, rel_model=Labels, to_field='id')
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    scheduled_at = DateTimeField(null=True)
    status = IntegerField()
    total_issue_count = IntegerField()
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', null=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'jira_imports'
        indexes = (
            (('project', 'jira_project_key'), False),
        )

class JiraTrackerData(BaseModel):
    created_at = DateTimeField()
    deployment_type = IntegerField()
    encrypted_api_url = CharField(null=True)
    encrypted_api_url_iv = CharField(null=True)
    encrypted_password = CharField(null=True)
    encrypted_password_iv = CharField(null=True)
    encrypted_url = CharField(null=True)
    encrypted_url_iv = CharField(null=True)
    encrypted_username = CharField(null=True)
    encrypted_username_iv = CharField(null=True)
    id = BigIntegerField(primary_key=True)
    issues_enabled = BooleanField()
    jira_issue_transition = CharField(db_column='jira_issue_transition_id', null=True)
    project_key = TextField(null=True)
    service = ForeignKeyField(db_column='service_id', rel_model=Services, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'jira_tracker_data'

class Keys(BaseModel):
    created_at = DateTimeField(null=True)
    expires_at = DateTimeField(null=True)
    fingerprint = CharField(null=True, unique=True)
    fingerprint_sha256 = BlobField(index=True, null=True)
    key = TextField(null=True)
    last_used_at = DateTimeField(index=True, null=True)
    public = BooleanField()
    title = CharField(null=True)
    type = CharField(null=True)
    updated_at = DateTimeField(null=True)
    user = IntegerField(db_column='user_id', index=True, null=True)

    class Meta:
        db_table = 'keys'
        indexes = (
            (('type', 'id'), True),
        )

class LabelLinks(BaseModel):
    created_at = DateTimeField(null=True)
    label = ForeignKeyField(db_column='label_id', null=True, rel_model=Labels, to_field='id')
    target = IntegerField(db_column='target_id', null=True)
    target_type = CharField(null=True)
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'label_links'
        indexes = (
            (('target', 'target_type'), False),
        )

class LabelPriorities(BaseModel):
    created_at = DateTimeField()
    label = ForeignKeyField(db_column='label_id', rel_model=Labels, to_field='id')
    priority = IntegerField(index=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'label_priorities'
        indexes = (
            (('project', 'label'), True),
        )

class LdapGroupLinks(BaseModel):
    cn = CharField(null=True)
    created_at = DateTimeField(null=True)
    filter = CharField(null=True)
    group_access = IntegerField()
    group = IntegerField(db_column='group_id')
    provider = CharField(null=True)
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'ldap_group_links'

class LfsFileLocks(BaseModel):
    created_at = DateTimeField()
    path = CharField(null=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'lfs_file_locks'
        indexes = (
            (('project', 'path'), True),
        )

class LfsObjects(BaseModel):
    created_at = DateTimeField(null=True)
    file = CharField(null=True)
    file_store = IntegerField(index=True, null=True)
    oid = CharField(unique=True)
    size = BigIntegerField()
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'lfs_objects'

class LfsObjectsProjects(BaseModel):
    created_at = DateTimeField(null=True)
    lfs_object = IntegerField(db_column='lfs_object_id', index=True)
    project = IntegerField(db_column='project_id')
    repository_type = IntegerField(null=True)
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'lfs_objects_projects'
        indexes = (
            (('lfs_object', 'project'), False),
        )

class Licenses(BaseModel):
    created_at = DateTimeField(null=True)
    data = TextField()
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'licenses'

class Lists(BaseModel):
    board = ForeignKeyField(db_column='board_id', rel_model=Boards, to_field='id')
    created_at = DateTimeField()
    label = ForeignKeyField(db_column='label_id', null=True, rel_model=Labels, to_field='id')
    limit_metric = CharField(null=True)
    list_type = IntegerField(index=True)
    max_issue_count = IntegerField()
    max_issue_weight = IntegerField()
    milestone = ForeignKeyField(db_column='milestone_id', null=True, rel_model=Milestones, to_field='id')
    position = IntegerField(null=True)
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', null=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'lists'
        indexes = (
            (('board', 'label'), True),
        )

class ListUserPreferences(BaseModel):
    collapsed = BooleanField(null=True)
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    list = ForeignKeyField(db_column='list_id', rel_model=Lists, to_field='id')
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'list_user_preferences'
        indexes = (
            (('user', 'list'), True),
        )

class Members(BaseModel):
    access_level = IntegerField(index=True)
    created_at = DateTimeField(null=True)
    created_by = IntegerField(db_column='created_by_id', null=True)
    expires_at = DateField(index=True, null=True)
    invite_accepted_at = DateTimeField(null=True)
    invite_email = CharField(index=True, null=True)
    invite_token = CharField(null=True, unique=True)
    ldap = BooleanField()
    notification_level = IntegerField()
    override = BooleanField()
    requested_at = DateTimeField(index=True, null=True)
    source = IntegerField(db_column='source_id')
    source_type = CharField()
    type = CharField(null=True)
    updated_at = DateTimeField(null=True)
    user = ForeignKeyField(db_column='user_id', null=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'members'
        indexes = (
            (('created_at', 'user'), False),
            (('source', 'source_type'), False),
            (('source_type', 'source'), False),
        )

class MergeRequestAssignees(BaseModel):
    created_at = DateTimeField(null=True)
    id = BigIntegerField(primary_key=True)
    merge_request = ForeignKeyField(db_column='merge_request_id', rel_model=MergeRequests, to_field='id')
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'merge_request_assignees'
        indexes = (
            (('user', 'merge_request'), True),
        )

class MergeRequestBlocks(BaseModel):
    blocked_merge_request = ForeignKeyField(db_column='blocked_merge_request_id', rel_model=MergeRequests, to_field='id')
    blocking_merge_request = ForeignKeyField(db_column='blocking_merge_request_id', rel_model=MergeRequests, related_name='merge_requests_blocking_merge_request_set', to_field='id')
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'merge_request_blocks'
        indexes = (
            (('blocking_merge_request', 'blocked_merge_request'), True),
        )

class MergeRequestContextCommits(BaseModel):
    author_email = TextField(null=True)
    author_name = TextField(null=True)
    authored_date = DateTimeField(null=True)
    committed_date = DateTimeField(null=True)
    committer_email = TextField(null=True)
    committer_name = TextField(null=True)
    id = BigIntegerField(primary_key=True)
    merge_request = ForeignKeyField(db_column='merge_request_id', null=True, rel_model=MergeRequests, to_field='id')
    message = TextField(null=True)
    relative_order = IntegerField()
    sha = BlobField()

    class Meta:
        db_table = 'merge_request_context_commits'
        indexes = (
            (('sha', 'merge_request'), True),
        )

class MergeRequestContextCommitDiffFiles(BaseModel):
    a_mode = CharField()
    b_mode = CharField()
    binary = BooleanField(null=True)
    deleted_file = BooleanField()
    diff = TextField(null=True)
    merge_request_context_commit = ForeignKeyField(db_column='merge_request_context_commit_id', null=True, rel_model=MergeRequestContextCommits, to_field='id')
    new_file = BooleanField()
    new_path = TextField()
    old_path = TextField()
    relative_order = IntegerField()
    renamed_file = BooleanField()
    sha = BlobField()
    too_large = BooleanField()

    class Meta:
        db_table = 'merge_request_context_commit_diff_files'
        indexes = (
            (('sha', 'merge_request_context_commit'), False),
        )

class MergeRequestDiffCommits(BaseModel):
    author_email = TextField(null=True)
    author_name = TextField(null=True)
    authored_date = DateTimeField(null=True)
    committed_date = DateTimeField(null=True)
    committer_email = TextField(null=True)
    committer_name = TextField(null=True)
    merge_request_diff = ForeignKeyField(db_column='merge_request_diff_id', rel_model=MergeRequestDiffs, to_field='id')
    message = TextField(null=True)
    relative_order = IntegerField()
    sha = BlobField(index=True)

    class Meta:
        db_table = 'merge_request_diff_commits'
        indexes = (
            (('merge_request_diff', 'relative_order'), True),
        )

class MergeRequestDiffFiles(BaseModel):
    a_mode = CharField()
    b_mode = CharField()
    binary = BooleanField(null=True)
    deleted_file = BooleanField()
    diff = TextField(null=True)
    external_diff_offset = IntegerField(null=True)
    external_diff_size = IntegerField(null=True)
    merge_request_diff = ForeignKeyField(db_column='merge_request_diff_id', rel_model=MergeRequestDiffs, to_field='id')
    new_file = BooleanField()
    new_path = TextField()
    old_path = TextField()
    relative_order = IntegerField()
    renamed_file = BooleanField()
    too_large = BooleanField()

    class Meta:
        db_table = 'merge_request_diff_files'
        indexes = (
            (('merge_request_diff', 'relative_order'), True),
        )

class MergeRequestMetrics(BaseModel):
    added_lines = IntegerField(null=True)
    commits_count = IntegerField(null=True)
    created_at = DateTimeField()
    diff_size = IntegerField(null=True)
    first_approved_at = DateTimeField(null=True)
    first_comment_at = DateTimeField(null=True)
    first_commit_at = DateTimeField(null=True)
    first_deployed_to_production_at = DateTimeField(index=True, null=True)
    first_reassigned_at = DateTimeField(null=True)
    last_commit_at = DateTimeField(null=True)
    latest_build_finished_at = DateTimeField(null=True)
    latest_build_started_at = DateTimeField(null=True)
    latest_closed_at = DateTimeField(index=True, null=True)
    latest_closed_by = ForeignKeyField(db_column='latest_closed_by_id', null=True, rel_model=Users, to_field='id')
    merge_request = ForeignKeyField(db_column='merge_request_id', rel_model=MergeRequests, to_field='id', unique=True)
    merged_at = DateTimeField(index=True, null=True)
    merged_by = ForeignKeyField(db_column='merged_by_id', null=True, rel_model=Users, related_name='users_merged_by_set', to_field='id')
    modified_paths_size = IntegerField(null=True)
    pipeline = ForeignKeyField(db_column='pipeline_id', null=True, rel_model=CiPipelines, to_field='id')
    removed_lines = IntegerField(null=True)
    target_project = ForeignKeyField(db_column='target_project_id', null=True, rel_model=Projects, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'merge_request_metrics'
        indexes = (
            (('merge_request', 'merged_at'), False),
            (('merged_at', 'target_project'), False),
        )

class MergeRequestUserMentions(BaseModel):
    id = BigIntegerField(primary_key=True)
    mentioned_groups_ids = UnknownField(null=True)  # ARRAY
    mentioned_projects_ids = UnknownField(null=True)  # ARRAY
    mentioned_users_ids = UnknownField(null=True)  # ARRAY
    merge_request = ForeignKeyField(db_column='merge_request_id', rel_model=MergeRequests, to_field='id', unique=True)
    note = ForeignKeyField(db_column='note_id', null=True, rel_model=Notes, to_field='id', unique=True)

    class Meta:
        db_table = 'merge_request_user_mentions'
        indexes = (
            (('merge_request', 'note'), True),
        )

class MergeRequestsClosingIssues(BaseModel):
    created_at = DateTimeField()
    issue = ForeignKeyField(db_column='issue_id', rel_model=Issues, to_field='id')
    merge_request = ForeignKeyField(db_column='merge_request_id', rel_model=MergeRequests, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'merge_requests_closing_issues'

class MergeTrains(BaseModel):
    created_at = DateTimeField()
    duration = IntegerField(null=True)
    id = BigIntegerField(primary_key=True)
    merge_request = ForeignKeyField(db_column='merge_request_id', rel_model=MergeRequests, to_field='id', unique=True)
    merged_at = DateTimeField(null=True)
    pipeline = ForeignKeyField(db_column='pipeline_id', null=True, rel_model=CiPipelines, to_field='id')
    status = IntegerField()
    target_branch = TextField()
    target_project = ForeignKeyField(db_column='target_project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'merge_trains'
        indexes = (
            (('target_project', 'target_branch', 'status'), False),
        )

class MetricsDashboardAnnotations(BaseModel):
    cluster = ForeignKeyField(db_column='cluster_id', null=True, rel_model=Clusters, to_field='id')
    dashboard_path = CharField()
    description = TextField()
    ending_at = DateTimeField(null=True)
    environment = ForeignKeyField(db_column='environment_id', null=True, rel_model=Environments, to_field='id')
    id = BigIntegerField(primary_key=True)
    panel_xid = CharField(null=True)
    starting_at = DateTimeField()

    class Meta:
        db_table = 'metrics_dashboard_annotations'
        indexes = (
            (('starting_at', 'ending_at', 'cluster', 'dashboard_path'), False),
            (('starting_at', 'ending_at', 'environment', 'dashboard_path'), False),
        )

class MetricsUsersStarredDashboards(BaseModel):
    created_at = DateTimeField()
    dashboard_path = TextField()
    id = BigIntegerField(primary_key=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'metrics_users_starred_dashboards'
        indexes = (
            (('project', 'user', 'dashboard_path'), True),
        )

class MilestoneReleases(BaseModel):
    milestone = ForeignKeyField(db_column='milestone_id', rel_model=Milestones, to_field='id')
    release = ForeignKeyField(db_column='release_id', rel_model=Releases, to_field='id')

    class Meta:
        db_table = 'milestone_releases'
        indexes = (
            (('milestone', 'release'), True),
        )

class NamespaceAggregationSchedules(BaseModel):
    namespace = ForeignKeyField(db_column='namespace_id', primary_key=True, rel_model=Namespaces, to_field='id')

    class Meta:
        db_table = 'namespace_aggregation_schedules'

class NamespaceLimits(BaseModel):
    additional_purchased_storage_ends_on = DateField(null=True)
    additional_purchased_storage_size = BigIntegerField()
    namespace = ForeignKeyField(db_column='namespace_id', primary_key=True, rel_model=Namespaces, to_field='id')
    temporary_storage_increase_ends_on = DateField(null=True)

    class Meta:
        db_table = 'namespace_limits'

class NamespaceRootStorageStatistics(BaseModel):
    build_artifacts_size = BigIntegerField()
    lfs_objects_size = BigIntegerField()
    namespace = ForeignKeyField(db_column='namespace_id', primary_key=True, rel_model=Namespaces, to_field='id')
    packages_size = BigIntegerField()
    repository_size = BigIntegerField()
    snippets_size = BigIntegerField()
    storage_size = BigIntegerField()
    updated_at = DateTimeField()
    wiki_size = BigIntegerField()

    class Meta:
        db_table = 'namespace_root_storage_statistics'

class NamespaceSettings(BaseModel):
    created_at = DateTimeField()
    namespace = ForeignKeyField(db_column='namespace_id', primary_key=True, rel_model=Namespaces, to_field='id')
    prevent_forking_outside_group = BooleanField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'namespace_settings'

class NamespaceStatistics(BaseModel):
    namespace = ForeignKeyField(db_column='namespace_id', rel_model=Namespaces, to_field='id', unique=True)
    shared_runners_seconds = IntegerField()
    shared_runners_seconds_last_reset = DateTimeField(null=True)

    class Meta:
        db_table = 'namespace_statistics'

class NoteDiffFiles(BaseModel):
    a_mode = CharField()
    b_mode = CharField()
    deleted_file = BooleanField()
    diff = TextField()
    diff_note = ForeignKeyField(db_column='diff_note_id', rel_model=Notes, to_field='id', unique=True)
    new_file = BooleanField()
    new_path = TextField()
    old_path = TextField()
    renamed_file = BooleanField()

    class Meta:
        db_table = 'note_diff_files'

class NotificationSettings(BaseModel):
    close_issue = BooleanField(null=True)
    close_merge_request = BooleanField(null=True)
    created_at = DateTimeField()
    failed_pipeline = BooleanField(null=True)
    fixed_pipeline = BooleanField(null=True)
    issue_due = BooleanField(null=True)
    level = IntegerField()
    merge_merge_request = BooleanField(null=True)
    moved_project = BooleanField()
    new_epic = BooleanField(null=True)
    new_issue = BooleanField(null=True)
    new_merge_request = BooleanField(null=True)
    new_note = BooleanField(null=True)
    new_release = BooleanField(null=True)
    notification_email = CharField(null=True)
    push_to_merge_request = BooleanField(null=True)
    reassign_issue = BooleanField(null=True)
    reassign_merge_request = BooleanField(null=True)
    reopen_issue = BooleanField(null=True)
    reopen_merge_request = BooleanField(null=True)
    source = IntegerField(db_column='source_id', null=True)
    source_type = CharField(null=True)
    success_pipeline = BooleanField(null=True)
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'notification_settings'
        indexes = (
            (('source', 'source_type'), False),
            (('source', 'source_type', 'user'), True),
        )

class OauthAccessGrants(BaseModel):
    application = IntegerField(db_column='application_id')
    created_at = DateTimeField()
    expires_in = IntegerField()
    redirect_uri = TextField()
    resource_owner = IntegerField(db_column='resource_owner_id')
    revoked_at = DateTimeField(null=True)
    scopes = CharField(null=True)
    token = CharField(unique=True)

    class Meta:
        db_table = 'oauth_access_grants'

class OauthAccessTokens(BaseModel):
    application = IntegerField(db_column='application_id', index=True, null=True)
    created_at = DateTimeField()
    expires_in = IntegerField(null=True)
    refresh_token = CharField(null=True, unique=True)
    resource_owner = IntegerField(db_column='resource_owner_id', index=True, null=True)
    revoked_at = DateTimeField(null=True)
    scopes = CharField(null=True)
    token = CharField(unique=True)

    class Meta:
        db_table = 'oauth_access_tokens'

class OauthOpenidRequests(BaseModel):
    access_grant = ForeignKeyField(db_column='access_grant_id', rel_model=OauthAccessGrants, to_field='id')
    nonce = CharField()

    class Meta:
        db_table = 'oauth_openid_requests'

class OpenProjectTrackerData(BaseModel):
    closed_status = CharField(db_column='closed_status_id', null=True)
    created_at = DateTimeField()
    encrypted_api_url = CharField(null=True)
    encrypted_api_url_iv = CharField(null=True)
    encrypted_token = CharField(null=True)
    encrypted_token_iv = CharField(null=True)
    encrypted_url = CharField(null=True)
    encrypted_url_iv = CharField(null=True)
    id = BigIntegerField(primary_key=True)
    project_identifier_code = CharField(null=True)
    service = ForeignKeyField(db_column='service_id', rel_model=Services, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'open_project_tracker_data'

class OperationsFeatureFlags(BaseModel):
    active = BooleanField()
    created_at = DateTimeField()
    description = TextField(null=True)
    id = BigIntegerField(primary_key=True)
    iid = IntegerField()
    name = CharField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()
    version = IntegerField()

    class Meta:
        db_table = 'operations_feature_flags'
        indexes = (
            (('project', 'iid'), True),
            (('project', 'name'), True),
        )

class OperationsFeatureFlagScopes(BaseModel):
    active = BooleanField()
    created_at = DateTimeField()
    environment_scope = CharField()
    feature_flag = ForeignKeyField(db_column='feature_flag_id', rel_model=OperationsFeatureFlags, to_field='id')
    id = BigIntegerField(primary_key=True)
    strategies = JSONField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'operations_feature_flag_scopes'
        indexes = (
            (('feature_flag', 'environment_scope'), True),
        )

class OperationsFeatureFlagsClients(BaseModel):
    id = BigIntegerField(primary_key=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    token_encrypted = CharField(null=True)

    class Meta:
        db_table = 'operations_feature_flags_clients'
        indexes = (
            (('project', 'token_encrypted'), True),
        )

class OperationsFeatureFlagsIssues(BaseModel):
    feature_flag = ForeignKeyField(db_column='feature_flag_id', rel_model=OperationsFeatureFlags, to_field='id')
    id = BigIntegerField(primary_key=True)
    issue = ForeignKeyField(db_column='issue_id', rel_model=Issues, to_field='id')

    class Meta:
        db_table = 'operations_feature_flags_issues'
        indexes = (
            (('feature_flag', 'issue'), True),
        )

class OperationsStrategies(BaseModel):
    feature_flag = ForeignKeyField(db_column='feature_flag_id', rel_model=OperationsFeatureFlags, to_field='id')
    id = BigIntegerField(primary_key=True)
    name = CharField()
    parameters = JSONField()

    class Meta:
        db_table = 'operations_strategies'

class OperationsScopes(BaseModel):
    environment_scope = CharField()
    id = BigIntegerField(primary_key=True)
    strategy = ForeignKeyField(db_column='strategy_id', rel_model=OperationsStrategies, to_field='id')

    class Meta:
        db_table = 'operations_scopes'
        indexes = (
            (('strategy', 'environment_scope'), True),
        )

class OperationsUserLists(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    iid = IntegerField()
    name = CharField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()
    user_xids = TextField()

    class Meta:
        db_table = 'operations_user_lists'
        indexes = (
            (('project', 'iid'), True),
            (('project', 'name'), True),
        )

class OperationsStrategiesUserLists(BaseModel):
    id = BigIntegerField(primary_key=True)
    strategy = ForeignKeyField(db_column='strategy_id', rel_model=OperationsStrategies, to_field='id')
    user_list = ForeignKeyField(db_column='user_list_id', rel_model=OperationsUserLists, to_field='id')

    class Meta:
        db_table = 'operations_strategies_user_lists'
        indexes = (
            (('strategy', 'user_list'), True),
        )

class PackagesPackages(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    name = CharField(index=True)
    package_type = IntegerField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()
    version = CharField(null=True)

    class Meta:
        db_table = 'packages_packages'
        indexes = (
            (('name', 'project'), False),
            (('package_type', 'version', 'name', 'project'), False),
            (('project', 'created_at'), False),
            (('project', 'package_type'), False),
            (('version', 'project'), False),
        )

class PackagesBuildInfos(BaseModel):
    id = BigIntegerField(primary_key=True)
    package = ForeignKeyField(db_column='package_id', rel_model=PackagesPackages, to_field='id', unique=True)
    pipeline = ForeignKeyField(db_column='pipeline_id', null=True, rel_model=CiPipelines, to_field='id')

    class Meta:
        db_table = 'packages_build_infos'

class PackagesComposerMetadata(BaseModel):
    composer_json = JSONField()
    package = ForeignKeyField(db_column='package_id', primary_key=True, rel_model=PackagesPackages, to_field='id')
    target_sha = BlobField()

    class Meta:
        db_table = 'packages_composer_metadata'
        indexes = (
            (('package', 'target_sha'), True),
        )

class PackagesPackageFiles(BaseModel):
    created_at = DateTimeField()
    file = TextField()
    file_md5 = BlobField(null=True)
    file_name = CharField()
    file_sha1 = BlobField(null=True)
    file_sha256 = BlobField(null=True)
    file_store = IntegerField(index=True, null=True)
    id = BigIntegerField(primary_key=True)
    package = ForeignKeyField(db_column='package_id', rel_model=PackagesPackages, to_field='id')
    size = BigIntegerField(null=True)
    updated_at = DateTimeField()
    verification_checksum = BlobField(index=True, null=True)
    verification_failure = CharField(index=True, null=True)
    verification_retry_at = DateTimeField(null=True)
    verification_retry_count = IntegerField(null=True)
    verified_at = DateTimeField(null=True)

    class Meta:
        db_table = 'packages_package_files'
        indexes = (
            (('file_name', 'package'), False),
        )

class PackagesConanFileMetadata(BaseModel):
    conan_file_type = IntegerField()
    conan_package_reference = CharField(null=True)
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    package_file = ForeignKeyField(db_column='package_file_id', rel_model=PackagesPackageFiles, to_field='id', unique=True)
    package_revision = CharField(null=True)
    recipe_revision = CharField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'packages_conan_file_metadata'

class PackagesConanMetadata(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    package_channel = CharField()
    package = ForeignKeyField(db_column='package_id', rel_model=PackagesPackages, to_field='id')
    package_username = CharField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'packages_conan_metadata'
        indexes = (
            (('package', 'package_username', 'package_channel'), True),
        )

class PackagesDependencies(BaseModel):
    id = BigIntegerField(primary_key=True)
    name = CharField()
    version_pattern = CharField()

    class Meta:
        db_table = 'packages_dependencies'
        indexes = (
            (('name', 'version_pattern'), True),
        )

class PackagesDependencyLinks(BaseModel):
    dependency = ForeignKeyField(db_column='dependency_id', rel_model=PackagesDependencies, to_field='id')
    dependency_type = IntegerField()
    id = BigIntegerField(primary_key=True)
    package = ForeignKeyField(db_column='package_id', rel_model=PackagesPackages, to_field='id')

    class Meta:
        db_table = 'packages_dependency_links'
        indexes = (
            (('package', 'dependency', 'dependency_type'), True),
        )

class PackagesMavenMetadata(BaseModel):
    app_group = CharField()
    app_name = CharField()
    app_version = CharField(null=True)
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    package = ForeignKeyField(db_column='package_id', rel_model=PackagesPackages, to_field='id')
    path = CharField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'packages_maven_metadata'
        indexes = (
            (('package', 'path'), False),
        )

class PackagesNugetDependencyLinkMetadata(BaseModel):
    dependency_link = ForeignKeyField(db_column='dependency_link_id', primary_key=True, rel_model=PackagesDependencyLinks, to_field='id')
    target_framework = TextField()

    class Meta:
        db_table = 'packages_nuget_dependency_link_metadata'

class PackagesNugetMetadata(BaseModel):
    icon_url = TextField(null=True)
    license_url = TextField(null=True)
    package = ForeignKeyField(db_column='package_id', primary_key=True, rel_model=PackagesPackages, to_field='id')
    project_url = TextField(null=True)

    class Meta:
        db_table = 'packages_nuget_metadata'

class PackagesPypiMetadata(BaseModel):
    package = ForeignKeyField(db_column='package_id', primary_key=True, rel_model=PackagesPackages, to_field='id')
    required_python = CharField()

    class Meta:
        db_table = 'packages_pypi_metadata'

class PackagesTags(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    name = CharField()
    package = ForeignKeyField(db_column='package_id', rel_model=PackagesPackages, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'packages_tags'
        indexes = (
            (('package', 'updated_at'), False),
        )

class PagesDomains(BaseModel):
    auto_ssl_enabled = BooleanField()
    auto_ssl_failed = BooleanField()
    certificate = TextField(null=True)
    certificate_source = IntegerField()
    certificate_valid_not_after = DateTimeField(index=True, null=True)
    certificate_valid_not_before = DateTimeField(null=True)
    domain = CharField(null=True)
    enabled_until = DateTimeField(null=True)
    encrypted_key = TextField(null=True)
    encrypted_key_iv = CharField(null=True)
    encrypted_key_salt = CharField(null=True)
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    remove_at = DateTimeField(index=True, null=True)
    scope = IntegerField(index=True)
    usage = IntegerField(index=True)
    verification_code = CharField()
    verified_at = DateTimeField(index=True, null=True)
    wildcard = BooleanField(index=True)

    class Meta:
        db_table = 'pages_domains'
        indexes = (
            (('enabled_until', 'project'), False),
            (('enabled_until', 'verified_at'), False),
            (('wildcard', 'domain'), True),
        )

class PagesDomainAcmeOrders(BaseModel):
    challenge_file_content = TextField()
    challenge_token = CharField(index=True)
    created_at = DateTimeField()
    encrypted_private_key = TextField()
    encrypted_private_key_iv = TextField()
    expires_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    pages_domain = ForeignKeyField(db_column='pages_domain_id', rel_model=PagesDomains, to_field='id')
    updated_at = DateTimeField()
    url = CharField()

    class Meta:
        db_table = 'pages_domain_acme_orders'

class PartitionedForeignKeys(BaseModel):
    cascade_delete = BooleanField()
    from_column = TextField()
    from_table = TextField()
    id = BigIntegerField(primary_key=True)
    to_column = TextField()
    to_table = TextField()

    class Meta:
        db_table = 'partitioned_foreign_keys'
        indexes = (
            (('from_table', 'from_column', 'to_table'), True),
        )

class PathLocks(BaseModel):
    created_at = DateTimeField()
    path = CharField(index=True)
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', null=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'path_locks'

class PersonalAccessTokens(BaseModel):
    after_expiry_notification_delivered = BooleanField()
    created_at = DateTimeField()
    expire_notification_delivered = BooleanField()
    expires_at = DateField(null=True)
    impersonation = BooleanField()
    last_used_at = DateTimeField(null=True)
    name = CharField()
    revoked = BooleanField(null=True)
    scopes = CharField()
    token_digest = CharField(null=True, unique=True)
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'personal_access_tokens'
        indexes = (
            (('expires_at', 'user'), False),
            (('id', 'expires_at'), False),
        )

class PlanLimits(BaseModel):
    ci_active_jobs = IntegerField()
    ci_active_pipelines = IntegerField()
    ci_instance_level_variables = IntegerField()
    ci_max_artifact_size_accessibility = IntegerField()
    ci_max_artifact_size_archive = IntegerField()
    ci_max_artifact_size_browser_performance = IntegerField()
    ci_max_artifact_size_cluster_applications = IntegerField()
    ci_max_artifact_size_cobertura = IntegerField()
    ci_max_artifact_size_codequality = IntegerField()
    ci_max_artifact_size_container_scanning = IntegerField()
    ci_max_artifact_size_coverage_fuzzing = IntegerField()
    ci_max_artifact_size_dast = IntegerField()
    ci_max_artifact_size_dependency_scanning = IntegerField()
    ci_max_artifact_size_dotenv = IntegerField()
    ci_max_artifact_size_junit = IntegerField()
    ci_max_artifact_size_license_management = IntegerField()
    ci_max_artifact_size_license_scanning = IntegerField()
    ci_max_artifact_size_load_performance = IntegerField()
    ci_max_artifact_size_lsif = IntegerField()
    ci_max_artifact_size_metadata = IntegerField()
    ci_max_artifact_size_metrics = IntegerField()
    ci_max_artifact_size_metrics_referee = IntegerField()
    ci_max_artifact_size_network_referee = IntegerField()
    ci_max_artifact_size_performance = IntegerField()
    ci_max_artifact_size_requirements = IntegerField()
    ci_max_artifact_size_sast = IntegerField()
    ci_max_artifact_size_secret_detection = IntegerField()
    ci_max_artifact_size_terraform = IntegerField()
    ci_max_artifact_size_trace = IntegerField()
    ci_needs_size_limit = IntegerField()
    ci_pipeline_schedules = IntegerField()
    ci_pipeline_size = IntegerField()
    ci_project_subscriptions = IntegerField()
    group_hooks = IntegerField()
    id = BigIntegerField(primary_key=True)
    offset_pagination_limit = IntegerField()
    plan = ForeignKeyField(db_column='plan_id', rel_model=Plans, to_field='id', unique=True)
    project_hooks = IntegerField()
    storage_size_limit = IntegerField()

    class Meta:
        db_table = 'plan_limits'

class ProductAnalyticsEventsExperimental(BaseModel):
    base_currency = CharField(null=True)
    br_colordepth = CharField(null=True)
    br_cookies = BooleanField(null=True)
    br_family = CharField(null=True)
    br_features_director = BooleanField(null=True)
    br_features_flash = BooleanField(null=True)
    br_features_gears = BooleanField(null=True)
    br_features_java = BooleanField(null=True)
    br_features_pdf = BooleanField(null=True)
    br_features_quicktime = BooleanField(null=True)
    br_features_realplayer = BooleanField(null=True)
    br_features_silverlight = BooleanField(null=True)
    br_features_windowsmedia = BooleanField(null=True)
    br_lang = CharField(null=True)
    br_name = CharField(null=True)
    br_renderengine = CharField(null=True)
    br_type = CharField(null=True)
    br_version = CharField(null=True)
    br_viewheight = IntegerField(null=True)
    br_viewwidth = IntegerField(null=True)
    collector_tstamp = DateTimeField()
    derived_tstamp = DateTimeField(null=True)
    doc_charset = CharField(null=True)
    doc_height = IntegerField(null=True)
    doc_width = IntegerField(null=True)
    domain_sessionid = CharField(null=True)
    domain_sessionidx = IntegerField(null=True)
    domain_userid = CharField(null=True)
    dvce_created_tstamp = DateTimeField(null=True)
    dvce_ismobile = BooleanField(null=True)
    dvce_screenheight = IntegerField(null=True)
    dvce_screenwidth = IntegerField(null=True)
    dvce_sent_tstamp = DateTimeField(null=True)
    dvce_type = CharField(null=True)
    etl_tags = CharField(null=True)
    etl_tstamp = DateTimeField(null=True)
    event = CharField(null=True)
    event_fingerprint = CharField(null=True)
    event_format = CharField(null=True)
    event_id = CharField()
    event_name = CharField(null=True)
    event_vendor = CharField(null=True)
    event_version = CharField(null=True)
    geo_city = CharField(null=True)
    geo_country = CharField(null=True)
    geo_latitude = FloatField(null=True)
    geo_longitude = FloatField(null=True)
    geo_region = CharField(null=True)
    geo_region_name = CharField(null=True)
    geo_timezone = CharField(null=True)
    geo_zipcode = CharField(null=True)
    id = BigIntegerField()
    ip_domain = CharField(null=True)
    ip_isp = CharField(null=True)
    ip_netspeed = CharField(null=True)
    ip_organization = CharField(null=True)
    mkt_campaign = CharField(null=True)
    mkt_clickid = CharField(null=True)
    mkt_content = CharField(null=True)
    mkt_medium = CharField(null=True)
    mkt_network = CharField(null=True)
    mkt_source = CharField(null=True)
    mkt_term = CharField(null=True)
    name_tracker = CharField(null=True)
    network_userid = CharField(null=True)
    os_family = CharField(null=True)
    os_manufacturer = CharField(null=True)
    os_name = CharField(null=True)
    os_timezone = CharField(null=True)
    page_referrer = TextField(null=True)
    page_title = CharField(null=True)
    page_url = TextField(null=True)
    page_urlfragment = CharField(null=True)
    page_urlhost = CharField(null=True)
    page_urlpath = CharField(null=True)
    page_urlport = IntegerField(null=True)
    page_urlquery = CharField(null=True)
    page_urlscheme = CharField(null=True)
    platform = CharField(null=True)
    pp_xoffset_max = IntegerField(null=True)
    pp_xoffset_min = IntegerField(null=True)
    pp_yoffset_max = IntegerField(null=True)
    pp_yoffset_min = IntegerField(null=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, related_name='projects_project_set', to_field='id')
    refr_domain_userid = CharField(null=True)
    refr_dvce_tstamp = DateTimeField(null=True)
    refr_medium = CharField(null=True)
    refr_source = CharField(null=True)
    refr_term = CharField(null=True)
    refr_urlfragment = CharField(null=True)
    refr_urlhost = CharField(null=True)
    refr_urlpath = CharField(null=True)
    refr_urlport = IntegerField(null=True)
    refr_urlquery = CharField(null=True)
    refr_urlscheme = CharField(null=True)
    se_action = CharField(null=True)
    se_category = CharField(null=True)
    se_label = CharField(null=True)
    se_property = CharField(null=True)
    se_value = FloatField(null=True)
    ti_category = CharField(null=True)
    ti_currency = CharField(null=True)
    ti_name = CharField(null=True)
    ti_orderid = CharField(null=True)
    ti_price = DecimalField(null=True)
    ti_price_base = DecimalField(null=True)
    ti_quantity = IntegerField(null=True)
    ti_sku = CharField(null=True)
    tr_affiliation = CharField(null=True)
    tr_city = CharField(null=True)
    tr_country = CharField(null=True)
    tr_currency = CharField(null=True)
    tr_orderid = CharField(null=True)
    tr_shipping = DecimalField(null=True)
    tr_shipping_base = DecimalField(null=True)
    tr_state = CharField(null=True)
    tr_tax = DecimalField(null=True)
    tr_tax_base = DecimalField(null=True)
    tr_total = DecimalField(null=True)
    tr_total_base = DecimalField(null=True)
    true_tstamp = DateTimeField(null=True)
    txn = IntegerField(db_column='txn_id', null=True)
    user_fingerprint = CharField(null=True)
    user = CharField(db_column='user_id', null=True)
    user_ipaddress = CharField(null=True)
    useragent = CharField(null=True)
    v_collector = CharField()
    v_etl = CharField()
    v_tracker = CharField(null=True)

    class Meta:
        db_table = 'product_analytics_events_experimental'
        primary_key = CompositeKey('id', 'project')

class ProjectAccessTokens(BaseModel):
    personal_access_token = ForeignKeyField(db_column='personal_access_token_id', rel_model=PersonalAccessTokens, to_field='id')
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')

    class Meta:
        db_table = 'project_access_tokens'
        indexes = (
            (('personal_access_token', 'project'), True),
        )
        primary_key = CompositeKey('personal_access_token', 'project')

class ProjectAlertingSettings(BaseModel):
    encrypted_token = CharField()
    encrypted_token_iv = CharField()
    project = ForeignKeyField(db_column='project_id', primary_key=True, rel_model=Projects, to_field='id')

    class Meta:
        db_table = 'project_alerting_settings'

class ProjectAliases(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    name = CharField(unique=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'project_aliases'

class ProjectAuthorizations(BaseModel):
    access_level = IntegerField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'project_authorizations'
        indexes = (
            (('user', 'project', 'access_level'), True),
        )

class ProjectAutoDevops(BaseModel):
    created_at = DateTimeField()
    deploy_strategy = IntegerField()
    enabled = BooleanField(null=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id', unique=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'project_auto_devops'

class ProjectCiCdSettings(BaseModel):
    default_git_depth = IntegerField(null=True)
    forward_deployment_enabled = BooleanField(null=True)
    group_runners_enabled = BooleanField()
    merge_pipelines_enabled = BooleanField(null=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id', unique=True)

    class Meta:
        db_table = 'project_ci_cd_settings'

class ProjectComplianceFrameworkSettings(BaseModel):
    framework = IntegerField()
    project = ForeignKeyField(db_column='project_id', primary_key=True, rel_model=Projects, to_field='id')

    class Meta:
        db_table = 'project_compliance_framework_settings'

class ProjectCustomAttributes(BaseModel):
    created_at = DateTimeField()
    key = CharField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()
    value = CharField()

    class Meta:
        db_table = 'project_custom_attributes'
        indexes = (
            (('key', 'value'), False),
            (('project', 'key'), True),
        )

class ProjectDailyStatistics(BaseModel):
    date = DateField(null=True)
    fetch_count = IntegerField()
    id = BigIntegerField(primary_key=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')

    class Meta:
        db_table = 'project_daily_statistics'
        indexes = (
            (('project', 'date'), True),
        )

class ProjectDeployTokens(BaseModel):
    created_at = DateTimeField()
    deploy_token = ForeignKeyField(db_column='deploy_token_id', rel_model=DeployTokens, to_field='id')
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')

    class Meta:
        db_table = 'project_deploy_tokens'
        indexes = (
            (('project', 'deploy_token'), True),
        )

class ProjectErrorTrackingSettings(BaseModel):
    api_url = CharField(null=True)
    enabled = BooleanField()
    encrypted_token = CharField(null=True)
    encrypted_token_iv = CharField(null=True)
    organization_name = CharField(null=True)
    project = ForeignKeyField(db_column='project_id', primary_key=True, rel_model=Projects, to_field='id')
    project_name = CharField(null=True)

    class Meta:
        db_table = 'project_error_tracking_settings'

class ProjectExportJobs(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    jid = CharField(unique=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    status = IntegerField(index=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'project_export_jobs'
        indexes = (
            (('project', 'jid'), False),
            (('project', 'status'), False),
        )

class ProjectFeatureUsages(BaseModel):
    jira_dvcs_cloud_last_sync_at = DateTimeField(null=True)
    jira_dvcs_server_last_sync_at = DateTimeField(null=True)
    project = ForeignKeyField(db_column='project_id', primary_key=True, rel_model=Projects, to_field='id')

    class Meta:
        db_table = 'project_feature_usages'
        indexes = (
            (('project', 'jira_dvcs_cloud_last_sync_at'), False),
            (('project', 'jira_dvcs_server_last_sync_at'), False),
        )

class ProjectFeatures(BaseModel):
    builds_access_level = IntegerField(null=True)
    created_at = DateTimeField(null=True)
    forking_access_level = IntegerField(null=True)
    issues_access_level = IntegerField(null=True)
    merge_requests_access_level = IntegerField(null=True)
    metrics_dashboard_access_level = IntegerField(null=True)
    pages_access_level = IntegerField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    repository_access_level = IntegerField()
    snippets_access_level = IntegerField()
    updated_at = DateTimeField(null=True)
    wiki_access_level = IntegerField(null=True)

    class Meta:
        db_table = 'project_features'

class ProjectGroupLinks(BaseModel):
    created_at = DateTimeField(null=True)
    expires_at = DateField(null=True)
    group_access = IntegerField()
    group = IntegerField(db_column='group_id', index=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'project_group_links'

class ProjectImportData(BaseModel):
    data = TextField(null=True)
    encrypted_credentials = TextField(null=True)
    encrypted_credentials_iv = CharField(null=True)
    encrypted_credentials_salt = CharField(null=True)
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')

    class Meta:
        db_table = 'project_import_data'

class ProjectIncidentManagementSettings(BaseModel):
    create_issue = BooleanField()
    encrypted_pagerduty_token = BlobField(null=True)
    encrypted_pagerduty_token_iv = BlobField(null=True)
    issue_template_key = TextField(null=True)
    pagerduty_active = BooleanField()
    project = ForeignKeyField(db_column='project_id', primary_key=True, rel_model=Projects, to_field='id')
    send_email = BooleanField()

    class Meta:
        db_table = 'project_incident_management_settings'

class ProjectMetricsSettings(BaseModel):
    dashboard_timezone = IntegerField()
    external_dashboard_url = CharField(null=True)
    project = ForeignKeyField(db_column='project_id', primary_key=True, rel_model=Projects, to_field='id')

    class Meta:
        db_table = 'project_metrics_settings'

class ProjectMirrorData(BaseModel):
    correlation_id_value = CharField(null=True)
    jid = CharField(null=True)
    last_error = TextField(null=True)
    last_successful_update_at = DateTimeField(index=True, null=True)
    last_update_at = DateTimeField(null=True)
    last_update_scheduled_at = DateTimeField(null=True)
    last_update_started_at = DateTimeField(null=True)
    next_execution_timestamp = DateTimeField(null=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id', unique=True)
    retry_count = IntegerField()
    status = CharField(index=True, null=True)

    class Meta:
        db_table = 'project_mirror_data'
        indexes = (
            (('last_update_at', 'retry_count'), False),
            (('retry_count', 'next_execution_timestamp'), False),
        )

class ProjectPagesMetadata(BaseModel):
    deployed = BooleanField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')

    class Meta:
        db_table = 'project_pages_metadata'

class ProjectRepositories(BaseModel):
    disk_path = CharField(unique=True)
    id = BigIntegerField(primary_key=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id', unique=True)
    shard = ForeignKeyField(db_column='shard_id', rel_model=Shards, to_field='id')

    class Meta:
        db_table = 'project_repositories'

class ProjectRepositoryStates(BaseModel):
    last_repository_verification_failure = CharField(index=True, null=True)
    last_repository_verification_ran_at = DateTimeField(null=True)
    last_wiki_verification_failure = CharField(index=True, null=True)
    last_wiki_verification_ran_at = DateTimeField(null=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    repository_retry_at = DateTimeField(null=True)
    repository_retry_count = IntegerField(null=True)
    repository_verification_checksum = BlobField(null=True)
    wiki_retry_at = DateTimeField(null=True)
    wiki_retry_count = IntegerField(null=True)
    wiki_verification_checksum = BlobField(null=True)

    class Meta:
        db_table = 'project_repository_states'
        indexes = (
            (('last_repository_verification_ran_at', 'project'), False),
            (('last_wiki_verification_ran_at', 'project'), False),
        )

class ProjectRepositoryStorageMoves(BaseModel):
    created_at = DateTimeField()
    destination_storage_name = TextField()
    id = BigIntegerField(primary_key=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    source_storage_name = TextField()
    state = IntegerField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'project_repository_storage_moves'

class ProjectSecuritySettings(BaseModel):
    auto_fix_container_scanning = BooleanField()
    auto_fix_dast = BooleanField()
    auto_fix_dependency_scanning = BooleanField()
    auto_fix_sast = BooleanField()
    created_at = DateTimeField()
    project = ForeignKeyField(db_column='project_id', primary_key=True, rel_model=Projects, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'project_security_settings'

class ProjectSettings(BaseModel):
    allow_merge_on_skipped_pipeline = BooleanField(null=True)
    created_at = DateTimeField()
    has_confluence = BooleanField()
    project = ForeignKeyField(db_column='project_id', primary_key=True, rel_model=Projects, to_field='id')
    push_rule = ForeignKeyField(db_column='push_rule_id', null=True, rel_model=PushRules, to_field='id', unique=True)
    show_default_award_emojis = BooleanField(null=True)
    squash_option = IntegerField(null=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'project_settings'

class ProjectStatistics(BaseModel):
    build_artifacts_size = BigIntegerField()
    commit_count = BigIntegerField()
    lfs_objects_size = BigIntegerField()
    namespace = IntegerField(db_column='namespace_id', index=True)
    packages_size = BigIntegerField()
    pipeline_artifacts_size = BigIntegerField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id', unique=True)
    repository_size = BigIntegerField()
    shared_runners_seconds = BigIntegerField()
    shared_runners_seconds_last_reset = DateTimeField(null=True)
    snippets_size = BigIntegerField(null=True)
    storage_size = BigIntegerField()
    wiki_size = BigIntegerField(null=True)

    class Meta:
        db_table = 'project_statistics'
        indexes = (
            (('project', 'repository_size'), False),
            (('storage_size', 'project'), False),
            (('wiki_size', 'project'), False),
        )

class ProjectTracingSettings(BaseModel):
    created_at = DateTimeField()
    external_url = CharField()
    id = BigIntegerField(primary_key=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id', unique=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'project_tracing_settings'

class ProtectedBranchMergeAccessLevels(BaseModel):
    access_level = IntegerField(null=True)
    created_at = DateTimeField()
    group = ForeignKeyField(db_column='group_id', null=True, rel_model=Namespaces, to_field='id')
    protected_branch = ForeignKeyField(db_column='protected_branch_id', rel_model=ProtectedBranches, to_field='id')
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', null=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'protected_branch_merge_access_levels'

class ProtectedBranchPushAccessLevels(BaseModel):
    access_level = IntegerField(null=True)
    created_at = DateTimeField()
    deploy_key = ForeignKeyField(db_column='deploy_key_id', null=True, rel_model=Keys, to_field='id')
    group = ForeignKeyField(db_column='group_id', null=True, rel_model=Namespaces, to_field='id')
    protected_branch = ForeignKeyField(db_column='protected_branch_id', rel_model=ProtectedBranches, to_field='id')
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', null=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'protected_branch_push_access_levels'

class ProtectedBranchUnprotectAccessLevels(BaseModel):
    access_level = IntegerField(null=True)
    group = ForeignKeyField(db_column='group_id', null=True, rel_model=Namespaces, to_field='id')
    protected_branch = ForeignKeyField(db_column='protected_branch_id', rel_model=ProtectedBranches, to_field='id')
    user = ForeignKeyField(db_column='user_id', null=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'protected_branch_unprotect_access_levels'

class ProtectedEnvironments(BaseModel):
    created_at = DateTimeField()
    name = CharField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'protected_environments'
        indexes = (
            (('project', 'name'), True),
        )

class ProtectedEnvironmentDeployAccessLevels(BaseModel):
    access_level = IntegerField(null=True)
    created_at = DateTimeField()
    group = ForeignKeyField(db_column='group_id', null=True, rel_model=Namespaces, to_field='id')
    protected_environment = ForeignKeyField(db_column='protected_environment_id', rel_model=ProtectedEnvironments, to_field='id')
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', null=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'protected_environment_deploy_access_levels'

class ProtectedTags(BaseModel):
    created_at = DateTimeField()
    name = CharField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'protected_tags'
        indexes = (
            (('project', 'name'), True),
        )

class ProtectedTagCreateAccessLevels(BaseModel):
    access_level = IntegerField(null=True)
    created_at = DateTimeField()
    group = ForeignKeyField(db_column='group_id', null=True, rel_model=Namespaces, to_field='id')
    protected_tag = ForeignKeyField(db_column='protected_tag_id', rel_model=ProtectedTags, to_field='id')
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', null=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'protected_tag_create_access_levels'

class PushEventPayloads(BaseModel):
    action = IntegerField()
    commit_count = BigIntegerField()
    commit_from = BlobField(null=True)
    commit_title = CharField(null=True)
    commit_to = BlobField(null=True)
    event = ForeignKeyField(db_column='event_id', rel_model=Events, to_field='id', unique=True)
    ref = TextField(null=True)
    ref_count = IntegerField(null=True)
    ref_type = IntegerField()

    class Meta:
        db_table = 'push_event_payloads'

class RawUsageData(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    payload = JSONField()
    recorded_at = DateTimeField(unique=True)
    sent_at = DateTimeField(null=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'raw_usage_data'

class RedirectRoutes(BaseModel):
    created_at = DateTimeField()
    path = CharField(unique=True)
    source = IntegerField(db_column='source_id')
    source_type = CharField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'redirect_routes'
        indexes = (
            (('source', 'source_type'), False),
        )

class ReleaseLinks(BaseModel):
    created_at = DateTimeField()
    filepath = CharField(null=True)
    id = BigIntegerField(primary_key=True)
    link_type = IntegerField(null=True)
    name = CharField()
    release = ForeignKeyField(db_column='release_id', rel_model=Releases, to_field='id')
    updated_at = DateTimeField()
    url = CharField()

    class Meta:
        db_table = 'release_links'
        indexes = (
            (('release', 'name'), True),
            (('release', 'url'), True),
        )

class RemoteMirrors(BaseModel):
    created_at = DateTimeField()
    enabled = BooleanField(null=True)
    encrypted_credentials = TextField(null=True)
    encrypted_credentials_iv = CharField(null=True)
    encrypted_credentials_salt = CharField(null=True)
    error_notification_sent = BooleanField(null=True)
    keep_divergent_refs = BooleanField(null=True)
    last_error = CharField(null=True)
    last_successful_update_at = DateTimeField(index=True, null=True)
    last_update_at = DateTimeField(null=True)
    last_update_started_at = DateTimeField(null=True)
    only_protected_branches = BooleanField()
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    remote_name = CharField(null=True)
    update_status = CharField(null=True)
    updated_at = DateTimeField()
    url = CharField(null=True)

    class Meta:
        db_table = 'remote_mirrors'

class RepositoryLanguages(BaseModel):
    programming_language = IntegerField(db_column='programming_language_id')
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    share = FloatField()

    class Meta:
        db_table = 'repository_languages'
        indexes = (
            (('project', 'programming_language'), True),
        )

class Requirements(BaseModel):
    author = ForeignKeyField(db_column='author_id', null=True, rel_model=Users, to_field='id')
    cached_markdown_version = IntegerField(null=True)
    created_at = DateTimeField(index=True)
    id = BigIntegerField(primary_key=True)
    iid = IntegerField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    state = IntegerField(index=True)
    title = CharField(index=True)
    title_html = TextField(null=True)
    updated_at = DateTimeField(index=True)

    class Meta:
        db_table = 'requirements'
        indexes = (
            (('project', 'iid'), True),
        )

class RequirementsManagementTestReports(BaseModel):
    author = ForeignKeyField(db_column='author_id', null=True, rel_model=Users, to_field='id')
    build = ForeignKeyField(db_column='build_id', null=True, rel_model=CiBuilds, to_field='id')
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    pipeline = ForeignKeyField(db_column='pipeline_id', null=True, rel_model=CiPipelines, to_field='id')
    requirement = ForeignKeyField(db_column='requirement_id', rel_model=Requirements, to_field='id')
    state = IntegerField()

    class Meta:
        db_table = 'requirements_management_test_reports'

class ResourceIterationEvents(BaseModel):
    action = IntegerField()
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    issue = ForeignKeyField(db_column='issue_id', null=True, rel_model=Issues, to_field='id')
    iteration = ForeignKeyField(db_column='iteration_id', null=True, rel_model=Sprints, to_field='id')
    merge_request = ForeignKeyField(db_column='merge_request_id', null=True, rel_model=MergeRequests, to_field='id')
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'resource_iteration_events'

class ResourceLabelEvents(BaseModel):
    action = IntegerField()
    cached_markdown_version = IntegerField(null=True)
    created_at = DateTimeField()
    epic = ForeignKeyField(db_column='epic_id', null=True, rel_model=Epics, to_field='id')
    id = BigIntegerField(primary_key=True)
    issue = ForeignKeyField(db_column='issue_id', null=True, rel_model=Issues, to_field='id')
    label = ForeignKeyField(db_column='label_id', null=True, rel_model=Labels, to_field='id')
    merge_request = ForeignKeyField(db_column='merge_request_id', null=True, rel_model=MergeRequests, to_field='id')
    reference = TextField(null=True)
    reference_html = TextField(null=True)
    user = ForeignKeyField(db_column='user_id', null=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'resource_label_events'
        indexes = (
            (('action', 'label', 'issue'), False),
            (('label', 'action'), False),
            (('label', 'merge_request', 'action'), False),
        )

class ResourceMilestoneEvents(BaseModel):
    action = IntegerField()
    created_at = DateTimeField(index=True)
    id = BigIntegerField(primary_key=True)
    issue = ForeignKeyField(db_column='issue_id', null=True, rel_model=Issues, to_field='id')
    merge_request = ForeignKeyField(db_column='merge_request_id', null=True, rel_model=MergeRequests, to_field='id')
    milestone = ForeignKeyField(db_column='milestone_id', null=True, rel_model=Milestones, to_field='id')
    state = IntegerField()
    user = ForeignKeyField(db_column='user_id', null=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'resource_milestone_events'

class ResourceStateEvents(BaseModel):
    close_after_error_tracking_resolve = BooleanField()
    close_auto_resolve_prometheus_alert = BooleanField()
    created_at = DateTimeField()
    epic = ForeignKeyField(db_column='epic_id', null=True, rel_model=Epics, to_field='id')
    id = BigIntegerField(primary_key=True)
    issue = ForeignKeyField(db_column='issue_id', null=True, rel_model=Issues, to_field='id')
    merge_request = ForeignKeyField(db_column='merge_request_id', null=True, rel_model=MergeRequests, to_field='id')
    source_commit = TextField(null=True)
    source_merge_request = ForeignKeyField(db_column='source_merge_request_id', null=True, rel_model=MergeRequests, related_name='merge_requests_source_merge_request_set', to_field='id')
    state = IntegerField()
    user = ForeignKeyField(db_column='user_id', null=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'resource_state_events'
        indexes = (
            (('issue', 'created_at'), False),
        )

class ResourceWeightEvents(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    issue = ForeignKeyField(db_column='issue_id', rel_model=Issues, to_field='id')
    user = ForeignKeyField(db_column='user_id', null=True, rel_model=Users, to_field='id')
    weight = IntegerField(null=True)

    class Meta:
        db_table = 'resource_weight_events'
        indexes = (
            (('issue', 'created_at'), False),
            (('issue', 'weight'), False),
        )

class Routes(BaseModel):
    created_at = DateTimeField(null=True)
    name = CharField(null=True)
    path = CharField(index=True)
    source = IntegerField(db_column='source_id')
    source_type = CharField()
    updated_at = DateTimeField(null=True)

    class Meta:
        db_table = 'routes'
        indexes = (
            (('source', 'source_type'), True),
        )

class SchemaMigrations(BaseModel):
    version = CharField(primary_key=True)

    class Meta:
        db_table = 'schema_migrations'

class ScimIdentities(BaseModel):
    active = BooleanField(null=True)
    created_at = DateTimeField()
    extern_uid = CharField()
    group = ForeignKeyField(db_column='group_id', rel_model=Namespaces, to_field='id')
    id = BigIntegerField(primary_key=True)
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'scim_identities'
        indexes = (
            (('group', 'user'), True),
        )

class ScimOauthAccessTokens(BaseModel):
    created_at = DateTimeField()
    group = ForeignKeyField(db_column='group_id', rel_model=Namespaces, to_field='id')
    token_encrypted = CharField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'scim_oauth_access_tokens'
        indexes = (
            (('group', 'token_encrypted'), True),
        )

class SecurityScans(BaseModel):
    build = ForeignKeyField(db_column='build_id', rel_model=CiBuilds, to_field='id')
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    scan_type = IntegerField(index=True)
    scanned_resources_count = IntegerField(null=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'security_scans'
        indexes = (
            (('build', 'scan_type'), True),
        )

class SentNotifications(BaseModel):
    commit = CharField(db_column='commit_id', null=True)
    in_reply_to_discussion = CharField(db_column='in_reply_to_discussion_id', null=True)
    line_code = CharField(null=True)
    note_type = CharField(null=True)
    noteable = IntegerField(db_column='noteable_id', index=True, null=True)
    noteable_type = CharField(null=True)
    position = TextField(null=True)
    project = IntegerField(db_column='project_id', null=True)
    recipient = IntegerField(db_column='recipient_id', null=True)
    reply_key = CharField(unique=True)

    class Meta:
        db_table = 'sent_notifications'

class SentryIssues(BaseModel):
    id = BigIntegerField(primary_key=True)
    issue = ForeignKeyField(db_column='issue_id', rel_model=Issues, to_field='id', unique=True)
    sentry_issue_identifier = BigIntegerField(index=True)

    class Meta:
        db_table = 'sentry_issues'

class ServerlessDomainCluster(BaseModel):
    certificate = TextField(null=True)
    clusters_applications_knative = ForeignKeyField(db_column='clusters_applications_knative_id', rel_model=ClustersApplicationsKnative, to_field='id', unique=True)
    created_at = DateTimeField()
    creator = ForeignKeyField(db_column='creator_id', null=True, rel_model=Users, to_field='id')
    encrypted_key = TextField(null=True)
    encrypted_key_iv = CharField(null=True)
    pages_domain = ForeignKeyField(db_column='pages_domain_id', rel_model=PagesDomains, to_field='id')
    updated_at = DateTimeField()
    uuid = CharField(primary_key=True)

    class Meta:
        db_table = 'serverless_domain_cluster'

class ServiceDeskSettings(BaseModel):
    issue_template_key = CharField(null=True)
    outgoing_name = CharField(null=True)
    project = ForeignKeyField(db_column='project_id', primary_key=True, rel_model=Projects, to_field='id')
    project_key = CharField(null=True)

    class Meta:
        db_table = 'service_desk_settings'

class SlackIntegrations(BaseModel):
    alias = CharField()
    created_at = DateTimeField()
    service = ForeignKeyField(db_column='service_id', rel_model=Services, to_field='id')
    team = CharField(db_column='team_id')
    team_name = CharField()
    updated_at = DateTimeField()
    user = CharField(db_column='user_id')

    class Meta:
        db_table = 'slack_integrations'
        indexes = (
            (('team', 'alias'), True),
        )

class SmartcardIdentities(BaseModel):
    id = BigIntegerField(primary_key=True)
    issuer = CharField()
    subject = CharField()
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'smartcard_identities'
        indexes = (
            (('subject', 'issuer'), True),
        )

class Snippets(BaseModel):
    author = IntegerField(db_column='author_id', index=True)
    cached_markdown_version = IntegerField(null=True)
    content = TextField(index=True, null=True)
    content_html = TextField(null=True)
    created_at = DateTimeField(index=True, null=True)
    description = TextField(index=True, null=True)
    description_html = TextField(null=True)
    encrypted_secret_token = CharField(null=True)
    encrypted_secret_token_iv = CharField(null=True)
    file_name = CharField(index=True, null=True)
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    secret = BooleanField()
    title = CharField(index=True, null=True)
    title_html = TextField(null=True)
    type = CharField(null=True)
    updated_at = DateTimeField(index=True, null=True)
    visibility_level = IntegerField()

    class Meta:
        db_table = 'snippets'
        indexes = (
            (('id', 'created_at'), False),
            (('id', 'type'), False),
            (('project', 'visibility_level'), False),
            (('visibility_level', 'secret'), False),
        )

class SnippetRepositories(BaseModel):
    disk_path = CharField(unique=True)
    shard = ForeignKeyField(db_column='shard_id', rel_model=Shards, to_field='id')
    snippet = ForeignKeyField(db_column='snippet_id', primary_key=True, rel_model=Snippets, to_field='id')

    class Meta:
        db_table = 'snippet_repositories'

class SnippetStatistics(BaseModel):
    commit_count = BigIntegerField()
    file_count = BigIntegerField()
    repository_size = BigIntegerField()
    snippet = ForeignKeyField(db_column='snippet_id', primary_key=True, rel_model=Snippets, to_field='id')

    class Meta:
        db_table = 'snippet_statistics'

class SnippetUserMentions(BaseModel):
    id = BigIntegerField(primary_key=True)
    mentioned_groups_ids = UnknownField(null=True)  # ARRAY
    mentioned_projects_ids = UnknownField(null=True)  # ARRAY
    mentioned_users_ids = UnknownField(null=True)  # ARRAY
    note = ForeignKeyField(db_column='note_id', null=True, rel_model=Notes, to_field='id', unique=True)
    snippet = ForeignKeyField(db_column='snippet_id', rel_model=Snippets, to_field='id', unique=True)

    class Meta:
        db_table = 'snippet_user_mentions'
        indexes = (
            (('snippet', 'note'), True),
        )

class SoftwareLicenses(BaseModel):
    name = CharField(unique=True)
    spdx_identifier = CharField(index=True, null=True)

    class Meta:
        db_table = 'software_licenses'

class SoftwareLicensePolicies(BaseModel):
    classification = IntegerField()
    created_at = DateTimeField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    software_license = ForeignKeyField(db_column='software_license_id', rel_model=SoftwareLicenses, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'software_license_policies'
        indexes = (
            (('project', 'software_license'), True),
        )

class SpamLogs(BaseModel):
    created_at = DateTimeField()
    description = TextField(null=True)
    noteable_type = CharField(null=True)
    recaptcha_verified = BooleanField()
    source_ip = CharField(null=True)
    submitted_as_ham = BooleanField()
    title = CharField(null=True)
    updated_at = DateTimeField()
    user_agent = CharField(null=True)
    user = IntegerField(db_column='user_id', null=True)
    via_api = BooleanField(null=True)

    class Meta:
        db_table = 'spam_logs'

class StatusPagePublishedIncidents(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    issue = ForeignKeyField(db_column='issue_id', rel_model=Issues, to_field='id', unique=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'status_page_published_incidents'

class StatusPageSettings(BaseModel):
    aws_access_key = CharField()
    aws_region = CharField()
    aws_s3_bucket_name = CharField()
    created_at = DateTimeField()
    enabled = BooleanField()
    encrypted_aws_secret_key = CharField()
    encrypted_aws_secret_key_iv = CharField()
    project = ForeignKeyField(db_column='project_id', primary_key=True, rel_model=Projects, to_field='id')
    status_page_url = TextField(null=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'status_page_settings'

class Subscriptions(BaseModel):
    created_at = DateTimeField(null=True)
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    subscribable = IntegerField(db_column='subscribable_id', null=True)
    subscribable_type = CharField(null=True)
    subscribed = BooleanField(null=True)
    updated_at = DateTimeField(null=True)
    user = IntegerField(db_column='user_id', null=True)

    class Meta:
        db_table = 'subscriptions'
        indexes = (
            (('user', 'subscribable', 'subscribable_type', 'project'), True),
        )

class Suggestions(BaseModel):
    applied = BooleanField()
    commit = CharField(db_column='commit_id', null=True)
    from_content = TextField()
    id = BigIntegerField(primary_key=True)
    lines_above = IntegerField()
    lines_below = IntegerField()
    note = ForeignKeyField(db_column='note_id', rel_model=Notes, to_field='id')
    outdated = BooleanField()
    relative_order = IntegerField()
    to_content = TextField()

    class Meta:
        db_table = 'suggestions'
        indexes = (
            (('note', 'relative_order'), True),
        )

class SystemNoteMetadata(BaseModel):
    action = CharField(null=True)
    commit_count = IntegerField(null=True)
    created_at = DateTimeField()
    description_version = ForeignKeyField(db_column='description_version_id', null=True, rel_model=DescriptionVersions, to_field='id', unique=True)
    note = ForeignKeyField(db_column='note_id', rel_model=Notes, to_field='id', unique=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'system_note_metadata'

class Taggings(BaseModel):
    context = CharField(null=True)
    created_at = DateTimeField(null=True)
    tag = IntegerField(db_column='tag_id', index=True, null=True)
    taggable = IntegerField(db_column='taggable_id', null=True)
    taggable_type = CharField(null=True)
    tagger = IntegerField(db_column='tagger_id', null=True)
    tagger_type = CharField(null=True)

    class Meta:
        db_table = 'taggings'
        indexes = (
            (('tag', 'taggable', 'taggable_type', 'tagger', 'tagger_type', 'context'), True),
            (('taggable', 'taggable_type'), False),
            (('taggable_type', 'context', 'taggable'), False),
        )

class Tags(BaseModel):
    name = CharField(index=True, null=True)
    taggings_count = IntegerField(null=True)

    class Meta:
        db_table = 'tags'

class TermAgreements(BaseModel):
    accepted = BooleanField()
    created_at = DateTimeField()
    term = ForeignKeyField(db_column='term_id', rel_model=ApplicationSettingTerms, to_field='id')
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'term_agreements'
        indexes = (
            (('term', 'user'), True),
        )

class TerraformStates(BaseModel):
    created_at = DateTimeField()
    file = CharField(null=True)
    file_store = IntegerField(index=True, null=True)
    id = BigIntegerField(primary_key=True)
    lock_xid = CharField(null=True)
    locked_at = DateTimeField(null=True)
    locked_by_user = ForeignKeyField(db_column='locked_by_user_id', null=True, rel_model=Users, to_field='id')
    name = CharField(null=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()
    uuid = CharField(unique=True)
    verification_checksum = BlobField(index=True, null=True)
    verification_failure = TextField(index=True, null=True)
    verification_retry_at = DateTimeField(null=True)
    verification_retry_count = IntegerField(null=True)
    verified_at = DateTimeField(null=True)

    class Meta:
        db_table = 'terraform_states'
        indexes = (
            (('project', 'name'), True),
        )

class Timelogs(BaseModel):
    created_at = DateTimeField()
    issue = ForeignKeyField(db_column='issue_id', null=True, rel_model=Issues, to_field='id')
    merge_request = ForeignKeyField(db_column='merge_request_id', null=True, rel_model=MergeRequests, to_field='id')
    note = ForeignKeyField(db_column='note_id', null=True, rel_model=Notes, to_field='id')
    spent_at = DateTimeField(index=True, null=True)
    time_spent = IntegerField()
    updated_at = DateTimeField()
    user = IntegerField(db_column='user_id', index=True, null=True)

    class Meta:
        db_table = 'timelogs'

class Todos(BaseModel):
    action = IntegerField()
    author = ForeignKeyField(db_column='author_id', rel_model=Users, to_field='id')
    commit = CharField(db_column='commit_id', index=True, null=True)
    created_at = DateTimeField(null=True)
    group = ForeignKeyField(db_column='group_id', null=True, rel_model=Namespaces, to_field='id')
    note = ForeignKeyField(db_column='note_id', null=True, rel_model=Notes, to_field='id')
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    resolved_by_action = IntegerField(null=True)
    state = CharField()
    target = IntegerField(db_column='target_id', null=True)
    target_type = CharField()
    updated_at = DateTimeField(null=True)
    user = ForeignKeyField(db_column='user_id', rel_model=Users, related_name='users_user_set', to_field='id')

    class Meta:
        db_table = 'todos'
        indexes = (
            (('created_at', 'author'), False),
            (('id', 'user'), False),
            (('target', 'target_type'), False),
            (('user', 'id'), False),
        )

class TrendingProjects(BaseModel):
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id', unique=True)

    class Meta:
        db_table = 'trending_projects'

class U2FRegistrations(BaseModel):
    certificate = TextField(null=True)
    counter = IntegerField(null=True)
    created_at = DateTimeField()
    key_handle = CharField(index=True, null=True)
    name = CharField(null=True)
    public_key = CharField(null=True)
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', null=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'u2f_registrations'

class Uploads(BaseModel):
    checksum = CharField(index=True, null=True)
    created_at = DateTimeField()
    model = IntegerField(db_column='model_id', null=True)
    model_type = CharField(null=True)
    mount_point = CharField(null=True)
    path = CharField()
    secret = CharField(null=True)
    size = BigIntegerField()
    store = IntegerField(index=True, null=True)
    uploader = CharField()

    class Meta:
        db_table = 'uploads'
        indexes = (
            (('model', 'model_type'), False),
            (('uploader', 'path'), False),
        )

class UserAgentDetails(BaseModel):
    created_at = DateTimeField()
    ip_address = CharField()
    subject = IntegerField(db_column='subject_id')
    subject_type = CharField()
    submitted = BooleanField()
    updated_at = DateTimeField()
    user_agent = CharField()

    class Meta:
        db_table = 'user_agent_details'
        indexes = (
            (('subject', 'subject_type'), False),
        )

class UserCallouts(BaseModel):
    dismissed_at = DateTimeField(null=True)
    feature_name = IntegerField()
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'user_callouts'
        indexes = (
            (('feature_name', 'user'), True),
        )

class UserCanonicalEmails(BaseModel):
    canonical_email = CharField(index=True)
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id', unique=True)

    class Meta:
        db_table = 'user_canonical_emails'
        indexes = (
            (('user', 'canonical_email'), True),
        )

class UserCustomAttributes(BaseModel):
    created_at = DateTimeField()
    key = CharField()
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')
    value = CharField()

    class Meta:
        db_table = 'user_custom_attributes'
        indexes = (
            (('key', 'value'), False),
            (('user', 'key'), True),
        )

class UserDetails(BaseModel):
    bio = CharField()
    bio_html = TextField(null=True)
    cached_markdown_version = IntegerField(null=True)
    job_title = CharField()
    user = ForeignKeyField(db_column='user_id', primary_key=True, rel_model=Users, to_field='id')
    webauthn_xid = TextField(null=True)

    class Meta:
        db_table = 'user_details'

class UserHighestRoles(BaseModel):
    highest_access_level = IntegerField(null=True)
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', primary_key=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'user_highest_roles'
        indexes = (
            (('user', 'highest_access_level'), False),
        )

class UserInteractedProjects(BaseModel):
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'user_interacted_projects'
        indexes = (
            (('user', 'project'), True),
        )

class UserPreferences(BaseModel):
    created_at = DateTimeField()
    epic_notes_filter = IntegerField()
    epics_sort = CharField(null=True)
    experience_level = IntegerField(null=True)
    feature_filter_type = BigIntegerField(null=True)
    first_day_of_week = IntegerField(null=True)
    issue_notes_filter = IntegerField()
    issues_sort = CharField(null=True)
    merge_request_notes_filter = IntegerField()
    merge_requests_sort = CharField(null=True)
    projects_sort = CharField(null=True)
    render_whitespace_in_code = BooleanField(null=True)
    roadmap_epics_state = IntegerField(null=True)
    roadmaps_sort = CharField(null=True)
    setup_for_company = BooleanField(null=True)
    show_whitespace_in_diffs = BooleanField()
    sourcegraph_enabled = BooleanField(null=True)
    tab_width = IntegerField(null=True)
    time_display_relative = BooleanField(null=True)
    time_format_in_24h = BooleanField(null=True)
    timezone = CharField(null=True)
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id', unique=True)
    view_diffs_file_by_file = BooleanField()

    class Meta:
        db_table = 'user_preferences'

class UserStatuses(BaseModel):
    cached_markdown_version = IntegerField(null=True)
    emoji = CharField()
    message = CharField(null=True)
    message_html = CharField(null=True)
    user = ForeignKeyField(db_column='user_id', primary_key=True, rel_model=Users, to_field='id')

    class Meta:
        db_table = 'user_statuses'

class UserSyncedAttributesMetadata(BaseModel):
    email_synced = BooleanField(null=True)
    location_synced = BooleanField(null=True)
    name_synced = BooleanField(null=True)
    provider = CharField(null=True)
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id', unique=True)

    class Meta:
        db_table = 'user_synced_attributes_metadata'

class UsersOpsDashboardProjects(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'users_ops_dashboard_projects'
        indexes = (
            (('user', 'project'), True),
        )

class UsersSecurityDashboardProjects(BaseModel):
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'users_security_dashboard_projects'
        indexes = (
            (('user', 'project'), True),
        )

class UsersStarProjects(BaseModel):
    created_at = DateTimeField(null=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField(null=True)
    user = IntegerField(db_column='user_id')

    class Meta:
        db_table = 'users_star_projects'
        indexes = (
            (('project', 'user'), True),
        )

class UsersStatistics(BaseModel):
    blocked = IntegerField()
    bots = IntegerField()
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    updated_at = DateTimeField()
    with_highest_role_developer = IntegerField()
    with_highest_role_guest = IntegerField()
    with_highest_role_maintainer = IntegerField()
    with_highest_role_owner = IntegerField()
    with_highest_role_reporter = IntegerField()
    without_groups_and_projects = IntegerField()

    class Meta:
        db_table = 'users_statistics'

class Vulnerabilities(BaseModel):
    author = ForeignKeyField(db_column='author_id', rel_model=Users, to_field='id')
    cached_markdown_version = IntegerField(null=True)
    confidence = IntegerField()
    confidence_overridden = BooleanField(null=True)
    confirmed_at = DateTimeField(null=True)
    confirmed_by = ForeignKeyField(db_column='confirmed_by_id', null=True, rel_model=Users, related_name='users_confirmed_by_set', to_field='id')
    created_at = DateTimeField()
    description = TextField(null=True)
    description_html = TextField(null=True)
    dismissed_at = DateTimeField(null=True)
    dismissed_by = ForeignKeyField(db_column='dismissed_by_id', null=True, rel_model=Users, related_name='users_dismissed_by_set', to_field='id')
    due_date = DateField(null=True)
    due_date_sourcing_milestone = ForeignKeyField(db_column='due_date_sourcing_milestone_id', null=True, rel_model=Milestones, to_field='id')
    epic = ForeignKeyField(db_column='epic_id', null=True, rel_model=Epics, to_field='id')
    id = BigIntegerField(primary_key=True)
    last_edited_at = DateTimeField(null=True)
    last_edited_by = ForeignKeyField(db_column='last_edited_by_id', null=True, rel_model=Users, related_name='users_last_edited_by_set', to_field='id')
    milestone = ForeignKeyField(db_column='milestone_id', null=True, rel_model=Milestones, related_name='milestones_milestone_set', to_field='id')
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    report_type = IntegerField()
    resolved_at = DateTimeField(null=True)
    resolved_by = ForeignKeyField(db_column='resolved_by_id', null=True, rel_model=Users, related_name='users_resolved_by_set', to_field='id')
    resolved_on_default_branch = BooleanField()
    severity = IntegerField()
    severity_overridden = BooleanField(null=True)
    start_date = DateField(null=True)
    start_date_sourcing_milestone = ForeignKeyField(db_column='start_date_sourcing_milestone_id', null=True, rel_model=Milestones, related_name='milestones_start_date_sourcing_milestone_set', to_field='id')
    state = IntegerField()
    title = CharField()
    title_html = TextField(null=True)
    updated_at = DateTimeField()
    updated_by = ForeignKeyField(db_column='updated_by_id', null=True, rel_model=Users, related_name='users_updated_by_set', to_field='id')

    class Meta:
        db_table = 'vulnerabilities'

class VulnerabilityExports(BaseModel):
    author = ForeignKeyField(db_column='author_id', rel_model=Users, to_field='id')
    created_at = DateTimeField()
    file = CharField(null=True)
    file_store = IntegerField(index=True, null=True)
    finished_at = DateTimeField(null=True)
    format = IntegerField()
    group = ForeignKeyField(db_column='group_id', null=True, rel_model=Namespaces, to_field='id')
    id = BigIntegerField(primary_key=True)
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    started_at = DateTimeField(null=True)
    status = CharField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'vulnerability_exports'

class VulnerabilityFeedback(BaseModel):
    author = ForeignKeyField(db_column='author_id', rel_model=Users, to_field='id')
    category = IntegerField()
    comment = TextField(null=True)
    comment_author = ForeignKeyField(db_column='comment_author_id', null=True, rel_model=Users, related_name='users_comment_author_set', to_field='id')
    comment_timestamp = DateTimeField(null=True)
    created_at = DateTimeField()
    feedback_type = IntegerField()
    issue = ForeignKeyField(db_column='issue_id', null=True, rel_model=Issues, to_field='id')
    merge_request = ForeignKeyField(db_column='merge_request_id', null=True, rel_model=MergeRequests, to_field='id')
    pipeline = ForeignKeyField(db_column='pipeline_id', null=True, rel_model=CiPipelines, to_field='id')
    project_fingerprint = CharField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'vulnerability_feedback'
        indexes = (
            (('category', 'project', 'project_fingerprint', 'feedback_type'), True),
        )

class VulnerabilityHistoricalStatistics(BaseModel):
    created_at = DateTimeField()
    critical = IntegerField()
    date = DateField()
    high = IntegerField()
    id = BigIntegerField(primary_key=True)
    info = IntegerField()
    letter_grade = IntegerField()
    low = IntegerField()
    medium = IntegerField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    total = IntegerField()
    unknown = IntegerField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'vulnerability_historical_statistics'
        indexes = (
            (('id', 'date'), False),
            (('project', 'date'), True),
        )

class VulnerabilityIdentifiers(BaseModel):
    created_at = DateTimeField()
    external = CharField(db_column='external_id')
    external_type = CharField()
    fingerprint = BlobField()
    id = BigIntegerField(primary_key=True)
    name = CharField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()
    url = TextField(null=True)

    class Meta:
        db_table = 'vulnerability_identifiers'
        indexes = (
            (('project', 'fingerprint'), True),
        )

class VulnerabilityIssueLinks(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    issue = ForeignKeyField(db_column='issue_id', rel_model=Issues, to_field='id')
    link_type = IntegerField()
    updated_at = DateTimeField()
    vulnerability = ForeignKeyField(db_column='vulnerability_id', rel_model=Vulnerabilities, to_field='id')

    class Meta:
        db_table = 'vulnerability_issue_links'
        indexes = (
            (('vulnerability', 'issue'), True),
            (('vulnerability', 'link_type'), True),
        )

class VulnerabilityScanners(BaseModel):
    created_at = DateTimeField()
    external = CharField(db_column='external_id')
    id = BigIntegerField(primary_key=True)
    name = CharField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()
    vendor = TextField()

    class Meta:
        db_table = 'vulnerability_scanners'
        indexes = (
            (('project', 'external'), True),
        )

class VulnerabilityOccurrences(BaseModel):
    confidence = IntegerField()
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    location_fingerprint = BlobField()
    metadata_version = CharField()
    name = CharField()
    primary_identifier = ForeignKeyField(db_column='primary_identifier_id', rel_model=VulnerabilityIdentifiers, to_field='id')
    project_fingerprint = BlobField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    raw_metadata = TextField()
    report_type = IntegerField()
    scanner = ForeignKeyField(db_column='scanner_id', rel_model=VulnerabilityScanners, to_field='id')
    severity = IntegerField()
    updated_at = DateTimeField()
    uuid = CharField(unique=True)
    vulnerability = ForeignKeyField(db_column='vulnerability_id', null=True, rel_model=Vulnerabilities, to_field='id')

    class Meta:
        db_table = 'vulnerability_occurrences'
        indexes = (
            (('location_fingerprint', 'project', 'scanner', 'primary_identifier'), True),
            (('report_type', 'project'), False),
        )

class VulnerabilityOccurrenceIdentifiers(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    identifier = ForeignKeyField(db_column='identifier_id', rel_model=VulnerabilityIdentifiers, to_field='id')
    occurrence = ForeignKeyField(db_column='occurrence_id', rel_model=VulnerabilityOccurrences, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'vulnerability_occurrence_identifiers'
        indexes = (
            (('occurrence', 'identifier'), True),
        )

class VulnerabilityOccurrencePipelines(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    occurrence = ForeignKeyField(db_column='occurrence_id', rel_model=VulnerabilityOccurrences, to_field='id')
    pipeline = ForeignKeyField(db_column='pipeline_id', rel_model=CiPipelines, to_field='id')
    updated_at = DateTimeField()

    class Meta:
        db_table = 'vulnerability_occurrence_pipelines'
        indexes = (
            (('occurrence', 'pipeline'), True),
        )

class VulnerabilityStatistics(BaseModel):
    created_at = DateTimeField()
    critical = IntegerField()
    high = IntegerField()
    id = BigIntegerField(primary_key=True)
    info = IntegerField()
    letter_grade = IntegerField(index=True)
    low = IntegerField()
    medium = IntegerField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id', unique=True)
    total = IntegerField()
    unknown = IntegerField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'vulnerability_statistics'

class VulnerabilityUserMentions(BaseModel):
    id = BigIntegerField(primary_key=True)
    mentioned_groups_ids = UnknownField(null=True)  # ARRAY
    mentioned_projects_ids = UnknownField(null=True)  # ARRAY
    mentioned_users_ids = UnknownField(null=True)  # ARRAY
    note = ForeignKeyField(db_column='note_id', null=True, rel_model=Notes, to_field='id', unique=True)
    vulnerability = ForeignKeyField(db_column='vulnerability_id', rel_model=Vulnerabilities, to_field='id', unique=True)

    class Meta:
        db_table = 'vulnerability_user_mentions'
        indexes = (
            (('vulnerability', 'note'), True),
        )

class WebHooks(BaseModel):
    confidential_issues_events = BooleanField()
    confidential_note_events = BooleanField(null=True)
    created_at = DateTimeField(null=True)
    deployment_events = BooleanField()
    enable_ssl_verification = BooleanField(null=True)
    encrypted_token = CharField(null=True)
    encrypted_token_iv = CharField(null=True)
    encrypted_url = CharField(null=True)
    encrypted_url_iv = CharField(null=True)
    group = IntegerField(db_column='group_id', index=True, null=True)
    issues_events = BooleanField()
    job_events = BooleanField()
    merge_requests_events = BooleanField()
    note_events = BooleanField()
    pipeline_events = BooleanField()
    project = ForeignKeyField(db_column='project_id', null=True, rel_model=Projects, to_field='id')
    push_events = BooleanField()
    push_events_branch_filter = TextField(null=True)
    repository_update_events = BooleanField()
    service = IntegerField(db_column='service_id', null=True)
    tag_push_events = BooleanField(null=True)
    type = CharField(index=True, null=True)
    updated_at = DateTimeField(null=True)
    wiki_page_events = BooleanField()

    class Meta:
        db_table = 'web_hooks'

class WebHookLogs(BaseModel):
    created_at = DateTimeField()
    execution_duration = FloatField(null=True)
    internal_error_message = CharField(null=True)
    request_data = TextField(null=True)
    request_headers = TextField(null=True)
    response_body = TextField(null=True)
    response_headers = TextField(null=True)
    response_status = CharField(null=True)
    trigger = CharField(null=True)
    updated_at = DateTimeField()
    url = CharField(null=True)
    web_hook = ForeignKeyField(db_column='web_hook_id', rel_model=WebHooks, to_field='id')

    class Meta:
        db_table = 'web_hook_logs'
        indexes = (
            (('web_hook', 'created_at'), False),
        )

class WebauthnRegistrations(BaseModel):
    counter = BigIntegerField()
    created_at = DateTimeField()
    credential_xid = TextField(unique=True)
    id = BigIntegerField(primary_key=True)
    name = TextField()
    public_key = TextField()
    updated_at = DateTimeField()
    user = ForeignKeyField(db_column='user_id', rel_model=Users, to_field='id')

    class Meta:
        db_table = 'webauthn_registrations'

class WikiPageMeta(BaseModel):
    created_at = DateTimeField()
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    title = CharField()
    updated_at = DateTimeField()

    class Meta:
        db_table = 'wiki_page_meta'

class WikiPageSlugs(BaseModel):
    canonical = BooleanField()
    created_at = DateTimeField()
    slug = CharField()
    updated_at = DateTimeField()
    wiki_page_meta = ForeignKeyField(db_column='wiki_page_meta_id', rel_model=WikiPageMeta, to_field='id')

    class Meta:
        db_table = 'wiki_page_slugs'
        indexes = (
            (('wiki_page_meta', 'slug'), True),
        )

class X509Issuers(BaseModel):
    created_at = DateTimeField()
    crl_url = CharField()
    id = BigIntegerField(primary_key=True)
    subject = CharField()
    subject_key_identifier = CharField(index=True)
    updated_at = DateTimeField()

    class Meta:
        db_table = 'x509_issuers'

class X509Certificates(BaseModel):
    certificate_status = IntegerField()
    created_at = DateTimeField()
    email = CharField()
    id = BigIntegerField(primary_key=True)
    serial_number = BlobField()
    subject = CharField()
    subject_key_identifier = CharField(index=True)
    updated_at = DateTimeField()
    x509_issuer = ForeignKeyField(db_column='x509_issuer_id', rel_model=X509Issuers, to_field='id')

    class Meta:
        db_table = 'x509_certificates'

class X509CommitSignatures(BaseModel):
    commit_sha = BlobField(index=True)
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()
    verification_status = IntegerField()
    x509_certificate = ForeignKeyField(db_column='x509_certificate_id', rel_model=X509Certificates, to_field='id')

    class Meta:
        db_table = 'x509_commit_signatures'

class ZoomMeetings(BaseModel):
    created_at = DateTimeField()
    id = BigIntegerField(primary_key=True)
    issue = ForeignKeyField(db_column='issue_id', rel_model=Issues, to_field='id')
    issue_status = IntegerField(index=True)
    project = ForeignKeyField(db_column='project_id', rel_model=Projects, to_field='id')
    updated_at = DateTimeField()
    url = CharField(null=True)

    class Meta:
        db_table = 'zoom_meetings'
        indexes = (
            (('issue', 'issue_status'), True),
        )