owpengram-server/internal/store/postgres/sqlcgen/user.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.31.1
// source: user.sql

package sqlcgen

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"
)

const createUser = `-- name: CreateUser :one
INSERT INTO users (access_hash, phone, first_name, last_name, username, country_code, premium_expires_at)
VALUES ($1, $2, $3, $4, $5, $6, $7)
RETURNING id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at, default_history_ttl_period, is_bot, bot_info_version, premium_expires_at, emoji_status_document_id, emoji_status_until, color_set, color, color_background_emoji_id, profile_color_set, profile_color, profile_color_background_emoji_id, birthday_day, birthday_month, birthday_year, personal_channel_id, deleted_at, deletion_source, deletion_reason, account_delete_at, emoji_status_collectible_id, emoji_status_collectible
`

type CreateUserParams struct {
	AccessHash       int64
	Phone            string
	FirstName        string
	LastName         string
	Username         string
	CountryCode      string
	PremiumExpiresAt pgtype.Timestamptz
}

func (q *Queries) CreateUser(ctx context.Context, arg CreateUserParams) (User, error) {
	row := q.db.QueryRow(ctx, createUser,
		arg.AccessHash,
		arg.Phone,
		arg.FirstName,
		arg.LastName,
		arg.Username,
		arg.CountryCode,
		arg.PremiumExpiresAt,
	)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
		&i.DefaultHistoryTtlPeriod,
		&i.IsBot,
		&i.BotInfoVersion,
		&i.PremiumExpiresAt,
		&i.EmojiStatusDocumentID,
		&i.EmojiStatusUntil,
		&i.ColorSet,
		&i.Color,
		&i.ColorBackgroundEmojiID,
		&i.ProfileColorSet,
		&i.ProfileColor,
		&i.ProfileColorBackgroundEmojiID,
		&i.BirthdayDay,
		&i.BirthdayMonth,
		&i.BirthdayYear,
		&i.PersonalChannelID,
		&i.DeletedAt,
		&i.DeletionSource,
		&i.DeletionReason,
		&i.AccountDeleteAt,
		&i.EmojiStatusCollectibleID,
		&i.EmojiStatusCollectible,
	)
	return i, err
}

const getUserByID = `-- name: GetUserByID :one
SELECT id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at, default_history_ttl_period, is_bot, bot_info_version, premium_expires_at, emoji_status_document_id, emoji_status_until, color_set, color, color_background_emoji_id, profile_color_set, profile_color, profile_color_background_emoji_id, birthday_day, birthday_month, birthday_year, personal_channel_id, deleted_at, deletion_source, deletion_reason, account_delete_at, emoji_status_collectible_id, emoji_status_collectible FROM users WHERE id = $1
`

func (q *Queries) GetUserByID(ctx context.Context, id int64) (User, error) {
	row := q.db.QueryRow(ctx, getUserByID, id)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
		&i.DefaultHistoryTtlPeriod,
		&i.IsBot,
		&i.BotInfoVersion,
		&i.PremiumExpiresAt,
		&i.EmojiStatusDocumentID,
		&i.EmojiStatusUntil,
		&i.ColorSet,
		&i.Color,
		&i.ColorBackgroundEmojiID,
		&i.ProfileColorSet,
		&i.ProfileColor,
		&i.ProfileColorBackgroundEmojiID,
		&i.BirthdayDay,
		&i.BirthdayMonth,
		&i.BirthdayYear,
		&i.PersonalChannelID,
		&i.DeletedAt,
		&i.DeletionSource,
		&i.DeletionReason,
		&i.AccountDeleteAt,
		&i.EmojiStatusCollectibleID,
		&i.EmojiStatusCollectible,
	)
	return i, err
}

const getUserByPhone = `-- name: GetUserByPhone :one
SELECT id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at, default_history_ttl_period, is_bot, bot_info_version, premium_expires_at, emoji_status_document_id, emoji_status_until, color_set, color, color_background_emoji_id, profile_color_set, profile_color, profile_color_background_emoji_id, birthday_day, birthday_month, birthday_year, personal_channel_id, deleted_at, deletion_source, deletion_reason, account_delete_at, emoji_status_collectible_id, emoji_status_collectible FROM users WHERE phone = $1 AND deleted_at IS NULL
`

func (q *Queries) GetUserByPhone(ctx context.Context, phone string) (User, error) {
	row := q.db.QueryRow(ctx, getUserByPhone, phone)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
		&i.DefaultHistoryTtlPeriod,
		&i.IsBot,
		&i.BotInfoVersion,
		&i.PremiumExpiresAt,
		&i.EmojiStatusDocumentID,
		&i.EmojiStatusUntil,
		&i.ColorSet,
		&i.Color,
		&i.ColorBackgroundEmojiID,
		&i.ProfileColorSet,
		&i.ProfileColor,
		&i.ProfileColorBackgroundEmojiID,
		&i.BirthdayDay,
		&i.BirthdayMonth,
		&i.BirthdayYear,
		&i.PersonalChannelID,
		&i.DeletedAt,
		&i.DeletionSource,
		&i.DeletionReason,
		&i.AccountDeleteAt,
		&i.EmojiStatusCollectibleID,
		&i.EmojiStatusCollectible,
	)
	return i, err
}

const getUserByUsername = `-- name: GetUserByUsername :one
SELECT id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at, default_history_ttl_period, is_bot, bot_info_version, premium_expires_at, emoji_status_document_id, emoji_status_until, color_set, color, color_background_emoji_id, profile_color_set, profile_color, profile_color_background_emoji_id, birthday_day, birthday_month, birthday_year, personal_channel_id, deleted_at, deletion_source, deletion_reason, account_delete_at, emoji_status_collectible_id, emoji_status_collectible FROM users WHERE lower(username) = lower($1) AND username <> '' AND deleted_at IS NULL
`

func (q *Queries) GetUserByUsername(ctx context.Context, lower string) (User, error) {
	row := q.db.QueryRow(ctx, getUserByUsername, lower)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
		&i.DefaultHistoryTtlPeriod,
		&i.IsBot,
		&i.BotInfoVersion,
		&i.PremiumExpiresAt,
		&i.EmojiStatusDocumentID,
		&i.EmojiStatusUntil,
		&i.ColorSet,
		&i.Color,
		&i.ColorBackgroundEmojiID,
		&i.ProfileColorSet,
		&i.ProfileColor,
		&i.ProfileColorBackgroundEmojiID,
		&i.BirthdayDay,
		&i.BirthdayMonth,
		&i.BirthdayYear,
		&i.PersonalChannelID,
		&i.DeletedAt,
		&i.DeletionSource,
		&i.DeletionReason,
		&i.AccountDeleteAt,
		&i.EmojiStatusCollectibleID,
		&i.EmojiStatusCollectible,
	)
	return i, err
}

const getUsersByIDs = `-- name: GetUsersByIDs :many
SELECT id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at, default_history_ttl_period, is_bot, bot_info_version, premium_expires_at, emoji_status_document_id, emoji_status_until, color_set, color, color_background_emoji_id, profile_color_set, profile_color, profile_color_background_emoji_id, birthday_day, birthday_month, birthday_year, personal_channel_id, deleted_at, deletion_source, deletion_reason, account_delete_at, emoji_status_collectible_id, emoji_status_collectible
FROM users
WHERE id = ANY($1::bigint[])
ORDER BY id
`

func (q *Queries) GetUsersByIDs(ctx context.Context, ids []int64) ([]User, error) {
	rows, err := q.db.Query(ctx, getUsersByIDs, ids)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []User
	for rows.Next() {
		var i User
		if err := rows.Scan(
			&i.ID,
			&i.AccessHash,
			&i.Phone,
			&i.FirstName,
			&i.LastName,
			&i.Username,
			&i.CountryCode,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.Verified,
			&i.Support,
			&i.About,
			&i.LastSeenAt,
			&i.DefaultHistoryTtlPeriod,
			&i.IsBot,
			&i.BotInfoVersion,
			&i.PremiumExpiresAt,
			&i.EmojiStatusDocumentID,
			&i.EmojiStatusUntil,
			&i.ColorSet,
			&i.Color,
			&i.ColorBackgroundEmojiID,
			&i.ProfileColorSet,
			&i.ProfileColor,
			&i.ProfileColorBackgroundEmojiID,
			&i.BirthdayDay,
			&i.BirthdayMonth,
			&i.BirthdayYear,
			&i.PersonalChannelID,
			&i.DeletedAt,
			&i.DeletionSource,
			&i.DeletionReason,
			&i.AccountDeleteAt,
			&i.EmojiStatusCollectibleID,
			&i.EmojiStatusCollectible,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUsersByPhones = `-- name: GetUsersByPhones :many
SELECT id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at, default_history_ttl_period, is_bot, bot_info_version, premium_expires_at, emoji_status_document_id, emoji_status_until, color_set, color, color_background_emoji_id, profile_color_set, profile_color, profile_color_background_emoji_id, birthday_day, birthday_month, birthday_year, personal_channel_id, deleted_at, deletion_source, deletion_reason, account_delete_at, emoji_status_collectible_id, emoji_status_collectible
FROM users
WHERE phone = ANY($1::text[]) AND deleted_at IS NULL
ORDER BY id
`

func (q *Queries) GetUsersByPhones(ctx context.Context, phones []string) ([]User, error) {
	rows, err := q.db.Query(ctx, getUsersByPhones, phones)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []User
	for rows.Next() {
		var i User
		if err := rows.Scan(
			&i.ID,
			&i.AccessHash,
			&i.Phone,
			&i.FirstName,
			&i.LastName,
			&i.Username,
			&i.CountryCode,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.Verified,
			&i.Support,
			&i.About,
			&i.LastSeenAt,
			&i.DefaultHistoryTtlPeriod,
			&i.IsBot,
			&i.BotInfoVersion,
			&i.PremiumExpiresAt,
			&i.EmojiStatusDocumentID,
			&i.EmojiStatusUntil,
			&i.ColorSet,
			&i.Color,
			&i.ColorBackgroundEmojiID,
			&i.ProfileColorSet,
			&i.ProfileColor,
			&i.ProfileColorBackgroundEmojiID,
			&i.BirthdayDay,
			&i.BirthdayMonth,
			&i.BirthdayYear,
			&i.PersonalChannelID,
			&i.DeletedAt,
			&i.DeletionSource,
			&i.DeletionReason,
			&i.AccountDeleteAt,
			&i.EmojiStatusCollectibleID,
			&i.EmojiStatusCollectible,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const searchUsers = `-- name: SearchUsers :many
WITH matched AS (
  SELECT
    u.id,
    u.access_hash,
    COALESCE(NULLIF(c.contact_phone, ''), u.phone)::text AS phone,
    COALESCE(NULLIF(c.contact_first_name, ''), u.first_name)::text AS first_name,
    COALESCE(c.contact_last_name, u.last_name)::text AS last_name,
    u.about,
    u.username,
    u.country_code,
    u.verified,
    u.support,
    u.is_bot,
    u.bot_info_version,
    u.premium_expires_at,
    u.emoji_status_document_id,
    u.emoji_status_until,
    u.emoji_status_collectible_id,
    u.emoji_status_collectible,
    u.color_set,
    u.color,
    u.color_background_emoji_id,
    u.profile_color_set,
    u.profile_color,
    u.profile_color_background_emoji_id,
    u.last_seen_at,
    (c.contact_user_id IS NOT NULL)::boolean AS contact,
    COALESCE(c.mutual, false)::boolean AS mutual,
    CASE
      WHEN $2::text <> '' AND u.phone = $2::text THEN 0
      WHEN lower(u.username) = $3::text THEN 1
      WHEN lower(COALESCE(NULLIF(c.contact_first_name, ''), u.first_name)) = $3::text THEN 2
      WHEN lower(u.first_name) = $3::text THEN 3
      WHEN c.contact_user_id IS NOT NULL THEN 4
      ELSE 5
    END AS rank
  FROM users u
  LEFT JOIN contacts c ON c.user_id = $4::bigint AND c.contact_user_id = u.id
  WHERE u.id <> $4::bigint
    AND u.deleted_at IS NULL
    AND $3::text <> ''
    AND (
      ($2::text <> '' AND u.phone LIKE $2::text || '%')
      OR lower(u.username) LIKE $5::text || '%' ESCAPE '\'
      OR lower(u.first_name) LIKE '%' || $5::text || '%' ESCAPE '\'
      OR lower(u.last_name) LIKE '%' || $5::text || '%' ESCAPE '\'
      OR lower(trim(u.first_name || ' ' || u.last_name)) LIKE '%' || $5::text || '%' ESCAPE '\'
      OR lower(c.contact_first_name) LIKE '%' || $5::text || '%' ESCAPE '\'
      OR lower(c.contact_last_name) LIKE '%' || $5::text || '%' ESCAPE '\'
      OR lower(trim(c.contact_first_name || ' ' || c.contact_last_name)) LIKE '%' || $5::text || '%' ESCAPE '\'
    )
)
SELECT
  id,
  access_hash,
  phone,
  first_name,
  last_name,
  about,
  username,
  country_code,
  verified,
  support,
  is_bot,
  bot_info_version,
  premium_expires_at,
  emoji_status_document_id,
  emoji_status_until,
  emoji_status_collectible_id,
  emoji_status_collectible,
  color_set,
  color,
  color_background_emoji_id,
  profile_color_set,
  profile_color,
  profile_color_background_emoji_id,
  last_seen_at,
  contact,
  mutual
FROM matched
ORDER BY contact DESC, rank, id
LIMIT $1
`

type SearchUsersParams struct {
	LimitCount    int32
	PhoneQuery    string
	QueryLower    string
	CurrentUserID int64
	QueryLike     string
}

type SearchUsersRow struct {
	ID                            int64
	AccessHash                    int64
	Phone                         string
	FirstName                     string
	LastName                      string
	About                         string
	Username                      string
	CountryCode                   string
	Verified                      bool
	Support                       bool
	IsBot                         bool
	BotInfoVersion                int32
	PremiumExpiresAt              pgtype.Timestamptz
	EmojiStatusDocumentID         int64
	EmojiStatusUntil              int64
	EmojiStatusCollectibleID      *int64
	EmojiStatusCollectible        []byte
	ColorSet                      bool
	Color                         int32
	ColorBackgroundEmojiID        int64
	ProfileColorSet               bool
	ProfileColor                  int32
	ProfileColorBackgroundEmojiID int64
	LastSeenAt                    int64
	Contact                       bool
	Mutual                        bool
}

func (q *Queries) SearchUsers(ctx context.Context, arg SearchUsersParams) ([]SearchUsersRow, error) {
	rows, err := q.db.Query(ctx, searchUsers,
		arg.LimitCount,
		arg.PhoneQuery,
		arg.QueryLower,
		arg.CurrentUserID,
		arg.QueryLike,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []SearchUsersRow
	for rows.Next() {
		var i SearchUsersRow
		if err := rows.Scan(
			&i.ID,
			&i.AccessHash,
			&i.Phone,
			&i.FirstName,
			&i.LastName,
			&i.About,
			&i.Username,
			&i.CountryCode,
			&i.Verified,
			&i.Support,
			&i.IsBot,
			&i.BotInfoVersion,
			&i.PremiumExpiresAt,
			&i.EmojiStatusDocumentID,
			&i.EmojiStatusUntil,
			&i.EmojiStatusCollectibleID,
			&i.EmojiStatusCollectible,
			&i.ColorSet,
			&i.Color,
			&i.ColorBackgroundEmojiID,
			&i.ProfileColorSet,
			&i.ProfileColor,
			&i.ProfileColorBackgroundEmojiID,
			&i.LastSeenAt,
			&i.Contact,
			&i.Mutual,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const setUserPremiumUntil = `-- name: SetUserPremiumUntil :one
UPDATE users
SET premium_expires_at = $1::timestamptz,
    updated_at = now()
WHERE id = $2::bigint AND deleted_at IS NULL
RETURNING id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at, default_history_ttl_period, is_bot, bot_info_version, premium_expires_at, emoji_status_document_id, emoji_status_until, color_set, color, color_background_emoji_id, profile_color_set, profile_color, profile_color_background_emoji_id, birthday_day, birthday_month, birthday_year, personal_channel_id, deleted_at, deletion_source, deletion_reason, account_delete_at, emoji_status_collectible_id, emoji_status_collectible
`

type SetUserPremiumUntilParams struct {
	PremiumExpiresAt pgtype.Timestamptz
	ID               int64
}

func (q *Queries) SetUserPremiumUntil(ctx context.Context, arg SetUserPremiumUntilParams) (User, error) {
	row := q.db.QueryRow(ctx, setUserPremiumUntil, arg.PremiumExpiresAt, arg.ID)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
		&i.DefaultHistoryTtlPeriod,
		&i.IsBot,
		&i.BotInfoVersion,
		&i.PremiumExpiresAt,
		&i.EmojiStatusDocumentID,
		&i.EmojiStatusUntil,
		&i.ColorSet,
		&i.Color,
		&i.ColorBackgroundEmojiID,
		&i.ProfileColorSet,
		&i.ProfileColor,
		&i.ProfileColorBackgroundEmojiID,
		&i.BirthdayDay,
		&i.BirthdayMonth,
		&i.BirthdayYear,
		&i.PersonalChannelID,
		&i.DeletedAt,
		&i.DeletionSource,
		&i.DeletionReason,
		&i.AccountDeleteAt,
		&i.EmojiStatusCollectibleID,
		&i.EmojiStatusCollectible,
	)
	return i, err
}

const setUserVerified = `-- name: SetUserVerified :one
UPDATE users
SET verified = $1::boolean,
    updated_at = now()
WHERE id = $2::bigint AND deleted_at IS NULL
RETURNING id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at, default_history_ttl_period, is_bot, bot_info_version, premium_expires_at, emoji_status_document_id, emoji_status_until, color_set, color, color_background_emoji_id, profile_color_set, profile_color, profile_color_background_emoji_id, birthday_day, birthday_month, birthday_year, personal_channel_id, deleted_at, deletion_source, deletion_reason, account_delete_at, emoji_status_collectible_id, emoji_status_collectible
`

type SetUserVerifiedParams struct {
	Verified bool
	ID       int64
}

func (q *Queries) SetUserVerified(ctx context.Context, arg SetUserVerifiedParams) (User, error) {
	row := q.db.QueryRow(ctx, setUserVerified, arg.Verified, arg.ID)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
		&i.DefaultHistoryTtlPeriod,
		&i.IsBot,
		&i.BotInfoVersion,
		&i.PremiumExpiresAt,
		&i.EmojiStatusDocumentID,
		&i.EmojiStatusUntil,
		&i.ColorSet,
		&i.Color,
		&i.ColorBackgroundEmojiID,
		&i.ProfileColorSet,
		&i.ProfileColor,
		&i.ProfileColorBackgroundEmojiID,
		&i.BirthdayDay,
		&i.BirthdayMonth,
		&i.BirthdayYear,
		&i.PersonalChannelID,
		&i.DeletedAt,
		&i.DeletionSource,
		&i.DeletionReason,
		&i.AccountDeleteAt,
		&i.EmojiStatusCollectibleID,
		&i.EmojiStatusCollectible,
	)
	return i, err
}

const sweepExpiredPremium = `-- name: SweepExpiredPremium :many
UPDATE users
SET premium_expires_at = NULL,
    updated_at = now()
WHERE id IN (
  SELECT id FROM users
  WHERE premium_expires_at IS NOT NULL
    AND deleted_at IS NULL
    AND premium_expires_at <= $1::timestamptz
  ORDER BY premium_expires_at
  LIMIT $2::int
)
RETURNING id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at, default_history_ttl_period, is_bot, bot_info_version, premium_expires_at, emoji_status_document_id, emoji_status_until, color_set, color, color_background_emoji_id, profile_color_set, profile_color, profile_color_background_emoji_id, birthday_day, birthday_month, birthday_year, personal_channel_id, deleted_at, deletion_source, deletion_reason, account_delete_at, emoji_status_collectible_id, emoji_status_collectible
`

type SweepExpiredPremiumParams struct {
	Now        pgtype.Timestamptz
	LimitCount int32
}

func (q *Queries) SweepExpiredPremium(ctx context.Context, arg SweepExpiredPremiumParams) ([]User, error) {
	rows, err := q.db.Query(ctx, sweepExpiredPremium, arg.Now, arg.LimitCount)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []User
	for rows.Next() {
		var i User
		if err := rows.Scan(
			&i.ID,
			&i.AccessHash,
			&i.Phone,
			&i.FirstName,
			&i.LastName,
			&i.Username,
			&i.CountryCode,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.Verified,
			&i.Support,
			&i.About,
			&i.LastSeenAt,
			&i.DefaultHistoryTtlPeriod,
			&i.IsBot,
			&i.BotInfoVersion,
			&i.PremiumExpiresAt,
			&i.EmojiStatusDocumentID,
			&i.EmojiStatusUntil,
			&i.ColorSet,
			&i.Color,
			&i.ColorBackgroundEmojiID,
			&i.ProfileColorSet,
			&i.ProfileColor,
			&i.ProfileColorBackgroundEmojiID,
			&i.BirthdayDay,
			&i.BirthdayMonth,
			&i.BirthdayYear,
			&i.PersonalChannelID,
			&i.DeletedAt,
			&i.DeletionSource,
			&i.DeletionReason,
			&i.AccountDeleteAt,
			&i.EmojiStatusCollectibleID,
			&i.EmojiStatusCollectible,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const updateUserBirthday = `-- name: UpdateUserBirthday :one
UPDATE users
SET birthday_day = $1::int,
    birthday_month = $2::int,
    birthday_year = $3::int,
    updated_at = now()
WHERE id = $4::bigint AND deleted_at IS NULL
RETURNING id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at, default_history_ttl_period, is_bot, bot_info_version, premium_expires_at, emoji_status_document_id, emoji_status_until, color_set, color, color_background_emoji_id, profile_color_set, profile_color, profile_color_background_emoji_id, birthday_day, birthday_month, birthday_year, personal_channel_id, deleted_at, deletion_source, deletion_reason, account_delete_at, emoji_status_collectible_id, emoji_status_collectible
`

type UpdateUserBirthdayParams struct {
	BirthdayDay   int32
	BirthdayMonth int32
	BirthdayYear  int32
	ID            int64
}

func (q *Queries) UpdateUserBirthday(ctx context.Context, arg UpdateUserBirthdayParams) (User, error) {
	row := q.db.QueryRow(ctx, updateUserBirthday,
		arg.BirthdayDay,
		arg.BirthdayMonth,
		arg.BirthdayYear,
		arg.ID,
	)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
		&i.DefaultHistoryTtlPeriod,
		&i.IsBot,
		&i.BotInfoVersion,
		&i.PremiumExpiresAt,
		&i.EmojiStatusDocumentID,
		&i.EmojiStatusUntil,
		&i.ColorSet,
		&i.Color,
		&i.ColorBackgroundEmojiID,
		&i.ProfileColorSet,
		&i.ProfileColor,
		&i.ProfileColorBackgroundEmojiID,
		&i.BirthdayDay,
		&i.BirthdayMonth,
		&i.BirthdayYear,
		&i.PersonalChannelID,
		&i.DeletedAt,
		&i.DeletionSource,
		&i.DeletionReason,
		&i.AccountDeleteAt,
		&i.EmojiStatusCollectibleID,
		&i.EmojiStatusCollectible,
	)
	return i, err
}

const updateUserColor = `-- name: UpdateUserColor :one
UPDATE users
SET color_set = $1::boolean,
    color = $2::int,
    color_background_emoji_id = $3::bigint,
    updated_at = now()
WHERE id = $4::bigint AND deleted_at IS NULL
RETURNING id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at, default_history_ttl_period, is_bot, bot_info_version, premium_expires_at, emoji_status_document_id, emoji_status_until, color_set, color, color_background_emoji_id, profile_color_set, profile_color, profile_color_background_emoji_id, birthday_day, birthday_month, birthday_year, personal_channel_id, deleted_at, deletion_source, deletion_reason, account_delete_at, emoji_status_collectible_id, emoji_status_collectible
`

type UpdateUserColorParams struct {
	ColorSet          bool
	Color             int32
	BackgroundEmojiID int64
	ID                int64
}

func (q *Queries) UpdateUserColor(ctx context.Context, arg UpdateUserColorParams) (User, error) {
	row := q.db.QueryRow(ctx, updateUserColor,
		arg.ColorSet,
		arg.Color,
		arg.BackgroundEmojiID,
		arg.ID,
	)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
		&i.DefaultHistoryTtlPeriod,
		&i.IsBot,
		&i.BotInfoVersion,
		&i.PremiumExpiresAt,
		&i.EmojiStatusDocumentID,
		&i.EmojiStatusUntil,
		&i.ColorSet,
		&i.Color,
		&i.ColorBackgroundEmojiID,
		&i.ProfileColorSet,
		&i.ProfileColor,
		&i.ProfileColorBackgroundEmojiID,
		&i.BirthdayDay,
		&i.BirthdayMonth,
		&i.BirthdayYear,
		&i.PersonalChannelID,
		&i.DeletedAt,
		&i.DeletionSource,
		&i.DeletionReason,
		&i.AccountDeleteAt,
		&i.EmojiStatusCollectibleID,
		&i.EmojiStatusCollectible,
	)
	return i, err
}

const updateUserEmojiStatus = `-- name: UpdateUserEmojiStatus :one
UPDATE users
SET emoji_status_document_id = $1::bigint,
    emoji_status_until = $2::bigint,
    emoji_status_collectible_id = $3::bigint,
    emoji_status_collectible = $4::jsonb,
    updated_at = now()
WHERE id = $5::bigint AND deleted_at IS NULL
RETURNING id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at, default_history_ttl_period, is_bot, bot_info_version, premium_expires_at, emoji_status_document_id, emoji_status_until, color_set, color, color_background_emoji_id, profile_color_set, profile_color, profile_color_background_emoji_id, birthday_day, birthday_month, birthday_year, personal_channel_id, deleted_at, deletion_source, deletion_reason, account_delete_at, emoji_status_collectible_id, emoji_status_collectible
`

type UpdateUserEmojiStatusParams struct {
	EmojiStatusDocumentID    int64
	EmojiStatusUntil         int64
	EmojiStatusCollectibleID *int64
	EmojiStatusCollectible   []byte
	ID                       int64
}

func (q *Queries) UpdateUserEmojiStatus(ctx context.Context, arg UpdateUserEmojiStatusParams) (User, error) {
	row := q.db.QueryRow(ctx, updateUserEmojiStatus,
		arg.EmojiStatusDocumentID,
		arg.EmojiStatusUntil,
		arg.EmojiStatusCollectibleID,
		arg.EmojiStatusCollectible,
		arg.ID,
	)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
		&i.DefaultHistoryTtlPeriod,
		&i.IsBot,
		&i.BotInfoVersion,
		&i.PremiumExpiresAt,
		&i.EmojiStatusDocumentID,
		&i.EmojiStatusUntil,
		&i.ColorSet,
		&i.Color,
		&i.ColorBackgroundEmojiID,
		&i.ProfileColorSet,
		&i.ProfileColor,
		&i.ProfileColorBackgroundEmojiID,
		&i.BirthdayDay,
		&i.BirthdayMonth,
		&i.BirthdayYear,
		&i.PersonalChannelID,
		&i.DeletedAt,
		&i.DeletionSource,
		&i.DeletionReason,
		&i.AccountDeleteAt,
		&i.EmojiStatusCollectibleID,
		&i.EmojiStatusCollectible,
	)
	return i, err
}

const updateUserLastSeen = `-- name: UpdateUserLastSeen :exec
UPDATE users
SET last_seen_at = GREATEST(last_seen_at, $1::bigint),
    updated_at = now()
WHERE id = $2::bigint AND deleted_at IS NULL
`

type UpdateUserLastSeenParams struct {
	LastSeenAt int64
	ID         int64
}

func (q *Queries) UpdateUserLastSeen(ctx context.Context, arg UpdateUserLastSeenParams) error {
	_, err := q.db.Exec(ctx, updateUserLastSeen, arg.LastSeenAt, arg.ID)
	return err
}

const updateUserPersonalChannel = `-- name: UpdateUserPersonalChannel :one
UPDATE users
SET personal_channel_id = $1::bigint,
    updated_at = now()
WHERE id = $2::bigint AND deleted_at IS NULL
RETURNING id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at, default_history_ttl_period, is_bot, bot_info_version, premium_expires_at, emoji_status_document_id, emoji_status_until, color_set, color, color_background_emoji_id, profile_color_set, profile_color, profile_color_background_emoji_id, birthday_day, birthday_month, birthday_year, personal_channel_id, deleted_at, deletion_source, deletion_reason, account_delete_at, emoji_status_collectible_id, emoji_status_collectible
`

type UpdateUserPersonalChannelParams struct {
	PersonalChannelID int64
	ID                int64
}

func (q *Queries) UpdateUserPersonalChannel(ctx context.Context, arg UpdateUserPersonalChannelParams) (User, error) {
	row := q.db.QueryRow(ctx, updateUserPersonalChannel, arg.PersonalChannelID, arg.ID)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
		&i.DefaultHistoryTtlPeriod,
		&i.IsBot,
		&i.BotInfoVersion,
		&i.PremiumExpiresAt,
		&i.EmojiStatusDocumentID,
		&i.EmojiStatusUntil,
		&i.ColorSet,
		&i.Color,
		&i.ColorBackgroundEmojiID,
		&i.ProfileColorSet,
		&i.ProfileColor,
		&i.ProfileColorBackgroundEmojiID,
		&i.BirthdayDay,
		&i.BirthdayMonth,
		&i.BirthdayYear,
		&i.PersonalChannelID,
		&i.DeletedAt,
		&i.DeletionSource,
		&i.DeletionReason,
		&i.AccountDeleteAt,
		&i.EmojiStatusCollectibleID,
		&i.EmojiStatusCollectible,
	)
	return i, err
}

const updateUserPhone = `-- name: UpdateUserPhone :one
UPDATE users
SET phone = $1::text,
    updated_at = now()
WHERE id = $2::bigint AND deleted_at IS NULL
RETURNING id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at, default_history_ttl_period, is_bot, bot_info_version, premium_expires_at, emoji_status_document_id, emoji_status_until, color_set, color, color_background_emoji_id, profile_color_set, profile_color, profile_color_background_emoji_id, birthday_day, birthday_month, birthday_year, personal_channel_id, deleted_at, deletion_source, deletion_reason, account_delete_at, emoji_status_collectible_id, emoji_status_collectible
`

type UpdateUserPhoneParams struct {
	Phone string
	ID    int64
}

func (q *Queries) UpdateUserPhone(ctx context.Context, arg UpdateUserPhoneParams) (User, error) {
	row := q.db.QueryRow(ctx, updateUserPhone, arg.Phone, arg.ID)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
		&i.DefaultHistoryTtlPeriod,
		&i.IsBot,
		&i.BotInfoVersion,
		&i.PremiumExpiresAt,
		&i.EmojiStatusDocumentID,
		&i.EmojiStatusUntil,
		&i.ColorSet,
		&i.Color,
		&i.ColorBackgroundEmojiID,
		&i.ProfileColorSet,
		&i.ProfileColor,
		&i.ProfileColorBackgroundEmojiID,
		&i.BirthdayDay,
		&i.BirthdayMonth,
		&i.BirthdayYear,
		&i.PersonalChannelID,
		&i.DeletedAt,
		&i.DeletionSource,
		&i.DeletionReason,
		&i.AccountDeleteAt,
		&i.EmojiStatusCollectibleID,
		&i.EmojiStatusCollectible,
	)
	return i, err
}

const updateUserProfile = `-- name: UpdateUserProfile :one
UPDATE users
SET first_name = $2,
    last_name = $3,
    about = $4,
    updated_at = now()
WHERE id = $1 AND deleted_at IS NULL
RETURNING id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at, default_history_ttl_period, is_bot, bot_info_version, premium_expires_at, emoji_status_document_id, emoji_status_until, color_set, color, color_background_emoji_id, profile_color_set, profile_color, profile_color_background_emoji_id, birthday_day, birthday_month, birthday_year, personal_channel_id, deleted_at, deletion_source, deletion_reason, account_delete_at, emoji_status_collectible_id, emoji_status_collectible
`

type UpdateUserProfileParams struct {
	ID        int64
	FirstName string
	LastName  string
	About     string
}

func (q *Queries) UpdateUserProfile(ctx context.Context, arg UpdateUserProfileParams) (User, error) {
	row := q.db.QueryRow(ctx, updateUserProfile,
		arg.ID,
		arg.FirstName,
		arg.LastName,
		arg.About,
	)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
		&i.DefaultHistoryTtlPeriod,
		&i.IsBot,
		&i.BotInfoVersion,
		&i.PremiumExpiresAt,
		&i.EmojiStatusDocumentID,
		&i.EmojiStatusUntil,
		&i.ColorSet,
		&i.Color,
		&i.ColorBackgroundEmojiID,
		&i.ProfileColorSet,
		&i.ProfileColor,
		&i.ProfileColorBackgroundEmojiID,
		&i.BirthdayDay,
		&i.BirthdayMonth,
		&i.BirthdayYear,
		&i.PersonalChannelID,
		&i.DeletedAt,
		&i.DeletionSource,
		&i.DeletionReason,
		&i.AccountDeleteAt,
		&i.EmojiStatusCollectibleID,
		&i.EmojiStatusCollectible,
	)
	return i, err
}

const updateUserProfileColor = `-- name: UpdateUserProfileColor :one
UPDATE users
SET profile_color_set = $1::boolean,
    profile_color = $2::int,
    profile_color_background_emoji_id = $3::bigint,
    updated_at = now()
WHERE id = $4::bigint AND deleted_at IS NULL
RETURNING id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at, default_history_ttl_period, is_bot, bot_info_version, premium_expires_at, emoji_status_document_id, emoji_status_until, color_set, color, color_background_emoji_id, profile_color_set, profile_color, profile_color_background_emoji_id, birthday_day, birthday_month, birthday_year, personal_channel_id, deleted_at, deletion_source, deletion_reason, account_delete_at, emoji_status_collectible_id, emoji_status_collectible
`

type UpdateUserProfileColorParams struct {
	ColorSet          bool
	Color             int32
	BackgroundEmojiID int64
	ID                int64
}

func (q *Queries) UpdateUserProfileColor(ctx context.Context, arg UpdateUserProfileColorParams) (User, error) {
	row := q.db.QueryRow(ctx, updateUserProfileColor,
		arg.ColorSet,
		arg.Color,
		arg.BackgroundEmojiID,
		arg.ID,
	)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
		&i.DefaultHistoryTtlPeriod,
		&i.IsBot,
		&i.BotInfoVersion,
		&i.PremiumExpiresAt,
		&i.EmojiStatusDocumentID,
		&i.EmojiStatusUntil,
		&i.ColorSet,
		&i.Color,
		&i.ColorBackgroundEmojiID,
		&i.ProfileColorSet,
		&i.ProfileColor,
		&i.ProfileColorBackgroundEmojiID,
		&i.BirthdayDay,
		&i.BirthdayMonth,
		&i.BirthdayYear,
		&i.PersonalChannelID,
		&i.DeletedAt,
		&i.DeletionSource,
		&i.DeletionReason,
		&i.AccountDeleteAt,
		&i.EmojiStatusCollectibleID,
		&i.EmojiStatusCollectible,
	)
	return i, err
}

const updateUserUsername = `-- name: UpdateUserUsername :one
UPDATE users
SET username = $2,
    updated_at = now()
WHERE id = $1 AND deleted_at IS NULL
RETURNING id, access_hash, phone, first_name, last_name, username, country_code, created_at, updated_at, verified, support, about, last_seen_at, default_history_ttl_period, is_bot, bot_info_version, premium_expires_at, emoji_status_document_id, emoji_status_until, color_set, color, color_background_emoji_id, profile_color_set, profile_color, profile_color_background_emoji_id, birthday_day, birthday_month, birthday_year, personal_channel_id, deleted_at, deletion_source, deletion_reason, account_delete_at, emoji_status_collectible_id, emoji_status_collectible
`

type UpdateUserUsernameParams struct {
	ID       int64
	Username string
}

func (q *Queries) UpdateUserUsername(ctx context.Context, arg UpdateUserUsernameParams) (User, error) {
	row := q.db.QueryRow(ctx, updateUserUsername, arg.ID, arg.Username)
	var i User
	err := row.Scan(
		&i.ID,
		&i.AccessHash,
		&i.Phone,
		&i.FirstName,
		&i.LastName,
		&i.Username,
		&i.CountryCode,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Verified,
		&i.Support,
		&i.About,
		&i.LastSeenAt,
		&i.DefaultHistoryTtlPeriod,
		&i.IsBot,
		&i.BotInfoVersion,
		&i.PremiumExpiresAt,
		&i.EmojiStatusDocumentID,
		&i.EmojiStatusUntil,
		&i.ColorSet,
		&i.Color,
		&i.ColorBackgroundEmojiID,
		&i.ProfileColorSet,
		&i.ProfileColor,
		&i.ProfileColorBackgroundEmojiID,
		&i.BirthdayDay,
		&i.BirthdayMonth,
		&i.BirthdayYear,
		&i.PersonalChannelID,
		&i.DeletedAt,
		&i.DeletionSource,
		&i.DeletionReason,
		&i.AccountDeleteAt,
		&i.EmojiStatusCollectibleID,
		&i.EmojiStatusCollectible,
	)
	return i, err
}