migrate

Documentation

Index

• Variables
• func Create(ctx context.Context, s *Schema, tables []*schema.Table, ...) error
• type Schema
  • func NewSchema(drv dialect.Driver) *Schema
  • func (s *Schema) Create(ctx context.Context, opts ...schema.MigrateOption) error
  • func (s *Schema) WriteTo(ctx context.Context, w io.Writer, opts ...schema.MigrateOption) error

Variables

var (
	// WithGlobalUniqueID sets the universal ids options to the migration.
	// If this option is enabled, ent migration will allocate a 1<<32 range
	// for the ids of each entity (table).
	// Note that this option cannot be applied on tables that already exist.
	WithGlobalUniqueID = schema.WithGlobalUniqueID
	// WithDropColumn sets the drop column option to the migration.
	// If this option is enabled, ent migration will drop old columns
	// that were used for both fields and edges. This defaults to false.
	WithDropColumn = schema.WithDropColumn
	// WithDropIndex sets the drop index option to the migration.
	// If this option is enabled, ent migration will drop old indexes
	// that were defined in the schema. This defaults to false.
	// Note that unique constraints are defined using `UNIQUE INDEX`,
	// and therefore, it's recommended to enable this option to get more
	// flexibility in the schema changes.
	WithDropIndex = schema.WithDropIndex
	// WithForeignKeys enables creating foreign-key in schema DDL. This defaults to true.
	WithForeignKeys = schema.WithForeignKeys
)

var (
	// APIPermissionsColumns holds the columns for the "api_permissions" table.
	APIPermissionsColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "path", Type: field.TypeString},
		{Name: "method", Type: field.TypeEnum, Enums: []string{"GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"}, Default: "GET"},
		{Name: "description", Type: field.TypeString, Nullable: true},
		{Name: "is_public", Type: field.TypeBool, Default: false},
	}
	// APIPermissionsTable holds the schema information for the "api_permissions" table.
	APIPermissionsTable = &schema.Table{
		Name:       "api_permissions",
		Columns:    APIPermissionsColumns,
		PrimaryKey: []*schema.Column{APIPermissionsColumns[0]},
		Indexes: []*schema.Index{
			{
				Name:    "apipermission_id",
				Unique:  false,
				Columns: []*schema.Column{APIPermissionsColumns[0]},
			},
			{
				Name:    "apipermission_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{APIPermissionsColumns[6]},
			},
			{
				Name:    "apipermission_created_at",
				Unique:  false,
				Columns: []*schema.Column{APIPermissionsColumns[2]},
			},
			{
				Name:    "apipermission_updated_at",
				Unique:  false,
				Columns: []*schema.Column{APIPermissionsColumns[4]},
			},
			{
				Name:    "apipermission_published_at",
				Unique:  false,
				Columns: []*schema.Column{APIPermissionsColumns[7]},
			},
			{
				Name:    "apipermission_path_method",
				Unique:  true,
				Columns: []*schema.Column{APIPermissionsColumns[9], APIPermissionsColumns[10]},
			},
		},
	}
	// APIPermissionMapsColumns holds the columns for the "api_permission_maps" table.
	APIPermissionMapsColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "api_id", Type: field.TypeUUID},
		{Name: "permission_code", Type: field.TypeString},
	}
	// APIPermissionMapsTable holds the schema information for the "api_permission_maps" table.
	APIPermissionMapsTable = &schema.Table{
		Name:       "api_permission_maps",
		Columns:    APIPermissionMapsColumns,
		PrimaryKey: []*schema.Column{APIPermissionMapsColumns[0]},
		Indexes: []*schema.Index{
			{
				Name:    "apipermissionmap_id",
				Unique:  false,
				Columns: []*schema.Column{APIPermissionMapsColumns[0]},
			},
			{
				Name:    "apipermissionmap_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{APIPermissionMapsColumns[6]},
			},
			{
				Name:    "apipermissionmap_created_at",
				Unique:  false,
				Columns: []*schema.Column{APIPermissionMapsColumns[2]},
			},
			{
				Name:    "apipermissionmap_updated_at",
				Unique:  false,
				Columns: []*schema.Column{APIPermissionMapsColumns[4]},
			},
			{
				Name:    "apipermissionmap_published_at",
				Unique:  false,
				Columns: []*schema.Column{APIPermissionMapsColumns[7]},
			},
			{
				Name:    "apipermissionmap_api_id_permission_code",
				Unique:  true,
				Columns: []*schema.Column{APIPermissionMapsColumns[9], APIPermissionMapsColumns[10]},
			},
			{
				Name:    "apipermissionmap_permission_code",
				Unique:  false,
				Columns: []*schema.Column{APIPermissionMapsColumns[10]},
			},
		},
	}
	// APIKeysColumns holds the columns for the "api_keys" table.
	APIKeysColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "owner_domain_id", Type: field.TypeUUID, Nullable: true},
		{Name: "name", Type: field.TypeString},
		{Name: "description", Type: field.TypeString, Nullable: true},
		{Name: "key", Type: field.TypeString, Unique: true},
		{Name: "secret_hash", Type: field.TypeString},
		{Name: "expires_at", Type: field.TypeTime, Nullable: true},
		{Name: "permissions", Type: field.TypeJSON, Nullable: true},
		{Name: "data_filters", Type: field.TypeJSON, Nullable: true},
		{Name: "rate_limit", Type: field.TypeInt, Default: 60},
		{Name: "daily_limit", Type: field.TypeInt, Default: 10000},
		{Name: "project_id", Type: field.TypeUUID, Nullable: true},
		{Name: "usage_count", Type: field.TypeInt64, Default: 0},
		{Name: "last_used_at", Type: field.TypeTime, Nullable: true},
		{Name: "last_used_ip", Type: field.TypeString, Nullable: true},
		{Name: "is_active", Type: field.TypeBool, Default: true},
		{Name: "api_key_role", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "role_api_keys", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "user_api_keys", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// APIKeysTable holds the schema information for the "api_keys" table.
	APIKeysTable = &schema.Table{
		Name:       "api_keys",
		Columns:    APIKeysColumns,
		PrimaryKey: []*schema.Column{APIKeysColumns[0]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "api_keys_roles_role",
				Columns:    []*schema.Column{APIKeysColumns[24]},
				RefColumns: []*schema.Column{RolesColumns[0]},
				OnDelete:   schema.SetNull,
			},
			{
				Symbol:     "api_keys_roles_api_keys",
				Columns:    []*schema.Column{APIKeysColumns[25]},
				RefColumns: []*schema.Column{RolesColumns[0]},
				OnDelete:   schema.SetNull,
			},
			{
				Symbol:     "api_keys_users_api_keys",
				Columns:    []*schema.Column{APIKeysColumns[26]},
				RefColumns: []*schema.Column{UsersColumns[0]},
				OnDelete:   schema.NoAction,
			},
		},
		Indexes: []*schema.Index{
			{
				Name:    "apikey_id",
				Unique:  false,
				Columns: []*schema.Column{APIKeysColumns[0]},
			},
			{
				Name:    "apikey_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{APIKeysColumns[6]},
			},
			{
				Name:    "apikey_created_at",
				Unique:  false,
				Columns: []*schema.Column{APIKeysColumns[2]},
			},
			{
				Name:    "apikey_updated_at",
				Unique:  false,
				Columns: []*schema.Column{APIKeysColumns[4]},
			},
			{
				Name:    "apikey_published_at",
				Unique:  false,
				Columns: []*schema.Column{APIKeysColumns[7]},
			},
			{
				Name:    "apikey_owner_domain_id",
				Unique:  false,
				Columns: []*schema.Column{APIKeysColumns[9]},
			},
			{
				Name:    "apikey_key",
				Unique:  false,
				Columns: []*schema.Column{APIKeysColumns[12]},
			},
			{
				Name:    "apikey_is_active",
				Unique:  false,
				Columns: []*schema.Column{APIKeysColumns[23]},
			},
		},
	}
	// AuditLogsColumns holds the columns for the "audit_logs" table.
	AuditLogsColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "owner_domain_id", Type: field.TypeUUID, Nullable: true},
		{Name: "action", Type: field.TypeString},
		{Name: "resource", Type: field.TypeString},
		{Name: "resource_id", Type: field.TypeString, Nullable: true},
		{Name: "before", Type: field.TypeJSON, Nullable: true},
		{Name: "after", Type: field.TypeJSON, Nullable: true},
		{Name: "ip_address", Type: field.TypeString, Nullable: true},
		{Name: "user_agent", Type: field.TypeString, Nullable: true},
	}
	// AuditLogsTable holds the schema information for the "audit_logs" table.
	AuditLogsTable = &schema.Table{
		Name:       "audit_logs",
		Columns:    AuditLogsColumns,
		PrimaryKey: []*schema.Column{AuditLogsColumns[0]},
		Indexes: []*schema.Index{
			{
				Name:    "auditlog_id",
				Unique:  false,
				Columns: []*schema.Column{AuditLogsColumns[0]},
			},
			{
				Name:    "auditlog_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{AuditLogsColumns[6]},
			},
			{
				Name:    "auditlog_created_at",
				Unique:  false,
				Columns: []*schema.Column{AuditLogsColumns[2]},
			},
			{
				Name:    "auditlog_updated_at",
				Unique:  false,
				Columns: []*schema.Column{AuditLogsColumns[4]},
			},
			{
				Name:    "auditlog_published_at",
				Unique:  false,
				Columns: []*schema.Column{AuditLogsColumns[7]},
			},
			{
				Name:    "auditlog_owner_domain_id",
				Unique:  false,
				Columns: []*schema.Column{AuditLogsColumns[9]},
			},
			{
				Name:    "auditlog_action_resource",
				Unique:  false,
				Columns: []*schema.Column{AuditLogsColumns[10], AuditLogsColumns[11]},
			},
		},
	}
	// DictionariesColumns holds the columns for the "dictionaries" table.
	DictionariesColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "owner_domain_id", Type: field.TypeUUID, Nullable: true},
		{Name: "code", Type: field.TypeString},
		{Name: "name", Type: field.TypeString},
		{Name: "description", Type: field.TypeString, Nullable: true},
		{Name: "status", Type: field.TypeBool, Default: true},
	}
	// DictionariesTable holds the schema information for the "dictionaries" table.
	DictionariesTable = &schema.Table{
		Name:       "dictionaries",
		Columns:    DictionariesColumns,
		PrimaryKey: []*schema.Column{DictionariesColumns[0]},
		Indexes: []*schema.Index{
			{
				Name:    "dictionary_id",
				Unique:  false,
				Columns: []*schema.Column{DictionariesColumns[0]},
			},
			{
				Name:    "dictionary_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{DictionariesColumns[6]},
			},
			{
				Name:    "dictionary_created_at",
				Unique:  false,
				Columns: []*schema.Column{DictionariesColumns[2]},
			},
			{
				Name:    "dictionary_updated_at",
				Unique:  false,
				Columns: []*schema.Column{DictionariesColumns[4]},
			},
			{
				Name:    "dictionary_published_at",
				Unique:  false,
				Columns: []*schema.Column{DictionariesColumns[7]},
			},
			{
				Name:    "dictionary_owner_domain_id",
				Unique:  false,
				Columns: []*schema.Column{DictionariesColumns[9]},
			},
			{
				Name:    "dictionary_owner_domain_id_code",
				Unique:  true,
				Columns: []*schema.Column{DictionariesColumns[9], DictionariesColumns[10]},
			},
		},
	}
	// DictionaryDetailsColumns holds the columns for the "dictionary_details" table.
	DictionaryDetailsColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "owner_domain_id", Type: field.TypeUUID, Nullable: true},
		{Name: "label", Type: field.TypeString},
		{Name: "value", Type: field.TypeString},
		{Name: "extend", Type: field.TypeString, Nullable: true},
		{Name: "sort", Type: field.TypeInt, Default: 0},
		{Name: "status", Type: field.TypeBool, Default: true},
		{Name: "dictionary_id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// DictionaryDetailsTable holds the schema information for the "dictionary_details" table.
	DictionaryDetailsTable = &schema.Table{
		Name:       "dictionary_details",
		Columns:    DictionaryDetailsColumns,
		PrimaryKey: []*schema.Column{DictionaryDetailsColumns[0]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "dictionary_details_dictionaries_items",
				Columns:    []*schema.Column{DictionaryDetailsColumns[15]},
				RefColumns: []*schema.Column{DictionariesColumns[0]},
				OnDelete:   schema.NoAction,
			},
		},
		Indexes: []*schema.Index{
			{
				Name:    "dictionarydetail_id",
				Unique:  false,
				Columns: []*schema.Column{DictionaryDetailsColumns[0]},
			},
			{
				Name:    "dictionarydetail_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{DictionaryDetailsColumns[6]},
			},
			{
				Name:    "dictionarydetail_created_at",
				Unique:  false,
				Columns: []*schema.Column{DictionaryDetailsColumns[2]},
			},
			{
				Name:    "dictionarydetail_updated_at",
				Unique:  false,
				Columns: []*schema.Column{DictionaryDetailsColumns[4]},
			},
			{
				Name:    "dictionarydetail_published_at",
				Unique:  false,
				Columns: []*schema.Column{DictionaryDetailsColumns[7]},
			},
			{
				Name:    "dictionarydetail_owner_domain_id",
				Unique:  false,
				Columns: []*schema.Column{DictionaryDetailsColumns[9]},
			},
		},
	}
	// DomainsColumns holds the columns for the "domains" table.
	DomainsColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "type_code", Type: field.TypeString, Size: 50},
		{Name: "key", Type: field.TypeString, Size: 200},
		{Name: "display_name", Type: field.TypeString, Size: 200},
		{Name: "status", Type: field.TypeEnum, Enums: []string{"active", "inactive", "suspended"}, Default: "active"},
		{Name: "metadata", Type: field.TypeJSON, Nullable: true},
		{Name: "domain_type_domains", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// DomainsTable holds the schema information for the "domains" table.
	DomainsTable = &schema.Table{
		Name:       "domains",
		Columns:    DomainsColumns,
		PrimaryKey: []*schema.Column{DomainsColumns[0]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "domains_domain_types_domains",
				Columns:    []*schema.Column{DomainsColumns[14]},
				RefColumns: []*schema.Column{DomainTypesColumns[0]},
				OnDelete:   schema.SetNull,
			},
		},
		Indexes: []*schema.Index{
			{
				Name:    "domain_id",
				Unique:  false,
				Columns: []*schema.Column{DomainsColumns[0]},
			},
			{
				Name:    "domain_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{DomainsColumns[6]},
			},
			{
				Name:    "domain_created_at",
				Unique:  false,
				Columns: []*schema.Column{DomainsColumns[2]},
			},
			{
				Name:    "domain_updated_at",
				Unique:  false,
				Columns: []*schema.Column{DomainsColumns[4]},
			},
			{
				Name:    "domain_published_at",
				Unique:  false,
				Columns: []*schema.Column{DomainsColumns[7]},
			},
			{
				Name:    "domain_type_code_key",
				Unique:  true,
				Columns: []*schema.Column{DomainsColumns[9], DomainsColumns[10]},
			},
			{
				Name:    "domain_status",
				Unique:  false,
				Columns: []*schema.Column{DomainsColumns[12]},
			},
			{
				Name:    "domain_type_code",
				Unique:  false,
				Columns: []*schema.Column{DomainsColumns[9]},
			},
		},
	}
	// DomainMembershipsColumns holds the columns for the "domain_memberships" table.
	DomainMembershipsColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "subject_type", Type: field.TypeEnum, Enums: []string{"user", "service_account"}, Default: "user"},
		{Name: "subject_id", Type: field.TypeUUID},
		{Name: "member_role", Type: field.TypeString, Size: 100, Default: "member"},
		{Name: "status", Type: field.TypeEnum, Enums: []string{"active", "inactive", "suspended"}, Default: "active"},
		{Name: "is_default", Type: field.TypeBool, Default: false},
		{Name: "domain_id", Type: field.TypeUUID},
	}
	// DomainMembershipsTable holds the schema information for the "domain_memberships" table.
	DomainMembershipsTable = &schema.Table{
		Name:       "domain_memberships",
		Columns:    DomainMembershipsColumns,
		PrimaryKey: []*schema.Column{DomainMembershipsColumns[0]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "domain_memberships_domains_memberships",
				Columns:    []*schema.Column{DomainMembershipsColumns[14]},
				RefColumns: []*schema.Column{DomainsColumns[0]},
				OnDelete:   schema.NoAction,
			},
		},
		Indexes: []*schema.Index{
			{
				Name:    "domainmembership_id",
				Unique:  false,
				Columns: []*schema.Column{DomainMembershipsColumns[0]},
			},
			{
				Name:    "domainmembership_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{DomainMembershipsColumns[6]},
			},
			{
				Name:    "domainmembership_created_at",
				Unique:  false,
				Columns: []*schema.Column{DomainMembershipsColumns[2]},
			},
			{
				Name:    "domainmembership_updated_at",
				Unique:  false,
				Columns: []*schema.Column{DomainMembershipsColumns[4]},
			},
			{
				Name:    "domainmembership_published_at",
				Unique:  false,
				Columns: []*schema.Column{DomainMembershipsColumns[7]},
			},
			{
				Name:    "domainmembership_domain_id_subject_type_subject_id",
				Unique:  true,
				Columns: []*schema.Column{DomainMembershipsColumns[14], DomainMembershipsColumns[9], DomainMembershipsColumns[10]},
			},
			{
				Name:    "domainmembership_subject_type_subject_id",
				Unique:  false,
				Columns: []*schema.Column{DomainMembershipsColumns[9], DomainMembershipsColumns[10]},
			},
			{
				Name:    "domainmembership_subject_id_is_default",
				Unique:  false,
				Columns: []*schema.Column{DomainMembershipsColumns[10], DomainMembershipsColumns[13]},
			},
			{
				Name:    "domainmembership_status",
				Unique:  false,
				Columns: []*schema.Column{DomainMembershipsColumns[12]},
			},
		},
	}
	// DomainRelationsColumns holds the columns for the "domain_relations" table.
	DomainRelationsColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "parent_domain_id", Type: field.TypeUUID},
		{Name: "child_domain_id", Type: field.TypeUUID},
		{Name: "relation_type", Type: field.TypeEnum, Enums: []string{"contains", "delegates", "inherits"}, Default: "contains"},
	}
	// DomainRelationsTable holds the schema information for the "domain_relations" table.
	DomainRelationsTable = &schema.Table{
		Name:       "domain_relations",
		Columns:    DomainRelationsColumns,
		PrimaryKey: []*schema.Column{DomainRelationsColumns[0]},
		Indexes: []*schema.Index{
			{
				Name:    "domainrelation_id",
				Unique:  false,
				Columns: []*schema.Column{DomainRelationsColumns[0]},
			},
			{
				Name:    "domainrelation_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{DomainRelationsColumns[6]},
			},
			{
				Name:    "domainrelation_created_at",
				Unique:  false,
				Columns: []*schema.Column{DomainRelationsColumns[2]},
			},
			{
				Name:    "domainrelation_updated_at",
				Unique:  false,
				Columns: []*schema.Column{DomainRelationsColumns[4]},
			},
			{
				Name:    "domainrelation_published_at",
				Unique:  false,
				Columns: []*schema.Column{DomainRelationsColumns[7]},
			},
			{
				Name:    "domainrelation_parent_domain_id_child_domain_id_relation_type",
				Unique:  true,
				Columns: []*schema.Column{DomainRelationsColumns[9], DomainRelationsColumns[10], DomainRelationsColumns[11]},
			},
			{
				Name:    "domainrelation_parent_domain_id",
				Unique:  false,
				Columns: []*schema.Column{DomainRelationsColumns[9]},
			},
			{
				Name:    "domainrelation_child_domain_id",
				Unique:  false,
				Columns: []*schema.Column{DomainRelationsColumns[10]},
			},
		},
	}
	// DomainTypesColumns holds the columns for the "domain_types" table.
	DomainTypesColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "code", Type: field.TypeString, Unique: true, Size: 50},
		{Name: "plugin_name", Type: field.TypeString, Nullable: true, Size: 100},
		{Name: "display_name", Type: field.TypeString, Size: 200},
		{Name: "status", Type: field.TypeEnum, Enums: []string{"active", "inactive"}, Default: "active"},
	}
	// DomainTypesTable holds the schema information for the "domain_types" table.
	DomainTypesTable = &schema.Table{
		Name:       "domain_types",
		Columns:    DomainTypesColumns,
		PrimaryKey: []*schema.Column{DomainTypesColumns[0]},
		Indexes: []*schema.Index{
			{
				Name:    "domaintype_id",
				Unique:  false,
				Columns: []*schema.Column{DomainTypesColumns[0]},
			},
			{
				Name:    "domaintype_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{DomainTypesColumns[6]},
			},
			{
				Name:    "domaintype_created_at",
				Unique:  false,
				Columns: []*schema.Column{DomainTypesColumns[2]},
			},
			{
				Name:    "domaintype_updated_at",
				Unique:  false,
				Columns: []*schema.Column{DomainTypesColumns[4]},
			},
			{
				Name:    "domaintype_published_at",
				Unique:  false,
				Columns: []*schema.Column{DomainTypesColumns[7]},
			},
			{
				Name:    "domaintype_code",
				Unique:  true,
				Columns: []*schema.Column{DomainTypesColumns[9]},
			},
			{
				Name:    "domaintype_status",
				Unique:  false,
				Columns: []*schema.Column{DomainTypesColumns[12]},
			},
		},
	}
	// InvitationTokensColumns holds the columns for the "invitation_tokens" table.
	InvitationTokensColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "tenant_id", Type: field.TypeUUID},
		{Name: "jti", Type: field.TypeString, Unique: true},
		{Name: "token", Type: field.TypeString, Unique: true},
		{Name: "token_hash", Type: field.TypeString, Unique: true},
		{Name: "email", Type: field.TypeString},
		{Name: "domain_type", Type: field.TypeString},
		{Name: "domain_key", Type: field.TypeString},
		{Name: "role_ids", Type: field.TypeJSON, Nullable: true},
		{Name: "expires_at", Type: field.TypeTime},
		{Name: "used_at", Type: field.TypeTime, Nullable: true},
		{Name: "is_used", Type: field.TypeBool, Default: false},
		{Name: "status", Type: field.TypeString, Default: "pending"},
		{Name: "invitation_token_user", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// InvitationTokensTable holds the schema information for the "invitation_tokens" table.
	InvitationTokensTable = &schema.Table{
		Name:       "invitation_tokens",
		Columns:    InvitationTokensColumns,
		PrimaryKey: []*schema.Column{InvitationTokensColumns[0]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "invitation_tokens_users_user",
				Columns:    []*schema.Column{InvitationTokensColumns[21]},
				RefColumns: []*schema.Column{UsersColumns[0]},
				OnDelete:   schema.SetNull,
			},
		},
		Indexes: []*schema.Index{
			{
				Name:    "invitationtoken_id",
				Unique:  false,
				Columns: []*schema.Column{InvitationTokensColumns[0]},
			},
			{
				Name:    "invitationtoken_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{InvitationTokensColumns[6]},
			},
			{
				Name:    "invitationtoken_created_at",
				Unique:  false,
				Columns: []*schema.Column{InvitationTokensColumns[2]},
			},
			{
				Name:    "invitationtoken_updated_at",
				Unique:  false,
				Columns: []*schema.Column{InvitationTokensColumns[4]},
			},
			{
				Name:    "invitationtoken_published_at",
				Unique:  false,
				Columns: []*schema.Column{InvitationTokensColumns[7]},
			},
			{
				Name:    "invitationtoken_jti",
				Unique:  true,
				Columns: []*schema.Column{InvitationTokensColumns[10]},
			},
			{
				Name:    "invitationtoken_token",
				Unique:  true,
				Columns: []*schema.Column{InvitationTokensColumns[11]},
			},
			{
				Name:    "invitationtoken_token_hash",
				Unique:  true,
				Columns: []*schema.Column{InvitationTokensColumns[12]},
			},
			{
				Name:    "invitationtoken_tenant_id",
				Unique:  false,
				Columns: []*schema.Column{InvitationTokensColumns[9]},
			},
			{
				Name:    "invitationtoken_domain_type_domain_key",
				Unique:  false,
				Columns: []*schema.Column{InvitationTokensColumns[14], InvitationTokensColumns[15]},
			},
			{
				Name:    "invitationtoken_email",
				Unique:  false,
				Columns: []*schema.Column{InvitationTokensColumns[13]},
			},
			{
				Name:    "invitationtoken_expires_at",
				Unique:  false,
				Columns: []*schema.Column{InvitationTokensColumns[17]},
			},
		},
	}
	// MediaColumns holds the columns for the "media" table.
	MediaColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "owner_domain_id", Type: field.TypeUUID, Nullable: true},
		{Name: "name", Type: field.TypeString},
		{Name: "alternative_text", Type: field.TypeString, Nullable: true},
		{Name: "caption", Type: field.TypeString, Nullable: true},
		{Name: "width", Type: field.TypeInt, Nullable: true},
		{Name: "height", Type: field.TypeInt, Nullable: true},
		{Name: "hash", Type: field.TypeString, Nullable: true},
		{Name: "ext", Type: field.TypeString, Nullable: true},
		{Name: "mime", Type: field.TypeString, Nullable: true},
		{Name: "size", Type: field.TypeFloat64, Nullable: true},
		{Name: "url", Type: field.TypeString},
		{Name: "preview_url", Type: field.TypeString, Nullable: true},
		{Name: "provider", Type: field.TypeString, Nullable: true},
		{Name: "provider_metadata", Type: field.TypeJSON, Nullable: true},
		{Name: "folder_path", Type: field.TypeString, Nullable: true},
		{Name: "locale", Type: field.TypeString, Nullable: true},
		{Name: "is_url_signed", Type: field.TypeBool, Nullable: true},
		{Name: "alias", Type: field.TypeString, Nullable: true},
		{Name: "folder_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "owner_id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// MediaTable holds the schema information for the "media" table.
	MediaTable = &schema.Table{
		Name:       "media",
		Columns:    MediaColumns,
		PrimaryKey: []*schema.Column{MediaColumns[0]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "media_media_folders_files",
				Columns:    []*schema.Column{MediaColumns[27]},
				RefColumns: []*schema.Column{MediaFoldersColumns[0]},
				OnDelete:   schema.SetNull,
			},
			{
				Symbol:     "media_users_media",
				Columns:    []*schema.Column{MediaColumns[28]},
				RefColumns: []*schema.Column{UsersColumns[0]},
				OnDelete:   schema.NoAction,
			},
		},
		Indexes: []*schema.Index{
			{
				Name:    "media_id",
				Unique:  false,
				Columns: []*schema.Column{MediaColumns[0]},
			},
			{
				Name:    "media_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{MediaColumns[6]},
			},
			{
				Name:    "media_created_at",
				Unique:  false,
				Columns: []*schema.Column{MediaColumns[2]},
			},
			{
				Name:    "media_updated_at",
				Unique:  false,
				Columns: []*schema.Column{MediaColumns[4]},
			},
			{
				Name:    "media_published_at",
				Unique:  false,
				Columns: []*schema.Column{MediaColumns[7]},
			},
			{
				Name:    "media_owner_domain_id",
				Unique:  false,
				Columns: []*schema.Column{MediaColumns[9]},
			},
			{
				Name:    "media_hash",
				Unique:  false,
				Columns: []*schema.Column{MediaColumns[15]},
			},
			{
				Name:    "media_folder_path",
				Unique:  false,
				Columns: []*schema.Column{MediaColumns[23]},
			},
			{
				Name:    "media_owner_domain_id_alias",
				Unique:  true,
				Columns: []*schema.Column{MediaColumns[9], MediaColumns[26]},
			},
			{
				Name:    "media_owner_domain_id_folder_id_created_at",
				Unique:  false,
				Columns: []*schema.Column{MediaColumns[9], MediaColumns[27], MediaColumns[2]},
			},
		},
	}
	// MediaFoldersColumns holds the columns for the "media_folders" table.
	MediaFoldersColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "owner_domain_id", Type: field.TypeUUID, Nullable: true},
		{Name: "name", Type: field.TypeString},
		{Name: "path", Type: field.TypeString},
		{Name: "depth", Type: field.TypeInt, Default: 0},
		{Name: "parent_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// MediaFoldersTable holds the schema information for the "media_folders" table.
	MediaFoldersTable = &schema.Table{
		Name:       "media_folders",
		Columns:    MediaFoldersColumns,
		PrimaryKey: []*schema.Column{MediaFoldersColumns[0]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "media_folders_media_folders_children",
				Columns:    []*schema.Column{MediaFoldersColumns[13]},
				RefColumns: []*schema.Column{MediaFoldersColumns[0]},
				OnDelete:   schema.SetNull,
			},
		},
		Indexes: []*schema.Index{
			{
				Name:    "mediafolder_id",
				Unique:  false,
				Columns: []*schema.Column{MediaFoldersColumns[0]},
			},
			{
				Name:    "mediafolder_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{MediaFoldersColumns[6]},
			},
			{
				Name:    "mediafolder_created_at",
				Unique:  false,
				Columns: []*schema.Column{MediaFoldersColumns[2]},
			},
			{
				Name:    "mediafolder_updated_at",
				Unique:  false,
				Columns: []*schema.Column{MediaFoldersColumns[4]},
			},
			{
				Name:    "mediafolder_published_at",
				Unique:  false,
				Columns: []*schema.Column{MediaFoldersColumns[7]},
			},
			{
				Name:    "mediafolder_owner_domain_id",
				Unique:  false,
				Columns: []*schema.Column{MediaFoldersColumns[9]},
			},
			{
				Name:    "mediafolder_owner_domain_id_path",
				Unique:  true,
				Columns: []*schema.Column{MediaFoldersColumns[9], MediaFoldersColumns[11]},
			},
			{
				Name:    "mediafolder_owner_domain_id_parent_id_name",
				Unique:  true,
				Columns: []*schema.Column{MediaFoldersColumns[9], MediaFoldersColumns[13], MediaFoldersColumns[10]},
			},
			{
				Name:    "mediafolder_owner_domain_id_parent_id",
				Unique:  false,
				Columns: []*schema.Column{MediaFoldersColumns[9], MediaFoldersColumns[13]},
			},
		},
	}
	// MediaFormatsColumns holds the columns for the "media_formats" table.
	MediaFormatsColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "owner_domain_id", Type: field.TypeUUID, Nullable: true},
		{Name: "name", Type: field.TypeString},
		{Name: "ext", Type: field.TypeString, Nullable: true},
		{Name: "url", Type: field.TypeString},
		{Name: "hash", Type: field.TypeString, Nullable: true},
		{Name: "mime", Type: field.TypeString, Nullable: true},
		{Name: "size", Type: field.TypeFloat64, Nullable: true},
		{Name: "size_in_bytes", Type: field.TypeInt64, Nullable: true},
		{Name: "width", Type: field.TypeInt, Nullable: true},
		{Name: "height", Type: field.TypeInt, Nullable: true},
		{Name: "provider_metadata", Type: field.TypeJSON, Nullable: true},
		{Name: "path", Type: field.TypeString, Nullable: true},
		{Name: "is_url_signed", Type: field.TypeBool, Nullable: true},
		{Name: "media_id", Type: field.TypeUUID},
	}
	// MediaFormatsTable holds the schema information for the "media_formats" table.
	MediaFormatsTable = &schema.Table{
		Name:       "media_formats",
		Columns:    MediaFormatsColumns,
		PrimaryKey: []*schema.Column{MediaFormatsColumns[0]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "media_formats_media_formats",
				Columns:    []*schema.Column{MediaFormatsColumns[22]},
				RefColumns: []*schema.Column{MediaColumns[0]},
				OnDelete:   schema.NoAction,
			},
		},
		Indexes: []*schema.Index{
			{
				Name:    "mediaformat_id",
				Unique:  false,
				Columns: []*schema.Column{MediaFormatsColumns[0]},
			},
			{
				Name:    "mediaformat_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{MediaFormatsColumns[6]},
			},
			{
				Name:    "mediaformat_created_at",
				Unique:  false,
				Columns: []*schema.Column{MediaFormatsColumns[2]},
			},
			{
				Name:    "mediaformat_updated_at",
				Unique:  false,
				Columns: []*schema.Column{MediaFormatsColumns[4]},
			},
			{
				Name:    "mediaformat_published_at",
				Unique:  false,
				Columns: []*schema.Column{MediaFormatsColumns[7]},
			},
			{
				Name:    "mediaformat_owner_domain_id",
				Unique:  false,
				Columns: []*schema.Column{MediaFormatsColumns[9]},
			},
			{
				Name:    "mediaformat_media_id_hash",
				Unique:  true,
				Columns: []*schema.Column{MediaFormatsColumns[22], MediaFormatsColumns[13]},
			},
			{
				Name:    "mediaformat_name",
				Unique:  false,
				Columns: []*schema.Column{MediaFormatsColumns[10]},
			},
		},
	}
	// MenusColumns holds the columns for the "menus" table.
	MenusColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "owner_domain_id", Type: field.TypeUUID, Nullable: true},
		{Name: "path", Type: field.TypeString},
		{Name: "name", Type: field.TypeString},
		{Name: "component", Type: field.TypeString, Nullable: true},
		{Name: "redirect", Type: field.TypeString, Nullable: true},
		{Name: "hidden", Type: field.TypeBool, Default: false},
		{Name: "affix", Type: field.TypeBool, Default: false},
		{Name: "icon", Type: field.TypeString, Nullable: true},
		{Name: "sort", Type: field.TypeInt, Default: 0},
		{Name: "meta", Type: field.TypeJSON, Nullable: true},
		{Name: "params", Type: field.TypeJSON, Nullable: true},
		{Name: "parent_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// MenusTable holds the schema information for the "menus" table.
	MenusTable = &schema.Table{
		Name:       "menus",
		Columns:    MenusColumns,
		PrimaryKey: []*schema.Column{MenusColumns[0]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "menus_menus_children",
				Columns:    []*schema.Column{MenusColumns[20]},
				RefColumns: []*schema.Column{MenusColumns[0]},
				OnDelete:   schema.SetNull,
			},
		},
		Indexes: []*schema.Index{
			{
				Name:    "menu_id",
				Unique:  false,
				Columns: []*schema.Column{MenusColumns[0]},
			},
			{
				Name:    "menu_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{MenusColumns[6]},
			},
			{
				Name:    "menu_created_at",
				Unique:  false,
				Columns: []*schema.Column{MenusColumns[2]},
			},
			{
				Name:    "menu_updated_at",
				Unique:  false,
				Columns: []*schema.Column{MenusColumns[4]},
			},
			{
				Name:    "menu_published_at",
				Unique:  false,
				Columns: []*schema.Column{MenusColumns[7]},
			},
			{
				Name:    "menu_owner_domain_id",
				Unique:  false,
				Columns: []*schema.Column{MenusColumns[9]},
			},
		},
	}
	// OperationLogsColumns holds the columns for the "operation_logs" table.
	OperationLogsColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "owner_domain_id", Type: field.TypeUUID, Nullable: true},
		{Name: "request_id", Type: field.TypeString, Nullable: true},
		{Name: "method", Type: field.TypeString},
		{Name: "path", Type: field.TypeString},
		{Name: "query_params", Type: field.TypeString, Nullable: true},
		{Name: "body", Type: field.TypeString, Nullable: true},
		{Name: "status", Type: field.TypeInt},
		{Name: "latency", Type: field.TypeInt64},
		{Name: "client_ip", Type: field.TypeString},
		{Name: "user_agent", Type: field.TypeString, Nullable: true},
		{Name: "error_message", Type: field.TypeString, Nullable: true},
		{Name: "user_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// OperationLogsTable holds the schema information for the "operation_logs" table.
	OperationLogsTable = &schema.Table{
		Name:       "operation_logs",
		Columns:    OperationLogsColumns,
		PrimaryKey: []*schema.Column{OperationLogsColumns[0]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "operation_logs_users_operation_logs",
				Columns:    []*schema.Column{OperationLogsColumns[20]},
				RefColumns: []*schema.Column{UsersColumns[0]},
				OnDelete:   schema.SetNull,
			},
		},
		Indexes: []*schema.Index{
			{
				Name:    "operationlog_id",
				Unique:  false,
				Columns: []*schema.Column{OperationLogsColumns[0]},
			},
			{
				Name:    "operationlog_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{OperationLogsColumns[6]},
			},
			{
				Name:    "operationlog_created_at",
				Unique:  false,
				Columns: []*schema.Column{OperationLogsColumns[2]},
			},
			{
				Name:    "operationlog_updated_at",
				Unique:  false,
				Columns: []*schema.Column{OperationLogsColumns[4]},
			},
			{
				Name:    "operationlog_published_at",
				Unique:  false,
				Columns: []*schema.Column{OperationLogsColumns[7]},
			},
			{
				Name:    "operationlog_owner_domain_id",
				Unique:  false,
				Columns: []*schema.Column{OperationLogsColumns[9]},
			},
			{
				Name:    "operationlog_request_id",
				Unique:  false,
				Columns: []*schema.Column{OperationLogsColumns[10]},
			},
			{
				Name:    "operationlog_user_id",
				Unique:  false,
				Columns: []*schema.Column{OperationLogsColumns[20]},
			},
			{
				Name:    "operationlog_status",
				Unique:  false,
				Columns: []*schema.Column{OperationLogsColumns[15]},
			},
			{
				Name:    "operationlog_path",
				Unique:  false,
				Columns: []*schema.Column{OperationLogsColumns[12]},
			},
			{
				Name:    "operationlog_method",
				Unique:  false,
				Columns: []*schema.Column{OperationLogsColumns[11]},
			},
		},
	}
	// OrganizationsColumns holds the columns for the "organizations" table.
	OrganizationsColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "domain_id", Type: field.TypeUUID},
		{Name: "code", Type: field.TypeString},
		{Name: "name", Type: field.TypeString},
		{Name: "path", Type: field.TypeString},
		{Name: "parent_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// OrganizationsTable holds the schema information for the "organizations" table.
	OrganizationsTable = &schema.Table{
		Name:       "organizations",
		Columns:    OrganizationsColumns,
		PrimaryKey: []*schema.Column{OrganizationsColumns[0]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "organizations_organizations_children",
				Columns:    []*schema.Column{OrganizationsColumns[13]},
				RefColumns: []*schema.Column{OrganizationsColumns[0]},
				OnDelete:   schema.SetNull,
			},
		},
		Indexes: []*schema.Index{
			{
				Name:    "organization_id",
				Unique:  false,
				Columns: []*schema.Column{OrganizationsColumns[0]},
			},
			{
				Name:    "organization_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{OrganizationsColumns[6]},
			},
			{
				Name:    "organization_created_at",
				Unique:  false,
				Columns: []*schema.Column{OrganizationsColumns[2]},
			},
			{
				Name:    "organization_updated_at",
				Unique:  false,
				Columns: []*schema.Column{OrganizationsColumns[4]},
			},
			{
				Name:    "organization_published_at",
				Unique:  false,
				Columns: []*schema.Column{OrganizationsColumns[7]},
			},
			{
				Name:    "organization_domain_id_code",
				Unique:  true,
				Columns: []*schema.Column{OrganizationsColumns[9], OrganizationsColumns[10]},
			},
			{
				Name:    "organization_domain_id_path",
				Unique:  false,
				Columns: []*schema.Column{OrganizationsColumns[9], OrganizationsColumns[12]},
			},
			{
				Name:    "organization_domain_id_parent_id",
				Unique:  false,
				Columns: []*schema.Column{OrganizationsColumns[9], OrganizationsColumns[13]},
			},
		},
	}
	// OrganizationMembersColumns holds the columns for the "organization_members" table.
	OrganizationMembersColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "domain_id", Type: field.TypeUUID},
		{Name: "is_primary", Type: field.TypeBool, Default: false},
		{Name: "organization_members", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "organization_id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "user_id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// OrganizationMembersTable holds the schema information for the "organization_members" table.
	OrganizationMembersTable = &schema.Table{
		Name:       "organization_members",
		Columns:    OrganizationMembersColumns,
		PrimaryKey: []*schema.Column{OrganizationMembersColumns[0]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "organization_members_organizations_members",
				Columns:    []*schema.Column{OrganizationMembersColumns[11]},
				RefColumns: []*schema.Column{OrganizationsColumns[0]},
				OnDelete:   schema.SetNull,
			},
			{
				Symbol:     "organization_members_organizations_organization",
				Columns:    []*schema.Column{OrganizationMembersColumns[12]},
				RefColumns: []*schema.Column{OrganizationsColumns[0]},
				OnDelete:   schema.NoAction,
			},
			{
				Symbol:     "organization_members_users_user",
				Columns:    []*schema.Column{OrganizationMembersColumns[13]},
				RefColumns: []*schema.Column{UsersColumns[0]},
				OnDelete:   schema.NoAction,
			},
		},
		Indexes: []*schema.Index{
			{
				Name:    "organizationmember_id",
				Unique:  false,
				Columns: []*schema.Column{OrganizationMembersColumns[0]},
			},
			{
				Name:    "organizationmember_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{OrganizationMembersColumns[6]},
			},
			{
				Name:    "organizationmember_created_at",
				Unique:  false,
				Columns: []*schema.Column{OrganizationMembersColumns[2]},
			},
			{
				Name:    "organizationmember_updated_at",
				Unique:  false,
				Columns: []*schema.Column{OrganizationMembersColumns[4]},
			},
			{
				Name:    "organizationmember_published_at",
				Unique:  false,
				Columns: []*schema.Column{OrganizationMembersColumns[7]},
			},
			{
				Name:    "organizationmember_domain_id_organization_id_user_id",
				Unique:  true,
				Columns: []*schema.Column{OrganizationMembersColumns[9], OrganizationMembersColumns[12], OrganizationMembersColumns[13]},
			},
			{
				Name:    "organizationmember_domain_id_organization_id",
				Unique:  false,
				Columns: []*schema.Column{OrganizationMembersColumns[9], OrganizationMembersColumns[12]},
			},
			{
				Name:    "organizationmember_domain_id_user_id",
				Unique:  false,
				Columns: []*schema.Column{OrganizationMembersColumns[9], OrganizationMembersColumns[13]},
			},
		},
	}
	// PasswordResetTokensColumns holds the columns for the "password_reset_tokens" table.
	PasswordResetTokensColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "jti", Type: field.TypeString, Unique: true},
		{Name: "token", Type: field.TypeString, Unique: true},
		{Name: "token_hash", Type: field.TypeString, Unique: true},
		{Name: "email", Type: field.TypeString},
		{Name: "expires_at", Type: field.TypeTime},
		{Name: "used_at", Type: field.TypeTime, Nullable: true},
		{Name: "is_used", Type: field.TypeBool, Default: false},
		{Name: "status", Type: field.TypeString, Default: "pending"},
		{Name: "password_reset_token_user", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// PasswordResetTokensTable holds the schema information for the "password_reset_tokens" table.
	PasswordResetTokensTable = &schema.Table{
		Name:       "password_reset_tokens",
		Columns:    PasswordResetTokensColumns,
		PrimaryKey: []*schema.Column{PasswordResetTokensColumns[0]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "password_reset_tokens_users_user",
				Columns:    []*schema.Column{PasswordResetTokensColumns[17]},
				RefColumns: []*schema.Column{UsersColumns[0]},
				OnDelete:   schema.SetNull,
			},
		},
		Indexes: []*schema.Index{
			{
				Name:    "passwordresettoken_id",
				Unique:  false,
				Columns: []*schema.Column{PasswordResetTokensColumns[0]},
			},
			{
				Name:    "passwordresettoken_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{PasswordResetTokensColumns[6]},
			},
			{
				Name:    "passwordresettoken_created_at",
				Unique:  false,
				Columns: []*schema.Column{PasswordResetTokensColumns[2]},
			},
			{
				Name:    "passwordresettoken_updated_at",
				Unique:  false,
				Columns: []*schema.Column{PasswordResetTokensColumns[4]},
			},
			{
				Name:    "passwordresettoken_published_at",
				Unique:  false,
				Columns: []*schema.Column{PasswordResetTokensColumns[7]},
			},
			{
				Name:    "passwordresettoken_jti",
				Unique:  true,
				Columns: []*schema.Column{PasswordResetTokensColumns[9]},
			},
			{
				Name:    "passwordresettoken_token",
				Unique:  true,
				Columns: []*schema.Column{PasswordResetTokensColumns[10]},
			},
			{
				Name:    "passwordresettoken_token_hash",
				Unique:  true,
				Columns: []*schema.Column{PasswordResetTokensColumns[11]},
			},
			{
				Name:    "passwordresettoken_email",
				Unique:  false,
				Columns: []*schema.Column{PasswordResetTokensColumns[12]},
			},
			{
				Name:    "passwordresettoken_expires_at",
				Unique:  false,
				Columns: []*schema.Column{PasswordResetTokensColumns[13]},
			},
			{
				Name:    "passwordresettoken_status",
				Unique:  false,
				Columns: []*schema.Column{PasswordResetTokensColumns[16]},
			},
		},
	}
	// PermissionsColumns holds the columns for the "permissions" table.
	PermissionsColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "code", Type: field.TypeString, Unique: true},
		{Name: "name", Type: field.TypeString, Nullable: true},
		{Name: "description", Type: field.TypeString, Nullable: true},
		{Name: "scope", Type: field.TypeEnum, Enums: []string{"api", "ui", "data"}, Default: "api"},
		{Name: "status", Type: field.TypeEnum, Enums: []string{"active", "deprecated"}, Default: "active"},
	}
	// PermissionsTable holds the schema information for the "permissions" table.
	PermissionsTable = &schema.Table{
		Name:       "permissions",
		Columns:    PermissionsColumns,
		PrimaryKey: []*schema.Column{PermissionsColumns[0]},
		Indexes: []*schema.Index{
			{
				Name:    "permission_id",
				Unique:  false,
				Columns: []*schema.Column{PermissionsColumns[0]},
			},
			{
				Name:    "permission_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{PermissionsColumns[6]},
			},
			{
				Name:    "permission_created_at",
				Unique:  false,
				Columns: []*schema.Column{PermissionsColumns[2]},
			},
			{
				Name:    "permission_updated_at",
				Unique:  false,
				Columns: []*schema.Column{PermissionsColumns[4]},
			},
			{
				Name:    "permission_published_at",
				Unique:  false,
				Columns: []*schema.Column{PermissionsColumns[7]},
			},
			{
				Name:    "permission_scope",
				Unique:  false,
				Columns: []*schema.Column{PermissionsColumns[12]},
			},
			{
				Name:    "permission_status",
				Unique:  false,
				Columns: []*schema.Column{PermissionsColumns[13]},
			},
		},
	}
	// PostsColumns holds the columns for the "posts" table.
	PostsColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "owner_domain_id", Type: field.TypeUUID, Nullable: true},
		{Name: "title", Type: field.TypeString},
		{Name: "content", Type: field.TypeString, Size: 2147483647},
		{Name: "slug", Type: field.TypeString},
		{Name: "status", Type: field.TypeEnum, Enums: []string{"draft", "published", "archived"}, Default: "draft"},
		{Name: "view_count", Type: field.TypeInt, Default: 0},
		{Name: "tags", Type: field.TypeJSON, Nullable: true},
	}
	// PostsTable holds the schema information for the "posts" table.
	PostsTable = &schema.Table{
		Name:       "posts",
		Columns:    PostsColumns,
		PrimaryKey: []*schema.Column{PostsColumns[0]},
		Indexes: []*schema.Index{
			{
				Name:    "post_id",
				Unique:  false,
				Columns: []*schema.Column{PostsColumns[0]},
			},
			{
				Name:    "post_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{PostsColumns[6]},
			},
			{
				Name:    "post_created_at",
				Unique:  false,
				Columns: []*schema.Column{PostsColumns[2]},
			},
			{
				Name:    "post_updated_at",
				Unique:  false,
				Columns: []*schema.Column{PostsColumns[4]},
			},
			{
				Name:    "post_published_at",
				Unique:  false,
				Columns: []*schema.Column{PostsColumns[7]},
			},
			{
				Name:    "post_owner_domain_id",
				Unique:  false,
				Columns: []*schema.Column{PostsColumns[9]},
			},
			{
				Name:    "post_owner_domain_id_slug",
				Unique:  true,
				Columns: []*schema.Column{PostsColumns[9], PostsColumns[12]},
			},
			{
				Name:    "post_status_published_at",
				Unique:  false,
				Columns: []*schema.Column{PostsColumns[13], PostsColumns[7]},
			},
		},
	}
	// ResourceDomainBindingsColumns holds the columns for the "resource_domain_bindings" table.
	ResourceDomainBindingsColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "resource_type", Type: field.TypeString, Size: 100},
		{Name: "resource_id", Type: field.TypeUUID},
		{Name: "access_level", Type: field.TypeEnum, Enums: []string{"read", "fork", "sync", "manage"}, Default: "read"},
		{Name: "status", Type: field.TypeEnum, Enums: []string{"active", "inactive"}, Default: "active"},
		{Name: "domain_id", Type: field.TypeUUID},
	}
	// ResourceDomainBindingsTable holds the schema information for the "resource_domain_bindings" table.
	ResourceDomainBindingsTable = &schema.Table{
		Name:       "resource_domain_bindings",
		Columns:    ResourceDomainBindingsColumns,
		PrimaryKey: []*schema.Column{ResourceDomainBindingsColumns[0]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "resource_domain_bindings_domains_bindings",
				Columns:    []*schema.Column{ResourceDomainBindingsColumns[13]},
				RefColumns: []*schema.Column{DomainsColumns[0]},
				OnDelete:   schema.NoAction,
			},
		},
		Indexes: []*schema.Index{
			{
				Name:    "resourcedomainbinding_id",
				Unique:  false,
				Columns: []*schema.Column{ResourceDomainBindingsColumns[0]},
			},
			{
				Name:    "resourcedomainbinding_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{ResourceDomainBindingsColumns[6]},
			},
			{
				Name:    "resourcedomainbinding_created_at",
				Unique:  false,
				Columns: []*schema.Column{ResourceDomainBindingsColumns[2]},
			},
			{
				Name:    "resourcedomainbinding_updated_at",
				Unique:  false,
				Columns: []*schema.Column{ResourceDomainBindingsColumns[4]},
			},
			{
				Name:    "resourcedomainbinding_published_at",
				Unique:  false,
				Columns: []*schema.Column{ResourceDomainBindingsColumns[7]},
			},
			{
				Name:    "resourcedomainbinding_resource_type_resource_id_domain_id",
				Unique:  true,
				Columns: []*schema.Column{ResourceDomainBindingsColumns[9], ResourceDomainBindingsColumns[10], ResourceDomainBindingsColumns[13]},
			},
			{
				Name:    "resourcedomainbinding_domain_id",
				Unique:  false,
				Columns: []*schema.Column{ResourceDomainBindingsColumns[13]},
			},
			{
				Name:    "resourcedomainbinding_resource_type_resource_id",
				Unique:  false,
				Columns: []*schema.Column{ResourceDomainBindingsColumns[9], ResourceDomainBindingsColumns[10]},
			},
			{
				Name:    "resourcedomainbinding_status",
				Unique:  false,
				Columns: []*schema.Column{ResourceDomainBindingsColumns[12]},
			},
		},
	}
	// RolesColumns holds the columns for the "roles" table.
	RolesColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "owner_domain_id", Type: field.TypeUUID, Nullable: true},
		{Name: "name", Type: field.TypeString},
		{Name: "code", Type: field.TypeString, Size: 50},
		{Name: "description", Type: field.TypeString, Nullable: true},
		{Name: "sort", Type: field.TypeInt, Default: 0},
		{Name: "is_system", Type: field.TypeBool, Default: false},
		{Name: "permissions", Type: field.TypeJSON},
		{Name: "default_data_scope", Type: field.TypeString, Default: "SELF"},
		{Name: "role_children", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// RolesTable holds the schema information for the "roles" table.
	RolesTable = &schema.Table{
		Name:       "roles",
		Columns:    RolesColumns,
		PrimaryKey: []*schema.Column{RolesColumns[0]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "roles_roles_children",
				Columns:    []*schema.Column{RolesColumns[17]},
				RefColumns: []*schema.Column{RolesColumns[0]},
				OnDelete:   schema.SetNull,
			},
		},
		Indexes: []*schema.Index{
			{
				Name:    "role_id",
				Unique:  false,
				Columns: []*schema.Column{RolesColumns[0]},
			},
			{
				Name:    "role_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{RolesColumns[6]},
			},
			{
				Name:    "role_created_at",
				Unique:  false,
				Columns: []*schema.Column{RolesColumns[2]},
			},
			{
				Name:    "role_updated_at",
				Unique:  false,
				Columns: []*schema.Column{RolesColumns[4]},
			},
			{
				Name:    "role_published_at",
				Unique:  false,
				Columns: []*schema.Column{RolesColumns[7]},
			},
			{
				Name:    "role_owner_domain_id",
				Unique:  false,
				Columns: []*schema.Column{RolesColumns[9]},
			},
			{
				Name:    "role_owner_domain_id_name",
				Unique:  true,
				Columns: []*schema.Column{RolesColumns[9], RolesColumns[10]},
			},
			{
				Name:    "role_owner_domain_id_code",
				Unique:  true,
				Columns: []*schema.Column{RolesColumns[9], RolesColumns[11]},
			},
			{
				Name:    "role_role_children",
				Unique:  false,
				Columns: []*schema.Column{RolesColumns[17]},
			},
		},
	}
	// RoleBindingsColumns holds the columns for the "role_bindings" table.
	RoleBindingsColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "owner_domain_id", Type: field.TypeUUID, Nullable: true},
		{Name: "subject_type", Type: field.TypeEnum, Enums: []string{"user", "service_account"}, Default: "user"},
		{Name: "subject_id", Type: field.TypeUUID},
		{Name: "role_code", Type: field.TypeString, Size: 100},
		{Name: "project_id", Type: field.TypeUUID, Nullable: true},
		{Name: "scope_type", Type: field.TypeEnum, Enums: []string{"CURRENT", "DESCENDANTS", "ASSIGNED_SET"}, Default: "CURRENT"},
		{Name: "scope_value", Type: field.TypeString, Nullable: true, Size: 500},
		{Name: "status", Type: field.TypeEnum, Enums: []string{"active", "inactive"}, Default: "active"},
	}
	// RoleBindingsTable holds the schema information for the "role_bindings" table.
	RoleBindingsTable = &schema.Table{
		Name:       "role_bindings",
		Columns:    RoleBindingsColumns,
		PrimaryKey: []*schema.Column{RoleBindingsColumns[0]},
		Indexes: []*schema.Index{
			{
				Name:    "rolebinding_id",
				Unique:  false,
				Columns: []*schema.Column{RoleBindingsColumns[0]},
			},
			{
				Name:    "rolebinding_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{RoleBindingsColumns[6]},
			},
			{
				Name:    "rolebinding_created_at",
				Unique:  false,
				Columns: []*schema.Column{RoleBindingsColumns[2]},
			},
			{
				Name:    "rolebinding_updated_at",
				Unique:  false,
				Columns: []*schema.Column{RoleBindingsColumns[4]},
			},
			{
				Name:    "rolebinding_published_at",
				Unique:  false,
				Columns: []*schema.Column{RoleBindingsColumns[7]},
			},
			{
				Name:    "rolebinding_owner_domain_id",
				Unique:  false,
				Columns: []*schema.Column{RoleBindingsColumns[9]},
			},
			{
				Name:    "rolebinding_owner_domain_id_subject_type_subject_id",
				Unique:  false,
				Columns: []*schema.Column{RoleBindingsColumns[9], RoleBindingsColumns[10], RoleBindingsColumns[11]},
			},
			{
				Name:    "rolebinding_owner_domain_id_role_code_status",
				Unique:  false,
				Columns: []*schema.Column{RoleBindingsColumns[9], RoleBindingsColumns[12], RoleBindingsColumns[16]},
			},
		},
	}
	// SessionsColumns holds the columns for the "sessions" table.
	SessionsColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "owner_domain_id", Type: field.TypeUUID, Nullable: true},
		{Name: "token_hash", Type: field.TypeString},
		{Name: "expires_at", Type: field.TypeTime},
		{Name: "ip_address", Type: field.TypeString, Nullable: true},
		{Name: "user_agent", Type: field.TypeString, Nullable: true},
		{Name: "is_revoked", Type: field.TypeBool, Default: false},
	}
	// SessionsTable holds the schema information for the "sessions" table.
	SessionsTable = &schema.Table{
		Name:       "sessions",
		Columns:    SessionsColumns,
		PrimaryKey: []*schema.Column{SessionsColumns[0]},
		Indexes: []*schema.Index{
			{
				Name:    "session_id",
				Unique:  false,
				Columns: []*schema.Column{SessionsColumns[0]},
			},
			{
				Name:    "session_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{SessionsColumns[6]},
			},
			{
				Name:    "session_created_at",
				Unique:  false,
				Columns: []*schema.Column{SessionsColumns[2]},
			},
			{
				Name:    "session_updated_at",
				Unique:  false,
				Columns: []*schema.Column{SessionsColumns[4]},
			},
			{
				Name:    "session_published_at",
				Unique:  false,
				Columns: []*schema.Column{SessionsColumns[7]},
			},
			{
				Name:    "session_owner_domain_id",
				Unique:  false,
				Columns: []*schema.Column{SessionsColumns[9]},
			},
			{
				Name:    "session_token_hash",
				Unique:  false,
				Columns: []*schema.Column{SessionsColumns[10]},
			},
			{
				Name:    "session_expires_at",
				Unique:  false,
				Columns: []*schema.Column{SessionsColumns[11]},
			},
			{
				Name:    "session_is_revoked",
				Unique:  false,
				Columns: []*schema.Column{SessionsColumns[14]},
			},
		},
	}
	// SystemConfigsColumns holds the columns for the "system_configs" table.
	SystemConfigsColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "key", Type: field.TypeString},
		{Name: "value", Type: field.TypeString, Size: 2147483647},
		{Name: "description", Type: field.TypeString, Nullable: true, Size: 2147483647},
	}
	// SystemConfigsTable holds the schema information for the "system_configs" table.
	SystemConfigsTable = &schema.Table{
		Name:       "system_configs",
		Columns:    SystemConfigsColumns,
		PrimaryKey: []*schema.Column{SystemConfigsColumns[0]},
		Indexes: []*schema.Index{
			{
				Name:    "systemconfig_id",
				Unique:  false,
				Columns: []*schema.Column{SystemConfigsColumns[0]},
			},
			{
				Name:    "systemconfig_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{SystemConfigsColumns[6]},
			},
			{
				Name:    "systemconfig_created_at",
				Unique:  false,
				Columns: []*schema.Column{SystemConfigsColumns[2]},
			},
			{
				Name:    "systemconfig_updated_at",
				Unique:  false,
				Columns: []*schema.Column{SystemConfigsColumns[4]},
			},
			{
				Name:    "systemconfig_published_at",
				Unique:  false,
				Columns: []*schema.Column{SystemConfigsColumns[7]},
			},
			{
				Name:    "systemconfig_key",
				Unique:  true,
				Columns: []*schema.Column{SystemConfigsColumns[9]},
			},
		},
	}
	// SystemErrorsColumns holds the columns for the "system_errors" table.
	SystemErrorsColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "owner_domain_id", Type: field.TypeUUID, Nullable: true},
		{Name: "error_level", Type: field.TypeEnum, Enums: []string{"info", "warning", "error", "critical"}, Default: "error"},
		{Name: "error_type", Type: field.TypeString},
		{Name: "error_msg", Type: field.TypeString},
		{Name: "error_stack", Type: field.TypeString, Nullable: true, Size: 2147483647},
		{Name: "error_code", Type: field.TypeString, Nullable: true},
		{Name: "request_id", Type: field.TypeString, Nullable: true},
		{Name: "request_method", Type: field.TypeString, Nullable: true},
		{Name: "request_path", Type: field.TypeString, Nullable: true},
		{Name: "request_body", Type: field.TypeString, Nullable: true},
		{Name: "response_body", Type: field.TypeString, Nullable: true},
		{Name: "user_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// SystemErrorsTable holds the schema information for the "system_errors" table.
	SystemErrorsTable = &schema.Table{
		Name:       "system_errors",
		Columns:    SystemErrorsColumns,
		PrimaryKey: []*schema.Column{SystemErrorsColumns[0]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "system_errors_users_system_errors",
				Columns:    []*schema.Column{SystemErrorsColumns[20]},
				RefColumns: []*schema.Column{UsersColumns[0]},
				OnDelete:   schema.SetNull,
			},
		},
		Indexes: []*schema.Index{
			{
				Name:    "systemerror_id",
				Unique:  false,
				Columns: []*schema.Column{SystemErrorsColumns[0]},
			},
			{
				Name:    "systemerror_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{SystemErrorsColumns[6]},
			},
			{
				Name:    "systemerror_created_at",
				Unique:  false,
				Columns: []*schema.Column{SystemErrorsColumns[2]},
			},
			{
				Name:    "systemerror_updated_at",
				Unique:  false,
				Columns: []*schema.Column{SystemErrorsColumns[4]},
			},
			{
				Name:    "systemerror_published_at",
				Unique:  false,
				Columns: []*schema.Column{SystemErrorsColumns[7]},
			},
			{
				Name:    "systemerror_owner_domain_id",
				Unique:  false,
				Columns: []*schema.Column{SystemErrorsColumns[9]},
			},
			{
				Name:    "systemerror_error_level",
				Unique:  false,
				Columns: []*schema.Column{SystemErrorsColumns[10]},
			},
			{
				Name:    "systemerror_error_type",
				Unique:  false,
				Columns: []*schema.Column{SystemErrorsColumns[11]},
			},
			{
				Name:    "systemerror_request_id",
				Unique:  false,
				Columns: []*schema.Column{SystemErrorsColumns[15]},
			},
		},
	}
	// TenantsColumns holds the columns for the "tenants" table.
	TenantsColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "code", Type: field.TypeString},
		{Name: "name", Type: field.TypeString},
		{Name: "description", Type: field.TypeString, Nullable: true},
		{Name: "status", Type: field.TypeEnum, Enums: []string{"active", "inactive"}, Default: "active"},
		{Name: "owner_id", Type: field.TypeUUID, Nullable: true},
		{Name: "parent_tenant_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// TenantsTable holds the schema information for the "tenants" table.
	TenantsTable = &schema.Table{
		Name:       "tenants",
		Columns:    TenantsColumns,
		PrimaryKey: []*schema.Column{TenantsColumns[0]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "tenants_tenants_children",
				Columns:    []*schema.Column{TenantsColumns[14]},
				RefColumns: []*schema.Column{TenantsColumns[0]},
				OnDelete:   schema.SetNull,
			},
		},
		Indexes: []*schema.Index{
			{
				Name:    "tenant_id",
				Unique:  false,
				Columns: []*schema.Column{TenantsColumns[0]},
			},
			{
				Name:    "tenant_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{TenantsColumns[6]},
			},
			{
				Name:    "tenant_created_at",
				Unique:  false,
				Columns: []*schema.Column{TenantsColumns[2]},
			},
			{
				Name:    "tenant_updated_at",
				Unique:  false,
				Columns: []*schema.Column{TenantsColumns[4]},
			},
			{
				Name:    "tenant_published_at",
				Unique:  false,
				Columns: []*schema.Column{TenantsColumns[7]},
			},
			{
				Name:    "tenant_code",
				Unique:  true,
				Columns: []*schema.Column{TenantsColumns[9]},
			},
			{
				Name:    "tenant_status",
				Unique:  false,
				Columns: []*schema.Column{TenantsColumns[12]},
			},
			{
				Name:    "tenant_parent_tenant_id",
				Unique:  false,
				Columns: []*schema.Column{TenantsColumns[14]},
			},
		},
	}
	// TenantUsersColumns holds the columns for the "tenant_users" table.
	TenantUsersColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "tenant_id", Type: field.TypeUUID},
		{Name: "role", Type: field.TypeString, Nullable: true},
		{Name: "status", Type: field.TypeEnum, Enums: []string{"active", "inactive"}, Default: "active"},
		{Name: "is_default", Type: field.TypeBool, Default: false},
		{Name: "user_id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// TenantUsersTable holds the schema information for the "tenant_users" table.
	TenantUsersTable = &schema.Table{
		Name:       "tenant_users",
		Columns:    TenantUsersColumns,
		PrimaryKey: []*schema.Column{TenantUsersColumns[0]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "tenant_users_users_user",
				Columns:    []*schema.Column{TenantUsersColumns[13]},
				RefColumns: []*schema.Column{UsersColumns[0]},
				OnDelete:   schema.NoAction,
			},
		},
		Indexes: []*schema.Index{
			{
				Name:    "tenantuser_id",
				Unique:  false,
				Columns: []*schema.Column{TenantUsersColumns[0]},
			},
			{
				Name:    "tenantuser_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{TenantUsersColumns[6]},
			},
			{
				Name:    "tenantuser_created_at",
				Unique:  false,
				Columns: []*schema.Column{TenantUsersColumns[2]},
			},
			{
				Name:    "tenantuser_updated_at",
				Unique:  false,
				Columns: []*schema.Column{TenantUsersColumns[4]},
			},
			{
				Name:    "tenantuser_published_at",
				Unique:  false,
				Columns: []*schema.Column{TenantUsersColumns[7]},
			},
			{
				Name:    "tenantuser_tenant_id_user_id",
				Unique:  true,
				Columns: []*schema.Column{TenantUsersColumns[9], TenantUsersColumns[13]},
			},
			{
				Name:    "tenantuser_user_id",
				Unique:  false,
				Columns: []*schema.Column{TenantUsersColumns[13]},
			},
		},
	}
	// UsersColumns holds the columns for the "users" table.
	UsersColumns = []*schema.Column{
		{Name: "id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "created_at", Type: field.TypeTime, Nullable: true},
		{Name: "updated_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
		{Name: "deleted_by_id", Type: field.TypeUUID, Nullable: true, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "deleted_at", Type: field.TypeTime, Nullable: true},
		{Name: "published_at", Type: field.TypeTime, Nullable: true},
		{Name: "archived_at", Type: field.TypeTime, Nullable: true},
		{Name: "owner_domain_id", Type: field.TypeUUID, Nullable: true},
		{Name: "username", Type: field.TypeString},
		{Name: "email", Type: field.TypeString},
		{Name: "password_hash", Type: field.TypeString, Nullable: true},
		{Name: "nickname", Type: field.TypeString, Default: "系统用户"},
		{Name: "phone", Type: field.TypeString, Nullable: true},
		{Name: "avatar", Type: field.TypeString, Nullable: true},
		{Name: "is_super_admin", Type: field.TypeBool, Default: false},
		{Name: "status", Type: field.TypeEnum, Enums: []string{"active", "inactive", "suspended"}, Default: "active"},
		{Name: "metadata", Type: field.TypeJSON, Nullable: true},
	}
	// UsersTable holds the schema information for the "users" table.
	UsersTable = &schema.Table{
		Name:       "users",
		Columns:    UsersColumns,
		PrimaryKey: []*schema.Column{UsersColumns[0]},
		Indexes: []*schema.Index{
			{
				Name:    "user_id",
				Unique:  false,
				Columns: []*schema.Column{UsersColumns[0]},
			},
			{
				Name:    "user_deleted_at",
				Unique:  false,
				Columns: []*schema.Column{UsersColumns[6]},
			},
			{
				Name:    "user_created_at",
				Unique:  false,
				Columns: []*schema.Column{UsersColumns[2]},
			},
			{
				Name:    "user_updated_at",
				Unique:  false,
				Columns: []*schema.Column{UsersColumns[4]},
			},
			{
				Name:    "user_published_at",
				Unique:  false,
				Columns: []*schema.Column{UsersColumns[7]},
			},
			{
				Name:    "user_owner_domain_id",
				Unique:  false,
				Columns: []*schema.Column{UsersColumns[9]},
			},
			{
				Name:    "user_owner_domain_id_username",
				Unique:  true,
				Columns: []*schema.Column{UsersColumns[9], UsersColumns[10]},
			},
			{
				Name:    "user_owner_domain_id_email",
				Unique:  true,
				Columns: []*schema.Column{UsersColumns[9], UsersColumns[11]},
			},
		},
	}
	// PostMediaColumns holds the columns for the "post_media" table.
	PostMediaColumns = []*schema.Column{
		{Name: "post_id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "media_id", Type: field.TypeUUID},
	}
	// PostMediaTable holds the schema information for the "post_media" table.
	PostMediaTable = &schema.Table{
		Name:       "post_media",
		Columns:    PostMediaColumns,
		PrimaryKey: []*schema.Column{PostMediaColumns[0], PostMediaColumns[1]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "post_media_post_id",
				Columns:    []*schema.Column{PostMediaColumns[0]},
				RefColumns: []*schema.Column{PostsColumns[0]},
				OnDelete:   schema.Cascade,
			},
			{
				Symbol:     "post_media_media_id",
				Columns:    []*schema.Column{PostMediaColumns[1]},
				RefColumns: []*schema.Column{MediaColumns[0]},
				OnDelete:   schema.Cascade,
			},
		},
	}
	// RoleMenusColumns holds the columns for the "role_menus" table.
	RoleMenusColumns = []*schema.Column{
		{Name: "role_id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "menu_id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// RoleMenusTable holds the schema information for the "role_menus" table.
	RoleMenusTable = &schema.Table{
		Name:       "role_menus",
		Columns:    RoleMenusColumns,
		PrimaryKey: []*schema.Column{RoleMenusColumns[0], RoleMenusColumns[1]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "role_menus_role_id",
				Columns:    []*schema.Column{RoleMenusColumns[0]},
				RefColumns: []*schema.Column{RolesColumns[0]},
				OnDelete:   schema.Cascade,
			},
			{
				Symbol:     "role_menus_menu_id",
				Columns:    []*schema.Column{RoleMenusColumns[1]},
				RefColumns: []*schema.Column{MenusColumns[0]},
				OnDelete:   schema.Cascade,
			},
		},
	}
	// UserRolesColumns holds the columns for the "user_roles" table.
	UserRolesColumns = []*schema.Column{
		{Name: "user_id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "role_id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// UserRolesTable holds the schema information for the "user_roles" table.
	UserRolesTable = &schema.Table{
		Name:       "user_roles",
		Columns:    UserRolesColumns,
		PrimaryKey: []*schema.Column{UserRolesColumns[0], UserRolesColumns[1]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "user_roles_user_id",
				Columns:    []*schema.Column{UserRolesColumns[0]},
				RefColumns: []*schema.Column{UsersColumns[0]},
				OnDelete:   schema.Cascade,
			},
			{
				Symbol:     "user_roles_role_id",
				Columns:    []*schema.Column{UserRolesColumns[1]},
				RefColumns: []*schema.Column{RolesColumns[0]},
				OnDelete:   schema.Cascade,
			},
		},
	}
	// UserPostsColumns holds the columns for the "user_posts" table.
	UserPostsColumns = []*schema.Column{
		{Name: "user_id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "post_id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// UserPostsTable holds the schema information for the "user_posts" table.
	UserPostsTable = &schema.Table{
		Name:       "user_posts",
		Columns:    UserPostsColumns,
		PrimaryKey: []*schema.Column{UserPostsColumns[0], UserPostsColumns[1]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "user_posts_user_id",
				Columns:    []*schema.Column{UserPostsColumns[0]},
				RefColumns: []*schema.Column{UsersColumns[0]},
				OnDelete:   schema.Cascade,
			},
			{
				Symbol:     "user_posts_post_id",
				Columns:    []*schema.Column{UserPostsColumns[1]},
				RefColumns: []*schema.Column{PostsColumns[0]},
				OnDelete:   schema.Cascade,
			},
		},
	}
	// UserSessionsColumns holds the columns for the "user_sessions" table.
	UserSessionsColumns = []*schema.Column{
		{Name: "user_id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "session_id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// UserSessionsTable holds the schema information for the "user_sessions" table.
	UserSessionsTable = &schema.Table{
		Name:       "user_sessions",
		Columns:    UserSessionsColumns,
		PrimaryKey: []*schema.Column{UserSessionsColumns[0], UserSessionsColumns[1]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "user_sessions_user_id",
				Columns:    []*schema.Column{UserSessionsColumns[0]},
				RefColumns: []*schema.Column{UsersColumns[0]},
				OnDelete:   schema.Cascade,
			},
			{
				Symbol:     "user_sessions_session_id",
				Columns:    []*schema.Column{UserSessionsColumns[1]},
				RefColumns: []*schema.Column{SessionsColumns[0]},
				OnDelete:   schema.Cascade,
			},
		},
	}
	// UserAuditLogsColumns holds the columns for the "user_audit_logs" table.
	UserAuditLogsColumns = []*schema.Column{
		{Name: "user_id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
		{Name: "audit_log_id", Type: field.TypeUUID, SchemaType: map[string]string{"mysql": "char(36)", "postgres": "uuid", "sqlite3": "text"}},
	}
	// UserAuditLogsTable holds the schema information for the "user_audit_logs" table.
	UserAuditLogsTable = &schema.Table{
		Name:       "user_audit_logs",
		Columns:    UserAuditLogsColumns,
		PrimaryKey: []*schema.Column{UserAuditLogsColumns[0], UserAuditLogsColumns[1]},
		ForeignKeys: []*schema.ForeignKey{
			{
				Symbol:     "user_audit_logs_user_id",
				Columns:    []*schema.Column{UserAuditLogsColumns[0]},
				RefColumns: []*schema.Column{UsersColumns[0]},
				OnDelete:   schema.Cascade,
			},
			{
				Symbol:     "user_audit_logs_audit_log_id",
				Columns:    []*schema.Column{UserAuditLogsColumns[1]},
				RefColumns: []*schema.Column{AuditLogsColumns[0]},
				OnDelete:   schema.Cascade,
			},
		},
	}
	// Tables holds all the tables in the schema.
	Tables = []*schema.Table{
		APIPermissionsTable,
		APIPermissionMapsTable,
		APIKeysTable,
		AuditLogsTable,
		DictionariesTable,
		DictionaryDetailsTable,
		DomainsTable,
		DomainMembershipsTable,
		DomainRelationsTable,
		DomainTypesTable,
		InvitationTokensTable,
		MediaTable,
		MediaFoldersTable,
		MediaFormatsTable,
		MenusTable,
		OperationLogsTable,
		OrganizationsTable,
		OrganizationMembersTable,
		PasswordResetTokensTable,
		PermissionsTable,
		PostsTable,
		ResourceDomainBindingsTable,
		RolesTable,
		RoleBindingsTable,
		SessionsTable,
		SystemConfigsTable,
		SystemErrorsTable,
		TenantsTable,
		TenantUsersTable,
		UsersTable,
		PostMediaTable,
		RoleMenusTable,
		UserRolesTable,
		UserPostsTable,
		UserSessionsTable,
		UserAuditLogsTable,
	}
)

Functions

func Create

func Create(ctx context.Context, s *Schema, tables []*schema.Table, opts ...schema.MigrateOption) error

Create creates all table resources using the given schema driver.

Types

type Schema

type Schema struct {
	// contains filtered or unexported fields
}

Schema is the API for creating, migrating and dropping a schema.

func NewSchema

func NewSchema(drv dialect.Driver) *Schema

NewSchema creates a new schema client.

func (*Schema) Create

func (s *Schema) Create(ctx context.Context, opts ...schema.MigrateOption) error

Create creates all schema resources.

func (*Schema) WriteTo

func (s *Schema) WriteTo(ctx context.Context, w io.Writer, opts ...schema.MigrateOption) error

WriteTo writes the schema changes to w instead of running them against the database.

if err := client.Schema.WriteTo(context.Background(), os.Stdout); err != nil {
	log.Fatal(err)
}