common/dal/sqlcgen/queries.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.29.0
// source: queries.sql

package sqlcgen

import (
	"context"
	"database/sql"
	"encoding/json"
	"time"

	"github.com/google/uuid"
	"github.com/lib/pq"
)

const accountPagination = `-- name: AccountPagination :many
SELECT a.id, a.user_id, a.created_at, a.deleted
FROM account a ORDER BY a.created_at DESC LIMIT $1 OFFSET $2
`

type AccountPaginationParams struct {
	Limit  int32 `db:"limit" json:"limit"`
	Offset int32 `db:"offset" json:"offset"`
}

func (q *Queries) AccountPagination(ctx context.Context, arg AccountPaginationParams) ([]Account, error) {
	rows, err := q.db.QueryContext(ctx, accountPagination, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Account
	for rows.Next() {
		var i Account
		if err := rows.Scan(
			&i.ID,
			&i.UserID,
			&i.CreatedAt,
			&i.Deleted,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const addAmoAccountUser = `-- name: AddAmoAccountUser :exec
INSERT INTO usersAmo (AmoID, AmoUserID, Name, Email, Role, "Group")
VALUES ($1, $2, $3, $4, $5, $6)
`

type AddAmoAccountUserParams struct {
	Amoid     int32  `db:"amoid" json:"amoid"`
	Amouserid int32  `db:"amouserid" json:"amouserid"`
	Name      string `db:"name" json:"name"`
	Email     string `db:"email" json:"email"`
	Role      int32  `db:"role" json:"role"`
	Group     int32  `db:"Group" json:"Group"`
}

func (q *Queries) AddAmoAccountUser(ctx context.Context, arg AddAmoAccountUserParams) error {
	_, err := q.db.ExecContext(ctx, addAmoAccountUser,
		arg.Amoid,
		arg.Amouserid,
		arg.Name,
		arg.Email,
		arg.Role,
		arg.Group,
	)
	return err
}

const addBitrixAccountUser = `-- name: AddBitrixAccountUser :exec
INSERT INTO BitrixAccountUsers (AccountID, BitrixIDUserID, Name, LastName, SecondName, Title,Email,UFDepartment,WorkPosition)
VALUES ($1, $2, $3, $4, $5, $6,$7,$8,$9)
`

type AddBitrixAccountUserParams struct {
	Accountid      string  `db:"accountid" json:"accountid"`
	Bitrixiduserid string  `db:"bitrixiduserid" json:"bitrixiduserid"`
	Name           string  `db:"name" json:"name"`
	Lastname       string  `db:"lastname" json:"lastname"`
	Secondname     string  `db:"secondname" json:"secondname"`
	Title          string  `db:"title" json:"title"`
	Email          string  `db:"email" json:"email"`
	Ufdepartment   []int32 `db:"ufdepartment" json:"ufdepartment"`
	Workposition   string  `db:"workposition" json:"workposition"`
}

func (q *Queries) AddBitrixAccountUser(ctx context.Context, arg AddBitrixAccountUserParams) error {
	_, err := q.db.ExecContext(ctx, addBitrixAccountUser,
		arg.Accountid,
		arg.Bitrixiduserid,
		arg.Name,
		arg.Lastname,
		arg.Secondname,
		arg.Title,
		arg.Email,
		pq.Array(arg.Ufdepartment),
		arg.Workposition,
	)
	return err
}

const allServiceStatistics = `-- name: AllServiceStatistics :one
WITH Registrations AS (
    SELECT COUNT(*) AS registration_count
    FROM account
    WHERE created_at >= to_timestamp($1) AND created_at <= to_timestamp($2)
),
     Quizes AS (
         SELECT COUNT(*) AS quiz_count
         FROM quiz
         WHERE deleted = false AND created_at >= to_timestamp($1) AND created_at <= to_timestamp($2)
     ),
     Results AS (
         SELECT COUNT(*) AS result_count
         FROM answer
         WHERE result = true AND created_at >= to_timestamp($1) AND created_at <= to_timestamp($2)
     )
SELECT
    (SELECT registration_count FROM Registrations) AS registrations,
    (SELECT quiz_count FROM Quizes) AS quizes,
    (SELECT result_count FROM Results) AS results
`

type AllServiceStatisticsParams struct {
	ToTimestamp   float64 `db:"to_timestamp" json:"to_timestamp"`
	ToTimestamp_2 float64 `db:"to_timestamp_2" json:"to_timestamp_2"`
}

type AllServiceStatisticsRow struct {
	Registrations int64 `db:"registrations" json:"registrations"`
	Quizes        int64 `db:"quizes" json:"quizes"`
	Results       int64 `db:"results" json:"results"`
}

func (q *Queries) AllServiceStatistics(ctx context.Context, arg AllServiceStatisticsParams) (AllServiceStatisticsRow, error) {
	row := q.db.QueryRowContext(ctx, allServiceStatistics, arg.ToTimestamp, arg.ToTimestamp_2)
	var i AllServiceStatisticsRow
	err := row.Scan(&i.Registrations, &i.Quizes, &i.Results)
	return i, err
}

const archiveQuiz = `-- name: ArchiveQuiz :exec
UPDATE quiz SET archived = true WHERE id=$1 AND accountId=$2
`

type ArchiveQuizParams struct {
	ID        int64  `db:"id" json:"id"`
	Accountid string `db:"accountid" json:"accountid"`
}

func (q *Queries) ArchiveQuiz(ctx context.Context, arg ArchiveQuizParams) error {
	_, err := q.db.ExecContext(ctx, archiveQuiz, arg.ID, arg.Accountid)
	return err
}

const changeBitrixQuizSettings = `-- name: ChangeBitrixQuizSettings :one
UPDATE BitrixRule
SET PerformerID = $1,PipelineID = $2,TypeID = $3,StageID= $4,SourceID = $5,StatusID = $6,FieldsRule = $7, TagsToAdd=$8, LeadFlag = $9
WHERE AccountID = (SELECT BitrixID FROM bitrixaccounts WHERE bitrixaccounts.AccountID = $10 AND bitrixaccounts.Deleted = false) AND QuizID = $11 AND Deleted = false
RETURNING id
`

type ChangeBitrixQuizSettingsParams struct {
	Performerid string          `db:"performerid" json:"performerid"`
	Pipelineid  int32           `db:"pipelineid" json:"pipelineid"`
	Typeid      string          `db:"typeid" json:"typeid"`
	Stageid     string          `db:"stageid" json:"stageid"`
	Sourceid    string          `db:"sourceid" json:"sourceid"`
	Statusid    string          `db:"statusid" json:"statusid"`
	Fieldsrule  json.RawMessage `db:"fieldsrule" json:"fieldsrule"`
	Tagstoadd   json.RawMessage `db:"tagstoadd" json:"tagstoadd"`
	Leadflag    bool            `db:"leadflag" json:"leadflag"`
	Accountid   string          `db:"accountid" json:"accountid"`
	Quizid      int32           `db:"quizid" json:"quizid"`
}

func (q *Queries) ChangeBitrixQuizSettings(ctx context.Context, arg ChangeBitrixQuizSettingsParams) (int64, error) {
	row := q.db.QueryRowContext(ctx, changeBitrixQuizSettings,
		arg.Performerid,
		arg.Pipelineid,
		arg.Typeid,
		arg.Stageid,
		arg.Sourceid,
		arg.Statusid,
		arg.Fieldsrule,
		arg.Tagstoadd,
		arg.Leadflag,
		arg.Accountid,
		arg.Quizid,
	)
	var id int64
	err := row.Scan(&id)
	return id, err
}

const changeQuizSettings = `-- name: ChangeQuizSettings :one
UPDATE rules
SET PerformerID = $1,PipelineID = $2,StepID = $3,FieldsRule = $4, TagsToAdd=$5, Deleted = false
WHERE AccountID = (SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $6 AND accountsAmo.Deleted = false) AND QuizID = $7
RETURNING id
`

type ChangeQuizSettingsParams struct {
	Performerid int32           `db:"performerid" json:"performerid"`
	Pipelineid  int32           `db:"pipelineid" json:"pipelineid"`
	Stepid      int32           `db:"stepid" json:"stepid"`
	Fieldsrule  json.RawMessage `db:"fieldsrule" json:"fieldsrule"`
	Tagstoadd   json.RawMessage `db:"tagstoadd" json:"tagstoadd"`
	Accountid   string          `db:"accountid" json:"accountid"`
	Quizid      int32           `db:"quizid" json:"quizid"`
}

func (q *Queries) ChangeQuizSettings(ctx context.Context, arg ChangeQuizSettingsParams) (int64, error) {
	row := q.db.QueryRowContext(ctx, changeQuizSettings,
		arg.Performerid,
		arg.Pipelineid,
		arg.Stepid,
		arg.Fieldsrule,
		arg.Tagstoadd,
		arg.Accountid,
		arg.Quizid,
	)
	var id int64
	err := row.Scan(&id)
	return id, err
}

const checkAndAddDefault = `-- name: CheckAndAddDefault :exec
UPDATE privileges
SET amount = $1, created_at = NOW()
WHERE privilege_name = $2
  AND (amount < $3 OR created_at <= NOW() - INTERVAL '1 month')
`

type CheckAndAddDefaultParams struct {
	Amount        int32  `db:"amount" json:"amount"`
	PrivilegeName string `db:"privilege_name" json:"privilege_name"`
	Amount_2      int32  `db:"amount_2" json:"amount_2"`
}

func (q *Queries) CheckAndAddDefault(ctx context.Context, arg CheckAndAddDefaultParams) error {
	_, err := q.db.ExecContext(ctx, checkAndAddDefault, arg.Amount, arg.PrivilegeName, arg.Amount_2)
	return err
}

const checkBitrixFields = `-- name: CheckBitrixFields :many
WITH user_data AS (
    SELECT BitrixID FROM BitrixAccounts WHERE BitrixAccounts.AccountID = $1 AND BitrixAccounts.Deleted = false
), new_fields AS (
    SELECT
    (field->>'bitrixID')::VARCHAR(255) AS BitrixID,
    (field->>'accountID')::VARCHAR(255) AS AccountID,
    CAST(field->>'entityID' AS FieldsType) AS EntityID,
    COALESCE(field->>'fieldName', '')::VARCHAR(255) AS FieldName,
    COALESCE(field->>'editFromLabel', '')::VARCHAR(255) AS EditFromLabel,
    CAST(field->>'fieldType' AS CustomFieldsType) AS FieldType,
    CURRENT_TIMESTAMP AS CreatedAt
    FROM json_array_elements($2::json) AS field
), inserted_fields AS (
INSERT INTO BitrixFields (BitrixID, AccountID, EntityID, FieldName, EditFromLabel, FieldType, CreatedAt)
SELECT
    nf.BitrixID,
    ud.BitrixID AS AccountID,
    nf.EntityID,
    nf.FieldName,
    nf.EditFromLabel,
    nf.FieldType,
    nf.CreatedAt
FROM new_fields nf
         JOIN user_data ud ON true
    ON CONFLICT (BitrixID, AccountID, EntityID) DO NOTHING
    RETURNING id, bitrixid, accountid, entityid, fieldname, editfromlabel, fieldtype, deleted, createdat
)
SELECT nf.bitrixid, nf.accountid, nf.entityid, nf.fieldname, nf.editfromlabel, nf.fieldtype, nf.createdat, ud.BitrixID AS AccountID
FROM new_fields nf
         JOIN user_data ud ON true
WHERE NOT EXISTS (
    SELECT id, ins.bitrixid, accountid, entityid, fieldname, editfromlabel, fieldtype, deleted, createdat, ud.bitrixid
    FROM inserted_fields ins
             JOIN user_data ud ON true
    WHERE ins.BitrixID = nf.BitrixID AND ins.AccountID = ud.BitrixID AND ins.EntityID = nf.EntityID
)
`

type CheckBitrixFieldsParams struct {
	Accountid string          `db:"accountid" json:"accountid"`
	Column2   json.RawMessage `db:"column_2" json:"column_2"`
}

type CheckBitrixFieldsRow struct {
	Bitrixid      string      `db:"bitrixid" json:"bitrixid"`
	Accountid     string      `db:"accountid" json:"accountid"`
	Entityid      interface{} `db:"entityid" json:"entityid"`
	Fieldname     string      `db:"fieldname" json:"fieldname"`
	Editfromlabel string      `db:"editfromlabel" json:"editfromlabel"`
	Fieldtype     interface{} `db:"fieldtype" json:"fieldtype"`
	Createdat     interface{} `db:"createdat" json:"createdat"`
	Accountid_2   string      `db:"accountid_2" json:"accountid_2"`
}

func (q *Queries) CheckBitrixFields(ctx context.Context, arg CheckBitrixFieldsParams) ([]CheckBitrixFieldsRow, error) {
	rows, err := q.db.QueryContext(ctx, checkBitrixFields, arg.Accountid, arg.Column2)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []CheckBitrixFieldsRow
	for rows.Next() {
		var i CheckBitrixFieldsRow
		if err := rows.Scan(
			&i.Bitrixid,
			&i.Accountid,
			&i.Entityid,
			&i.Fieldname,
			&i.Editfromlabel,
			&i.Fieldtype,
			&i.Createdat,
			&i.Accountid_2,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const checkBitrixPipelines = `-- name: CheckBitrixPipelines :many
WITH new_pipelines AS (
    SELECT (pipeline->>'bitrixID')::INT AS BitrixID,
            (pipeline->>'accountID')::varchar(255) AS AccountID,
            COALESCE(pipeline->>'name', '')::varchar(255) AS Name,
            (pipeline->>'entityTypeId')::INT as EntityTypeId,
           CURRENT_TIMESTAMP AS createdAt
    FROM json_array_elements($1::json) AS pipeline
), inserted_pipelines AS(
INSERT INTO PipelineBitrix (BitrixID, AccountID, Name, EntityTypeId, createdAt)
SELECT np.BitrixID,
       np.AccountID,
       np.Name,
       np.EntityTypeId,
       np.createdAt
FROM new_pipelines np
    ON CONFLICT (BitrixID, AccountID) WHERE Deleted = false DO NOTHING
        RETURNING id, bitrixid, accountid, name, entitytypeid, deleted, createdat
)
SELECT np.bitrixid, np.accountid, np.name, np.entitytypeid, np.createdat
FROM new_pipelines np
WHERE NOT EXISTS (
    SELECT id, bitrixid, accountid, name, entitytypeid, deleted, createdat
    FROM inserted_pipelines ins
    WHERE ins.BitrixID = np.BitrixID AND ins.AccountID = np.AccountID
)
`

type CheckBitrixPipelinesRow struct {
	Bitrixid     int32       `db:"bitrixid" json:"bitrixid"`
	Accountid    string      `db:"accountid" json:"accountid"`
	Name         string      `db:"name" json:"name"`
	Entitytypeid int32       `db:"entitytypeid" json:"entitytypeid"`
	Createdat    interface{} `db:"createdat" json:"createdat"`
}

func (q *Queries) CheckBitrixPipelines(ctx context.Context, dollar_1 json.RawMessage) ([]CheckBitrixPipelinesRow, error) {
	rows, err := q.db.QueryContext(ctx, checkBitrixPipelines, dollar_1)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []CheckBitrixPipelinesRow
	for rows.Next() {
		var i CheckBitrixPipelinesRow
		if err := rows.Scan(
			&i.Bitrixid,
			&i.Accountid,
			&i.Name,
			&i.Entitytypeid,
			&i.Createdat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const checkBitrixSteps = `-- name: CheckBitrixSteps :many
WITH new_steps AS (
    SELECT (step->>'bitrixID')::VARCHAR(255) AS BitrixID,
            (step->>'pipelineID')::INT AS PipelineID,
            (step->>'accountID')::VARCHAR(255) AS AccountID,
            (step->>'entityID')::VARCHAR(255) AS EntityID,
            (step->>'statusID')::VARCHAR(255) AS StatusID,
            COALESCE(step->>'name', '')::VARCHAR(255) AS Name,
            COALESCE(step->>'nameInit', '')::VARCHAR(255) AS NameInit,
            COALESCE(step->>'color', '')::VARCHAR(50) AS Color,
            CURRENT_TIMESTAMP AS CreatedAt
    FROM json_array_elements($1::json) AS step
), inserted_steps AS (
INSERT INTO StepBitrix (BitrixID, PipelineID, AccountID,EntityID, StatusID, Name,NameInit, Color, CreatedAt)
SELECT ns.BitrixID,
       ns.PipelineID,
       ns.AccountID,
       ns.EntityID,
       ns.StatusID,
       ns.Name,
       ns.NameInit,
       ns.Color,
       ns.CreatedAt
FROM new_steps ns
    ON CONFLICT (BitrixID, AccountID) WHERE Deleted = false DO NOTHING
    RETURNING id, accountid, bitrixid, entityid, statusid, name, nameinit, color, pipelineid, deleted, createdat
)
SELECT ns.bitrixid, ns.pipelineid, ns.accountid, ns.entityid, ns.statusid, ns.name, ns.nameinit, ns.color, ns.createdat
FROM new_steps ns
WHERE NOT EXISTS (
    SELECT id, accountid, bitrixid, entityid, statusid, name, nameinit, color, pipelineid, deleted, createdat
    FROM inserted_steps ins
    WHERE ins.BitrixID = ns.BitrixID AND ins.AccountID = ns.AccountID
)
`

type CheckBitrixStepsRow struct {
	Bitrixid   string      `db:"bitrixid" json:"bitrixid"`
	Pipelineid int32       `db:"pipelineid" json:"pipelineid"`
	Accountid  string      `db:"accountid" json:"accountid"`
	Entityid   string      `db:"entityid" json:"entityid"`
	Statusid   string      `db:"statusid" json:"statusid"`
	Name       string      `db:"name" json:"name"`
	Nameinit   string      `db:"nameinit" json:"nameinit"`
	Color      string      `db:"color" json:"color"`
	Createdat  interface{} `db:"createdat" json:"createdat"`
}

func (q *Queries) CheckBitrixSteps(ctx context.Context, dollar_1 json.RawMessage) ([]CheckBitrixStepsRow, error) {
	rows, err := q.db.QueryContext(ctx, checkBitrixSteps, dollar_1)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []CheckBitrixStepsRow
	for rows.Next() {
		var i CheckBitrixStepsRow
		if err := rows.Scan(
			&i.Bitrixid,
			&i.Pipelineid,
			&i.Accountid,
			&i.Entityid,
			&i.Statusid,
			&i.Name,
			&i.Nameinit,
			&i.Color,
			&i.Createdat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const checkExpiredBitrixToken = `-- name: CheckExpiredBitrixToken :one
SELECT accountid, refreshtoken, accesstoken, authcode, expiration, createdat FROM BitrixTokens WHERE AccountID = $1 AND Expiration <= NOW()
`

func (q *Queries) CheckExpiredBitrixToken(ctx context.Context, accountid string) (Bitrixtoken, error) {
	row := q.db.QueryRowContext(ctx, checkExpiredBitrixToken, accountid)
	var i Bitrixtoken
	err := row.Scan(
		&i.Accountid,
		&i.Refreshtoken,
		&i.Accesstoken,
		&i.Authcode,
		&i.Expiration,
		&i.Createdat,
	)
	return i, err
}

const checkExpiredToken = `-- name: CheckExpiredToken :one
SELECT accountid, refreshtoken, accesstoken, authcode, expiration, createdat FROM tokens WHERE AccountID = $1 AND Expiration <= NOW()
`

func (q *Queries) CheckExpiredToken(ctx context.Context, accountid string) (Token, error) {
	row := q.db.QueryRowContext(ctx, checkExpiredToken, accountid)
	var i Token
	err := row.Scan(
		&i.Accountid,
		&i.Refreshtoken,
		&i.Accesstoken,
		&i.Authcode,
		&i.Expiration,
		&i.Createdat,
	)
	return i, err
}

const checkFields = `-- name: CheckFields :many
WITH user_data AS (
    SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
), new_fields AS (
    SELECT (field->>'AmoID')::INT AS amoID,
           COALESCE(field->>'Code', '')::varchar(255) AS code,
           COALESCE(field->>'Name', '')::varchar(512) AS name,
           CAST(field->>'Entity' AS entitytype) AS Entity,
           COALESCE(field->>'Type', '')::fieldtype AS type,
           CURRENT_TIMESTAMP AS createdAt
    FROM json_array_elements($2::json) AS field
), inserted_fields AS(
    INSERT INTO fields (amoID, code, accountID, name, Entity, type, createdAt)
           SELECT nf.amoID,
                  nf.code,
                  ud.AmoID,
                  nf.name,
                  nf.Entity,
                  nf.type,
                  nf.createdAt
           FROM new_fields nf
                    JOIN user_data ud ON true
           ON CONFLICT (amoID, accountID, entity) DO UPDATE SET Deleted=false
           RETURNING id, amoid, code, accountid, name, entity, type, deleted, createdat
)
SELECT nf.amoid, nf.code, nf.name, nf.entity, nf.type, nf.createdat,ud.AmoID
FROM new_fields nf
         JOIN user_data ud ON true
WHERE NOT EXISTS (
    SELECT id, ins.amoid, code, accountid, name, entity, type, deleted, createdat, ud.amoid
    FROM inserted_fields ins
             JOIN user_data ud ON true
    WHERE ins.amoID = nf.amoID AND ins.accountID = ud.amoid AND ins.Entity = nf.Entity
)
`

type CheckFieldsParams struct {
	Accountid string          `db:"accountid" json:"accountid"`
	Column2   json.RawMessage `db:"column_2" json:"column_2"`
}

type CheckFieldsRow struct {
	Amoid     int32       `db:"amoid" json:"amoid"`
	Code      string      `db:"code" json:"code"`
	Name      string      `db:"name" json:"name"`
	Entity    interface{} `db:"entity" json:"entity"`
	Type      interface{} `db:"type" json:"type"`
	Createdat interface{} `db:"createdat" json:"createdat"`
	Amoid_2   int32       `db:"amoid_2" json:"amoid_2"`
}

func (q *Queries) CheckFields(ctx context.Context, arg CheckFieldsParams) ([]CheckFieldsRow, error) {
	rows, err := q.db.QueryContext(ctx, checkFields, arg.Accountid, arg.Column2)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []CheckFieldsRow
	for rows.Next() {
		var i CheckFieldsRow
		if err := rows.Scan(
			&i.Amoid,
			&i.Code,
			&i.Name,
			&i.Entity,
			&i.Type,
			&i.Createdat,
			&i.Amoid_2,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const checkIsOwnerAudience = `-- name: CheckIsOwnerAudience :one
SELECT EXISTS ( SELECT 1 FROM gigachatAudience ga JOIN quiz q ON ga.QuizID = q.id
    WHERE ga.QuizID = $1 AND ga.ID = $2 AND q.accountid = $3 AND ga.Deleted = FALSE
) AS is_owner
`

type CheckIsOwnerAudienceParams struct {
	Quizid    int64  `db:"quizid" json:"quizid"`
	ID        int64  `db:"id" json:"id"`
	Accountid string `db:"accountid" json:"accountid"`
}

func (q *Queries) CheckIsOwnerAudience(ctx context.Context, arg CheckIsOwnerAudienceParams) (bool, error) {
	row := q.db.QueryRowContext(ctx, checkIsOwnerAudience, arg.Quizid, arg.ID, arg.Accountid)
	var is_owner bool
	err := row.Scan(&is_owner)
	return is_owner, err
}

const checkLeadTargetOwner = `-- name: CheckLeadTargetOwner :one
SELECT accountid FROM leadtarget WHERE id = $1 AND accountid = $2
`

type CheckLeadTargetOwnerParams struct {
	ID        int64  `db:"id" json:"id"`
	Accountid string `db:"accountid" json:"accountid"`
}

func (q *Queries) CheckLeadTargetOwner(ctx context.Context, arg CheckLeadTargetOwnerParams) (string, error) {
	row := q.db.QueryRowContext(ctx, checkLeadTargetOwner, arg.ID, arg.Accountid)
	var accountid string
	err := row.Scan(&accountid)
	return accountid, err
}

const checkPipelines = `-- name: CheckPipelines :many
WITH new_pipelines AS (
    SELECT (pipeline->>'AmoID')::INT AS amoID,
           (pipeline->>'AccountID')::INT AS accountID,
           COALESCE(pipeline->>'Name', '')::varchar(512) AS name,
           CASE WHEN (pipeline->>'IsArchive') = 'true' THEN TRUE ELSE FALSE END AS isArchive,
           CURRENT_TIMESTAMP AS createdAt
    FROM json_array_elements($1::json) AS pipeline
), inserted_pipelines AS(
    INSERT INTO pipelines (amoID, accountID, name, isArchive, createdAt)
        SELECT np.amoID,
               np.accountID,
               np.name,
               np.isArchive,
               np.createdAt
        FROM new_pipelines np
        ON CONFLICT (amoID, accountID) DO NOTHING
        RETURNING id, amoid, accountid, name, isarchive, deleted, createdat
)
SELECT np.amoid, np.accountid, np.name, np.isarchive, np.createdat
FROM new_pipelines np
WHERE NOT EXISTS (
    SELECT id, amoid, accountid, name, isarchive, deleted, createdat
    FROM inserted_pipelines ins
    WHERE ins.amoID = np.amoID AND ins.accountID = np.accountID
)
`

type CheckPipelinesRow struct {
	Amoid     int32       `db:"amoid" json:"amoid"`
	Accountid int32       `db:"accountid" json:"accountid"`
	Name      string      `db:"name" json:"name"`
	Isarchive bool        `db:"isarchive" json:"isarchive"`
	Createdat interface{} `db:"createdat" json:"createdat"`
}

func (q *Queries) CheckPipelines(ctx context.Context, dollar_1 json.RawMessage) ([]CheckPipelinesRow, error) {
	rows, err := q.db.QueryContext(ctx, checkPipelines, dollar_1)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []CheckPipelinesRow
	for rows.Next() {
		var i CheckPipelinesRow
		if err := rows.Scan(
			&i.Amoid,
			&i.Accountid,
			&i.Name,
			&i.Isarchive,
			&i.Createdat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const checkQuestionOwner = `-- name: CheckQuestionOwner :one
SELECT qz.accountid  FROM question q
                              JOIN quiz qz ON q.quiz_id = qz.id WHERE q.id = $1 AND qz.accountid = $2
`

type CheckQuestionOwnerParams struct {
	ID        int64  `db:"id" json:"id"`
	Accountid string `db:"accountid" json:"accountid"`
}

func (q *Queries) CheckQuestionOwner(ctx context.Context, arg CheckQuestionOwnerParams) (string, error) {
	row := q.db.QueryRowContext(ctx, checkQuestionOwner, arg.ID, arg.Accountid)
	var accountid string
	err := row.Scan(&accountid)
	return accountid, err
}

const checkQuizOwner = `-- name: CheckQuizOwner :one
SELECT accountid FROM quiz WHERE id = $1 AND accountid = $2
`

type CheckQuizOwnerParams struct {
	ID        int64  `db:"id" json:"id"`
	Accountid string `db:"accountid" json:"accountid"`
}

func (q *Queries) CheckQuizOwner(ctx context.Context, arg CheckQuizOwnerParams) (string, error) {
	row := q.db.QueryRowContext(ctx, checkQuizOwner, arg.ID, arg.Accountid)
	var accountid string
	err := row.Scan(&accountid)
	return accountid, err
}

const checkResultOwner = `-- name: CheckResultOwner :one
SELECT q.accountid FROM answer a JOIN quiz q ON a.quiz_id = q.id WHERE a.id = $1 AND a.deleted = FALSE AND a.start = false
`

func (q *Queries) CheckResultOwner(ctx context.Context, id int64) (string, error) {
	row := q.db.QueryRowContext(ctx, checkResultOwner, id)
	var accountid string
	err := row.Scan(&accountid)
	return accountid, err
}

const checkResultsOwner = `-- name: CheckResultsOwner :many
SELECT a.id
FROM answer a
         JOIN quiz q ON a.quiz_id = q.id
WHERE a.id = ANY($1::bigint[]) AND a.deleted = FALSE AND q.accountid = $2 AND a.start = false
`

type CheckResultsOwnerParams struct {
	Column1   []int64 `db:"column_1" json:"column_1"`
	Accountid string  `db:"accountid" json:"accountid"`
}

func (q *Queries) CheckResultsOwner(ctx context.Context, arg CheckResultsOwnerParams) ([]int64, error) {
	rows, err := q.db.QueryContext(ctx, checkResultsOwner, pq.Array(arg.Column1), arg.Accountid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []int64
	for rows.Next() {
		var id int64
		if err := rows.Scan(&id); err != nil {
			return nil, err
		}
		items = append(items, id)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const checkSteps = `-- name: CheckSteps :many
WITH new_steps AS (
    SELECT (step->>'AmoID')::INT AS amoID,
           (step->>'PipelineID')::INT AS pipelineID,
           (step->>'AccountID')::INT AS accountID,
           COALESCE(step->>'Name', '')::varchar(512) AS name,
           COALESCE(step->>'Color', '')::varchar(50) AS color,
           CURRENT_TIMESTAMP AS createdAt
    FROM json_array_elements($1::json) AS step
), inserted_steps AS (
    INSERT INTO steps (amoID, pipelineID, accountID, name, color, createdAt)
        SELECT ns.amoID,
               ns.pipelineID,
               ns.accountID,
               ns.name,
               ns.color,
               ns.createdAt
        FROM new_steps ns
        ON CONFLICT (amoID, accountID, PipelineID) DO NOTHING
        RETURNING id, amoid, pipelineid, accountid, name, color, deleted, createdat
)
SELECT ns.amoid, ns.pipelineid, ns.accountid, ns.name, ns.color, ns.createdat
FROM new_steps ns
WHERE NOT EXISTS (
    SELECT id, amoid, pipelineid, accountid, name, color, deleted, createdat
    FROM inserted_steps ins
    WHERE ins.amoID = ns.amoID AND ins.accountID = ns.accountID AND ins.pipelineID = ns.pipelineID
)
`

type CheckStepsRow struct {
	Amoid      int32       `db:"amoid" json:"amoid"`
	Pipelineid int32       `db:"pipelineid" json:"pipelineid"`
	Accountid  int32       `db:"accountid" json:"accountid"`
	Name       string      `db:"name" json:"name"`
	Color      string      `db:"color" json:"color"`
	Createdat  interface{} `db:"createdat" json:"createdat"`
}

func (q *Queries) CheckSteps(ctx context.Context, dollar_1 json.RawMessage) ([]CheckStepsRow, error) {
	rows, err := q.db.QueryContext(ctx, checkSteps, dollar_1)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []CheckStepsRow
	for rows.Next() {
		var i CheckStepsRow
		if err := rows.Scan(
			&i.Amoid,
			&i.Pipelineid,
			&i.Accountid,
			&i.Name,
			&i.Color,
			&i.Createdat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const checkTags = `-- name: CheckTags :many
WITH user_data AS (
    SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
), new_tags AS (
    SELECT (tag->>'AmoID')::INT AS amoID,
           (tag->>'Entity')::entitytype AS Entity,
           COALESCE(tag->>'Name', '')::VARCHAR(512) AS name,
           COALESCE(tag->>'Color', '')::VARCHAR(50) AS color
    FROM json_array_elements($2::json) AS tag
), inserted_tags AS (
    INSERT INTO tags (amoID, accountID, Entity, name, color, createdAt)
        SELECT nt.amoID,
               ud.AmoID,
               nt.Entity,
               nt.name,
               nt.color,
               CURRENT_TIMESTAMP
        FROM new_tags nt
                 JOIN user_data ud ON true
        ON CONFLICT (amoID, accountID, Entity) DO UPDATE SET Deleted = false
        RETURNING id, amoid, accountid, entity, name, color, deleted, createdat
)
SELECT nt.amoid, nt.entity, nt.name, nt.color,ud.AmoID
FROM new_tags nt
         JOIN user_data ud ON true
WHERE NOT EXISTS (
    SELECT id, ins.amoid, accountid, entity, name, color, deleted, createdat, ud.amoid
    FROM inserted_tags ins
             JOIN user_data ud ON true
    WHERE ins.amoID = nt.amoID AND ins.accountID = ud.amoid AND ins.Entity = nt.Entity
)
`

type CheckTagsParams struct {
	Accountid string          `db:"accountid" json:"accountid"`
	Column2   json.RawMessage `db:"column_2" json:"column_2"`
}

type CheckTagsRow struct {
	Amoid   int32       `db:"amoid" json:"amoid"`
	Entity  interface{} `db:"entity" json:"entity"`
	Name    string      `db:"name" json:"name"`
	Color   string      `db:"color" json:"color"`
	Amoid_2 int32       `db:"amoid_2" json:"amoid_2"`
}

func (q *Queries) CheckTags(ctx context.Context, arg CheckTagsParams) ([]CheckTagsRow, error) {
	rows, err := q.db.QueryContext(ctx, checkTags, arg.Accountid, arg.Column2)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []CheckTagsRow
	for rows.Next() {
		var i CheckTagsRow
		if err := rows.Scan(
			&i.Amoid,
			&i.Entity,
			&i.Name,
			&i.Color,
			&i.Amoid_2,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const copyQuestion = `-- name: CopyQuestion :one
INSERT INTO question(
    quiz_id, title, description, questiontype, required,
    page, content, version, parent_ids
)
SELECT $1, title, description, questiontype, required,
       page, content, version, parent_ids
FROM question WHERE question.id=$2
RETURNING question.id, quiz_id, created_at, updated_at
`

type CopyQuestionParams struct {
	QuizID int64 `db:"quiz_id" json:"quiz_id"`
	ID     int64 `db:"id" json:"id"`
}

type CopyQuestionRow struct {
	ID        int64        `db:"id" json:"id"`
	QuizID    int64        `db:"quiz_id" json:"quiz_id"`
	CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
	UpdatedAt sql.NullTime `db:"updated_at" json:"updated_at"`
}

func (q *Queries) CopyQuestion(ctx context.Context, arg CopyQuestionParams) (CopyQuestionRow, error) {
	row := q.db.QueryRowContext(ctx, copyQuestion, arg.QuizID, arg.ID)
	var i CopyQuestionRow
	err := row.Scan(
		&i.ID,
		&i.QuizID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const copyQuestionQuizID = `-- name: CopyQuestionQuizID :exec
INSERT INTO question (
    quiz_id, title, description, questiontype, required,
    page, content, version, parent_ids, created_at, updated_at
)
SELECT
    $2, title, description, questiontype, required,
    page, content, version, parent_ids, created_at, updated_at
FROM
    question
WHERE
    question.quiz_id = $1 AND deleted = false
`

type CopyQuestionQuizIDParams struct {
	QuizID   int64 `db:"quiz_id" json:"quiz_id"`
	QuizID_2 int64 `db:"quiz_id_2" json:"quiz_id_2"`
}

func (q *Queries) CopyQuestionQuizID(ctx context.Context, arg CopyQuestionQuizIDParams) error {
	_, err := q.db.ExecContext(ctx, copyQuestionQuizID, arg.QuizID, arg.QuizID_2)
	return err
}

const copyQuiz = `-- name: CopyQuiz :one
INSERT INTO quiz(
    accountid, archived,fingerprinting,repeatable,note_prevented,mail_notifications,unique_answers,name,description,config,
    status,limit_answers,due_to,time_of_passing,pausable,version,version_comment,parent_ids,questions_count, super, group_id
)
SELECT accountid, archived,fingerprinting,repeatable,note_prevented,mail_notifications,unique_answers,name,description,config,
       status,limit_answers,due_to,time_of_passing,pausable,version,version_comment,parent_ids,questions_count, super, group_id
FROM quiz WHERE quiz.id=$1 AND quiz.accountId=$2
RETURNING id, qid,created_at, updated_at
`

type CopyQuizParams struct {
	ID        int64  `db:"id" json:"id"`
	Accountid string `db:"accountid" json:"accountid"`
}

type CopyQuizRow struct {
	ID        int64         `db:"id" json:"id"`
	Qid       uuid.NullUUID `db:"qid" json:"qid"`
	CreatedAt sql.NullTime  `db:"created_at" json:"created_at"`
	UpdatedAt sql.NullTime  `db:"updated_at" json:"updated_at"`
}

func (q *Queries) CopyQuiz(ctx context.Context, arg CopyQuizParams) (CopyQuizRow, error) {
	row := q.db.QueryRowContext(ctx, copyQuiz, arg.ID, arg.Accountid)
	var i CopyQuizRow
	err := row.Scan(
		&i.ID,
		&i.Qid,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const copyQuizQuestions = `-- name: CopyQuizQuestions :exec
INSERT INTO question(
    quiz_id, title, description, questiontype, required, page, content, version, parent_ids
)
SELECT $2, title, description, questiontype, required, page, content, version, parent_ids
FROM question WHERE question.quiz_id=$1 AND deleted=false
`

type CopyQuizQuestionsParams struct {
	QuizID   int64 `db:"quiz_id" json:"quiz_id"`
	QuizID_2 int64 `db:"quiz_id_2" json:"quiz_id_2"`
}

func (q *Queries) CopyQuizQuestions(ctx context.Context, arg CopyQuizQuestionsParams) error {
	_, err := q.db.ExecContext(ctx, copyQuizQuestions, arg.QuizID, arg.QuizID_2)
	return err
}

const createAccount = `-- name: CreateAccount :one
INSERT INTO account (id, user_id, created_at, deleted) VALUES ($1, $2, $3, $4) RETURNING id, user_id, created_at, deleted
`

type CreateAccountParams struct {
	ID        uuid.UUID `db:"id" json:"id"`
	UserID    string    `db:"user_id" json:"user_id"`
	CreatedAt time.Time `db:"created_at" json:"created_at"`
	Deleted   bool      `db:"deleted" json:"deleted"`
}

func (q *Queries) CreateAccount(ctx context.Context, arg CreateAccountParams) (Account, error) {
	row := q.db.QueryRowContext(ctx, createAccount,
		arg.ID,
		arg.UserID,
		arg.CreatedAt,
		arg.Deleted,
	)
	var i Account
	err := row.Scan(
		&i.ID,
		&i.UserID,
		&i.CreatedAt,
		&i.Deleted,
	)
	return i, err
}

const createAmoAccount = `-- name: CreateAmoAccount :exec

INSERT INTO accountsAmo (AccountID, AmoID,Name, Subdomain, Country,DriveURL)
VALUES ($1, $2, $3, $4, $5, $6)
`

type CreateAmoAccountParams struct {
	Accountid string `db:"accountid" json:"accountid"`
	Amoid     int32  `db:"amoid" json:"amoid"`
	Name      string `db:"name" json:"name"`
	Subdomain string `db:"subdomain" json:"subdomain"`
	Country   string `db:"country" json:"country"`
	Driveurl  string `db:"driveurl" json:"driveurl"`
}

// amo methods:
func (q *Queries) CreateAmoAccount(ctx context.Context, arg CreateAmoAccountParams) error {
	_, err := q.db.ExecContext(ctx, createAmoAccount,
		arg.Accountid,
		arg.Amoid,
		arg.Name,
		arg.Subdomain,
		arg.Country,
		arg.Driveurl,
	)
	return err
}

const createBitrixAccount = `-- name: CreateBitrixAccount :exec
INSERT INTO BitrixAccounts (AccountID, BitrixID, Subdomain)
VALUES ($1, $2, $3)
`

type CreateBitrixAccountParams struct {
	Accountid string `db:"accountid" json:"accountid"`
	Bitrixid  string `db:"bitrixid" json:"bitrixid"`
	Subdomain string `db:"subdomain" json:"subdomain"`
}

func (q *Queries) CreateBitrixAccount(ctx context.Context, arg CreateBitrixAccountParams) error {
	_, err := q.db.ExecContext(ctx, createBitrixAccount, arg.Accountid, arg.Bitrixid, arg.Subdomain)
	return err
}

const createBitrixWebHook = `-- name: CreateBitrixWebHook :exec
INSERT INTO BitrixTokens (AccountID, RefreshToken, AccessToken, AuthCode, Expiration, CreatedAt)
VALUES ($1, $2, $3, $4, $5, $6)
`

type CreateBitrixWebHookParams struct {
	Accountid    string    `db:"accountid" json:"accountid"`
	Refreshtoken string    `db:"refreshtoken" json:"refreshtoken"`
	Accesstoken  string    `db:"accesstoken" json:"accesstoken"`
	Authcode     string    `db:"authcode" json:"authcode"`
	Expiration   time.Time `db:"expiration" json:"expiration"`
	Createdat    time.Time `db:"createdat" json:"createdat"`
}

func (q *Queries) CreateBitrixWebHook(ctx context.Context, arg CreateBitrixWebHookParams) error {
	_, err := q.db.ExecContext(ctx, createBitrixWebHook,
		arg.Accountid,
		arg.Refreshtoken,
		arg.Accesstoken,
		arg.Authcode,
		arg.Expiration,
		arg.Createdat,
	)
	return err
}

const createLeadTarget = `-- name: CreateLeadTarget :one
INSERT INTO leadtarget (accountID,type,quizID,target,InviteLink) VALUES ($1,$2,$3,$4,$5) RETURNING id, accountid, type, quizid, target, invitelink, deleted, createdat
`

type CreateLeadTargetParams struct {
	Accountid  string      `db:"accountid" json:"accountid"`
	Type       interface{} `db:"type" json:"type"`
	Quizid     int32       `db:"quizid" json:"quizid"`
	Target     string      `db:"target" json:"target"`
	Invitelink string      `db:"invitelink" json:"invitelink"`
}

func (q *Queries) CreateLeadTarget(ctx context.Context, arg CreateLeadTargetParams) (Leadtarget, error) {
	row := q.db.QueryRowContext(ctx, createLeadTarget,
		arg.Accountid,
		arg.Type,
		arg.Quizid,
		arg.Target,
		arg.Invitelink,
	)
	var i Leadtarget
	err := row.Scan(
		&i.ID,
		&i.Accountid,
		&i.Type,
		&i.Quizid,
		&i.Target,
		&i.Invitelink,
		&i.Deleted,
		&i.Createdat,
	)
	return i, err
}

const createQuizAudience = `-- name: CreateQuizAudience :one
INSERT INTO gigachatAudience (QuizID, Sex, Age) VALUES ($1, $2, $3) RETURNING ID
`

type CreateQuizAudienceParams struct {
	Quizid int64  `db:"quizid" json:"quizid"`
	Sex    int32  `db:"sex" json:"sex"`
	Age    string `db:"age" json:"age"`
}

func (q *Queries) CreateQuizAudience(ctx context.Context, arg CreateQuizAudienceParams) (int64, error) {
	row := q.db.QueryRowContext(ctx, createQuizAudience, arg.Quizid, arg.Sex, arg.Age)
	var id int64
	err := row.Scan(&id)
	return id, err
}

const createQuizUtm = `-- name: CreateQuizUtm :one
INSERT into quiz_utm (quizID,utm) values ($1,$2) RETURNING id, quizid, utm, deleted, created_at
`

type CreateQuizUtmParams struct {
	Quizid int64  `db:"quizid" json:"quizid"`
	Utm    string `db:"utm" json:"utm"`
}

func (q *Queries) CreateQuizUtm(ctx context.Context, arg CreateQuizUtmParams) (QuizUtm, error) {
	row := q.db.QueryRowContext(ctx, createQuizUtm, arg.Quizid, arg.Utm)
	var i QuizUtm
	err := row.Scan(
		&i.ID,
		&i.Quizid,
		&i.Utm,
		&i.Deleted,
		&i.CreatedAt,
	)
	return i, err
}

const createTgAccount = `-- name: CreateTgAccount :one
INSERT INTO tgAccounts (ApiID, ApiHash, PhoneNumber,Password, Status)
VALUES ($1, $2, $3, $4, $5) RETURNING id
`

type CreateTgAccountParams struct {
	Apiid       int32       `db:"apiid" json:"apiid"`
	Apihash     string      `db:"apihash" json:"apihash"`
	Phonenumber string      `db:"phonenumber" json:"phonenumber"`
	Password    string      `db:"password" json:"password"`
	Status      interface{} `db:"status" json:"status"`
}

func (q *Queries) CreateTgAccount(ctx context.Context, arg CreateTgAccountParams) (int64, error) {
	row := q.db.QueryRowContext(ctx, createTgAccount,
		arg.Apiid,
		arg.Apihash,
		arg.Phonenumber,
		arg.Password,
		arg.Status,
	)
	var id int64
	err := row.Scan(&id)
	return id, err
}

const createWebHook = `-- name: CreateWebHook :exec
INSERT INTO tokens (AccountID, RefreshToken, AccessToken, AuthCode, Expiration, CreatedAt)
VALUES ($1, $2, $3, $4, $5, $6)
`

type CreateWebHookParams struct {
	Accountid    string       `db:"accountid" json:"accountid"`
	Refreshtoken string       `db:"refreshtoken" json:"refreshtoken"`
	Accesstoken  string       `db:"accesstoken" json:"accesstoken"`
	Authcode     string       `db:"authcode" json:"authcode"`
	Expiration   time.Time    `db:"expiration" json:"expiration"`
	Createdat    sql.NullTime `db:"createdat" json:"createdat"`
}

func (q *Queries) CreateWebHook(ctx context.Context, arg CreateWebHookParams) error {
	_, err := q.db.ExecContext(ctx, createWebHook,
		arg.Accountid,
		arg.Refreshtoken,
		arg.Accesstoken,
		arg.Authcode,
		arg.Expiration,
		arg.Createdat,
	)
	return err
}

const decrementManual = `-- name: DecrementManual :one
UPDATE privileges p SET amount = amount - 1 FROM account a
WHERE p.account_id = a.id AND a.user_id = $1 AND p.privilegeID = $2 AND p.amount > 0
RETURNING p.id, p.privilegeID, p.account_id, p.privilege_name, p.amount, p.created_at
`

type DecrementManualParams struct {
	UserID      string `db:"user_id" json:"user_id"`
	Privilegeid string `db:"privilegeid" json:"privilegeid"`
}

func (q *Queries) DecrementManual(ctx context.Context, arg DecrementManualParams) (Privilege, error) {
	row := q.db.QueryRowContext(ctx, decrementManual, arg.UserID, arg.Privilegeid)
	var i Privilege
	err := row.Scan(
		&i.ID,
		&i.Privilegeid,
		&i.AccountID,
		&i.PrivilegeName,
		&i.Amount,
		&i.CreatedAt,
	)
	return i, err
}

const deleteAccountById = `-- name: DeleteAccountById :exec
DELETE FROM account WHERE id = $1
`

func (q *Queries) DeleteAccountById(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.ExecContext(ctx, deleteAccountById, id)
	return err
}

const deleteBitrixFields = `-- name: DeleteBitrixFields :exec
UPDATE BitrixFields SET Deleted = true WHERE ID = ANY($1::bigint[])
`

func (q *Queries) DeleteBitrixFields(ctx context.Context, dollar_1 []int64) error {
	_, err := q.db.ExecContext(ctx, deleteBitrixFields, pq.Array(dollar_1))
	return err
}

const deleteBitrixPipelines = `-- name: DeleteBitrixPipelines :exec
UPDATE PipelineBitrix SET Deleted = true WHERE ID = ANY($1::bigint[])
`

func (q *Queries) DeleteBitrixPipelines(ctx context.Context, dollar_1 []int64) error {
	_, err := q.db.ExecContext(ctx, deleteBitrixPipelines, pq.Array(dollar_1))
	return err
}

const deleteBitrixSteps = `-- name: DeleteBitrixSteps :exec
UPDATE StepBitrix SET Deleted = true WHERE ID = ANY($1::bigint[])
`

func (q *Queries) DeleteBitrixSteps(ctx context.Context, dollar_1 []int64) error {
	_, err := q.db.ExecContext(ctx, deleteBitrixSteps, pq.Array(dollar_1))
	return err
}

const deleteBitrixUsers = `-- name: DeleteBitrixUsers :exec
UPDATE BitrixAccountUsers SET Deleted = true WHERE ID = ANY($1::bigint[])
`

func (q *Queries) DeleteBitrixUsers(ctx context.Context, dollar_1 []int64) error {
	_, err := q.db.ExecContext(ctx, deleteBitrixUsers, pq.Array(dollar_1))
	return err
}

const deleteFields = `-- name: DeleteFields :exec
UPDATE fields SET Deleted = true WHERE ID = ANY($1::bigint[])
`

func (q *Queries) DeleteFields(ctx context.Context, dollar_1 []int64) error {
	_, err := q.db.ExecContext(ctx, deleteFields, pq.Array(dollar_1))
	return err
}

const deleteLeadTarget = `-- name: DeleteLeadTarget :exec
UPDATE leadtarget SET deleted = true WHERE id = $1
`

func (q *Queries) DeleteLeadTarget(ctx context.Context, id int64) error {
	_, err := q.db.ExecContext(ctx, deleteLeadTarget, id)
	return err
}

const deletePipelines = `-- name: DeletePipelines :exec
UPDATE pipelines SET Deleted = true WHERE ID = ANY($1::bigint[])
`

func (q *Queries) DeletePipelines(ctx context.Context, dollar_1 []int64) error {
	_, err := q.db.ExecContext(ctx, deletePipelines, pq.Array(dollar_1))
	return err
}

const deletePrivilegeByAccID = `-- name: DeletePrivilegeByAccID :exec
DELETE FROM privileges WHERE account_id = $1
`

func (q *Queries) DeletePrivilegeByAccID(ctx context.Context, accountID uuid.UUID) error {
	_, err := q.db.ExecContext(ctx, deletePrivilegeByAccID, accountID)
	return err
}

const deletePrivilegeByID = `-- name: DeletePrivilegeByID :exec
DELETE FROM privileges WHERE id = $1
`

func (q *Queries) DeletePrivilegeByID(ctx context.Context, id int32) error {
	_, err := q.db.ExecContext(ctx, deletePrivilegeByID, id)
	return err
}

const deleteQuestion = `-- name: DeleteQuestion :one
UPDATE question SET deleted=true WHERE id=$1 RETURNING question.id, question.quiz_id, question.title, question.description, question.questiontype, question.required, question.deleted, question.page, question.content, question.version, question.parent_ids, question.created_at, question.updated_at, question.session, question.auditory
`

func (q *Queries) DeleteQuestion(ctx context.Context, id int64) (Question, error) {
	row := q.db.QueryRowContext(ctx, deleteQuestion, id)
	var i Question
	err := row.Scan(
		&i.ID,
		&i.QuizID,
		&i.Title,
		&i.Description,
		&i.Questiontype,
		&i.Required,
		&i.Deleted,
		&i.Page,
		&i.Content,
		&i.Version,
		pq.Array(&i.ParentIds),
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Session,
		&i.Auditory,
	)
	return i, err
}

const deleteQuizAudience = `-- name: DeleteQuizAudience :exec
UPDATE gigachatAudience set Deleted = TRUE WHERE QuizID = $1 and ID = $2
`

type DeleteQuizAudienceParams struct {
	Quizid int64 `db:"quizid" json:"quizid"`
	ID     int64 `db:"id" json:"id"`
}

func (q *Queries) DeleteQuizAudience(ctx context.Context, arg DeleteQuizAudienceParams) error {
	_, err := q.db.ExecContext(ctx, deleteQuizAudience, arg.Quizid, arg.ID)
	return err
}

const deleteQuizByID = `-- name: DeleteQuizByID :one
UPDATE quiz SET deleted=true WHERE quiz.id=$1 AND accountid=$2 RETURNING quiz.id, quiz.qid, quiz.accountid, quiz.deleted, quiz.archived, quiz.fingerprinting, quiz.repeatable, quiz.note_prevented, quiz.mail_notifications, quiz.unique_answers, quiz.super, quiz.group_id, quiz.name, quiz.description, quiz.config, quiz.status, quiz.limit_answers, quiz.due_to, quiz.time_of_passing, quiz.pausable, quiz.version, quiz.version_comment, quiz.parent_ids, quiz.created_at, quiz.updated_at, quiz.questions_count, quiz.answers_count, quiz.average_time_passing, quiz.sessions_count, quiz.gigachat
`

type DeleteQuizByIDParams struct {
	ID        int64  `db:"id" json:"id"`
	Accountid string `db:"accountid" json:"accountid"`
}

func (q *Queries) DeleteQuizByID(ctx context.Context, arg DeleteQuizByIDParams) (Quiz, error) {
	row := q.db.QueryRowContext(ctx, deleteQuizByID, arg.ID, arg.Accountid)
	var i Quiz
	err := row.Scan(
		&i.ID,
		&i.Qid,
		&i.Accountid,
		&i.Deleted,
		&i.Archived,
		&i.Fingerprinting,
		&i.Repeatable,
		&i.NotePrevented,
		&i.MailNotifications,
		&i.UniqueAnswers,
		&i.Super,
		&i.GroupID,
		&i.Name,
		&i.Description,
		&i.Config,
		&i.Status,
		&i.LimitAnswers,
		&i.DueTo,
		&i.TimeOfPassing,
		&i.Pausable,
		&i.Version,
		&i.VersionComment,
		pq.Array(&i.ParentIds),
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.QuestionsCount,
		&i.AnswersCount,
		&i.AverageTimePassing,
		&i.SessionsCount,
		&i.Gigachat,
	)
	return i, err
}

const deleteSteps = `-- name: DeleteSteps :exec
UPDATE steps SET Deleted = true WHERE ID = ANY($1::bigint[])
`

func (q *Queries) DeleteSteps(ctx context.Context, dollar_1 []int64) error {
	_, err := q.db.ExecContext(ctx, deleteSteps, pq.Array(dollar_1))
	return err
}

const deleteTags = `-- name: DeleteTags :exec
UPDATE tags SET Deleted = true WHERE ID = ANY($1::bigint[])
`

func (q *Queries) DeleteTags(ctx context.Context, dollar_1 []int64) error {
	_, err := q.db.ExecContext(ctx, deleteTags, pq.Array(dollar_1))
	return err
}

const deleteUsers = `-- name: DeleteUsers :exec
UPDATE usersAmo SET Deleted = true WHERE ID = ANY($1::bigint[])
`

func (q *Queries) DeleteUsers(ctx context.Context, dollar_1 []int64) error {
	_, err := q.db.ExecContext(ctx, deleteUsers, pq.Array(dollar_1))
	return err
}

const deviceStatistics = `-- name: DeviceStatistics :many
WITH DeviceStats AS (
    SELECT
        device_type,
        COUNT(*) AS device_count
    FROM
        answer
    WHERE
        answer.quiz_id = $1
      AND created_at >= to_timestamp($2)
      AND created_at <= to_timestamp($3)
      AND result = TRUE
    GROUP BY
        device_type
),
     OSStats AS (
         SELECT
             os,
             COUNT(*) AS os_count
         FROM
             answer
         WHERE
             answer.quiz_id = $1
           AND created_at >= to_timestamp($2)
           AND created_at <= to_timestamp($3)
           AND result = TRUE
         GROUP BY
             os
     ),
     BrowserStats AS (
         SELECT
             browser,
             COUNT(*) AS browser_count
         FROM
             answer
         WHERE
             answer.quiz_id = $1
           AND created_at >= to_timestamp($2)
           AND created_at <= to_timestamp($3)
           AND result = TRUE
         GROUP BY
             browser
     ),
     TotalStats AS (
         SELECT
             COUNT(*) AS total_count
         FROM
             answer
         WHERE
             answer.quiz_id = $1
           AND created_at >= to_timestamp($2)
           AND created_at <= to_timestamp($3)
           AND result = TRUE
     )
SELECT
    DeviceStats.device_type,
    CAST((DeviceStats.device_count::FLOAT / TotalStats.total_count) * 100.0 AS FLOAT8) AS device_percentage,
    OSStats.os,
    CAST((OSStats.os_count::FLOAT / TotalStats.total_count) * 100.0 AS FLOAT8) AS os_percentage,
    BrowserStats.browser,
    CAST((BrowserStats.browser_count::FLOAT / TotalStats.total_count) * 100.0 AS FLOAT8) AS browser_percentage
FROM
    DeviceStats,
    OSStats,
    BrowserStats,
    TotalStats
`

type DeviceStatisticsParams struct {
	QuizID        int64   `db:"quiz_id" json:"quiz_id"`
	ToTimestamp   float64 `db:"to_timestamp" json:"to_timestamp"`
	ToTimestamp_2 float64 `db:"to_timestamp_2" json:"to_timestamp_2"`
}

type DeviceStatisticsRow struct {
	DeviceType        string  `db:"device_type" json:"device_type"`
	DevicePercentage  float64 `db:"device_percentage" json:"device_percentage"`
	Os                string  `db:"os" json:"os"`
	OsPercentage      float64 `db:"os_percentage" json:"os_percentage"`
	Browser           string  `db:"browser" json:"browser"`
	BrowserPercentage float64 `db:"browser_percentage" json:"browser_percentage"`
}

func (q *Queries) DeviceStatistics(ctx context.Context, arg DeviceStatisticsParams) ([]DeviceStatisticsRow, error) {
	rows, err := q.db.QueryContext(ctx, deviceStatistics, arg.QuizID, arg.ToTimestamp, arg.ToTimestamp_2)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []DeviceStatisticsRow
	for rows.Next() {
		var i DeviceStatisticsRow
		if err := rows.Scan(
			&i.DeviceType,
			&i.DevicePercentage,
			&i.Os,
			&i.OsPercentage,
			&i.Browser,
			&i.BrowserPercentage,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const duplicateQuestion = `-- name: DuplicateQuestion :one
INSERT INTO question(
    quiz_id, title, description, questiontype, required,
    page, content, version, parent_ids
)
SELECT quiz_id, title, description, questiontype, required,
       page, content, version, parent_ids
FROM question WHERE question.id=$1
RETURNING question.id, quiz_id, created_at, updated_at
`

type DuplicateQuestionRow struct {
	ID        int64        `db:"id" json:"id"`
	QuizID    int64        `db:"quiz_id" json:"quiz_id"`
	CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
	UpdatedAt sql.NullTime `db:"updated_at" json:"updated_at"`
}

func (q *Queries) DuplicateQuestion(ctx context.Context, id int64) (DuplicateQuestionRow, error) {
	row := q.db.QueryRowContext(ctx, duplicateQuestion, id)
	var i DuplicateQuestionRow
	err := row.Scan(
		&i.ID,
		&i.QuizID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const generalStatistics = `-- name: GeneralStatistics :many
WITH TimeBucket AS (
    SELECT
        date_trunc('hour', timestamp_bucket)::TIMESTAMP AS time_interval_start,
        COALESCE(LEAD(
                 date_trunc('hour', timestamp_bucket)::TIMESTAMP
                     ) OVER (ORDER BY timestamp_bucket), NOW()) AS time_interval_end
    FROM
        generate_series(TO_TIMESTAMP($1), TO_TIMESTAMP($2), CASE
                                                                WHEN EXTRACT(epoch FROM TO_TIMESTAMP($2)) - EXTRACT(epoch FROM TO_TIMESTAMP($1)) > 172800 THEN '1 day'::interval
                                                                ELSE '1 hour'::interval
            END) AS timestamp_bucket
),
     OpenStats AS (
         SELECT
             tb.time_interval_start,
             tb.time_interval_end,
             COUNT(DISTINCT session) AS open_count
         FROM
             (
                 SELECT
                     session,
                     MIN(created_at) AS first_start_time
                 FROM
                     answer
                 WHERE
                     answer.quiz_id = $3
                   AND start = TRUE
                   AND created_at >= TO_TIMESTAMP($1)
                   AND created_at <= TO_TIMESTAMP($2)
                 GROUP BY
                     session
             ) AS first_starts
                 JOIN TimeBucket tb ON date_trunc('hour', first_starts.first_start_time) >= tb.time_interval_start
                 AND date_trunc('hour', first_starts.first_start_time) < tb.time_interval_end
         GROUP BY
             tb.time_interval_start, tb.time_interval_end
     ),
     ResultStats AS (
         SELECT
             tb.time_interval_start,
             tb.time_interval_end,
             COUNT(DISTINCT session) AS true_result_count
         FROM
             (
                 SELECT
                     session,
                     MIN(created_at) AS first_result_time
                 FROM
                     answer
                 WHERE
                     answer.quiz_id = $3
                   AND result = TRUE
                   AND created_at >= TO_TIMESTAMP($1)
                   AND created_at <= TO_TIMESTAMP($2)
                 GROUP BY
                     session
             ) AS first_results
                 JOIN TimeBucket tb ON date_trunc('hour', first_results.first_result_time) >= tb.time_interval_start
                 AND date_trunc('hour', first_results.first_result_time) < tb.time_interval_end
         GROUP BY
             tb.time_interval_start, tb.time_interval_end
     ),
     AvTimeStats AS (
         SELECT
             tb.time_interval_start,
             tb.time_interval_end,
             AVG(EXTRACT(epoch FROM (a.created_at)) - EXTRACT(epoch FROM (b.created_at))) AS avg_time
         FROM
             answer a
                 JOIN answer b ON a.session = b.session
                 JOIN TimeBucket tb ON date_trunc('hour', a.created_at) >= tb.time_interval_start
                 AND date_trunc('hour', a.created_at) < tb.time_interval_end
         WHERE
             a.quiz_id = $3
           AND a.result = TRUE
           AND b.start = TRUE
           AND b.quiz_id = $3
           AND a.created_at >= TO_TIMESTAMP($1)
           AND a.created_at <= TO_TIMESTAMP($2)
           AND b.created_at >= TO_TIMESTAMP($1)
           AND b.created_at <= TO_TIMESTAMP($2)
         GROUP BY
             tb.time_interval_start, tb.time_interval_end
     )
SELECT
    tb.time_interval_start AS time_bucket,
    COALESCE(os.open_count, 0) AS open_count,
    COALESCE(rs.true_result_count, 0) AS true_result_count,
    CASE
        WHEN COALESCE(os.open_count, 0) > 0 THEN COALESCE(rs.true_result_count, 0)::float / COALESCE(os.open_count, 0)::float
        ELSE 0
        END::float AS conversion,
    COALESCE(at.avg_time, 0) AS avg_time
FROM
    TimeBucket tb
        LEFT JOIN
    OpenStats os ON tb.time_interval_start = os.time_interval_start
        AND tb.time_interval_end = os.time_interval_end
        LEFT JOIN
    ResultStats rs ON tb.time_interval_start = rs.time_interval_start
        AND tb.time_interval_end = rs.time_interval_end
        LEFT JOIN
    AvTimeStats at ON tb.time_interval_start = at.time_interval_start
        AND tb.time_interval_end = at.time_interval_end
`

type GeneralStatisticsParams struct {
	ToTimestamp   float64 `db:"to_timestamp" json:"to_timestamp"`
	ToTimestamp_2 float64 `db:"to_timestamp_2" json:"to_timestamp_2"`
	QuizID        int64   `db:"quiz_id" json:"quiz_id"`
}

type GeneralStatisticsRow struct {
	TimeBucket      time.Time `db:"time_bucket" json:"time_bucket"`
	OpenCount       int64     `db:"open_count" json:"open_count"`
	TrueResultCount int64     `db:"true_result_count" json:"true_result_count"`
	Conversion      float64   `db:"conversion" json:"conversion"`
	AvgTime         float64   `db:"avg_time" json:"avg_time"`
}

func (q *Queries) GeneralStatistics(ctx context.Context, arg GeneralStatisticsParams) ([]GeneralStatisticsRow, error) {
	rows, err := q.db.QueryContext(ctx, generalStatistics, arg.ToTimestamp, arg.ToTimestamp_2, arg.QuizID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GeneralStatisticsRow
	for rows.Next() {
		var i GeneralStatisticsRow
		if err := rows.Scan(
			&i.TimeBucket,
			&i.OpenCount,
			&i.TrueResultCount,
			&i.Conversion,
			&i.AvgTime,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getAccAndPrivilegeByEmail = `-- name: GetAccAndPrivilegeByEmail :many
SELECT
    a.id,
    a.user_id,
    a.created_at,
    COALESCE(p.ID,0),
    coalesce(p.privilegeid,''),
    coalesce(p.amount,0),
    coalesce(p.created_at,Now())
FROM
    account AS a
        LEFT JOIN privileges AS p ON a.id = p.account_id
WHERE
    a.user_id = $1
`

type GetAccAndPrivilegeByEmailRow struct {
	ID          uuid.UUID `db:"id" json:"id"`
	UserID      string    `db:"user_id" json:"user_id"`
	CreatedAt   time.Time `db:"created_at" json:"created_at"`
	ID_2        int32     `db:"id_2" json:"id_2"`
	Privilegeid string    `db:"privilegeid" json:"privilegeid"`
	Amount      int32     `db:"amount" json:"amount"`
	CreatedAt_2 time.Time `db:"created_at_2" json:"created_at_2"`
}

func (q *Queries) GetAccAndPrivilegeByEmail(ctx context.Context, userID string) ([]GetAccAndPrivilegeByEmailRow, error) {
	rows, err := q.db.QueryContext(ctx, getAccAndPrivilegeByEmail, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetAccAndPrivilegeByEmailRow
	for rows.Next() {
		var i GetAccAndPrivilegeByEmailRow
		if err := rows.Scan(
			&i.ID,
			&i.UserID,
			&i.CreatedAt,
			&i.ID_2,
			&i.Privilegeid,
			&i.Amount,
			&i.CreatedAt_2,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getAccountWithPrivileges = `-- name: GetAccountWithPrivileges :many
SELECT a.id, a.user_id, a.created_at, a.deleted,
       coalesce(p.id,0) AS privilege_id,
       coalesce(p.privilegeID,''),
       coalesce(p.privilege_name,''),
       coalesce(p.amount,0), coalesce(p.created_at,Now()) AS privilege_created_at
FROM account a
         LEFT JOIN privileges AS p ON a.id = p.account_id
WHERE a.user_id = $1
`

type GetAccountWithPrivilegesRow struct {
	ID                 uuid.UUID `db:"id" json:"id"`
	UserID             string    `db:"user_id" json:"user_id"`
	CreatedAt          time.Time `db:"created_at" json:"created_at"`
	Deleted            bool      `db:"deleted" json:"deleted"`
	PrivilegeID        int32     `db:"privilege_id" json:"privilege_id"`
	Privilegeid        string    `db:"privilegeid" json:"privilegeid"`
	PrivilegeName      string    `db:"privilege_name" json:"privilege_name"`
	Amount             int32     `db:"amount" json:"amount"`
	PrivilegeCreatedAt time.Time `db:"privilege_created_at" json:"privilege_created_at"`
}

func (q *Queries) GetAccountWithPrivileges(ctx context.Context, userID string) ([]GetAccountWithPrivilegesRow, error) {
	rows, err := q.db.QueryContext(ctx, getAccountWithPrivileges, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetAccountWithPrivilegesRow
	for rows.Next() {
		var i GetAccountWithPrivilegesRow
		if err := rows.Scan(
			&i.ID,
			&i.UserID,
			&i.CreatedAt,
			&i.Deleted,
			&i.PrivilegeID,
			&i.Privilegeid,
			&i.PrivilegeName,
			&i.Amount,
			&i.PrivilegeCreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getAllAnswersByQuizID = `-- name: GetAllAnswersByQuizID :many
SELECT DISTINCT ON (a.question_id)
    a.content, a.created_at, a.question_id, a.id,a.version, q.questiontype::Text as questiontype, quiz.qid
FROM
    answer a
        JOIN
    question q ON a.question_id = q.id
        JOIN
    quiz ON q.quiz_id = quiz.id
WHERE
    a.session = $1 AND a.start = false AND a.deleted = false
ORDER BY
    a.question_id ASC, a.created_at DESC
`

type GetAllAnswersByQuizIDRow struct {
	Content      sql.NullString `db:"content" json:"content"`
	CreatedAt    sql.NullTime   `db:"created_at" json:"created_at"`
	QuestionID   int64          `db:"question_id" json:"question_id"`
	ID           int64          `db:"id" json:"id"`
	Version      int32          `db:"version" json:"version"`
	Questiontype string         `db:"questiontype" json:"questiontype"`
	Qid          uuid.NullUUID  `db:"qid" json:"qid"`
}

func (q *Queries) GetAllAnswersByQuizID(ctx context.Context, session sql.NullString) ([]GetAllAnswersByQuizIDRow, error) {
	rows, err := q.db.QueryContext(ctx, getAllAnswersByQuizID, session)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetAllAnswersByQuizIDRow
	for rows.Next() {
		var i GetAllAnswersByQuizIDRow
		if err := rows.Scan(
			&i.Content,
			&i.CreatedAt,
			&i.QuestionID,
			&i.ID,
			&i.Version,
			&i.Questiontype,
			&i.Qid,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getAllBitrixTokens = `-- name: GetAllBitrixTokens :many
SELECT accountid, refreshtoken, accesstoken, authcode, expiration, createdat FROM BitrixTokens
`

func (q *Queries) GetAllBitrixTokens(ctx context.Context) ([]Bitrixtoken, error) {
	rows, err := q.db.QueryContext(ctx, getAllBitrixTokens)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Bitrixtoken
	for rows.Next() {
		var i Bitrixtoken
		if err := rows.Scan(
			&i.Accountid,
			&i.Refreshtoken,
			&i.Accesstoken,
			&i.Authcode,
			&i.Expiration,
			&i.Createdat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getAllCompanyUsers = `-- name: GetAllCompanyUsers :many
SELECT id, amoid, amouserid, name, email, role, "Group", deleted, createdat FROM usersamo WHERE amoid = $1 AND deleted = false
`

func (q *Queries) GetAllCompanyUsers(ctx context.Context, amoid int32) ([]Usersamo, error) {
	rows, err := q.db.QueryContext(ctx, getAllCompanyUsers, amoid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Usersamo
	for rows.Next() {
		var i Usersamo
		if err := rows.Scan(
			&i.ID,
			&i.Amoid,
			&i.Amouserid,
			&i.Name,
			&i.Email,
			&i.Role,
			&i.Group,
			&i.Deleted,
			&i.Createdat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getAllQuizUtms = `-- name: GetAllQuizUtms :many
SELECT id, quizid, utm, deleted, created_at from quiz_utm where quizID = $1 and deleted=false
`

func (q *Queries) GetAllQuizUtms(ctx context.Context, quizid int64) ([]QuizUtm, error) {
	rows, err := q.db.QueryContext(ctx, getAllQuizUtms, quizid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []QuizUtm
	for rows.Next() {
		var i QuizUtm
		if err := rows.Scan(
			&i.ID,
			&i.Quizid,
			&i.Utm,
			&i.Deleted,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getAllTgAccounts = `-- name: GetAllTgAccounts :many
SELECT id, apiid, apihash, phonenumber, password, status, deleted, createdat FROM tgAccounts WHERE Deleted = false
`

func (q *Queries) GetAllTgAccounts(ctx context.Context) ([]Tgaccount, error) {
	rows, err := q.db.QueryContext(ctx, getAllTgAccounts)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Tgaccount
	for rows.Next() {
		var i Tgaccount
		if err := rows.Scan(
			&i.ID,
			&i.Apiid,
			&i.Apihash,
			&i.Phonenumber,
			&i.Password,
			&i.Status,
			&i.Deleted,
			&i.Createdat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getAllTokens = `-- name: GetAllTokens :many
SELECT accountid, refreshtoken, accesstoken, authcode, expiration, createdat FROM tokens
`

func (q *Queries) GetAllTokens(ctx context.Context) ([]Token, error) {
	rows, err := q.db.QueryContext(ctx, getAllTokens)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Token
	for rows.Next() {
		var i Token
		if err := rows.Scan(
			&i.Accountid,
			&i.Refreshtoken,
			&i.Accesstoken,
			&i.Authcode,
			&i.Expiration,
			&i.Createdat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getBitrixFieldByID = `-- name: GetBitrixFieldByID :one
SELECT id, bitrixid, accountid, entityid, fieldname, editfromlabel, fieldtype, deleted, createdat FROM BitrixFields WHERE BitrixID = $1 AND Deleted = false
`

func (q *Queries) GetBitrixFieldByID(ctx context.Context, bitrixid string) (Bitrixfield, error) {
	row := q.db.QueryRowContext(ctx, getBitrixFieldByID, bitrixid)
	var i Bitrixfield
	err := row.Scan(
		&i.ID,
		&i.Bitrixid,
		&i.Accountid,
		&i.Entityid,
		&i.Fieldname,
		&i.Editfromlabel,
		&i.Fieldtype,
		&i.Deleted,
		&i.Createdat,
	)
	return i, err
}

const getBitrixFieldsWithPagination = `-- name: GetBitrixFieldsWithPagination :many
WITH user_data AS (
    SELECT BitrixID FROM BitrixAccounts WHERE BitrixAccounts.AccountID = $1 AND BitrixAccounts.Deleted = false
)
SELECT f.id, f.bitrixid, f.accountid, f.entityid, f.fieldname, f.editfromlabel, f.fieldtype, f.deleted, f.createdat, COUNT(*) OVER() as total_count
FROM BitrixFields f JOIN user_data u ON f.AccountID = u.BitrixID
WHERE f.Deleted = false
ORDER BY f.ID OFFSET ($2 - 1) * $3 LIMIT $3
`

type GetBitrixFieldsWithPaginationParams struct {
	Accountid string      `db:"accountid" json:"accountid"`
	Column2   interface{} `db:"column_2" json:"column_2"`
	Limit     int32       `db:"limit" json:"limit"`
}

type GetBitrixFieldsWithPaginationRow struct {
	ID            int64       `db:"id" json:"id"`
	Bitrixid      string      `db:"bitrixid" json:"bitrixid"`
	Accountid     string      `db:"accountid" json:"accountid"`
	Entityid      interface{} `db:"entityid" json:"entityid"`
	Fieldname     string      `db:"fieldname" json:"fieldname"`
	Editfromlabel string      `db:"editfromlabel" json:"editfromlabel"`
	Fieldtype     interface{} `db:"fieldtype" json:"fieldtype"`
	Deleted       bool        `db:"deleted" json:"deleted"`
	Createdat     time.Time   `db:"createdat" json:"createdat"`
	TotalCount    int64       `db:"total_count" json:"total_count"`
}

func (q *Queries) GetBitrixFieldsWithPagination(ctx context.Context, arg GetBitrixFieldsWithPaginationParams) ([]GetBitrixFieldsWithPaginationRow, error) {
	rows, err := q.db.QueryContext(ctx, getBitrixFieldsWithPagination, arg.Accountid, arg.Column2, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetBitrixFieldsWithPaginationRow
	for rows.Next() {
		var i GetBitrixFieldsWithPaginationRow
		if err := rows.Scan(
			&i.ID,
			&i.Bitrixid,
			&i.Accountid,
			&i.Entityid,
			&i.Fieldname,
			&i.Editfromlabel,
			&i.Fieldtype,
			&i.Deleted,
			&i.Createdat,
			&i.TotalCount,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getBitrixPipelinesWithPagination = `-- name: GetBitrixPipelinesWithPagination :many
WITH user_data AS (
    SELECT BitrixID FROM BitrixAccounts WHERE BitrixAccounts.AccountID = $1 AND BitrixAccounts.Deleted = false
)
SELECT p.id, p.bitrixid, p.accountid, p.name, p.entitytypeid, p.deleted, p.createdat, COUNT(*) OVER() as total_count
FROM PipelineBitrix p JOIN user_data u ON p.AccountID = u.BitrixID
WHERE p.Deleted = false
ORDER BY p.ID OFFSET ($2 - 1) * $3 LIMIT $3
`

type GetBitrixPipelinesWithPaginationParams struct {
	Accountid string      `db:"accountid" json:"accountid"`
	Column2   interface{} `db:"column_2" json:"column_2"`
	Limit     int32       `db:"limit" json:"limit"`
}

type GetBitrixPipelinesWithPaginationRow struct {
	ID           int64     `db:"id" json:"id"`
	Bitrixid     int32     `db:"bitrixid" json:"bitrixid"`
	Accountid    string    `db:"accountid" json:"accountid"`
	Name         string    `db:"name" json:"name"`
	Entitytypeid int32     `db:"entitytypeid" json:"entitytypeid"`
	Deleted      bool      `db:"deleted" json:"deleted"`
	Createdat    time.Time `db:"createdat" json:"createdat"`
	TotalCount   int64     `db:"total_count" json:"total_count"`
}

func (q *Queries) GetBitrixPipelinesWithPagination(ctx context.Context, arg GetBitrixPipelinesWithPaginationParams) ([]GetBitrixPipelinesWithPaginationRow, error) {
	rows, err := q.db.QueryContext(ctx, getBitrixPipelinesWithPagination, arg.Accountid, arg.Column2, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetBitrixPipelinesWithPaginationRow
	for rows.Next() {
		var i GetBitrixPipelinesWithPaginationRow
		if err := rows.Scan(
			&i.ID,
			&i.Bitrixid,
			&i.Accountid,
			&i.Name,
			&i.Entitytypeid,
			&i.Deleted,
			&i.Createdat,
			&i.TotalCount,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getBitrixQuizRule = `-- name: GetBitrixQuizRule :one
SELECT id, accountid, quizid, performerid, pipelineid, typeid, stageid, sourceid, statusid, fieldsrule, tagstoadd, deleted, createdat, leadflag FROM BitrixRule WHERE QuizID = $1 AND Deleted = false
`

func (q *Queries) GetBitrixQuizRule(ctx context.Context, quizid int32) (Bitrixrule, error) {
	row := q.db.QueryRowContext(ctx, getBitrixQuizRule, quizid)
	var i Bitrixrule
	err := row.Scan(
		&i.ID,
		&i.Accountid,
		&i.Quizid,
		&i.Performerid,
		&i.Pipelineid,
		&i.Typeid,
		&i.Stageid,
		&i.Sourceid,
		&i.Statusid,
		&i.Fieldsrule,
		&i.Tagstoadd,
		&i.Deleted,
		&i.Createdat,
		&i.Leadflag,
	)
	return i, err
}

const getBitrixStepsWithPagination = `-- name: GetBitrixStepsWithPagination :many
WITH user_data AS (
    SELECT BitrixID FROM BitrixAccounts WHERE BitrixAccounts.AccountID = $1 AND BitrixAccounts.Deleted = false
)
SELECT s.id, s.accountid, s.bitrixid, s.entityid, s.statusid, s.name, s.nameinit, s.color, s.pipelineid, s.deleted, s.createdat, COUNT(*) OVER() as total_count
FROM StepBitrix s JOIN user_data u ON s.AccountID = u.BitrixID
WHERE s.Deleted = false ORDER BY s.ID OFFSET ($2 - 1) * $3 LIMIT $3
`

type GetBitrixStepsWithPaginationParams struct {
	Accountid string      `db:"accountid" json:"accountid"`
	Column2   interface{} `db:"column_2" json:"column_2"`
	Limit     int32       `db:"limit" json:"limit"`
}

type GetBitrixStepsWithPaginationRow struct {
	ID         int64     `db:"id" json:"id"`
	Accountid  string    `db:"accountid" json:"accountid"`
	Bitrixid   string    `db:"bitrixid" json:"bitrixid"`
	Entityid   string    `db:"entityid" json:"entityid"`
	Statusid   string    `db:"statusid" json:"statusid"`
	Name       string    `db:"name" json:"name"`
	Nameinit   string    `db:"nameinit" json:"nameinit"`
	Color      string    `db:"color" json:"color"`
	Pipelineid int32     `db:"pipelineid" json:"pipelineid"`
	Deleted    bool      `db:"deleted" json:"deleted"`
	Createdat  time.Time `db:"createdat" json:"createdat"`
	TotalCount int64     `db:"total_count" json:"total_count"`
}

func (q *Queries) GetBitrixStepsWithPagination(ctx context.Context, arg GetBitrixStepsWithPaginationParams) ([]GetBitrixStepsWithPaginationRow, error) {
	rows, err := q.db.QueryContext(ctx, getBitrixStepsWithPagination, arg.Accountid, arg.Column2, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetBitrixStepsWithPaginationRow
	for rows.Next() {
		var i GetBitrixStepsWithPaginationRow
		if err := rows.Scan(
			&i.ID,
			&i.Accountid,
			&i.Bitrixid,
			&i.Entityid,
			&i.Statusid,
			&i.Name,
			&i.Nameinit,
			&i.Color,
			&i.Pipelineid,
			&i.Deleted,
			&i.Createdat,
			&i.TotalCount,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getBitrixTokenById = `-- name: GetBitrixTokenById :one
SELECT accountid, refreshtoken, accesstoken, authcode, expiration, createdat FROM BitrixTokens WHERE accountID = $1
`

func (q *Queries) GetBitrixTokenById(ctx context.Context, accountid string) (Bitrixtoken, error) {
	row := q.db.QueryRowContext(ctx, getBitrixTokenById, accountid)
	var i Bitrixtoken
	err := row.Scan(
		&i.Accountid,
		&i.Refreshtoken,
		&i.Accesstoken,
		&i.Authcode,
		&i.Expiration,
		&i.Createdat,
	)
	return i, err
}

const getCurrentBitrixCompany = `-- name: GetCurrentBitrixCompany :one
SELECT id, accountid, bitrixid, deleted, createdat, subdomain FROM BitrixAccounts WHERE AccountID = $1 AND Deleted = false
`

func (q *Queries) GetCurrentBitrixCompany(ctx context.Context, accountid string) (Bitrixaccount, error) {
	row := q.db.QueryRowContext(ctx, getCurrentBitrixCompany, accountid)
	var i Bitrixaccount
	err := row.Scan(
		&i.ID,
		&i.Accountid,
		&i.Bitrixid,
		&i.Deleted,
		&i.Createdat,
		&i.Subdomain,
	)
	return i, err
}

const getCurrentCompany = `-- name: GetCurrentCompany :one
SELECT id, accountid, amoid, name, deleted, createdat, subdomain, country, driveurl FROM accountsAmo WHERE AccountID = $1 AND Deleted = false
`

func (q *Queries) GetCurrentCompany(ctx context.Context, accountid string) (Accountsamo, error) {
	row := q.db.QueryRowContext(ctx, getCurrentCompany, accountid)
	var i Accountsamo
	err := row.Scan(
		&i.ID,
		&i.Accountid,
		&i.Amoid,
		&i.Name,
		&i.Deleted,
		&i.Createdat,
		&i.Subdomain,
		&i.Country,
		&i.Driveurl,
	)
	return i, err
}

const getExistingContactAmo = `-- name: GetExistingContactAmo :many
WITH getAmoID AS (
    SELECT AmoID FROM amoContact WHERE amoContact.AccountID = $1 AND  amoContact.Field = ANY($2::text[])
) SELECT id, accountid, amoid, field FROM amoContact
WHERE amoContact.AccountID = $1 AND amoContact.AmoID IN (SELECT AmoID FROM getAmoID)
`

type GetExistingContactAmoParams struct {
	Accountid int32    `db:"accountid" json:"accountid"`
	Column2   []string `db:"column_2" json:"column_2"`
}

func (q *Queries) GetExistingContactAmo(ctx context.Context, arg GetExistingContactAmoParams) ([]Amocontact, error) {
	rows, err := q.db.QueryContext(ctx, getExistingContactAmo, arg.Accountid, pq.Array(arg.Column2))
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Amocontact
	for rows.Next() {
		var i Amocontact
		if err := rows.Scan(
			&i.ID,
			&i.Accountid,
			&i.Amoid,
			&i.Field,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getExistingContactBitrix = `-- name: GetExistingContactBitrix :many
WITH getBitrixID AS (
    SELECT BitrixID FROM bitrixContact WHERE bitrixContact.AccountID = $1 AND  bitrixContact.Field = ANY($2::text[])
) SELECT id, accountid, bitrixid, field FROM bitrixContact
WHERE bitrixContact.AccountID = $1 AND bitrixContact.BitrixID IN (SELECT BitrixID FROM getBitrixID)
`

type GetExistingContactBitrixParams struct {
	Accountid string   `db:"accountid" json:"accountid"`
	Column2   []string `db:"column_2" json:"column_2"`
}

func (q *Queries) GetExistingContactBitrix(ctx context.Context, arg GetExistingContactBitrixParams) ([]Bitrixcontact, error) {
	rows, err := q.db.QueryContext(ctx, getExistingContactBitrix, arg.Accountid, pq.Array(arg.Column2))
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Bitrixcontact
	for rows.Next() {
		var i Bitrixcontact
		if err := rows.Scan(
			&i.ID,
			&i.Accountid,
			&i.Bitrixid,
			&i.Field,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getExpiredCountPrivilege = `-- name: GetExpiredCountPrivilege :many
SELECT p.id, p.privilegeID, p.privilege_name, p.amount, p.created_at, a.user_id
FROM privileges p
         JOIN account a ON p.account_id = a.id
WHERE p.amount = 0
  AND p.privilegeID = $1
`

type GetExpiredCountPrivilegeRow struct {
	ID            int32     `db:"id" json:"id"`
	Privilegeid   string    `db:"privilegeid" json:"privilegeid"`
	PrivilegeName string    `db:"privilege_name" json:"privilege_name"`
	Amount        int32     `db:"amount" json:"amount"`
	CreatedAt     time.Time `db:"created_at" json:"created_at"`
	UserID        string    `db:"user_id" json:"user_id"`
}

func (q *Queries) GetExpiredCountPrivilege(ctx context.Context, privilegeid string) ([]GetExpiredCountPrivilegeRow, error) {
	rows, err := q.db.QueryContext(ctx, getExpiredCountPrivilege, privilegeid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetExpiredCountPrivilegeRow
	for rows.Next() {
		var i GetExpiredCountPrivilegeRow
		if err := rows.Scan(
			&i.ID,
			&i.Privilegeid,
			&i.PrivilegeName,
			&i.Amount,
			&i.CreatedAt,
			&i.UserID,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getExpiredDayPrivilege = `-- name: GetExpiredDayPrivilege :many
SELECT p.id, p.privilegeID, p.privilege_name, p.amount, p.created_at, a.user_id
FROM privileges p
         JOIN account a ON p.account_id = a.id
WHERE p.created_at + p.amount * interval '1 day' < NOW()
  AND p.privilegeID = $1
`

type GetExpiredDayPrivilegeRow struct {
	ID            int32     `db:"id" json:"id"`
	Privilegeid   string    `db:"privilegeid" json:"privilegeid"`
	PrivilegeName string    `db:"privilege_name" json:"privilege_name"`
	Amount        int32     `db:"amount" json:"amount"`
	CreatedAt     time.Time `db:"created_at" json:"created_at"`
	UserID        string    `db:"user_id" json:"user_id"`
}

func (q *Queries) GetExpiredDayPrivilege(ctx context.Context, privilegeid string) ([]GetExpiredDayPrivilegeRow, error) {
	rows, err := q.db.QueryContext(ctx, getExpiredDayPrivilege, privilegeid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetExpiredDayPrivilegeRow
	for rows.Next() {
		var i GetExpiredDayPrivilegeRow
		if err := rows.Scan(
			&i.ID,
			&i.Privilegeid,
			&i.PrivilegeName,
			&i.Amount,
			&i.CreatedAt,
			&i.UserID,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getFieldByAmoID = `-- name: GetFieldByAmoID :one
SELECT id, amoid, code, accountid, name, entity, type, deleted, createdat FROM fields WHERE AmoID = $1 AND Deleted = false
`

func (q *Queries) GetFieldByAmoID(ctx context.Context, amoid int32) (Field, error) {
	row := q.db.QueryRowContext(ctx, getFieldByAmoID, amoid)
	var i Field
	err := row.Scan(
		&i.ID,
		&i.Amoid,
		&i.Code,
		&i.Accountid,
		&i.Name,
		&i.Entity,
		&i.Type,
		&i.Deleted,
		&i.Createdat,
	)
	return i, err
}

const getFieldsCount = `-- name: GetFieldsCount :one
WITH user_data AS (
    SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
)
SELECT COUNT(*) FROM fields f JOIN user_data u ON f.AccountID = u.AmoID WHERE f.Deleted = false
`

func (q *Queries) GetFieldsCount(ctx context.Context, accountid string) (int64, error) {
	row := q.db.QueryRowContext(ctx, getFieldsCount, accountid)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const getFieldsWithPagination = `-- name: GetFieldsWithPagination :many
WITH user_data AS (
    SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
)
SELECT f.id, f.amoid, f.code, f.accountid, f.name, f.entity, f.type, f.deleted, f.createdat
FROM fields f JOIN user_data u ON f.AccountID = u.AmoID
WHERE f.Deleted = false
ORDER BY f.ID OFFSET ($2 - 1) * $3 LIMIT $3
`

type GetFieldsWithPaginationParams struct {
	Accountid string      `db:"accountid" json:"accountid"`
	Column2   interface{} `db:"column_2" json:"column_2"`
	Limit     int32       `db:"limit" json:"limit"`
}

func (q *Queries) GetFieldsWithPagination(ctx context.Context, arg GetFieldsWithPaginationParams) ([]Field, error) {
	rows, err := q.db.QueryContext(ctx, getFieldsWithPagination, arg.Accountid, arg.Column2, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Field
	for rows.Next() {
		var i Field
		if err := rows.Scan(
			&i.ID,
			&i.Amoid,
			&i.Code,
			&i.Accountid,
			&i.Name,
			&i.Entity,
			&i.Type,
			&i.Deleted,
			&i.Createdat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getLeadTarget = `-- name: GetLeadTarget :many
SELECT id, accountid, type, quizid, target, invitelink, deleted, createdat FROM leadtarget WHERE accountID = $1 AND quizID = $2 AND deleted=false
`

type GetLeadTargetParams struct {
	Accountid string `db:"accountid" json:"accountid"`
	Quizid    int32  `db:"quizid" json:"quizid"`
}

func (q *Queries) GetLeadTarget(ctx context.Context, arg GetLeadTargetParams) ([]Leadtarget, error) {
	rows, err := q.db.QueryContext(ctx, getLeadTarget, arg.Accountid, arg.Quizid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Leadtarget
	for rows.Next() {
		var i Leadtarget
		if err := rows.Scan(
			&i.ID,
			&i.Accountid,
			&i.Type,
			&i.Quizid,
			&i.Target,
			&i.Invitelink,
			&i.Deleted,
			&i.Createdat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getListCreatedQuizzes = `-- name: GetListCreatedQuizzes :many
SELECT id
FROM quiz
WHERE accountid = $1
`

func (q *Queries) GetListCreatedQuizzes(ctx context.Context, accountid string) ([]int64, error) {
	rows, err := q.db.QueryContext(ctx, getListCreatedQuizzes, accountid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []int64
	for rows.Next() {
		var id int64
		if err := rows.Scan(&id); err != nil {
			return nil, err
		}
		items = append(items, id)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getListStartQuiz = `-- name: GetListStartQuiz :many
SELECT id FROM quiz WHERE accountid = $1 AND status = 'start'
`

func (q *Queries) GetListStartQuiz(ctx context.Context, accountid string) ([]int64, error) {
	rows, err := q.db.QueryContext(ctx, getListStartQuiz, accountid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []int64
	for rows.Next() {
		var id int64
		if err := rows.Scan(&id); err != nil {
			return nil, err
		}
		items = append(items, id)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getPipelinesCount = `-- name: GetPipelinesCount :one
WITH user_data AS (
    SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
)
SELECT COUNT(*) FROM pipelines p JOIN user_data u ON p.AccountID = u.AmoID WHERE p.Deleted = false
`

func (q *Queries) GetPipelinesCount(ctx context.Context, accountid string) (int64, error) {
	row := q.db.QueryRowContext(ctx, getPipelinesCount, accountid)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const getPipelinesWithPagination = `-- name: GetPipelinesWithPagination :many
WITH user_data AS (
    SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
)
SELECT p.id, p.amoid, p.accountid, p.name, p.isarchive, p.deleted, p.createdat
FROM pipelines p JOIN user_data u ON p.AccountID = u.AmoID
WHERE p.Deleted = false
ORDER BY p.ID OFFSET ($2 - 1) * $3 LIMIT $3
`

type GetPipelinesWithPaginationParams struct {
	Accountid string      `db:"accountid" json:"accountid"`
	Column2   interface{} `db:"column_2" json:"column_2"`
	Limit     int32       `db:"limit" json:"limit"`
}

func (q *Queries) GetPipelinesWithPagination(ctx context.Context, arg GetPipelinesWithPaginationParams) ([]Pipeline, error) {
	rows, err := q.db.QueryContext(ctx, getPipelinesWithPagination, arg.Accountid, arg.Column2, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Pipeline
	for rows.Next() {
		var i Pipeline
		if err := rows.Scan(
			&i.ID,
			&i.Amoid,
			&i.Accountid,
			&i.Name,
			&i.Isarchive,
			&i.Deleted,
			&i.Createdat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getPrivilegesByAccountID = `-- name: GetPrivilegesByAccountID :many
SELECT id,privilegeID,privilege_name,amount, created_at FROM privileges WHERE account_id = $1
`

type GetPrivilegesByAccountIDRow struct {
	ID            int32     `db:"id" json:"id"`
	Privilegeid   string    `db:"privilegeid" json:"privilegeid"`
	PrivilegeName string    `db:"privilege_name" json:"privilege_name"`
	Amount        int32     `db:"amount" json:"amount"`
	CreatedAt     time.Time `db:"created_at" json:"created_at"`
}

func (q *Queries) GetPrivilegesByAccountID(ctx context.Context, accountID uuid.UUID) ([]GetPrivilegesByAccountIDRow, error) {
	rows, err := q.db.QueryContext(ctx, getPrivilegesByAccountID, accountID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetPrivilegesByAccountIDRow
	for rows.Next() {
		var i GetPrivilegesByAccountIDRow
		if err := rows.Scan(
			&i.ID,
			&i.Privilegeid,
			&i.PrivilegeName,
			&i.Amount,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getPrivilegesByAccountIDWC = `-- name: GetPrivilegesByAccountIDWC :many
SELECT p.id,p.privilegeID,p.privilege_name,p.amount, p.created_at FROM privileges as p JOIN account as a on p.account_id = a.id WHERE a.user_id = $1
`

type GetPrivilegesByAccountIDWCRow struct {
	ID            int32     `db:"id" json:"id"`
	Privilegeid   string    `db:"privilegeid" json:"privilegeid"`
	PrivilegeName string    `db:"privilege_name" json:"privilege_name"`
	Amount        int32     `db:"amount" json:"amount"`
	CreatedAt     time.Time `db:"created_at" json:"created_at"`
}

func (q *Queries) GetPrivilegesByAccountIDWC(ctx context.Context, userID string) ([]GetPrivilegesByAccountIDWCRow, error) {
	rows, err := q.db.QueryContext(ctx, getPrivilegesByAccountIDWC, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetPrivilegesByAccountIDWCRow
	for rows.Next() {
		var i GetPrivilegesByAccountIDWCRow
		if err := rows.Scan(
			&i.ID,
			&i.Privilegeid,
			&i.PrivilegeName,
			&i.Amount,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getPrivilegesQuizAccount = `-- name: GetPrivilegesQuizAccount :many
SELECT
    p.privilegeID,
    p.privilege_name,
    p.amount,
    p.created_at,
    a.id,
    qz.config
FROM
    privileges AS p
        INNER JOIN account AS a ON p.account_id = a.id
        INNER JOIN quiz AS qz ON qz.accountid = a.user_id
WHERE
    qz.id = $1
`

type GetPrivilegesQuizAccountRow struct {
	Privilegeid   string         `db:"privilegeid" json:"privilegeid"`
	PrivilegeName string         `db:"privilege_name" json:"privilege_name"`
	Amount        int32          `db:"amount" json:"amount"`
	CreatedAt     time.Time      `db:"created_at" json:"created_at"`
	ID            uuid.UUID      `db:"id" json:"id"`
	Config        sql.NullString `db:"config" json:"config"`
}

func (q *Queries) GetPrivilegesQuizAccount(ctx context.Context, id int64) ([]GetPrivilegesQuizAccountRow, error) {
	rows, err := q.db.QueryContext(ctx, getPrivilegesQuizAccount, id)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetPrivilegesQuizAccountRow
	for rows.Next() {
		var i GetPrivilegesQuizAccountRow
		if err := rows.Scan(
			&i.Privilegeid,
			&i.PrivilegeName,
			&i.Amount,
			&i.CreatedAt,
			&i.ID,
			&i.Config,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getQidOwner = `-- name: GetQidOwner :one
SELECT accountid FROM quiz where qid=$1
`

func (q *Queries) GetQidOwner(ctx context.Context, qid uuid.NullUUID) (string, error) {
	row := q.db.QueryRowContext(ctx, getQidOwner, qid)
	var accountid string
	err := row.Scan(&accountid)
	return accountid, err
}

const getQuestionHistory = `-- name: GetQuestionHistory :many
SELECT id, quiz_id, title, description, questiontype, required, deleted, page, content, version, parent_ids, created_at, updated_at, session, auditory FROM question WHERE question.id = $1 OR question.id = ANY(
    SELECT unnest(parent_ids) FROM question WHERE id = $1
) ORDER BY question.id DESC LIMIT $2 OFFSET $3
`

type GetQuestionHistoryParams struct {
	ID     int64 `db:"id" json:"id"`
	Limit  int32 `db:"limit" json:"limit"`
	Offset int32 `db:"offset" json:"offset"`
}

func (q *Queries) GetQuestionHistory(ctx context.Context, arg GetQuestionHistoryParams) ([]Question, error) {
	rows, err := q.db.QueryContext(ctx, getQuestionHistory, arg.ID, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Question
	for rows.Next() {
		var i Question
		if err := rows.Scan(
			&i.ID,
			&i.QuizID,
			&i.Title,
			&i.Description,
			&i.Questiontype,
			&i.Required,
			&i.Deleted,
			&i.Page,
			&i.Content,
			&i.Version,
			pq.Array(&i.ParentIds),
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.Session,
			&i.Auditory,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getQuestionListByIDs = `-- name: GetQuestionListByIDs :many
SELECT id, quiz_id, title, description, questiontype, required, deleted, page, content, version, parent_ids, created_at, updated_at, session, auditory FROM question WHERE id = ANY($1::int[]) AND deleted = FALSE
`

func (q *Queries) GetQuestionListByIDs(ctx context.Context, dollar_1 []int32) ([]Question, error) {
	rows, err := q.db.QueryContext(ctx, getQuestionListByIDs, pq.Array(dollar_1))
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Question
	for rows.Next() {
		var i Question
		if err := rows.Scan(
			&i.ID,
			&i.QuizID,
			&i.Title,
			&i.Description,
			&i.Questiontype,
			&i.Required,
			&i.Deleted,
			&i.Page,
			&i.Content,
			&i.Version,
			pq.Array(&i.ParentIds),
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.Session,
			&i.Auditory,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getQuestionTitle = `-- name: GetQuestionTitle :one
SELECT title, questiontype,page FROM question WHERE id = $1
`

type GetQuestionTitleRow struct {
	Title        string        `db:"title" json:"title"`
	Questiontype interface{}   `db:"questiontype" json:"questiontype"`
	Page         sql.NullInt16 `db:"page" json:"page"`
}

func (q *Queries) GetQuestionTitle(ctx context.Context, id int64) (GetQuestionTitleRow, error) {
	row := q.db.QueryRowContext(ctx, getQuestionTitle, id)
	var i GetQuestionTitleRow
	err := row.Scan(&i.Title, &i.Questiontype, &i.Page)
	return i, err
}

const getQuestions = `-- name: GetQuestions :many
SELECT id, quiz_id, title, description, questiontype, required, deleted, page, content, version, parent_ids, created_at, updated_at,auditory FROM question WHERE quiz_id = $1 AND deleted = FALSE ORDER BY page ASC
`

type GetQuestionsRow struct {
	ID           int64          `db:"id" json:"id"`
	QuizID       int64          `db:"quiz_id" json:"quiz_id"`
	Title        string         `db:"title" json:"title"`
	Description  sql.NullString `db:"description" json:"description"`
	Questiontype interface{}    `db:"questiontype" json:"questiontype"`
	Required     sql.NullBool   `db:"required" json:"required"`
	Deleted      sql.NullBool   `db:"deleted" json:"deleted"`
	Page         sql.NullInt16  `db:"page" json:"page"`
	Content      sql.NullString `db:"content" json:"content"`
	Version      sql.NullInt16  `db:"version" json:"version"`
	ParentIds    []int32        `db:"parent_ids" json:"parent_ids"`
	CreatedAt    sql.NullTime   `db:"created_at" json:"created_at"`
	UpdatedAt    sql.NullTime   `db:"updated_at" json:"updated_at"`
	Auditory     int64          `db:"auditory" json:"auditory"`
}

func (q *Queries) GetQuestions(ctx context.Context, quizID int64) ([]GetQuestionsRow, error) {
	rows, err := q.db.QueryContext(ctx, getQuestions, quizID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetQuestionsRow
	for rows.Next() {
		var i GetQuestionsRow
		if err := rows.Scan(
			&i.ID,
			&i.QuizID,
			&i.Title,
			&i.Description,
			&i.Questiontype,
			&i.Required,
			&i.Deleted,
			&i.Page,
			&i.Content,
			&i.Version,
			pq.Array(&i.ParentIds),
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.Auditory,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getQuestionsAI = `-- name: GetQuestionsAI :many
SELECT q.id, q.quiz_id, q.title, q.description, q.questiontype, q.required, q.deleted, q.page, q.content, q.version, q.parent_ids, q.created_at, q.updated_at, q.session,q.auditory FROM question q
WHERE q.quiz_id = $1 AND q.auditory = $2 AND (q.session = $3 OR q.session = '') AND q.deleted = FALSE
ORDER BY (q.session != '') ASC, --без сессии первые потом с сессией
         q.page, --по возрастанию страницы
         q.created_at --по времени создания
    LIMIT $4 OFFSET $5
`

type GetQuestionsAIParams struct {
	QuizID   int64  `db:"quiz_id" json:"quiz_id"`
	Auditory int64  `db:"auditory" json:"auditory"`
	Session  string `db:"session" json:"session"`
	Limit    int32  `db:"limit" json:"limit"`
	Offset   int32  `db:"offset" json:"offset"`
}

func (q *Queries) GetQuestionsAI(ctx context.Context, arg GetQuestionsAIParams) ([]Question, error) {
	rows, err := q.db.QueryContext(ctx, getQuestionsAI,
		arg.QuizID,
		arg.Auditory,
		arg.Session,
		arg.Limit,
		arg.Offset,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Question
	for rows.Next() {
		var i Question
		if err := rows.Scan(
			&i.ID,
			&i.QuizID,
			&i.Title,
			&i.Description,
			&i.Questiontype,
			&i.Required,
			&i.Deleted,
			&i.Page,
			&i.Content,
			&i.Version,
			pq.Array(&i.ParentIds),
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.Session,
			&i.Auditory,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getQuestionsAICount = `-- name: GetQuestionsAICount :one
SELECT COUNT(*) AS count FROM question WHERE quiz_id = $1 AND auditory = $2 AND (session = $3 OR session = '') AND deleted = FALSE
`

type GetQuestionsAICountParams struct {
	QuizID   int64  `db:"quiz_id" json:"quiz_id"`
	Auditory int64  `db:"auditory" json:"auditory"`
	Session  string `db:"session" json:"session"`
}

func (q *Queries) GetQuestionsAICount(ctx context.Context, arg GetQuestionsAICountParams) (int64, error) {
	row := q.db.QueryRowContext(ctx, getQuestionsAICount, arg.QuizID, arg.Auditory, arg.Session)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const getQuizAudience = `-- name: GetQuizAudience :many
SELECT id, quizid, age, deleted, createdat, sex FROM gigachatAudience WHERE QuizID = $1 AND Deleted = FALSE
`

func (q *Queries) GetQuizAudience(ctx context.Context, quizid int64) ([]Gigachataudience, error) {
	rows, err := q.db.QueryContext(ctx, getQuizAudience, quizid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Gigachataudience
	for rows.Next() {
		var i Gigachataudience
		if err := rows.Scan(
			&i.ID,
			&i.Quizid,
			&i.Age,
			&i.Deleted,
			&i.Createdat,
			&i.Sex,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getQuizById = `-- name: GetQuizById :one
SELECT id, qid, accountid, deleted, archived, fingerprinting, repeatable, note_prevented, mail_notifications, unique_answers, super, group_id, name, description, config, status, limit_answers, due_to, time_of_passing, pausable, version, version_comment, parent_ids, created_at, updated_at, questions_count, answers_count, average_time_passing, sessions_count, gigachat FROM quiz WHERE id=$1 AND accountId=$2
`

type GetQuizByIdParams struct {
	ID        int64  `db:"id" json:"id"`
	Accountid string `db:"accountid" json:"accountid"`
}

func (q *Queries) GetQuizById(ctx context.Context, arg GetQuizByIdParams) (Quiz, error) {
	row := q.db.QueryRowContext(ctx, getQuizById, arg.ID, arg.Accountid)
	var i Quiz
	err := row.Scan(
		&i.ID,
		&i.Qid,
		&i.Accountid,
		&i.Deleted,
		&i.Archived,
		&i.Fingerprinting,
		&i.Repeatable,
		&i.NotePrevented,
		&i.MailNotifications,
		&i.UniqueAnswers,
		&i.Super,
		&i.GroupID,
		&i.Name,
		&i.Description,
		&i.Config,
		&i.Status,
		&i.LimitAnswers,
		&i.DueTo,
		&i.TimeOfPassing,
		&i.Pausable,
		&i.Version,
		&i.VersionComment,
		pq.Array(&i.ParentIds),
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.QuestionsCount,
		&i.AnswersCount,
		&i.AverageTimePassing,
		&i.SessionsCount,
		&i.Gigachat,
	)
	return i, err
}

const getQuizByQid = `-- name: GetQuizByQid :one
SELECT id, qid, accountid, deleted, archived, fingerprinting, repeatable, note_prevented, mail_notifications, unique_answers, super, group_id, name, description, config, status, limit_answers, due_to, time_of_passing, pausable, version, version_comment, parent_ids, created_at, updated_at, questions_count, answers_count, average_time_passing, sessions_count, gigachat FROM quiz
WHERE
    deleted = false AND
    archived = false AND
    (status = 'start' OR status = 'ai') AND
    qid = $1
`

func (q *Queries) GetQuizByQid(ctx context.Context, qid uuid.NullUUID) (Quiz, error) {
	row := q.db.QueryRowContext(ctx, getQuizByQid, qid)
	var i Quiz
	err := row.Scan(
		&i.ID,
		&i.Qid,
		&i.Accountid,
		&i.Deleted,
		&i.Archived,
		&i.Fingerprinting,
		&i.Repeatable,
		&i.NotePrevented,
		&i.MailNotifications,
		&i.UniqueAnswers,
		&i.Super,
		&i.GroupID,
		&i.Name,
		&i.Description,
		&i.Config,
		&i.Status,
		&i.LimitAnswers,
		&i.DueTo,
		&i.TimeOfPassing,
		&i.Pausable,
		&i.Version,
		&i.VersionComment,
		pq.Array(&i.ParentIds),
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.QuestionsCount,
		&i.AnswersCount,
		&i.AverageTimePassing,
		&i.SessionsCount,
		&i.Gigachat,
	)
	return i, err
}

const getQuizConfig = `-- name: GetQuizConfig :one
SELECT config, accountid FROM quiz WHERE id = $1 AND deleted = false
`

type GetQuizConfigRow struct {
	Config    sql.NullString `db:"config" json:"config"`
	Accountid string         `db:"accountid" json:"accountid"`
}

func (q *Queries) GetQuizConfig(ctx context.Context, id int64) (GetQuizConfigRow, error) {
	row := q.db.QueryRowContext(ctx, getQuizConfig, id)
	var i GetQuizConfigRow
	err := row.Scan(&i.Config, &i.Accountid)
	return i, err
}

const getQuizHistory = `-- name: GetQuizHistory :many
SELECT id, qid, accountid, deleted, archived, fingerprinting, repeatable, note_prevented, mail_notifications, unique_answers, super, group_id, name, description, config, status, limit_answers, due_to, time_of_passing, pausable, version, version_comment, parent_ids, created_at, updated_at, questions_count, answers_count, average_time_passing, sessions_count, gigachat FROM quiz WHERE quiz.id = $1 AND quiz.accountId = $4 OR quiz.id = ANY(
    SELECT unnest(parent_ids) FROM quiz WHERE id = $1
) ORDER BY quiz.id DESC LIMIT $2 OFFSET $3
`

type GetQuizHistoryParams struct {
	ID        int64  `db:"id" json:"id"`
	Limit     int32  `db:"limit" json:"limit"`
	Offset    int32  `db:"offset" json:"offset"`
	Accountid string `db:"accountid" json:"accountid"`
}

func (q *Queries) GetQuizHistory(ctx context.Context, arg GetQuizHistoryParams) ([]Quiz, error) {
	rows, err := q.db.QueryContext(ctx, getQuizHistory,
		arg.ID,
		arg.Limit,
		arg.Offset,
		arg.Accountid,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Quiz
	for rows.Next() {
		var i Quiz
		if err := rows.Scan(
			&i.ID,
			&i.Qid,
			&i.Accountid,
			&i.Deleted,
			&i.Archived,
			&i.Fingerprinting,
			&i.Repeatable,
			&i.NotePrevented,
			&i.MailNotifications,
			&i.UniqueAnswers,
			&i.Super,
			&i.GroupID,
			&i.Name,
			&i.Description,
			&i.Config,
			&i.Status,
			&i.LimitAnswers,
			&i.DueTo,
			&i.TimeOfPassing,
			&i.Pausable,
			&i.Version,
			&i.VersionComment,
			pq.Array(&i.ParentIds),
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.QuestionsCount,
			&i.AnswersCount,
			&i.AverageTimePassing,
			&i.SessionsCount,
			&i.Gigachat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getQuizPrivilegeUsage = `-- name: GetQuizPrivilegeUsage :one
SELECT id, quiz_id, privilege_id, used_count, created_at, updated_at FROM quiz_privilege_usage
WHERE quiz_id = $1 AND privilege_id = $2 LIMIT 1
`

type GetQuizPrivilegeUsageParams struct {
	QuizID      int64  `db:"quiz_id" json:"quiz_id"`
	PrivilegeID string `db:"privilege_id" json:"privilege_id"`
}

func (q *Queries) GetQuizPrivilegeUsage(ctx context.Context, arg GetQuizPrivilegeUsageParams) (QuizPrivilegeUsage, error) {
	row := q.db.QueryRowContext(ctx, getQuizPrivilegeUsage, arg.QuizID, arg.PrivilegeID)
	var i QuizPrivilegeUsage
	err := row.Scan(
		&i.ID,
		&i.QuizID,
		&i.PrivilegeID,
		&i.UsedCount,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getQuizRule = `-- name: GetQuizRule :one
SELECT id, accountid, quizid, performerid, pipelineid, stepid, fieldsrule, deleted, createdat, tagstoadd FROM rules WHERE QuizID = $1 AND AccountID = (SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $2 AND accountsAmo.Deleted = false) AND Deleted = false
`

type GetQuizRuleParams struct {
	Quizid    int32  `db:"quizid" json:"quizid"`
	Accountid string `db:"accountid" json:"accountid"`
}

func (q *Queries) GetQuizRule(ctx context.Context, arg GetQuizRuleParams) (Rule, error) {
	row := q.db.QueryRowContext(ctx, getQuizRule, arg.Quizid, arg.Accountid)
	var i Rule
	err := row.Scan(
		&i.ID,
		&i.Accountid,
		&i.Quizid,
		&i.Performerid,
		&i.Pipelineid,
		&i.Stepid,
		&i.Fieldsrule,
		&i.Deleted,
		&i.Createdat,
		&i.Tagstoadd,
	)
	return i, err
}

const getResultAnswers = `-- name: GetResultAnswers :many
SELECT DISTINCT on (question_id) id, content, quiz_id, question_id, fingerprint, session,created_at, result, new,deleted, device_type,device,os,browser,ip,version FROM answer WHERE session = (
    SELECT session FROM answer WHERE answer.id = $1) ORDER BY question_id, created_at DESC
`

type GetResultAnswersRow struct {
	ID          int64          `db:"id" json:"id"`
	Content     sql.NullString `db:"content" json:"content"`
	QuizID      int64          `db:"quiz_id" json:"quiz_id"`
	QuestionID  int64          `db:"question_id" json:"question_id"`
	Fingerprint sql.NullString `db:"fingerprint" json:"fingerprint"`
	Session     sql.NullString `db:"session" json:"session"`
	CreatedAt   sql.NullTime   `db:"created_at" json:"created_at"`
	Result      sql.NullBool   `db:"result" json:"result"`
	New         sql.NullBool   `db:"new" json:"new"`
	Deleted     sql.NullBool   `db:"deleted" json:"deleted"`
	DeviceType  string         `db:"device_type" json:"device_type"`
	Device      string         `db:"device" json:"device"`
	Os          string         `db:"os" json:"os"`
	Browser     string         `db:"browser" json:"browser"`
	Ip          string         `db:"ip" json:"ip"`
	Version     int32          `db:"version" json:"version"`
}

func (q *Queries) GetResultAnswers(ctx context.Context, id int64) ([]GetResultAnswersRow, error) {
	rows, err := q.db.QueryContext(ctx, getResultAnswers, id)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetResultAnswersRow
	for rows.Next() {
		var i GetResultAnswersRow
		if err := rows.Scan(
			&i.ID,
			&i.Content,
			&i.QuizID,
			&i.QuestionID,
			&i.Fingerprint,
			&i.Session,
			&i.CreatedAt,
			&i.Result,
			&i.New,
			&i.Deleted,
			&i.DeviceType,
			&i.Device,
			&i.Os,
			&i.Browser,
			&i.Ip,
			&i.Version,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getStepsCount = `-- name: GetStepsCount :one
WITH user_data AS (
    SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
)
SELECT COUNT(*) FROM steps s  JOIN user_data u ON s.AccountID = u.AmoID WHERE s.Deleted = false AND s.PipelineID = $2
`

type GetStepsCountParams struct {
	Accountid  string `db:"accountid" json:"accountid"`
	Pipelineid int32  `db:"pipelineid" json:"pipelineid"`
}

func (q *Queries) GetStepsCount(ctx context.Context, arg GetStepsCountParams) (int64, error) {
	row := q.db.QueryRowContext(ctx, getStepsCount, arg.Accountid, arg.Pipelineid)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const getStepsWithPagination = `-- name: GetStepsWithPagination :many
WITH user_data AS (
    SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
)
SELECT s.id, s.amoid, s.pipelineid, s.accountid, s.name, s.color, s.deleted, s.createdat
FROM steps s JOIN user_data u ON s.AccountID = u.AmoID
WHERE s.Deleted = false AND s.PipelineID = $4
ORDER BY s.ID OFFSET ($2 - 1) * $3 LIMIT $3
`

type GetStepsWithPaginationParams struct {
	Accountid  string      `db:"accountid" json:"accountid"`
	Column2    interface{} `db:"column_2" json:"column_2"`
	Limit      int32       `db:"limit" json:"limit"`
	Pipelineid int32       `db:"pipelineid" json:"pipelineid"`
}

func (q *Queries) GetStepsWithPagination(ctx context.Context, arg GetStepsWithPaginationParams) ([]Step, error) {
	rows, err := q.db.QueryContext(ctx, getStepsWithPagination,
		arg.Accountid,
		arg.Column2,
		arg.Limit,
		arg.Pipelineid,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Step
	for rows.Next() {
		var i Step
		if err := rows.Scan(
			&i.ID,
			&i.Amoid,
			&i.Pipelineid,
			&i.Accountid,
			&i.Name,
			&i.Color,
			&i.Deleted,
			&i.Createdat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getTagsCount = `-- name: GetTagsCount :one
WITH user_data AS (
    SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
)
SELECT COUNT(*) FROM tags t JOIN user_data u ON t.AccountID = u.AmoID WHERE t.Deleted = false
`

func (q *Queries) GetTagsCount(ctx context.Context, accountid string) (int64, error) {
	row := q.db.QueryRowContext(ctx, getTagsCount, accountid)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const getTagsWithPagination = `-- name: GetTagsWithPagination :many
WITH user_data AS (
    SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
)
SELECT t.id, t.amoid, t.accountid, t.entity, t.name, t.color, t.deleted, t.createdat
FROM tags t JOIN user_data u ON t.AccountID = u.AmoID
WHERE t.Deleted = false
ORDER BY t.ID OFFSET ($2 - 1) * $3 LIMIT $3
`

type GetTagsWithPaginationParams struct {
	Accountid string      `db:"accountid" json:"accountid"`
	Column2   interface{} `db:"column_2" json:"column_2"`
	Limit     int32       `db:"limit" json:"limit"`
}

func (q *Queries) GetTagsWithPagination(ctx context.Context, arg GetTagsWithPaginationParams) ([]Tag, error) {
	rows, err := q.db.QueryContext(ctx, getTagsWithPagination, arg.Accountid, arg.Column2, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Tag
	for rows.Next() {
		var i Tag
		if err := rows.Scan(
			&i.ID,
			&i.Amoid,
			&i.Accountid,
			&i.Entity,
			&i.Name,
			&i.Color,
			&i.Deleted,
			&i.Createdat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getTokenById = `-- name: GetTokenById :one
SELECT accountid, refreshtoken, accesstoken, authcode, expiration, createdat FROM tokens WHERE accountID = $1
`

func (q *Queries) GetTokenById(ctx context.Context, accountid string) (Token, error) {
	row := q.db.QueryRowContext(ctx, getTokenById, accountid)
	var i Token
	err := row.Scan(
		&i.Accountid,
		&i.Refreshtoken,
		&i.Accesstoken,
		&i.Authcode,
		&i.Expiration,
		&i.Createdat,
	)
	return i, err
}

const getUserBitrixFieldsByID = `-- name: GetUserBitrixFieldsByID :many
SELECT id, bitrixid, accountid, entityid, fieldname, editfromlabel, fieldtype, deleted, createdat FROM BitrixFields WHERE AccountID = $1 AND Deleted = false
`

func (q *Queries) GetUserBitrixFieldsByID(ctx context.Context, accountid string) ([]Bitrixfield, error) {
	rows, err := q.db.QueryContext(ctx, getUserBitrixFieldsByID, accountid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Bitrixfield
	for rows.Next() {
		var i Bitrixfield
		if err := rows.Scan(
			&i.ID,
			&i.Bitrixid,
			&i.Accountid,
			&i.Entityid,
			&i.Fieldname,
			&i.Editfromlabel,
			&i.Fieldtype,
			&i.Deleted,
			&i.Createdat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUserBitrixPipelinesByID = `-- name: GetUserBitrixPipelinesByID :many
SELECT id, bitrixid, accountid, name, entitytypeid, deleted, createdat FROM PipelineBitrix WHERE AccountID = $1 AND Deleted = false
`

func (q *Queries) GetUserBitrixPipelinesByID(ctx context.Context, accountid string) ([]Pipelinebitrix, error) {
	rows, err := q.db.QueryContext(ctx, getUserBitrixPipelinesByID, accountid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Pipelinebitrix
	for rows.Next() {
		var i Pipelinebitrix
		if err := rows.Scan(
			&i.ID,
			&i.Bitrixid,
			&i.Accountid,
			&i.Name,
			&i.Entitytypeid,
			&i.Deleted,
			&i.Createdat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUserBitrixStepsByID = `-- name: GetUserBitrixStepsByID :many
SELECT id, accountid, bitrixid, entityid, statusid, name, nameinit, color, pipelineid, deleted, createdat FROM StepBitrix WHERE AccountID = $1 AND Deleted = false
`

func (q *Queries) GetUserBitrixStepsByID(ctx context.Context, accountid string) ([]Stepbitrix, error) {
	rows, err := q.db.QueryContext(ctx, getUserBitrixStepsByID, accountid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Stepbitrix
	for rows.Next() {
		var i Stepbitrix
		if err := rows.Scan(
			&i.ID,
			&i.Accountid,
			&i.Bitrixid,
			&i.Entityid,
			&i.Statusid,
			&i.Name,
			&i.Nameinit,
			&i.Color,
			&i.Pipelineid,
			&i.Deleted,
			&i.Createdat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUserFieldsByID = `-- name: GetUserFieldsByID :many
SELECT ID,AmoID,Code,AccountID,Name,Entity,Type
FROM fields
WHERE AccountID = $1 AND Deleted = false
`

type GetUserFieldsByIDRow struct {
	ID        int64       `db:"id" json:"id"`
	Amoid     int32       `db:"amoid" json:"amoid"`
	Code      string      `db:"code" json:"code"`
	Accountid int32       `db:"accountid" json:"accountid"`
	Name      string      `db:"name" json:"name"`
	Entity    interface{} `db:"entity" json:"entity"`
	Type      interface{} `db:"type" json:"type"`
}

func (q *Queries) GetUserFieldsByID(ctx context.Context, accountid int32) ([]GetUserFieldsByIDRow, error) {
	rows, err := q.db.QueryContext(ctx, getUserFieldsByID, accountid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetUserFieldsByIDRow
	for rows.Next() {
		var i GetUserFieldsByIDRow
		if err := rows.Scan(
			&i.ID,
			&i.Amoid,
			&i.Code,
			&i.Accountid,
			&i.Name,
			&i.Entity,
			&i.Type,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUserPipelinesByID = `-- name: GetUserPipelinesByID :many
SELECT ID,AmoID,AccountID,Name,IsArchive
FROM pipelines
WHERE AccountID = $1 AND Deleted = false
`

type GetUserPipelinesByIDRow struct {
	ID        int64  `db:"id" json:"id"`
	Amoid     int32  `db:"amoid" json:"amoid"`
	Accountid int32  `db:"accountid" json:"accountid"`
	Name      string `db:"name" json:"name"`
	Isarchive bool   `db:"isarchive" json:"isarchive"`
}

func (q *Queries) GetUserPipelinesByID(ctx context.Context, accountid int32) ([]GetUserPipelinesByIDRow, error) {
	rows, err := q.db.QueryContext(ctx, getUserPipelinesByID, accountid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetUserPipelinesByIDRow
	for rows.Next() {
		var i GetUserPipelinesByIDRow
		if err := rows.Scan(
			&i.ID,
			&i.Amoid,
			&i.Accountid,
			&i.Name,
			&i.Isarchive,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUserStepsByID = `-- name: GetUserStepsByID :many
SELECT ID,AmoID,PipelineID,AccountID,Name,Color
FROM steps
WHERE AccountID = $1 AND Deleted = false
`

type GetUserStepsByIDRow struct {
	ID         int64  `db:"id" json:"id"`
	Amoid      int32  `db:"amoid" json:"amoid"`
	Pipelineid int32  `db:"pipelineid" json:"pipelineid"`
	Accountid  int32  `db:"accountid" json:"accountid"`
	Name       string `db:"name" json:"name"`
	Color      string `db:"color" json:"color"`
}

func (q *Queries) GetUserStepsByID(ctx context.Context, accountid int32) ([]GetUserStepsByIDRow, error) {
	rows, err := q.db.QueryContext(ctx, getUserStepsByID, accountid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetUserStepsByIDRow
	for rows.Next() {
		var i GetUserStepsByIDRow
		if err := rows.Scan(
			&i.ID,
			&i.Amoid,
			&i.Pipelineid,
			&i.Accountid,
			&i.Name,
			&i.Color,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUserTagsByID = `-- name: GetUserTagsByID :many
SELECT ID,AmoID,AccountID,Name,Entity,Color
FROM tags
WHERE AccountID = $1 AND Deleted = false
`

type GetUserTagsByIDRow struct {
	ID        int64       `db:"id" json:"id"`
	Amoid     int32       `db:"amoid" json:"amoid"`
	Accountid int32       `db:"accountid" json:"accountid"`
	Name      string      `db:"name" json:"name"`
	Entity    interface{} `db:"entity" json:"entity"`
	Color     string      `db:"color" json:"color"`
}

func (q *Queries) GetUserTagsByID(ctx context.Context, accountid int32) ([]GetUserTagsByIDRow, error) {
	rows, err := q.db.QueryContext(ctx, getUserTagsByID, accountid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetUserTagsByIDRow
	for rows.Next() {
		var i GetUserTagsByIDRow
		if err := rows.Scan(
			&i.ID,
			&i.Amoid,
			&i.Accountid,
			&i.Name,
			&i.Entity,
			&i.Color,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUserUsersByID = `-- name: GetUserUsersByID :many
SELECT id, amoid, amouserid, name, email, role, "Group", deleted, createdat FROM usersAmo WHERE amoid = $1 AND Deleted = false
`

func (q *Queries) GetUserUsersByID(ctx context.Context, amoid int32) ([]Usersamo, error) {
	rows, err := q.db.QueryContext(ctx, getUserUsersByID, amoid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Usersamo
	for rows.Next() {
		var i Usersamo
		if err := rows.Scan(
			&i.ID,
			&i.Amoid,
			&i.Amouserid,
			&i.Name,
			&i.Email,
			&i.Role,
			&i.Group,
			&i.Deleted,
			&i.Createdat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUserUsersByIDBitrix = `-- name: GetUserUsersByIDBitrix :many
SELECT id, accountid, bitrixiduserid, name, lastname, secondname, title, email, ufdepartment, workposition, deleted, createdat FROM BitrixAccountUsers WHERE accountID = $1 AND Deleted = false
`

func (q *Queries) GetUserUsersByIDBitrix(ctx context.Context, accountid string) ([]Bitrixaccountuser, error) {
	rows, err := q.db.QueryContext(ctx, getUserUsersByIDBitrix, accountid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Bitrixaccountuser
	for rows.Next() {
		var i Bitrixaccountuser
		if err := rows.Scan(
			&i.ID,
			&i.Accountid,
			&i.Bitrixiduserid,
			&i.Name,
			&i.Lastname,
			&i.Secondname,
			&i.Title,
			&i.Email,
			pq.Array(&i.Ufdepartment),
			&i.Workposition,
			&i.Deleted,
			&i.Createdat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUsersBitrixWithPagination = `-- name: GetUsersBitrixWithPagination :many

WITH user_data AS (
    SELECT BitrixID FROM BitrixAccounts WHERE BitrixAccounts.AccountID = $1 AND BitrixAccounts.Deleted = false
)
SELECT u.id, u.accountid, u.bitrixiduserid, u.name, u.lastname, u.secondname, u.title, u.email, u.ufdepartment, u.workposition, u.deleted, u.createdat, COUNT(*) OVER() as total_count
FROM BitrixAccountUsers u
         JOIN user_data a ON u.BitrixID = a.BitrixID
WHERE u.Deleted = false
ORDER BY u.ID OFFSET ($2 - 1) * $3 LIMIT $3
`

type GetUsersBitrixWithPaginationParams struct {
	Accountid string      `db:"accountid" json:"accountid"`
	Column2   interface{} `db:"column_2" json:"column_2"`
	Limit     int32       `db:"limit" json:"limit"`
}

type GetUsersBitrixWithPaginationRow struct {
	ID             int64     `db:"id" json:"id"`
	Accountid      string    `db:"accountid" json:"accountid"`
	Bitrixiduserid string    `db:"bitrixiduserid" json:"bitrixiduserid"`
	Name           string    `db:"name" json:"name"`
	Lastname       string    `db:"lastname" json:"lastname"`
	Secondname     string    `db:"secondname" json:"secondname"`
	Title          string    `db:"title" json:"title"`
	Email          string    `db:"email" json:"email"`
	Ufdepartment   []int32   `db:"ufdepartment" json:"ufdepartment"`
	Workposition   string    `db:"workposition" json:"workposition"`
	Deleted        bool      `db:"deleted" json:"deleted"`
	Createdat      time.Time `db:"createdat" json:"createdat"`
	TotalCount     int64     `db:"total_count" json:"total_count"`
}

// BITRIX
func (q *Queries) GetUsersBitrixWithPagination(ctx context.Context, arg GetUsersBitrixWithPaginationParams) ([]GetUsersBitrixWithPaginationRow, error) {
	rows, err := q.db.QueryContext(ctx, getUsersBitrixWithPagination, arg.Accountid, arg.Column2, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetUsersBitrixWithPaginationRow
	for rows.Next() {
		var i GetUsersBitrixWithPaginationRow
		if err := rows.Scan(
			&i.ID,
			&i.Accountid,
			&i.Bitrixiduserid,
			&i.Name,
			&i.Lastname,
			&i.Secondname,
			&i.Title,
			&i.Email,
			pq.Array(&i.Ufdepartment),
			&i.Workposition,
			&i.Deleted,
			&i.Createdat,
			&i.TotalCount,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUsersCount = `-- name: GetUsersCount :one
WITH user_data AS (
    SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
)
SELECT COUNT(*) FROM usersAmo u JOIN user_data a ON u.AmoID = a.AmoID WHERE u.Deleted = false
`

func (q *Queries) GetUsersCount(ctx context.Context, accountid string) (int64, error) {
	row := q.db.QueryRowContext(ctx, getUsersCount, accountid)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const getUsersWithPagination = `-- name: GetUsersWithPagination :many
WITH user_data AS (
    SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND accountsAmo.Deleted = false
)
SELECT u.id, u.amoid, u.amouserid, u.name, u.email, u.role, u."Group", u.deleted, u.createdat
FROM usersAmo u
         JOIN user_data a ON u.AmoID = a.AmoID
WHERE u.Deleted = false
ORDER BY u.ID OFFSET ($2 - 1) * $3 LIMIT $3
`

type GetUsersWithPaginationParams struct {
	Accountid string      `db:"accountid" json:"accountid"`
	Column2   interface{} `db:"column_2" json:"column_2"`
	Limit     int32       `db:"limit" json:"limit"`
}

func (q *Queries) GetUsersWithPagination(ctx context.Context, arg GetUsersWithPaginationParams) ([]Usersamo, error) {
	rows, err := q.db.QueryContext(ctx, getUsersWithPagination, arg.Accountid, arg.Column2, arg.Limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Usersamo
	for rows.Next() {
		var i Usersamo
		if err := rows.Scan(
			&i.ID,
			&i.Amoid,
			&i.Amouserid,
			&i.Name,
			&i.Email,
			&i.Role,
			&i.Group,
			&i.Deleted,
			&i.Createdat,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const gettingAmoUsersTrueResults = `-- name: GettingAmoUsersTrueResults :many
SELECT a.quiz_id,a.id,a.result,a.question_id,a.content,a.session,
      COALESCE((SELECT a2.utm
      FROM answer a2
      WHERE a2.start = true AND a2.session = a.session
      LIMIT 1), '{}'::jsonb) AS utm
,t.accesstoken,r.accountid,r.fieldsrule,r.tagstoadd,r.performerid,r.stepid,r.pipelineid,(SELECT u.name FROM usersAmo u WHERE u.AmoUserID = r.performerid AND u.amoid = r.accountid AND u.deleted = false) AS performer_name,u.subdomain,u.accountid,u.driveurl
FROM answer a
         INNER JOIN quiz q ON a.quiz_id = q.id
         LEFT JOIN amoCRMStatuses s ON a.id = s.AnswerID
         INNER JOIN rules r ON q.id = r.QuizID
         INNER JOIN tokens t ON q.accountid = t.AccountID
         INNER JOIN accountsAmo u ON q.accountid = u.accountid AND u.amoid = r.accountid
WHERE a.result = true
  AND s.id IS NULL
  AND a.deleted = false
  AND r.deleted = false
  AND q.deleted = false
  AND u.deleted = false
`

type GettingAmoUsersTrueResultsRow struct {
	QuizID        int64           `db:"quiz_id" json:"quiz_id"`
	ID            int64           `db:"id" json:"id"`
	Result        sql.NullBool    `db:"result" json:"result"`
	QuestionID    int64           `db:"question_id" json:"question_id"`
	Content       sql.NullString  `db:"content" json:"content"`
	Session       sql.NullString  `db:"session" json:"session"`
	Utm           interface{}     `db:"utm" json:"utm"`
	Accesstoken   string          `db:"accesstoken" json:"accesstoken"`
	Accountid     int32           `db:"accountid" json:"accountid"`
	Fieldsrule    json.RawMessage `db:"fieldsrule" json:"fieldsrule"`
	Tagstoadd     json.RawMessage `db:"tagstoadd" json:"tagstoadd"`
	Performerid   int32           `db:"performerid" json:"performerid"`
	Stepid        int32           `db:"stepid" json:"stepid"`
	Pipelineid    int32           `db:"pipelineid" json:"pipelineid"`
	PerformerName string          `db:"performer_name" json:"performer_name"`
	Subdomain     string          `db:"subdomain" json:"subdomain"`
	Accountid_2   string          `db:"accountid_2" json:"accountid_2"`
	Driveurl      string          `db:"driveurl" json:"driveurl"`
}

func (q *Queries) GettingAmoUsersTrueResults(ctx context.Context) ([]GettingAmoUsersTrueResultsRow, error) {
	rows, err := q.db.QueryContext(ctx, gettingAmoUsersTrueResults)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GettingAmoUsersTrueResultsRow
	for rows.Next() {
		var i GettingAmoUsersTrueResultsRow
		if err := rows.Scan(
			&i.QuizID,
			&i.ID,
			&i.Result,
			&i.QuestionID,
			&i.Content,
			&i.Session,
			&i.Utm,
			&i.Accesstoken,
			&i.Accountid,
			&i.Fieldsrule,
			&i.Tagstoadd,
			&i.Performerid,
			&i.Stepid,
			&i.Pipelineid,
			&i.PerformerName,
			&i.Subdomain,
			&i.Accountid_2,
			&i.Driveurl,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const gettingBitrixUsersTrueResults = `-- name: GettingBitrixUsersTrueResults :many
SELECT a.quiz_id,a.id,a.result,a.question_id,a.content,a.session,
       COALESCE((SELECT a2.utm
                 FROM answer a2
                 WHERE a2.start = true AND a2.session = a.session
                 LIMIT 1), '{}'::jsonb) AS utm
        ,t.accesstoken,r.accountid,r.fieldsrule,r.tagstoadd,r.performerid,r.TypeID,r.StageID,r.SourceID,r.StatusID,r.pipelineid,(SELECT u.name FROM BitrixAccountUsers u WHERE u.bitrixiduserid = r.performerid AND u.deleted = false) AS performer_name,u.subdomain,u.accountid,r.leadflag
FROM answer a
         INNER JOIN quiz q ON a.quiz_id = q.id
         LEFT JOIN bitrixcrmstatuses s ON a.id = s.AnswerID
         INNER JOIN bitrixrule r ON q.id = r.QuizID
         INNER JOIN bitrixtokens t ON q.accountid = t.AccountID
         INNER JOIN bitrixaccounts u ON q.accountid = u.accountid AND u.bitrixid = r.accountid
WHERE a.result = true
  AND s.id IS NULL
  AND a.deleted = false
  AND r.deleted = false
  AND q.deleted = false
  AND u.deleted = false
`

type GettingBitrixUsersTrueResultsRow struct {
	QuizID        int64           `db:"quiz_id" json:"quiz_id"`
	ID            int64           `db:"id" json:"id"`
	Result        sql.NullBool    `db:"result" json:"result"`
	QuestionID    int64           `db:"question_id" json:"question_id"`
	Content       sql.NullString  `db:"content" json:"content"`
	Session       sql.NullString  `db:"session" json:"session"`
	Utm           interface{}     `db:"utm" json:"utm"`
	Accesstoken   string          `db:"accesstoken" json:"accesstoken"`
	Accountid     string          `db:"accountid" json:"accountid"`
	Fieldsrule    json.RawMessage `db:"fieldsrule" json:"fieldsrule"`
	Tagstoadd     json.RawMessage `db:"tagstoadd" json:"tagstoadd"`
	Performerid   string          `db:"performerid" json:"performerid"`
	Typeid        string          `db:"typeid" json:"typeid"`
	Stageid       string          `db:"stageid" json:"stageid"`
	Sourceid      string          `db:"sourceid" json:"sourceid"`
	Statusid      string          `db:"statusid" json:"statusid"`
	Pipelineid    int32           `db:"pipelineid" json:"pipelineid"`
	PerformerName string          `db:"performer_name" json:"performer_name"`
	Subdomain     string          `db:"subdomain" json:"subdomain"`
	Accountid_2   string          `db:"accountid_2" json:"accountid_2"`
	Leadflag      bool            `db:"leadflag" json:"leadflag"`
}

func (q *Queries) GettingBitrixUsersTrueResults(ctx context.Context) ([]GettingBitrixUsersTrueResultsRow, error) {
	rows, err := q.db.QueryContext(ctx, gettingBitrixUsersTrueResults)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GettingBitrixUsersTrueResultsRow
	for rows.Next() {
		var i GettingBitrixUsersTrueResultsRow
		if err := rows.Scan(
			&i.QuizID,
			&i.ID,
			&i.Result,
			&i.QuestionID,
			&i.Content,
			&i.Session,
			&i.Utm,
			&i.Accesstoken,
			&i.Accountid,
			&i.Fieldsrule,
			&i.Tagstoadd,
			&i.Performerid,
			&i.Typeid,
			&i.Stageid,
			&i.Sourceid,
			&i.Statusid,
			&i.Pipelineid,
			&i.PerformerName,
			&i.Subdomain,
			&i.Accountid_2,
			&i.Leadflag,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const incrementQuizPrivilegeUsage = `-- name: IncrementQuizPrivilegeUsage :exec
UPDATE quiz_privilege_usage SET used_count = used_count + 1,  updated_at = CURRENT_TIMESTAMP
WHERE quiz_id = $1 AND privilege_id = $2
`

type IncrementQuizPrivilegeUsageParams struct {
	QuizID      int64  `db:"quiz_id" json:"quiz_id"`
	PrivilegeID string `db:"privilege_id" json:"privilege_id"`
}

func (q *Queries) IncrementQuizPrivilegeUsage(ctx context.Context, arg IncrementQuizPrivilegeUsageParams) error {
	_, err := q.db.ExecContext(ctx, incrementQuizPrivilegeUsage, arg.QuizID, arg.PrivilegeID)
	return err
}

const insertAnswers = `-- name: InsertAnswers :one
INSERT INTO answer(
    content,
    quiz_id,
    question_id,
    fingerprint,
    session,
    result,
    email,
    device_type,
    device,
    os,
    browser,
    ip,
    start,
    utm,
    version
) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15)
RETURNING id, content, quiz_id, question_id, fingerprint, session, created_at, result, new, deleted, email, device_type, device, os, browser, ip, start, utm, version
`

type InsertAnswersParams struct {
	Content     sql.NullString  `db:"content" json:"content"`
	QuizID      int64           `db:"quiz_id" json:"quiz_id"`
	QuestionID  int64           `db:"question_id" json:"question_id"`
	Fingerprint sql.NullString  `db:"fingerprint" json:"fingerprint"`
	Session     sql.NullString  `db:"session" json:"session"`
	Result      sql.NullBool    `db:"result" json:"result"`
	Email       string          `db:"email" json:"email"`
	DeviceType  string          `db:"device_type" json:"device_type"`
	Device      string          `db:"device" json:"device"`
	Os          string          `db:"os" json:"os"`
	Browser     string          `db:"browser" json:"browser"`
	Ip          string          `db:"ip" json:"ip"`
	Start       bool            `db:"start" json:"start"`
	Utm         json.RawMessage `db:"utm" json:"utm"`
	Version     int32           `db:"version" json:"version"`
}

func (q *Queries) InsertAnswers(ctx context.Context, arg InsertAnswersParams) (Answer, error) {
	row := q.db.QueryRowContext(ctx, insertAnswers,
		arg.Content,
		arg.QuizID,
		arg.QuestionID,
		arg.Fingerprint,
		arg.Session,
		arg.Result,
		arg.Email,
		arg.DeviceType,
		arg.Device,
		arg.Os,
		arg.Browser,
		arg.Ip,
		arg.Start,
		arg.Utm,
		arg.Version,
	)
	var i Answer
	err := row.Scan(
		&i.ID,
		&i.Content,
		&i.QuizID,
		&i.QuestionID,
		&i.Fingerprint,
		&i.Session,
		&i.CreatedAt,
		&i.Result,
		&i.New,
		&i.Deleted,
		&i.Email,
		&i.DeviceType,
		&i.Device,
		&i.Os,
		&i.Browser,
		&i.Ip,
		&i.Start,
		&i.Utm,
		&i.Version,
	)
	return i, err
}

const insertContactAmo = `-- name: InsertContactAmo :one
INSERT INTO amoContact (AccountID, AmoID, Field) VALUES ($1, $2, $3) RETURNING AmoID
`

type InsertContactAmoParams struct {
	Accountid int32  `db:"accountid" json:"accountid"`
	Amoid     int32  `db:"amoid" json:"amoid"`
	Field     string `db:"field" json:"field"`
}

func (q *Queries) InsertContactAmo(ctx context.Context, arg InsertContactAmoParams) (int32, error) {
	row := q.db.QueryRowContext(ctx, insertContactAmo, arg.Accountid, arg.Amoid, arg.Field)
	var amoid int32
	err := row.Scan(&amoid)
	return amoid, err
}

const insertContactBitrix = `-- name: InsertContactBitrix :one
INSERT INTO bitrixContact (AccountID, BitrixID, Field) VALUES ($1, $2, $3) RETURNING BitrixID
`

type InsertContactBitrixParams struct {
	Accountid string `db:"accountid" json:"accountid"`
	Bitrixid  int32  `db:"bitrixid" json:"bitrixid"`
	Field     string `db:"field" json:"field"`
}

func (q *Queries) InsertContactBitrix(ctx context.Context, arg InsertContactBitrixParams) (int32, error) {
	row := q.db.QueryRowContext(ctx, insertContactBitrix, arg.Accountid, arg.Bitrixid, arg.Field)
	var bitrixid int32
	err := row.Scan(&bitrixid)
	return bitrixid, err
}

const insertPrivilege = `-- name: InsertPrivilege :exec
INSERT INTO privileges (privilegeID, account_id, privilege_name, amount, created_at) VALUES ($1, $2, $3, $4, $5)
`

type InsertPrivilegeParams struct {
	Privilegeid   string    `db:"privilegeid" json:"privilegeid"`
	AccountID     uuid.UUID `db:"account_id" json:"account_id"`
	PrivilegeName string    `db:"privilege_name" json:"privilege_name"`
	Amount        int32     `db:"amount" json:"amount"`
	CreatedAt     time.Time `db:"created_at" json:"created_at"`
}

func (q *Queries) InsertPrivilege(ctx context.Context, arg InsertPrivilegeParams) error {
	_, err := q.db.ExecContext(ctx, insertPrivilege,
		arg.Privilegeid,
		arg.AccountID,
		arg.PrivilegeName,
		arg.Amount,
		arg.CreatedAt,
	)
	return err
}

const insertQuestion = `-- name: InsertQuestion :one
INSERT INTO question (
    quiz_id,
    title,
    description,
    questiontype,
    required,
    page,
    content,
    parent_ids,
    updated_at,
    session,
    auditory
)
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11)
    RETURNING id, created_at, updated_at
`

type InsertQuestionParams struct {
	QuizID       int64          `db:"quiz_id" json:"quiz_id"`
	Title        string         `db:"title" json:"title"`
	Description  sql.NullString `db:"description" json:"description"`
	Questiontype interface{}    `db:"questiontype" json:"questiontype"`
	Required     sql.NullBool   `db:"required" json:"required"`
	Page         sql.NullInt16  `db:"page" json:"page"`
	Content      sql.NullString `db:"content" json:"content"`
	ParentIds    []int32        `db:"parent_ids" json:"parent_ids"`
	UpdatedAt    sql.NullTime   `db:"updated_at" json:"updated_at"`
	Session      string         `db:"session" json:"session"`
	Auditory     int64          `db:"auditory" json:"auditory"`
}

type InsertQuestionRow struct {
	ID        int64        `db:"id" json:"id"`
	CreatedAt sql.NullTime `db:"created_at" json:"created_at"`
	UpdatedAt sql.NullTime `db:"updated_at" json:"updated_at"`
}

func (q *Queries) InsertQuestion(ctx context.Context, arg InsertQuestionParams) (InsertQuestionRow, error) {
	row := q.db.QueryRowContext(ctx, insertQuestion,
		arg.QuizID,
		arg.Title,
		arg.Description,
		arg.Questiontype,
		arg.Required,
		arg.Page,
		arg.Content,
		pq.Array(arg.ParentIds),
		arg.UpdatedAt,
		arg.Session,
		arg.Auditory,
	)
	var i InsertQuestionRow
	err := row.Scan(&i.ID, &i.CreatedAt, &i.UpdatedAt)
	return i, err
}

const insertQuiz = `-- name: InsertQuiz :one
INSERT INTO quiz (accountid,
                  fingerprinting,
                  repeatable,
                  note_prevented,
                  mail_notifications,
                  unique_answers,
                  super,
                  group_id,
                  name,
                  description,
                  config,
                  status,
                  limit_answers,
                  due_to,
                  time_of_passing,
                  pausable,
                  parent_ids,
                  questions_count,
                  qid
)
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19)
RETURNING id, created_at, updated_at, qid
`

type InsertQuizParams struct {
	Accountid         string         `db:"accountid" json:"accountid"`
	Fingerprinting    sql.NullBool   `db:"fingerprinting" json:"fingerprinting"`
	Repeatable        sql.NullBool   `db:"repeatable" json:"repeatable"`
	NotePrevented     sql.NullBool   `db:"note_prevented" json:"note_prevented"`
	MailNotifications sql.NullBool   `db:"mail_notifications" json:"mail_notifications"`
	UniqueAnswers     sql.NullBool   `db:"unique_answers" json:"unique_answers"`
	Super             sql.NullBool   `db:"super" json:"super"`
	GroupID           sql.NullInt64  `db:"group_id" json:"group_id"`
	Name              sql.NullString `db:"name" json:"name"`
	Description       sql.NullString `db:"description" json:"description"`
	Config            sql.NullString `db:"config" json:"config"`
	Status            interface{}    `db:"status" json:"status"`
	LimitAnswers      sql.NullInt32  `db:"limit_answers" json:"limit_answers"`
	DueTo             sql.NullInt32  `db:"due_to" json:"due_to"`
	TimeOfPassing     sql.NullInt32  `db:"time_of_passing" json:"time_of_passing"`
	Pausable          sql.NullBool   `db:"pausable" json:"pausable"`
	ParentIds         []int32        `db:"parent_ids" json:"parent_ids"`
	QuestionsCount    sql.NullInt32  `db:"questions_count" json:"questions_count"`
	Qid               uuid.NullUUID  `db:"qid" json:"qid"`
}

type InsertQuizRow struct {
	ID        int64         `db:"id" json:"id"`
	CreatedAt sql.NullTime  `db:"created_at" json:"created_at"`
	UpdatedAt sql.NullTime  `db:"updated_at" json:"updated_at"`
	Qid       uuid.NullUUID `db:"qid" json:"qid"`
}

func (q *Queries) InsertQuiz(ctx context.Context, arg InsertQuizParams) (InsertQuizRow, error) {
	row := q.db.QueryRowContext(ctx, insertQuiz,
		arg.Accountid,
		arg.Fingerprinting,
		arg.Repeatable,
		arg.NotePrevented,
		arg.MailNotifications,
		arg.UniqueAnswers,
		arg.Super,
		arg.GroupID,
		arg.Name,
		arg.Description,
		arg.Config,
		arg.Status,
		arg.LimitAnswers,
		arg.DueTo,
		arg.TimeOfPassing,
		arg.Pausable,
		pq.Array(arg.ParentIds),
		arg.QuestionsCount,
		arg.Qid,
	)
	var i InsertQuizRow
	err := row.Scan(
		&i.ID,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Qid,
	)
	return i, err
}

const insertQuizPrivilegeUsage = `-- name: InsertQuizPrivilegeUsage :one
INSERT INTO quiz_privilege_usage (quiz_id, privilege_id, used_count)
VALUES ($1, $2, 0) RETURNING id, quiz_id, privilege_id, used_count, created_at, updated_at
`

type InsertQuizPrivilegeUsageParams struct {
	QuizID      int64  `db:"quiz_id" json:"quiz_id"`
	PrivilegeID string `db:"privilege_id" json:"privilege_id"`
}

func (q *Queries) InsertQuizPrivilegeUsage(ctx context.Context, arg InsertQuizPrivilegeUsageParams) (QuizPrivilegeUsage, error) {
	row := q.db.QueryRowContext(ctx, insertQuizPrivilegeUsage, arg.QuizID, arg.PrivilegeID)
	var i QuizPrivilegeUsage
	err := row.Scan(
		&i.ID,
		&i.QuizID,
		&i.PrivilegeID,
		&i.UsedCount,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const moveToHistory = `-- name: MoveToHistory :one
INSERT INTO question(
    quiz_id, title, description, questiontype, required,
    page, content, version, parent_ids, deleted
)
SELECT quiz_id, title, description, questiontype, required,
       page, content, version, parent_ids, true as deleted
FROM question WHERE question.id=$1
RETURNING question.id, quiz_id, parent_ids
`

type MoveToHistoryRow struct {
	ID        int64   `db:"id" json:"id"`
	QuizID    int64   `db:"quiz_id" json:"quiz_id"`
	ParentIds []int32 `db:"parent_ids" json:"parent_ids"`
}

func (q *Queries) MoveToHistory(ctx context.Context, id int64) (MoveToHistoryRow, error) {
	row := q.db.QueryRowContext(ctx, moveToHistory, id)
	var i MoveToHistoryRow
	err := row.Scan(&i.ID, &i.QuizID, pq.Array(&i.ParentIds))
	return i, err
}

const moveToHistoryQuiz = `-- name: MoveToHistoryQuiz :one
INSERT INTO quiz(deleted,
                 accountid, archived,fingerprinting,repeatable,note_prevented,mail_notifications,unique_answers,name,description,config,
                 status,limit_answers,due_to,time_of_passing,pausable,version,version_comment,parent_ids,questions_count,answers_count,average_time_passing, super, group_id
)
SELECT true as deleted, accountid, archived,fingerprinting,repeatable,note_prevented,mail_notifications,unique_answers,name,description,config,
       status,limit_answers,due_to,time_of_passing,pausable,version,version_comment,parent_ids,questions_count,answers_count,average_time_passing, super, group_id
FROM quiz WHERE quiz.id=$1 AND quiz.accountid=$2
RETURNING quiz.id, qid, parent_ids
`

type MoveToHistoryQuizParams struct {
	ID        int64  `db:"id" json:"id"`
	Accountid string `db:"accountid" json:"accountid"`
}

type MoveToHistoryQuizRow struct {
	ID        int64         `db:"id" json:"id"`
	Qid       uuid.NullUUID `db:"qid" json:"qid"`
	ParentIds []int32       `db:"parent_ids" json:"parent_ids"`
}

func (q *Queries) MoveToHistoryQuiz(ctx context.Context, arg MoveToHistoryQuizParams) (MoveToHistoryQuizRow, error) {
	row := q.db.QueryRowContext(ctx, moveToHistoryQuiz, arg.ID, arg.Accountid)
	var i MoveToHistoryQuizRow
	err := row.Scan(&i.ID, &i.Qid, pq.Array(&i.ParentIds))
	return i, err
}

const questionsStatistics = `-- name: QuestionsStatistics :many
WITH QuizAnswers AS (
SELECT 
	session, start, result, question_id, created_at, content, quiz_id
	FROM answer
	WHERE answer.quiz_id = $1 AND created_at between TO_TIMESTAMP($2)::timestamp and TO_TIMESTAMP($3)::timestamp
), QuizQuestions AS (SELECT title, page, id from question where quiz_id = $1), Funnel AS (
    SELECT
                COUNT(DISTINCT a.session) FILTER (WHERE a.start = FALSE) AS count_start_false,
                COUNT(DISTINCT a.session) FILTER (WHERE a.start = TRUE) AS count_start_true,
                COUNT(DISTINCT CASE WHEN a.result = FALSE AND qid_true_result IS NOT NULL THEN a.session END) AS count_f_result_with_t_question,
                COUNT(DISTINCT a.session) FILTER (WHERE a.result = TRUE) AS count_t_result
    FROM
        QuizAnswers a
            LEFT JOIN (
            SELECT DISTINCT a.session, q.id AS qid_true_result
            FROM QuizAnswers a
                     JOIN question q ON a.question_id = q.id
            WHERE a.result = TRUE AND a.quiz_id = $1
        ) AS q ON a.session = q.session
),
     Results AS (
         SELECT
             COALESCE(q.title, '') AS question_title,
             COUNT(*) AS total_answers,
             CAST(COUNT(*) * 100.0 / NULLIF(SUM(COUNT(*)) FILTER (WHERE a.result = TRUE) OVER (PARTITION BY a.quiz_id), 0) AS FLOAT8) AS percentage
         FROM
             question q
                 JOIN answer a ON q.id = a.question_id
         WHERE
             a.quiz_id = $1
           AND a.created_at >= TO_TIMESTAMP($2)
           AND a.created_at <= TO_TIMESTAMP($3)
           AND a.result = TRUE
         GROUP BY
             q.title, a.quiz_id, a.result
         HAVING
             COUNT(*) >= 1
     ),
     LastContent AS (
         SELECT
             a.question_id,
             a.content AS last_answer_content,
             a.result,
             a.start
         FROM
             QuizAnswers a
                 LEFT JOIN (
                 SELECT
                     session,
                     question_id,
                     MAX(created_at) AS last_created_at
                 FROM
                     QuizAnswers
                 WHERE
                     quiz_id = $1
                   AND start != true
                   AND created_at >= TO_TIMESTAMP($2)
                   AND created_at <= TO_TIMESTAMP($3)
                 GROUP BY
                     question_id, session
             ) AS last_created_at_one_session ON a.session = last_created_at_one_session.session AND a.question_id = last_created_at_one_session.question_id AND a.created_at = last_created_at_one_session.last_created_at
     ),
     Questions AS (
         SELECT
             q.title AS question_title,
             q.page AS question_page,
             lc.last_answer_content AS answer_content,
             CAST(
                     COUNT(CASE WHEN a.result = FALSE THEN 1 END) * 100.0 / NULLIF(SUM(COUNT(CASE WHEN a.result = FALSE THEN 1 END)) OVER (PARTITION BY q.id), 0) AS FLOAT8
             ) AS percentage
         FROM
             question q
                 JOIN LastContent lc ON q.id = lc.question_id
                 JOIN answer a ON q.id = a.question_id
         WHERE
             a.quiz_id = $1
           AND a.start != true
           AND a.created_at >= TO_TIMESTAMP($2)
           AND a.created_at <= TO_TIMESTAMP($3)
         GROUP BY
             q.id, q.title, lc.last_answer_content
         HAVING
             COUNT(*) >= 1
     )
SELECT
    Funnel.count_start_false,
    Funnel.count_start_true,
    Funnel.count_f_result_with_t_question,
    Funnel.count_t_result,
    COALESCE(Results.question_title, '') AS results_title,
    COALESCE(Results.percentage, 0) AS results_percentage,
    COALESCE(Questions.question_title, '') AS questions_title,
    COALESCE(Questions.question_page, 0) AS questions_page,
    COALESCE(Questions.answer_content, '') AS answer_content,
    COALESCE(Questions.percentage, 0) AS questions_percentage
FROM
    Funnel
        LEFT JOIN Results ON true
        LEFT JOIN Questions ON Questions.percentage >= 1
`

type QuestionsStatisticsParams struct {
	QuizID        int64   `db:"quiz_id" json:"quiz_id"`
	ToTimestamp   float64 `db:"to_timestamp" json:"to_timestamp"`
	ToTimestamp_2 float64 `db:"to_timestamp_2" json:"to_timestamp_2"`
}

type QuestionsStatisticsRow struct {
	CountStartFalse           int64   `db:"count_start_false" json:"count_start_false"`
	CountStartTrue            int64   `db:"count_start_true" json:"count_start_true"`
	CountFResultWithTQuestion int64   `db:"count_f_result_with_t_question" json:"count_f_result_with_t_question"`
	CountTResult              int64   `db:"count_t_result" json:"count_t_result"`
	ResultsTitle              string  `db:"results_title" json:"results_title"`
	ResultsPercentage         float64 `db:"results_percentage" json:"results_percentage"`
	QuestionsTitle            string  `db:"questions_title" json:"questions_title"`
	QuestionsPage             int16   `db:"questions_page" json:"questions_page"`
	AnswerContent             string  `db:"answer_content" json:"answer_content"`
	QuestionsPercentage       float64 `db:"questions_percentage" json:"questions_percentage"`
}

func (q *Queries) QuestionsStatistics(ctx context.Context, arg QuestionsStatisticsParams) ([]QuestionsStatisticsRow, error) {
	rows, err := q.db.QueryContext(ctx, questionsStatistics, arg.QuizID, arg.ToTimestamp, arg.ToTimestamp_2)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []QuestionsStatisticsRow
	for rows.Next() {
		var i QuestionsStatisticsRow
		if err := rows.Scan(
			&i.CountStartFalse,
			&i.CountStartTrue,
			&i.CountFResultWithTQuestion,
			&i.CountTResult,
			&i.ResultsTitle,
			&i.ResultsPercentage,
			&i.QuestionsTitle,
			&i.QuestionsPage,
			&i.AnswerContent,
			&i.QuestionsPercentage,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const quizCopyQid = `-- name: QuizCopyQid :one
INSERT INTO quiz (
    accountid, archived, fingerprinting, repeatable, note_prevented, mail_notifications, unique_answers, name, description, config,
    status, limit_answers, due_to, time_of_passing, pausable, version, version_comment, parent_ids, questions_count, answers_count, average_time_passing, super, group_id
)
SELECT
    $2, archived, fingerprinting, repeatable, note_prevented, mail_notifications, unique_answers, name, description, config,
    status, limit_answers, due_to, time_of_passing, pausable, version, version_comment, parent_ids, questions_count, answers_count, average_time_passing, super, group_id
FROM
    quiz as q
WHERE
    q.qid = $1
RETURNING (select id from quiz where qid = $1),id, qid
`

type QuizCopyQidParams struct {
	Qid       uuid.NullUUID `db:"qid" json:"qid"`
	Accountid string        `db:"accountid" json:"accountid"`
}

type QuizCopyQidRow struct {
	ID   int64         `db:"id" json:"id"`
	ID_2 int64         `db:"id_2" json:"id_2"`
	Qid  uuid.NullUUID `db:"qid" json:"qid"`
}

func (q *Queries) QuizCopyQid(ctx context.Context, arg QuizCopyQidParams) (QuizCopyQidRow, error) {
	row := q.db.QueryRowContext(ctx, quizCopyQid, arg.Qid, arg.Accountid)
	var i QuizCopyQidRow
	err := row.Scan(&i.ID, &i.ID_2, &i.Qid)
	return i, err
}

const resetQuizPrivilegeUsageCount = `-- name: ResetQuizPrivilegeUsageCount :exec
UPDATE quiz_privilege_usage SET used_count = 0, updated_at = CURRENT_TIMESTAMP
WHERE quiz_id = $1 AND privilege_id = $2
`

type ResetQuizPrivilegeUsageCountParams struct {
	QuizID      int64  `db:"quiz_id" json:"quiz_id"`
	PrivilegeID string `db:"privilege_id" json:"privilege_id"`
}

func (q *Queries) ResetQuizPrivilegeUsageCount(ctx context.Context, arg ResetQuizPrivilegeUsageCountParams) error {
	_, err := q.db.ExecContext(ctx, resetQuizPrivilegeUsageCount, arg.QuizID, arg.PrivilegeID)
	return err
}

const searchIDByAppIDanAppHash = `-- name: SearchIDByAppIDanAppHash :one
SELECT id, apiid, apihash, phonenumber, password, status, deleted, createdat FROM tgAccounts WHERE ApiID = $1 and ApiHash=$2 and Deleted = false
`

type SearchIDByAppIDanAppHashParams struct {
	Apiid   int32  `db:"apiid" json:"apiid"`
	Apihash string `db:"apihash" json:"apihash"`
}

func (q *Queries) SearchIDByAppIDanAppHash(ctx context.Context, arg SearchIDByAppIDanAppHashParams) (Tgaccount, error) {
	row := q.db.QueryRowContext(ctx, searchIDByAppIDanAppHash, arg.Apiid, arg.Apihash)
	var i Tgaccount
	err := row.Scan(
		&i.ID,
		&i.Apiid,
		&i.Apihash,
		&i.Phonenumber,
		&i.Password,
		&i.Status,
		&i.Deleted,
		&i.Createdat,
	)
	return i, err
}

const setBitrixQuizSettings = `-- name: SetBitrixQuizSettings :one
INSERT INTO BitrixRule (AccountID, QuizID, PerformerID, PipelineID, TypeID,StageID,SourceID,StatusID, FieldsRule,TagsToAdd,LeadFlag)
SELECT u.bitrixid AS AccountID,$1 AS QuizID,$2 AS PerformerID,$3 AS PipelineID,
       $4 AS TypeID,$5 AS StageID,$6 AS SourceID,$7 AS StatusID,$8 AS FieldsRule,$9 AS TagsToAdd, $10 AS LeadFlag FROM bitrixaccounts u WHERE u.AccountID = $11 AND u.Deleted = false
RETURNING id
`

type SetBitrixQuizSettingsParams struct {
	Quizid      int32           `db:"quizid" json:"quizid"`
	Performerid string          `db:"performerid" json:"performerid"`
	Pipelineid  int32           `db:"pipelineid" json:"pipelineid"`
	Typeid      string          `db:"typeid" json:"typeid"`
	Stageid     string          `db:"stageid" json:"stageid"`
	Sourceid    string          `db:"sourceid" json:"sourceid"`
	Statusid    string          `db:"statusid" json:"statusid"`
	Fieldsrule  json.RawMessage `db:"fieldsrule" json:"fieldsrule"`
	Tagstoadd   json.RawMessage `db:"tagstoadd" json:"tagstoadd"`
	Leadflag    bool            `db:"leadflag" json:"leadflag"`
	Accountid   string          `db:"accountid" json:"accountid"`
}

func (q *Queries) SetBitrixQuizSettings(ctx context.Context, arg SetBitrixQuizSettingsParams) (int64, error) {
	row := q.db.QueryRowContext(ctx, setBitrixQuizSettings,
		arg.Quizid,
		arg.Performerid,
		arg.Pipelineid,
		arg.Typeid,
		arg.Stageid,
		arg.Sourceid,
		arg.Statusid,
		arg.Fieldsrule,
		arg.Tagstoadd,
		arg.Leadflag,
		arg.Accountid,
	)
	var id int64
	err := row.Scan(&id)
	return id, err
}

const setQuizSettings = `-- name: SetQuizSettings :one
INSERT INTO rules (AccountID, QuizID, PerformerID, PipelineID, StepID, FieldsRule,TagsToAdd)
SELECT u.AmoID AS AccountID,$1 AS QuizID,$2 AS PerformerID,$3 AS PipelineID,
       $4 AS StepID,$5 AS FieldsRule,$6 AS TagsToAdd FROM accountsamo u WHERE u.AccountID = $7 AND u.Deleted = false
RETURNING id
`

type SetQuizSettingsParams struct {
	Quizid      int32           `db:"quizid" json:"quizid"`
	Performerid int32           `db:"performerid" json:"performerid"`
	Pipelineid  int32           `db:"pipelineid" json:"pipelineid"`
	Stepid      int32           `db:"stepid" json:"stepid"`
	Fieldsrule  json.RawMessage `db:"fieldsrule" json:"fieldsrule"`
	Tagstoadd   json.RawMessage `db:"tagstoadd" json:"tagstoadd"`
	Accountid   string          `db:"accountid" json:"accountid"`
}

func (q *Queries) SetQuizSettings(ctx context.Context, arg SetQuizSettingsParams) (int64, error) {
	row := q.db.QueryRowContext(ctx, setQuizSettings,
		arg.Quizid,
		arg.Performerid,
		arg.Pipelineid,
		arg.Stepid,
		arg.Fieldsrule,
		arg.Tagstoadd,
		arg.Accountid,
	)
	var id int64
	err := row.Scan(&id)
	return id, err
}

const settingDealAmoStatus = `-- name: SettingDealAmoStatus :exec
INSERT INTO amoCRMStatuses (AccountID, DealID, AnswerID, Status)
SELECT u.AmoID, $1, $2, $3
FROM tokens AS t
         JOIN accountsAmo AS u ON t.AccountID = u.AccountID
WHERE t.AccessToken = $4 AND u.Deleted = false
`

type SettingDealAmoStatusParams struct {
	Dealid      int32  `db:"dealid" json:"dealid"`
	Answerid    int64  `db:"answerid" json:"answerid"`
	Status      string `db:"status" json:"status"`
	Accesstoken string `db:"accesstoken" json:"accesstoken"`
}

func (q *Queries) SettingDealAmoStatus(ctx context.Context, arg SettingDealAmoStatusParams) error {
	_, err := q.db.ExecContext(ctx, settingDealAmoStatus,
		arg.Dealid,
		arg.Answerid,
		arg.Status,
		arg.Accesstoken,
	)
	return err
}

const settingDealBitrixStatus = `-- name: SettingDealBitrixStatus :exec
INSERT INTO bitrixCRMStatuses (AccountID, DealID, AnswerID, Status)
SELECT u.BitrixID, $1, $2, $3
FROM BitrixTokens AS t
         JOIN BitrixAccounts AS u ON t.AccountID = u.AccountID
WHERE t.AccessToken = $4 AND u.Deleted = false
`

type SettingDealBitrixStatusParams struct {
	Dealid      int32  `db:"dealid" json:"dealid"`
	Answerid    int64  `db:"answerid" json:"answerid"`
	Status      string `db:"status" json:"status"`
	Accesstoken string `db:"accesstoken" json:"accesstoken"`
}

func (q *Queries) SettingDealBitrixStatus(ctx context.Context, arg SettingDealBitrixStatusParams) error {
	_, err := q.db.ExecContext(ctx, settingDealBitrixStatus,
		arg.Dealid,
		arg.Answerid,
		arg.Status,
		arg.Accesstoken,
	)
	return err
}

const softDeleteAccount = `-- name: SoftDeleteAccount :exec
WITH amoCompany AS (
    SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $1 AND deleted = false
),usersDel AS (
    UPDATE usersAmo SET Deleted = true WHERE AmoID = (SELECT AmoID FROM amoCompany)
),
     companyDel AS ( UPDATE accountsAmo SET Deleted = true WHERE AmoID = (SELECT AmoID FROM amoCompany)
     )
DELETE FROM tokens WHERE tokens.AccountID = $1
`

func (q *Queries) SoftDeleteAccount(ctx context.Context, accountid string) error {
	_, err := q.db.ExecContext(ctx, softDeleteAccount, accountid)
	return err
}

const softDeleteBitrixAccount = `-- name: SoftDeleteBitrixAccount :exec
WITH bitrixCompany AS (
    SELECT BitrixID FROM BitrixAccounts WHERE BitrixAccounts.AccountID = $1 AND deleted = false
),usersDel AS (
UPDATE BitrixAccountUsers SET Deleted = true WHERE BitrixID = (SELECT BitrixID FROM bitrixCompany)
    ),
     companyDel AS ( UPDATE BitrixAccounts SET Deleted = true WHERE BitrixID = (SELECT BitrixID FROM bitrixCompany)
     )
DELETE FROM BitrixTokens WHERE BitrixTokens.AccountID = $1
`

func (q *Queries) SoftDeleteBitrixAccount(ctx context.Context, accountid string) error {
	_, err := q.db.ExecContext(ctx, softDeleteBitrixAccount, accountid)
	return err
}

const softDeleteQuizUtm = `-- name: SoftDeleteQuizUtm :exec
UPDATE quiz_utm set deleted = true where id = $1
`

func (q *Queries) SoftDeleteQuizUtm(ctx context.Context, id int64) error {
	_, err := q.db.ExecContext(ctx, softDeleteQuizUtm, id)
	return err
}

const softDeleteResultByID = `-- name: SoftDeleteResultByID :exec
UPDATE answer SET deleted = TRUE WHERE id = $1 AND deleted = FALSE
`

func (q *Queries) SoftDeleteResultByID(ctx context.Context, id int64) error {
	_, err := q.db.ExecContext(ctx, softDeleteResultByID, id)
	return err
}

const softDeleteTgAccount = `-- name: SoftDeleteTgAccount :exec
UPDATE tgAccounts SET Deleted = true WHERE id = $1
`

func (q *Queries) SoftDeleteTgAccount(ctx context.Context, id int64) error {
	_, err := q.db.ExecContext(ctx, softDeleteTgAccount, id)
	return err
}

const templateCopy = `-- name: TemplateCopy :one
WITH copied_quiz AS (
    INSERT INTO quiz (accountid, name,fingerprinting,repeatable,note_prevented,mail_notifications,unique_answers,super,group_id, description, config, status,limit_answers,due_to,time_of_passing,pausable,version,version_comment, parent_ids)
        SELECT $1 AS accountid,name,fingerprinting,repeatable,note_prevented,mail_notifications,unique_answers,super,group_id, description, config, 'stop' AS status,limit_answers,due_to,time_of_passing,pausable,version,version_comment, parent_ids
        FROM quiz
        WHERE qid = $2 and status = 'template'
        RETURNING id
)
INSERT INTO question (quiz_id, title, description, questiontype, required, deleted, page, content, version, parent_ids)
SELECT cq.id AS quiz_id, q.title, q.description, q.questiontype, q.required, q.deleted, q.page, q.content, q.version, q.parent_ids
FROM question q
         JOIN quiz old ON q.quiz_id = old.id
         JOIN copied_quiz cq ON old.qid = $2
RETURNING quiz_id
`

type TemplateCopyParams struct {
	Accountid string        `db:"accountid" json:"accountid"`
	Qid       uuid.NullUUID `db:"qid" json:"qid"`
}

func (q *Queries) TemplateCopy(ctx context.Context, arg TemplateCopyParams) (int64, error) {
	row := q.db.QueryRowContext(ctx, templateCopy, arg.Accountid, arg.Qid)
	var quiz_id int64
	err := row.Scan(&quiz_id)
	return quiz_id, err
}

const updateAmoAccount = `-- name: UpdateAmoAccount :exec
UPDATE accountsAmo SET Name = $2, Subdomain = $3, Country = $4, DriveURL = $5 WHERE AccountID = $1 AND Deleted = false
`

type UpdateAmoAccountParams struct {
	Accountid string `db:"accountid" json:"accountid"`
	Name      string `db:"name" json:"name"`
	Subdomain string `db:"subdomain" json:"subdomain"`
	Country   string `db:"country" json:"country"`
	Driveurl  string `db:"driveurl" json:"driveurl"`
}

func (q *Queries) UpdateAmoAccount(ctx context.Context, arg UpdateAmoAccountParams) error {
	_, err := q.db.ExecContext(ctx, updateAmoAccount,
		arg.Accountid,
		arg.Name,
		arg.Subdomain,
		arg.Country,
		arg.Driveurl,
	)
	return err
}

const updateAmoAccountUser = `-- name: UpdateAmoAccountUser :exec
UPDATE usersAmo SET Name = $3, Email = $4, Role = $5, "Group" = $6
WHERE AmoID = $1 AND AmoUserID = $2 AND deleted = false
`

type UpdateAmoAccountUserParams struct {
	Amoid     int32  `db:"amoid" json:"amoid"`
	Amouserid int32  `db:"amouserid" json:"amouserid"`
	Name      string `db:"name" json:"name"`
	Email     string `db:"email" json:"email"`
	Role      int32  `db:"role" json:"role"`
	Group     int32  `db:"Group" json:"Group"`
}

func (q *Queries) UpdateAmoAccountUser(ctx context.Context, arg UpdateAmoAccountUserParams) error {
	_, err := q.db.ExecContext(ctx, updateAmoAccountUser,
		arg.Amoid,
		arg.Amouserid,
		arg.Name,
		arg.Email,
		arg.Role,
		arg.Group,
	)
	return err
}

const updateAmoContact = `-- name: UpdateAmoContact :exec
UPDATE amoContact SET Field = $1,AmoID=$3 WHERE ID = $2
`

type UpdateAmoContactParams struct {
	Field string `db:"field" json:"field"`
	ID    int64  `db:"id" json:"id"`
	Amoid int32  `db:"amoid" json:"amoid"`
}

func (q *Queries) UpdateAmoContact(ctx context.Context, arg UpdateAmoContactParams) error {
	_, err := q.db.ExecContext(ctx, updateAmoContact, arg.Field, arg.ID, arg.Amoid)
	return err
}

const updateBitrixAccount = `-- name: UpdateBitrixAccount :exec
UPDATE BitrixAccounts SET Subdomain = $2 WHERE AccountID = $1 AND Deleted = false
`

type UpdateBitrixAccountParams struct {
	Accountid string `db:"accountid" json:"accountid"`
	Subdomain string `db:"subdomain" json:"subdomain"`
}

func (q *Queries) UpdateBitrixAccount(ctx context.Context, arg UpdateBitrixAccountParams) error {
	_, err := q.db.ExecContext(ctx, updateBitrixAccount, arg.Accountid, arg.Subdomain)
	return err
}

const updateBitrixAccountUser = `-- name: UpdateBitrixAccountUser :exec
UPDATE BitrixAccountUsers SET Name = $3, LastName = $4, SecondName = $5, Title= $6, Email = $7,UFDepartment = $8,WorkPosition=$9
WHERE AccountID = $1 AND BitrixIDUserID = $2 AND deleted = false
`

type UpdateBitrixAccountUserParams struct {
	Accountid      string  `db:"accountid" json:"accountid"`
	Bitrixiduserid string  `db:"bitrixiduserid" json:"bitrixiduserid"`
	Name           string  `db:"name" json:"name"`
	Lastname       string  `db:"lastname" json:"lastname"`
	Secondname     string  `db:"secondname" json:"secondname"`
	Title          string  `db:"title" json:"title"`
	Email          string  `db:"email" json:"email"`
	Ufdepartment   []int32 `db:"ufdepartment" json:"ufdepartment"`
	Workposition   string  `db:"workposition" json:"workposition"`
}

func (q *Queries) UpdateBitrixAccountUser(ctx context.Context, arg UpdateBitrixAccountUserParams) error {
	_, err := q.db.ExecContext(ctx, updateBitrixAccountUser,
		arg.Accountid,
		arg.Bitrixiduserid,
		arg.Name,
		arg.Lastname,
		arg.Secondname,
		arg.Title,
		arg.Email,
		pq.Array(arg.Ufdepartment),
		arg.Workposition,
	)
	return err
}

const updateBitrixContact = `-- name: UpdateBitrixContact :exec
UPDATE bitrixContact SET Field = $1,BitrixID=$3 WHERE ID = $2
`

type UpdateBitrixContactParams struct {
	Field    string `db:"field" json:"field"`
	ID       int64  `db:"id" json:"id"`
	Bitrixid int32  `db:"bitrixid" json:"bitrixid"`
}

func (q *Queries) UpdateBitrixContact(ctx context.Context, arg UpdateBitrixContactParams) error {
	_, err := q.db.ExecContext(ctx, updateBitrixContact, arg.Field, arg.ID, arg.Bitrixid)
	return err
}

const updateBitrixFieldRules = `-- name: UpdateBitrixFieldRules :exec
UPDATE BitrixRule SET FieldsRule = $1
WHERE AccountID = (SELECT BitrixID FROM bitrixaccounts WHERE bitrixaccounts.AccountID = $2 AND bitrixaccounts.Deleted = false) AND QuizID = $3 AND Deleted = false
`

type UpdateBitrixFieldRulesParams struct {
	Fieldsrule json.RawMessage `db:"fieldsrule" json:"fieldsrule"`
	Accountid  string          `db:"accountid" json:"accountid"`
	Quizid     int32           `db:"quizid" json:"quizid"`
}

func (q *Queries) UpdateBitrixFieldRules(ctx context.Context, arg UpdateBitrixFieldRulesParams) error {
	_, err := q.db.ExecContext(ctx, updateBitrixFieldRules, arg.Fieldsrule, arg.Accountid, arg.Quizid)
	return err
}

const updateBitrixFields = `-- name: UpdateBitrixFields :exec
UPDATE BitrixFields AS f SET
    FieldName = (update_data ->> 'fieldName')::varchar(255),
    EditFromLabel = (update_data ->> 'editFromLabel')::varchar(255),
    FieldType = (update_data ->> 'fieldType')::CustomFieldsType
FROM json_array_elements($1::json) AS update_data
WHERE f.BitrixID = (update_data ->> 'bitrixID')::VARCHAR(255)
  AND f.AccountID = (update_data ->> 'accountID')::VARCHAR(255)
  AND f.EntityID = (update_data ->> 'entityID')::FieldsType
`

func (q *Queries) UpdateBitrixFields(ctx context.Context, dollar_1 json.RawMessage) error {
	_, err := q.db.ExecContext(ctx, updateBitrixFields, dollar_1)
	return err
}

const updateBitrixPipelines = `-- name: UpdateBitrixPipelines :exec
UPDATE PipelineBitrix AS p
SET Name = (update_data ->> 'name')::varchar(255),EntityTypeId = (update_data ->> 'entityTypeId')::INT
FROM json_array_elements($1::json) AS update_data
WHERE p.BitrixID = (update_data ->> 'BitrixID')::INT
  AND p.AccountID = (update_data ->> 'AccountID')::varchar(255)
`

func (q *Queries) UpdateBitrixPipelines(ctx context.Context, dollar_1 json.RawMessage) error {
	_, err := q.db.ExecContext(ctx, updateBitrixPipelines, dollar_1)
	return err
}

const updateBitrixSteps = `-- name: UpdateBitrixSteps :exec
UPDATE StepBitrix AS s SET
    Name = (update_data ->> 'name')::varchar(255),
    NameInit = (update_data ->> 'nameInit')::varchar(255),
    Color = (update_data ->> 'color')::varchar(50),
    EntityID = (update_data ->> 'entityID')::varchar(255),
    StatusID = (update_data ->> 'statusID')::varchar(255),
    PipelineID = (update_data ->> 'pipelineID')::INT
FROM json_array_elements($1::json) AS update_data
WHERE s.BitrixID = (update_data ->> 'bitrixID')::VARCHAR(255)
  AND s.AccountID = (update_data ->> 'accountID')::VARCHAR(255)
`

func (q *Queries) UpdateBitrixSteps(ctx context.Context, dollar_1 json.RawMessage) error {
	_, err := q.db.ExecContext(ctx, updateBitrixSteps, dollar_1)
	return err
}

const updateFieldRules = `-- name: UpdateFieldRules :exec
UPDATE rules SET FieldsRule = $1
WHERE AccountID = (SELECT AmoID FROM accountsAmo WHERE accountsAmo.AccountID = $2 AND accountsAmo.Deleted = false) AND QuizID = $3 AND Deleted = false
`

type UpdateFieldRulesParams struct {
	Fieldsrule json.RawMessage `db:"fieldsrule" json:"fieldsrule"`
	Accountid  string          `db:"accountid" json:"accountid"`
	Quizid     int32           `db:"quizid" json:"quizid"`
}

func (q *Queries) UpdateFieldRules(ctx context.Context, arg UpdateFieldRulesParams) error {
	_, err := q.db.ExecContext(ctx, updateFieldRules, arg.Fieldsrule, arg.Accountid, arg.Quizid)
	return err
}

const updateFields = `-- name: UpdateFields :exec
UPDATE fields AS f
SET name = (update_data ->> 'Name')::varchar(512),
    code = (update_data ->> 'Code')::varchar(255),
    type = (update_data ->> 'Type')::fieldtype
FROM json_array_elements($1::json) AS update_data
WHERE f.amoID = (update_data ->> 'AmoID')::INT
  AND f.accountID = (update_data ->> 'AccountID')::INT
  AND f.Entity = (update_data ->> 'Entity')::entitytype
`

func (q *Queries) UpdateFields(ctx context.Context, dollar_1 json.RawMessage) error {
	_, err := q.db.ExecContext(ctx, updateFields, dollar_1)
	return err
}

const updateGigaChatQuizFlag = `-- name: UpdateGigaChatQuizFlag :exec
UPDATE quiz SET gigachat = $3 WHERE id = $1 AND accountid = $2 AND deleted = false
`

type UpdateGigaChatQuizFlagParams struct {
	ID        int64  `db:"id" json:"id"`
	Accountid string `db:"accountid" json:"accountid"`
	Gigachat  bool   `db:"gigachat" json:"gigachat"`
}

func (q *Queries) UpdateGigaChatQuizFlag(ctx context.Context, arg UpdateGigaChatQuizFlagParams) error {
	_, err := q.db.ExecContext(ctx, updateGigaChatQuizFlag, arg.ID, arg.Accountid, arg.Gigachat)
	return err
}

const updateLeadTarget = `-- name: UpdateLeadTarget :one
UPDATE leadtarget SET target = $1,InviteLink = $2 WHERE id = $3 AND deleted=false RETURNING id, accountid, type, quizid, target, invitelink, deleted, createdat
`

type UpdateLeadTargetParams struct {
	Target     string `db:"target" json:"target"`
	Invitelink string `db:"invitelink" json:"invitelink"`
	ID         int64  `db:"id" json:"id"`
}

func (q *Queries) UpdateLeadTarget(ctx context.Context, arg UpdateLeadTargetParams) (Leadtarget, error) {
	row := q.db.QueryRowContext(ctx, updateLeadTarget, arg.Target, arg.Invitelink, arg.ID)
	var i Leadtarget
	err := row.Scan(
		&i.ID,
		&i.Accountid,
		&i.Type,
		&i.Quizid,
		&i.Target,
		&i.Invitelink,
		&i.Deleted,
		&i.Createdat,
	)
	return i, err
}

const updatePipelines = `-- name: UpdatePipelines :exec
UPDATE pipelines AS p
SET name = (update_data ->> 'Name')::varchar(512),
    isArchive = CASE WHEN (update_data ->> 'IsArchive') = 'true' THEN TRUE ELSE FALSE END
FROM json_array_elements($1::json) AS update_data
WHERE p.amoID = (update_data ->> 'AmoID')::INT
  AND p.accountID = (update_data ->> 'AccountID')::INT
`

func (q *Queries) UpdatePipelines(ctx context.Context, dollar_1 json.RawMessage) error {
	_, err := q.db.ExecContext(ctx, updatePipelines, dollar_1)
	return err
}

const updatePrivilege = `-- name: UpdatePrivilege :exec
UPDATE privileges SET amount = $1, created_at = $2 WHERE account_id = $3 AND privilegeID = $4
`

type UpdatePrivilegeParams struct {
	Amount      int32     `db:"amount" json:"amount"`
	CreatedAt   time.Time `db:"created_at" json:"created_at"`
	AccountID   uuid.UUID `db:"account_id" json:"account_id"`
	Privilegeid string    `db:"privilegeid" json:"privilegeid"`
}

func (q *Queries) UpdatePrivilege(ctx context.Context, arg UpdatePrivilegeParams) error {
	_, err := q.db.ExecContext(ctx, updatePrivilege,
		arg.Amount,
		arg.CreatedAt,
		arg.AccountID,
		arg.Privilegeid,
	)
	return err
}

const updatePrivilegeAmount = `-- name: UpdatePrivilegeAmount :exec
UPDATE privileges SET amount = $1 WHERE id = $2
`

type UpdatePrivilegeAmountParams struct {
	Amount int32 `db:"amount" json:"amount"`
	ID     int32 `db:"id" json:"id"`
}

func (q *Queries) UpdatePrivilegeAmount(ctx context.Context, arg UpdatePrivilegeAmountParams) error {
	_, err := q.db.ExecContext(ctx, updatePrivilegeAmount, arg.Amount, arg.ID)
	return err
}

const updateStatusTg = `-- name: UpdateStatusTg :exec
UPDATE tgAccounts SET Status = $1 WHERE id = $2
`

type UpdateStatusTgParams struct {
	Status interface{} `db:"status" json:"status"`
	ID     int64       `db:"id" json:"id"`
}

func (q *Queries) UpdateStatusTg(ctx context.Context, arg UpdateStatusTgParams) error {
	_, err := q.db.ExecContext(ctx, updateStatusTg, arg.Status, arg.ID)
	return err
}

const updateSteps = `-- name: UpdateSteps :exec
UPDATE steps AS s
SET name = (update_data ->> 'Name')::varchar(512),
    color = (update_data ->> 'Color')::varchar(50)
FROM json_array_elements($1::json) AS update_data
WHERE s.amoID = (update_data ->> 'AmoID')::INT
  AND s.accountID = (update_data ->> 'AccountID')::INT
  AND s.pipelineID = (update_data ->> 'PipelineID')::INT
`

func (q *Queries) UpdateSteps(ctx context.Context, dollar_1 json.RawMessage) error {
	_, err := q.db.ExecContext(ctx, updateSteps, dollar_1)
	return err
}

const updateTags = `-- name: UpdateTags :exec
UPDATE tags AS t
SET name = (update_data ->> 'Name')::varchar(512),
    color = (update_data ->> 'Color')::varchar(50)
FROM json_array_elements($1::json) AS update_data
WHERE t.amoID = (update_data ->> 'AmoID')::INT
  AND t.accountID = (update_data ->> 'AccountID')::INT
  AND t.Entity = (update_data ->> 'Entity')::entitytype
`

func (q *Queries) UpdateTags(ctx context.Context, dollar_1 json.RawMessage) error {
	_, err := q.db.ExecContext(ctx, updateTags, dollar_1)
	return err
}

const updatingDealAmoStatus = `-- name: UpdatingDealAmoStatus :exec
UPDATE amoCRMStatuses SET Status = $1
WHERE DealID = $2 AND AccountID = (SELECT u.AmoID FROM tokens AS t JOIN accountsAmo AS u ON t.AccountID = u.AccountID WHERE t.AccessToken = $3 AND u.Deleted = false)
`

type UpdatingDealAmoStatusParams struct {
	Status      string `db:"status" json:"status"`
	Dealid      int32  `db:"dealid" json:"dealid"`
	Accesstoken string `db:"accesstoken" json:"accesstoken"`
}

func (q *Queries) UpdatingDealAmoStatus(ctx context.Context, arg UpdatingDealAmoStatusParams) error {
	_, err := q.db.ExecContext(ctx, updatingDealAmoStatus, arg.Status, arg.Dealid, arg.Accesstoken)
	return err
}

const webhookBitrixDelete = `-- name: WebhookBitrixDelete :exec
WITH companyDel AS (
UPDATE BitrixAccounts SET Deleted = true WHERE BitrixAccounts.BitrixID = $1 RETURNING AccountID
),
     userDel AS (
UPDATE BitrixAccountUsers SET Deleted = true WHERE AccountID = $1
    )
DELETE FROM BitrixTokens WHERE AccountID IN (SELECT AccountID FROM companyDel)
`

func (q *Queries) WebhookBitrixDelete(ctx context.Context, bitrixid string) error {
	_, err := q.db.ExecContext(ctx, webhookBitrixDelete, bitrixid)
	return err
}

const webhookBitrixUpdate = `-- name: WebhookBitrixUpdate :exec
UPDATE BitrixTokens SET AccessToken = $1,RefreshToken = $2,Expiration = to_timestamp(($3)::bigint) AT TIME ZONE 'UTC' + INTERVAL '3 hours',CreatedAt = to_timestamp(($4)::bigint) AT TIME ZONE 'UTC' + INTERVAL '3 hours'
WHERE accountID = $5
`

type WebhookBitrixUpdateParams struct {
	Accesstoken  string `db:"accesstoken" json:"accesstoken"`
	Refreshtoken string `db:"refreshtoken" json:"refreshtoken"`
	Column3      int64  `db:"column_3" json:"column_3"`
	Column4      int64  `db:"column_4" json:"column_4"`
	Accountid    string `db:"accountid" json:"accountid"`
}

func (q *Queries) WebhookBitrixUpdate(ctx context.Context, arg WebhookBitrixUpdateParams) error {
	_, err := q.db.ExecContext(ctx, webhookBitrixUpdate,
		arg.Accesstoken,
		arg.Refreshtoken,
		arg.Column3,
		arg.Column4,
		arg.Accountid,
	)
	return err
}

const webhookDelete = `-- name: WebhookDelete :exec
WITH companyDel AS (
    UPDATE accountsAmo SET Deleted = true WHERE accountsAmo.AmoID = $1 RETURNING AccountID
),
     userDel AS (
         UPDATE usersAmo SET Deleted = true WHERE AmoID = $1
     )
DELETE FROM tokens WHERE AccountID IN (SELECT AccountID FROM companyDel)
`

func (q *Queries) WebhookDelete(ctx context.Context, amoid int32) error {
	_, err := q.db.ExecContext(ctx, webhookDelete, amoid)
	return err
}

const webhookUpdate = `-- name: WebhookUpdate :exec
UPDATE tokens SET AccessToken = $1,RefreshToken = $2,Expiration = to_timestamp(($3)::bigint) AT TIME ZONE 'UTC' + INTERVAL '3 hours',CreatedAt = to_timestamp(($4)::bigint) AT TIME ZONE 'UTC' + INTERVAL '3 hours'
WHERE accountID = $5
`

type WebhookUpdateParams struct {
	Accesstoken  string `db:"accesstoken" json:"accesstoken"`
	Refreshtoken string `db:"refreshtoken" json:"refreshtoken"`
	Column3      int64  `db:"column_3" json:"column_3"`
	Column4      int64  `db:"column_4" json:"column_4"`
	Accountid    string `db:"accountid" json:"accountid"`
}

func (q *Queries) WebhookUpdate(ctx context.Context, arg WebhookUpdateParams) error {
	_, err := q.db.ExecContext(ctx, webhookUpdate,
		arg.Accesstoken,
		arg.Refreshtoken,
		arg.Column3,
		arg.Column4,
		arg.Accountid,
	)
	return err
}

const workerStatProcess = `-- name: WorkerStatProcess :exec
WITH answer_aggregates AS (
    SELECT
        quiz_id,
        COUNT(DISTINCT session) AS unique_true_answers_count
    FROM
        answer
    WHERE
        result = TRUE
    GROUP BY
        quiz_id
),
     question_aggregates AS (
         SELECT
             q.id AS quiz_id,
             COUNT(qs.id) AS total_questions
         FROM
             quiz q
                 INNER JOIN
             question qs ON q.id = qs.quiz_id
         WHERE
             q.deleted = false
           AND q.archived = false
           AND qs.deleted = false
         GROUP BY
             q.id
     ),
     session_times_aggregates AS (
         SELECT
             quiz_id, COUNT(session) as sess,
             AVG(extract(epoch FROM session_time)) AS average_session_time
         FROM (
                  SELECT
                      quiz_id,
                      session,
                      (MAX(created_at) - MIN(created_at)) AS session_time
                  FROM
                      answer
                  GROUP BY
                      quiz_id,
                      session
              ) AS all_sessions
         GROUP BY
             quiz_id
     )
UPDATE quiz q
SET
    questions_count = COALESCE(qa.total_questions, 0),
    answers_count = COALESCE(aa.unique_true_answers_count, 0),
    average_time_passing = COALESCE(sta.average_session_time, 0),
    sessions_count = COALESCE(sta.sess,0)
FROM
    (SELECT id, qid, accountid, deleted, archived, fingerprinting, repeatable, note_prevented, mail_notifications, unique_answers, super, group_id, name, description, config, status, limit_answers, due_to, time_of_passing, pausable, version, version_comment, parent_ids, created_at, updated_at, questions_count, answers_count, average_time_passing, sessions_count, gigachat FROM quiz WHERE deleted = FALSE AND archived = FALSE) q_sub
        LEFT JOIN answer_aggregates aa ON q_sub.id = aa.quiz_id
        LEFT JOIN question_aggregates qa ON q_sub.id = qa.quiz_id
        LEFT JOIN session_times_aggregates sta ON q_sub.id = sta.quiz_id
WHERE
    q.id = q_sub.id
`

func (q *Queries) WorkerStatProcess(ctx context.Context) error {
	_, err := q.db.ExecContext(ctx, workerStatProcess)
	return err
}

const workerTimeoutProcess = `-- name: WorkerTimeoutProcess :exec
UPDATE quiz SET status = 'timeout' WHERE deleted = false AND due_to <> 0 AND due_to < EXTRACT(epoch FROM CURRENT_TIMESTAMP)
`

func (q *Queries) WorkerTimeoutProcess(ctx context.Context) error {
	_, err := q.db.ExecContext(ctx, workerTimeoutProcess)
	return err
}