// Package attendance code generated by oapi sdk gen
/*
 * MIT License
 *
 * Copyright (c) 2022 Lark Technologies Pte. Ltd.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice, shall be included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

package larkattendance

import (
	"io"

	"bytes"

	"io/ioutil"

	"fmt"

	"context"
	"errors"

	"github.com/larksuite/oapi-sdk-go/v3/core"
)

const (
	CreateGroupEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	CreateGroupEmployeeTypeEmployeeNo = "employee_no" // 员工工号
)

const (
	CreateGroupDeptTypeOpenId = "open_id" // 开放openID
)

const (
	GetGroupEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	GetGroupEmployeeTypeEmployeeNo = "employee_no" // 员工工号
)

const (
	GetGroupDeptTypeOpenId = "open_id" // 开放openID
)

const (
	PatchLeaveAccrualRecordUserIDTypeLeaveBalancesLeaveUserIDTypeOpenID         = "open_id"          // 标识一个用户在某个应用中的身份。同一个用户在不同应用中的 Open ID 不同。
	PatchLeaveAccrualRecordUserIDTypeLeaveBalancesLeaveUserIDTypePeopleCorehrID = "people_corehr_id" // 以飞书人事的 ID 来识别用户
	PatchLeaveAccrualRecordUserIDTypeLeaveBalancesLeaveUserIDTypeUnionID        = "union_id"         // 标识一个用户在某个应用开发商下的身份。同一用户在同一开发商下的应用中的 Union ID 是相同的，在不同开发商下的应用中的 Union ID 是不同的。通过 Union ID，应用开发商可以把同个用户在多个应用中的身份关联起来。
	PatchLeaveAccrualRecordUserIDTypeLeaveBalancesLeaveUserIDTypeUserID         = "user_id"          // 标识一个用户在某个租户内的身份。同一个用户在租户 A 和租户 B 内的 User ID 是不同的。在同一个租户内，一个用户的 User ID 在所有应用（包括商店应用）中都保持一致。User ID 主要用于在不同的应用间打通用户数据。
)

const (
	GetLeaveEmployExpireRecordUserIDTypeLeaveBalancesLeaveUserIDTypeOpenID         = "open_id"          // 标识一个用户在某个应用中的身份。同一个用户在不同应用中的 Open ID 不同。
	GetLeaveEmployExpireRecordUserIDTypeLeaveBalancesLeaveUserIDTypePeopleCorehrID = "people_corehr_id" // 以飞书人事的ID来识别用户
	GetLeaveEmployExpireRecordUserIDTypeLeaveBalancesLeaveUserIDTypeUnionID        = "union_id"         // 标识一个用户在某个应用开发商下的身份。同一用户在同一开发商下的应用中的 Union ID 是相同的，在不同开发商下的应用中的 Union ID 是不同的。通过 Union ID，应用开发商可以把同个用户在多个应用中的身份关联起来。
	GetLeaveEmployExpireRecordUserIDTypeLeaveBalancesLeaveUserIDTypeUserID         = "user_id"          // 标识一个用户在某个租户内的身份。同一个用户在租户 A 和租户 B 内的 User ID 是不同的。在同一个租户内，一个用户的 User ID 在所有应用（包括商店应用）中都保持一致。User ID 主要用于在不同的应用间打通用户数据。
)

const (
	CreateShiftEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	CreateShiftEmployeeTypeEmployeeNo = "employee_no" // 员工工号
)

const (
	CreateApprovalEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	CreateApprovalEmployeeTypeEmployeeNo = "employee_no" // 员工工号
	CreateApprovalEmployeeTypeOpenId     = "open_id"     // 用户在某个应用中的身份
)

const (
	CheckDateTypePeriodTime = "PeriodTime" // 单据作用时间（即写入的end_time）
	CheckDateTypeCreateTime = "CreateTime" // 单据创建时间
	CheckDateTypeUpdateTime = "UpdateTime" // 单据状态更新时间
)

const (
	ApprovalStatusTodo     = 0 // 待审批
	ApprovalStatusRejected = 1 // 审批未通过
	ApprovalStatusApproved = 2 // 审批通过
	ApprovalStatusCanceled = 3 // 审批已取消
	ApprovalStatusReverted = 4 // 已撤回

)

const (
	GetApprovedInfoEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	GetApprovedInfoEmployeeTypeEmployeeNo = "employee_no" // 员工工号
	GetApprovedInfoEmployeeTypeOpenId     = "open_id"     // 用户在某个应用中的身份
)

const (
	SaveGroupScheduleShiftEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	SaveGroupScheduleShiftEmployeeTypeEmployeeNo = "employee_no" // 员工工号
)

const (
	BatchCreateTempUserDailyShiftEmployeeTypeEmployeeID = "employee_id" // employee_id
	BatchCreateTempUserDailyShiftEmployeeTypeEmployeeNo = "employee_no" // employee_no
)

const (
	QueryUserScheduleShiftsEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	QueryUserScheduleShiftsEmployeeTypeEmployeeNo = "employee_no" // 员工工号
)

const (
	ImportUserClockInFlowsEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	ImportUserClockInFlowsEmployeeTypeEmployeeNo = "employee_no" // 员工工号
)

const (
	GetUserClockInFlowDetailEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	GetUserClockInFlowDetailEmployeeTypeEmployeeNo = "employee_no" // 员工工号
)

const (
	GetUserClockInFlowsEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	GetUserClockInFlowsEmployeeTypeEmployeeNo = "employee_no" // 员工工号
)

const (
	ModifyUserSettingEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	ModifyUserSettingEmployeeTypeEmployeeNo = "employee_no" // 员工工号
)

const (
	QueryUserSettingEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	QueryUserSettingEmployeeTypeEmployeeNo = "employee_no" // 员工工号
)

const (
	QueryStatisticsDataLocaleEn = "en" // 英文
	QueryStatisticsDataLocaleJa = "ja" // 日文
	QueryStatisticsDataLocaleZh = "zh" // 中文
)

const (
	QueryStatisticsDataStatsTypeDaily = "daily" // 日度统计
	QueryStatisticsDataStatsTypeMonth = "month" // 月度统计
)

const (
	QueryStatisticsDataEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	QueryStatisticsDataEmployeeTypeEmployeeNo = "employee_no" // 员工工号
)

const (
	QueryUserFieldLocaleEn = "en" // 英文
	QueryUserFieldLocaleJa = "ja" // 日文
	QueryUserFieldLocaleZh = "zh" // 中文
)

const (
	QueryUserFieldStatsTypeDaily = "daily" // 日度统计
	QueryUserFieldStatsTypeMonth = "month" // 月度统计
)

const (
	QueryUserFieldEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	QueryUserFieldEmployeeTypeEmployeeNo = "employee_no" // 员工工号
)

const (
	QueryViewLocaleEn = "en" // 英文
	QueryViewLocaleJa = "ja" // 日文
	QueryViewLocaleZh = "zh" // 中文
)

const (
	QueryViewStatsTypeDaily = "daily" // 日度统计
	QueryViewStatsTypeMonth = "month" // 月度统计
)

const (
	QueryViewEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	QueryViewEmployeeTypeEmployeeNo = "employee_no" // 员工工号
)

const (
	UpdateViewEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	UpdateViewEmployeeTypeEmployeeNo = "employee_no" // 员工工号
)

const (
	GetUserTaskClockInFlowsEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	GetUserTaskClockInFlowsEmployeeTypeEmployeeNo = "employee_no" // 员工工号
)

const (
	CreateRemedyPunchEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	CreateRemedyPunchEmployeeTypeEmployeeNo = "employee_no" // 员工工号
)

const (
	CheckDateTypeQueryUserTaskRemedyPeriodTime = "PeriodTime" // 单据作用时间（即remedy_time）
	CheckDateTypeQueryUserTaskRemedyCreateTime = "CreateTime" // 单据创建时间
	CheckDateTypeQueryUserTaskRemedyUpdateTime = "UpdateTime" // 单据状态更新时间
)

const (
	RemedyStatusPending  = 0 // 待审批
	RemedyStatusRejected = 1 // 未通过
	RemedyStatusPass     = 2 // 已通过
	RemedyStatusCancel   = 3 // 已取消
	RemedyStatusWithdraw = 4 // 已撤回

)

const (
	GetUserRemedyListEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	GetUserRemedyListEmployeeTypeEmployeeNo = "employee_no" // 员工工号
)

const (
	QueryUserAllowedRemedysEmployeeTypeEmployeeId = "employee_id" // 员工employeeId
	QueryUserAllowedRemedysEmployeeTypeEmployeeNo = "employee_no" // 员工工号
)

type ClockInAbnormalSettings struct {
	IgnoreUntilLatestClockout *bool `json:"ignore_until_latest_clockout,omitempty"` // 在最晚下班打卡之前忽略异常卡（仅灰度租户有效）
}

type ClockInAbnormalSettingsBuilder struct {
	ignoreUntilLatestClockout     bool // 在最晚下班打卡之前忽略异常卡（仅灰度租户有效）
	ignoreUntilLatestClockoutFlag bool
}

func NewClockInAbnormalSettingsBuilder() *ClockInAbnormalSettingsBuilder {
	builder := &ClockInAbnormalSettingsBuilder{}
	return builder
}

// 在最晚下班打卡之前忽略异常卡（仅灰度租户有效）
//
// 示例值：
func (builder *ClockInAbnormalSettingsBuilder) IgnoreUntilLatestClockout(ignoreUntilLatestClockout bool) *ClockInAbnormalSettingsBuilder {
	builder.ignoreUntilLatestClockout = ignoreUntilLatestClockout
	builder.ignoreUntilLatestClockoutFlag = true
	return builder
}

func (builder *ClockInAbnormalSettingsBuilder) Build() *ClockInAbnormalSettings {
	req := &ClockInAbnormalSettings{}
	if builder.ignoreUntilLatestClockoutFlag {
		req.IgnoreUntilLatestClockout = &builder.ignoreUntilLatestClockout

	}
	return req
}

type AntiCheatConfig struct {
	InterceptSuspectedCheatPunch *bool `json:"intercept_suspected_cheat_punch,omitempty"` // 拦截疑似作弊打卡；关闭时，其余防作弊开关都会关闭

	CheckCheatSoftwarePunch *bool `json:"check_cheat_software_punch,omitempty"` // 是否校验疑似作弊软件打卡

	CheckBuddyPunch *bool `json:"check_buddy_punch,omitempty"` // 是否校验疑似他人代打卡

	CheckSimulateWifiPunch *bool `json:"check_simulate_wifi_punch,omitempty"` // 是否校验疑似模拟 WI-FI 打卡

	CheckChangeDevicePunch *bool `json:"check_change_device_punch,omitempty"` // 是否校验更换设备打卡

	AllowChangeDeviceNum *int `json:"allow_change_device_num,omitempty"` // 同一考勤人员最多可绑定打卡设备数量上限，开启校验更换设备打卡时必填

	SuspectedCheatHandleMethod *int `json:"suspected_cheat_handle_method,omitempty"` // 疑似作弊打卡时的处理方式，开启拦截疑似作弊打卡时必填
}

type AntiCheatConfigBuilder struct {
	interceptSuspectedCheatPunch     bool // 拦截疑似作弊打卡；关闭时，其余防作弊开关都会关闭
	interceptSuspectedCheatPunchFlag bool

	checkCheatSoftwarePunch     bool // 是否校验疑似作弊软件打卡
	checkCheatSoftwarePunchFlag bool

	checkBuddyPunch     bool // 是否校验疑似他人代打卡
	checkBuddyPunchFlag bool

	checkSimulateWifiPunch     bool // 是否校验疑似模拟 WI-FI 打卡
	checkSimulateWifiPunchFlag bool

	checkChangeDevicePunch     bool // 是否校验更换设备打卡
	checkChangeDevicePunchFlag bool

	allowChangeDeviceNum     int // 同一考勤人员最多可绑定打卡设备数量上限，开启校验更换设备打卡时必填
	allowChangeDeviceNumFlag bool

	suspectedCheatHandleMethod     int // 疑似作弊打卡时的处理方式，开启拦截疑似作弊打卡时必填
	suspectedCheatHandleMethodFlag bool
}

func NewAntiCheatConfigBuilder() *AntiCheatConfigBuilder {
	builder := &AntiCheatConfigBuilder{}
	return builder
}

// 拦截疑似作弊打卡；关闭时，其余防作弊开关都会关闭
//
// 示例值：true
func (builder *AntiCheatConfigBuilder) InterceptSuspectedCheatPunch(interceptSuspectedCheatPunch bool) *AntiCheatConfigBuilder {
	builder.interceptSuspectedCheatPunch = interceptSuspectedCheatPunch
	builder.interceptSuspectedCheatPunchFlag = true
	return builder
}

// 是否校验疑似作弊软件打卡
//
// 示例值：true
func (builder *AntiCheatConfigBuilder) CheckCheatSoftwarePunch(checkCheatSoftwarePunch bool) *AntiCheatConfigBuilder {
	builder.checkCheatSoftwarePunch = checkCheatSoftwarePunch
	builder.checkCheatSoftwarePunchFlag = true
	return builder
}

// 是否校验疑似他人代打卡
//
// 示例值：true
func (builder *AntiCheatConfigBuilder) CheckBuddyPunch(checkBuddyPunch bool) *AntiCheatConfigBuilder {
	builder.checkBuddyPunch = checkBuddyPunch
	builder.checkBuddyPunchFlag = true
	return builder
}

// 是否校验疑似模拟 WI-FI 打卡
//
// 示例值：true
func (builder *AntiCheatConfigBuilder) CheckSimulateWifiPunch(checkSimulateWifiPunch bool) *AntiCheatConfigBuilder {
	builder.checkSimulateWifiPunch = checkSimulateWifiPunch
	builder.checkSimulateWifiPunchFlag = true
	return builder
}

// 是否校验更换设备打卡
//
// 示例值：true
func (builder *AntiCheatConfigBuilder) CheckChangeDevicePunch(checkChangeDevicePunch bool) *AntiCheatConfigBuilder {
	builder.checkChangeDevicePunch = checkChangeDevicePunch
	builder.checkChangeDevicePunchFlag = true
	return builder
}

// 同一考勤人员最多可绑定打卡设备数量上限，开启校验更换设备打卡时必填
//
// 示例值：1
func (builder *AntiCheatConfigBuilder) AllowChangeDeviceNum(allowChangeDeviceNum int) *AntiCheatConfigBuilder {
	builder.allowChangeDeviceNum = allowChangeDeviceNum
	builder.allowChangeDeviceNumFlag = true
	return builder
}

// 疑似作弊打卡时的处理方式，开启拦截疑似作弊打卡时必填
//
// 示例值：1
func (builder *AntiCheatConfigBuilder) SuspectedCheatHandleMethod(suspectedCheatHandleMethod int) *AntiCheatConfigBuilder {
	builder.suspectedCheatHandleMethod = suspectedCheatHandleMethod
	builder.suspectedCheatHandleMethodFlag = true
	return builder
}

func (builder *AntiCheatConfigBuilder) Build() *AntiCheatConfig {
	req := &AntiCheatConfig{}
	if builder.interceptSuspectedCheatPunchFlag {
		req.InterceptSuspectedCheatPunch = &builder.interceptSuspectedCheatPunch

	}
	if builder.checkCheatSoftwarePunchFlag {
		req.CheckCheatSoftwarePunch = &builder.checkCheatSoftwarePunch

	}
	if builder.checkBuddyPunchFlag {
		req.CheckBuddyPunch = &builder.checkBuddyPunch

	}
	if builder.checkSimulateWifiPunchFlag {
		req.CheckSimulateWifiPunch = &builder.checkSimulateWifiPunch

	}
	if builder.checkChangeDevicePunchFlag {
		req.CheckChangeDevicePunch = &builder.checkChangeDevicePunch

	}
	if builder.allowChangeDeviceNumFlag {
		req.AllowChangeDeviceNum = &builder.allowChangeDeviceNum

	}
	if builder.suspectedCheatHandleMethodFlag {
		req.SuspectedCheatHandleMethod = &builder.suspectedCheatHandleMethod

	}
	return req
}

type AntiCheatPunch struct {
	InterceptSuspectedCheatPunch *bool `json:"intercept_suspected_cheat_punch,omitempty"` // 拦截疑似作弊打卡，默认关闭；关闭时，其余防作弊开关都会关闭

	CheckCheatSoftwarePunch *bool `json:"check_cheat_software_punch,omitempty"` // 是否校验疑似作弊软件打卡，默认关闭

	CheckBuddyPunch *bool `json:"check_buddy_punch,omitempty"` // 是否校验疑似他人代打卡，默认关闭

	CheckSimulateWifiPunch *bool `json:"check_simulate_wifi_punch,omitempty"` // 是否校验疑似模拟 WI-FI 打卡，默认关闭

	CheckChangeDevicePunch *bool `json:"check_change_device_punch,omitempty"` // 是否校验更换设备打卡，默认关闭

	AllowChangeDeviceNum *int `json:"allow_change_device_num,omitempty"` // 同一考勤人员最多可绑定打卡设备数量上限，开启校验更换设备打卡时必填

	SuspectedCheatHandleMethod *int `json:"suspected_cheat_handle_method,omitempty"` // 疑似作弊打卡时的处理方式
}

type AntiCheatPunchBuilder struct {
	interceptSuspectedCheatPunch     bool // 拦截疑似作弊打卡，默认关闭；关闭时，其余防作弊开关都会关闭
	interceptSuspectedCheatPunchFlag bool

	checkCheatSoftwarePunch     bool // 是否校验疑似作弊软件打卡，默认关闭
	checkCheatSoftwarePunchFlag bool

	checkBuddyPunch     bool // 是否校验疑似他人代打卡，默认关闭
	checkBuddyPunchFlag bool

	checkSimulateWifiPunch     bool // 是否校验疑似模拟 WI-FI 打卡，默认关闭
	checkSimulateWifiPunchFlag bool

	checkChangeDevicePunch     bool // 是否校验更换设备打卡，默认关闭
	checkChangeDevicePunchFlag bool

	allowChangeDeviceNum     int // 同一考勤人员最多可绑定打卡设备数量上限，开启校验更换设备打卡时必填
	allowChangeDeviceNumFlag bool

	suspectedCheatHandleMethod     int // 疑似作弊打卡时的处理方式
	suspectedCheatHandleMethodFlag bool
}

func NewAntiCheatPunchBuilder() *AntiCheatPunchBuilder {
	builder := &AntiCheatPunchBuilder{}
	return builder
}

// 拦截疑似作弊打卡，默认关闭；关闭时，其余防作弊开关都会关闭
//
// 示例值：true
func (builder *AntiCheatPunchBuilder) InterceptSuspectedCheatPunch(interceptSuspectedCheatPunch bool) *AntiCheatPunchBuilder {
	builder.interceptSuspectedCheatPunch = interceptSuspectedCheatPunch
	builder.interceptSuspectedCheatPunchFlag = true
	return builder
}

// 是否校验疑似作弊软件打卡，默认关闭
//
// 示例值：true
func (builder *AntiCheatPunchBuilder) CheckCheatSoftwarePunch(checkCheatSoftwarePunch bool) *AntiCheatPunchBuilder {
	builder.checkCheatSoftwarePunch = checkCheatSoftwarePunch
	builder.checkCheatSoftwarePunchFlag = true
	return builder
}

// 是否校验疑似他人代打卡，默认关闭
//
// 示例值：true
func (builder *AntiCheatPunchBuilder) CheckBuddyPunch(checkBuddyPunch bool) *AntiCheatPunchBuilder {
	builder.checkBuddyPunch = checkBuddyPunch
	builder.checkBuddyPunchFlag = true
	return builder
}

// 是否校验疑似模拟 WI-FI 打卡，默认关闭
//
// 示例值：true
func (builder *AntiCheatPunchBuilder) CheckSimulateWifiPunch(checkSimulateWifiPunch bool) *AntiCheatPunchBuilder {
	builder.checkSimulateWifiPunch = checkSimulateWifiPunch
	builder.checkSimulateWifiPunchFlag = true
	return builder
}

// 是否校验更换设备打卡，默认关闭
//
// 示例值：true
func (builder *AntiCheatPunchBuilder) CheckChangeDevicePunch(checkChangeDevicePunch bool) *AntiCheatPunchBuilder {
	builder.checkChangeDevicePunch = checkChangeDevicePunch
	builder.checkChangeDevicePunchFlag = true
	return builder
}

// 同一考勤人员最多可绑定打卡设备数量上限，开启校验更换设备打卡时必填
//
// 示例值：2
func (builder *AntiCheatPunchBuilder) AllowChangeDeviceNum(allowChangeDeviceNum int) *AntiCheatPunchBuilder {
	builder.allowChangeDeviceNum = allowChangeDeviceNum
	builder.allowChangeDeviceNumFlag = true
	return builder
}

// 疑似作弊打卡时的处理方式
//
// 示例值：1
func (builder *AntiCheatPunchBuilder) SuspectedCheatHandleMethod(suspectedCheatHandleMethod int) *AntiCheatPunchBuilder {
	builder.suspectedCheatHandleMethod = suspectedCheatHandleMethod
	builder.suspectedCheatHandleMethodFlag = true
	return builder
}

func (builder *AntiCheatPunchBuilder) Build() *AntiCheatPunch {
	req := &AntiCheatPunch{}
	if builder.interceptSuspectedCheatPunchFlag {
		req.InterceptSuspectedCheatPunch = &builder.interceptSuspectedCheatPunch

	}
	if builder.checkCheatSoftwarePunchFlag {
		req.CheckCheatSoftwarePunch = &builder.checkCheatSoftwarePunch

	}
	if builder.checkBuddyPunchFlag {
		req.CheckBuddyPunch = &builder.checkBuddyPunch

	}
	if builder.checkSimulateWifiPunchFlag {
		req.CheckSimulateWifiPunch = &builder.checkSimulateWifiPunch

	}
	if builder.checkChangeDevicePunchFlag {
		req.CheckChangeDevicePunch = &builder.checkChangeDevicePunch

	}
	if builder.allowChangeDeviceNumFlag {
		req.AllowChangeDeviceNum = &builder.allowChangeDeviceNum

	}
	if builder.suspectedCheatHandleMethodFlag {
		req.SuspectedCheatHandleMethod = &builder.suspectedCheatHandleMethod

	}
	return req
}

type ApprovalDailyDetail struct {
	Date *string `json:"date,omitempty"` // 日期

	Duration *string `json:"duration,omitempty"` // 加班时长

	OvertimeUnit *int `json:"overtime_unit,omitempty"` // 加班时长单位

	OvertimeDateType *int `json:"overtime_date_type,omitempty"` // 加班日期类型

	SettleTypeEnum *int `json:"settle_type_enum,omitempty"` // 加班结算方式类型
}

type ApprovalDailyDetailBuilder struct {
	date     string // 日期
	dateFlag bool

	duration     string // 加班时长
	durationFlag bool

	overtimeUnit     int // 加班时长单位
	overtimeUnitFlag bool

	overtimeDateType     int // 加班日期类型
	overtimeDateTypeFlag bool

	settleTypeEnum     int // 加班结算方式类型
	settleTypeEnumFlag bool
}

func NewApprovalDailyDetailBuilder() *ApprovalDailyDetailBuilder {
	builder := &ApprovalDailyDetailBuilder{}
	return builder
}

// 日期
//
// 示例值：2024-10-21
func (builder *ApprovalDailyDetailBuilder) Date(date string) *ApprovalDailyDetailBuilder {
	builder.date = date
	builder.dateFlag = true
	return builder
}

// 加班时长
//
// 示例值：5
func (builder *ApprovalDailyDetailBuilder) Duration(duration string) *ApprovalDailyDetailBuilder {
	builder.duration = duration
	builder.durationFlag = true
	return builder
}

// 加班时长单位
//
// 示例值：
func (builder *ApprovalDailyDetailBuilder) OvertimeUnit(overtimeUnit int) *ApprovalDailyDetailBuilder {
	builder.overtimeUnit = overtimeUnit
	builder.overtimeUnitFlag = true
	return builder
}

// 加班日期类型
//
// 示例值：
func (builder *ApprovalDailyDetailBuilder) OvertimeDateType(overtimeDateType int) *ApprovalDailyDetailBuilder {
	builder.overtimeDateType = overtimeDateType
	builder.overtimeDateTypeFlag = true
	return builder
}

// 加班结算方式类型
//
// 示例值：1
func (builder *ApprovalDailyDetailBuilder) SettleTypeEnum(settleTypeEnum int) *ApprovalDailyDetailBuilder {
	builder.settleTypeEnum = settleTypeEnum
	builder.settleTypeEnumFlag = true
	return builder
}

func (builder *ApprovalDailyDetailBuilder) Build() *ApprovalDailyDetail {
	req := &ApprovalDailyDetail{}
	if builder.dateFlag {
		req.Date = &builder.date

	}
	if builder.durationFlag {
		req.Duration = &builder.duration

	}
	if builder.overtimeUnitFlag {
		req.OvertimeUnit = &builder.overtimeUnit

	}
	if builder.overtimeDateTypeFlag {
		req.OvertimeDateType = &builder.overtimeDateType

	}
	if builder.settleTypeEnumFlag {
		req.SettleTypeEnum = &builder.settleTypeEnum

	}
	return req
}

type ApprovalInfo struct {
	ApprovalId *string `json:"approval_id,omitempty"` // 审批实例 ID

	ApprovalType *string `json:"approval_type,omitempty"` // 审批类型

	Status *int `json:"status,omitempty"` // 审批状态
}

type ApprovalInfoBuilder struct {
	approvalId     string // 审批实例 ID
	approvalIdFlag bool

	approvalType     string // 审批类型
	approvalTypeFlag bool

	status     int // 审批状态
	statusFlag bool
}

func NewApprovalInfoBuilder() *ApprovalInfoBuilder {
	builder := &ApprovalInfoBuilder{}
	return builder
}

// 审批实例 ID
//
// 示例值：6737202939523236113
func (builder *ApprovalInfoBuilder) ApprovalId(approvalId string) *ApprovalInfoBuilder {
	builder.approvalId = approvalId
	builder.approvalIdFlag = true
	return builder
}

// 审批类型
//
// 示例值：remedy
func (builder *ApprovalInfoBuilder) ApprovalType(approvalType string) *ApprovalInfoBuilder {
	builder.approvalType = approvalType
	builder.approvalTypeFlag = true
	return builder
}

// 审批状态
//
// 示例值：0
func (builder *ApprovalInfoBuilder) Status(status int) *ApprovalInfoBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

func (builder *ApprovalInfoBuilder) Build() *ApprovalInfo {
	req := &ApprovalInfo{}
	if builder.approvalIdFlag {
		req.ApprovalId = &builder.approvalId

	}
	if builder.approvalTypeFlag {
		req.ApprovalType = &builder.approvalType

	}
	if builder.statusFlag {
		req.Status = &builder.status

	}
	return req
}

type ArchiveField struct {
	Code *string `json:"code,omitempty"` // 字段编号

	Title *string `json:"title,omitempty"` // 字段名称

	UpperTitles []string `json:"upper_titles,omitempty"` // 一级表头名字
}

type ArchiveFieldBuilder struct {
	code     string // 字段编号
	codeFlag bool

	title     string // 字段名称
	titleFlag bool

	upperTitles     []string // 一级表头名字
	upperTitlesFlag bool
}

func NewArchiveFieldBuilder() *ArchiveFieldBuilder {
	builder := &ArchiveFieldBuilder{}
	return builder
}

// 字段编号
//
// 示例值：1
func (builder *ArchiveFieldBuilder) Code(code string) *ArchiveFieldBuilder {
	builder.code = code
	builder.codeFlag = true
	return builder
}

// 字段名称
//
// 示例值：工号
func (builder *ArchiveFieldBuilder) Title(title string) *ArchiveFieldBuilder {
	builder.title = title
	builder.titleFlag = true
	return builder
}

// 一级表头名字
//
// 示例值：
func (builder *ArchiveFieldBuilder) UpperTitles(upperTitles []string) *ArchiveFieldBuilder {
	builder.upperTitles = upperTitles
	builder.upperTitlesFlag = true
	return builder
}

func (builder *ArchiveFieldBuilder) Build() *ArchiveField {
	req := &ArchiveField{}
	if builder.codeFlag {
		req.Code = &builder.code

	}
	if builder.titleFlag {
		req.Title = &builder.title

	}
	if builder.upperTitlesFlag {
		req.UpperTitles = builder.upperTitles
	}
	return req
}

type ArchiveFieldData struct {
	Code *string `json:"code,omitempty"` // 字段编码(查询归档报表表头返回)

	Value *string `json:"value,omitempty"` // 字段结果值
}

type ArchiveFieldDataBuilder struct {
	code     string // 字段编码(查询归档报表表头返回)
	codeFlag bool

	value     string // 字段结果值
	valueFlag bool
}

func NewArchiveFieldDataBuilder() *ArchiveFieldDataBuilder {
	builder := &ArchiveFieldDataBuilder{}
	return builder
}

// 字段编码(查询归档报表表头返回)
//
// 示例值：abd754f7
func (builder *ArchiveFieldDataBuilder) Code(code string) *ArchiveFieldDataBuilder {
	builder.code = code
	builder.codeFlag = true
	return builder
}

// 字段结果值
//
// 示例值：1
func (builder *ArchiveFieldDataBuilder) Value(value string) *ArchiveFieldDataBuilder {
	builder.value = value
	builder.valueFlag = true
	return builder
}

func (builder *ArchiveFieldDataBuilder) Build() *ArchiveFieldData {
	req := &ArchiveFieldData{}
	if builder.codeFlag {
		req.Code = &builder.code

	}
	if builder.valueFlag {
		req.Value = &builder.value

	}
	return req
}

type ArchiveReportData struct {
	MemberId *string `json:"member_id,omitempty"` // 用户ID

	StartTime *string `json:"start_time,omitempty"` // 考勤开始时间

	EndTime *string `json:"end_time,omitempty"` // 考勤结束时间

	FieldDatas []*ArchiveFieldData `json:"field_datas,omitempty"` // 字段结果(不超过200个)
}

type ArchiveReportDataBuilder struct {
	memberId     string // 用户ID
	memberIdFlag bool

	startTime     string // 考勤开始时间
	startTimeFlag bool

	endTime     string // 考勤结束时间
	endTimeFlag bool

	fieldDatas     []*ArchiveFieldData // 字段结果(不超过200个)
	fieldDatasFlag bool
}

func NewArchiveReportDataBuilder() *ArchiveReportDataBuilder {
	builder := &ArchiveReportDataBuilder{}
	return builder
}

// 用户ID
//
// 示例值：1aaxxd
func (builder *ArchiveReportDataBuilder) MemberId(memberId string) *ArchiveReportDataBuilder {
	builder.memberId = memberId
	builder.memberIdFlag = true
	return builder
}

// 考勤开始时间
//
// 示例值：20210109
func (builder *ArchiveReportDataBuilder) StartTime(startTime string) *ArchiveReportDataBuilder {
	builder.startTime = startTime
	builder.startTimeFlag = true
	return builder
}

// 考勤结束时间
//
// 示例值：20210109
func (builder *ArchiveReportDataBuilder) EndTime(endTime string) *ArchiveReportDataBuilder {
	builder.endTime = endTime
	builder.endTimeFlag = true
	return builder
}

// 字段结果(不超过200个)
//
// 示例值：
func (builder *ArchiveReportDataBuilder) FieldDatas(fieldDatas []*ArchiveFieldData) *ArchiveReportDataBuilder {
	builder.fieldDatas = fieldDatas
	builder.fieldDatasFlag = true
	return builder
}

func (builder *ArchiveReportDataBuilder) Build() *ArchiveReportData {
	req := &ArchiveReportData{}
	if builder.memberIdFlag {
		req.MemberId = &builder.memberId

	}
	if builder.startTimeFlag {
		req.StartTime = &builder.startTime

	}
	if builder.endTimeFlag {
		req.EndTime = &builder.endTime

	}
	if builder.fieldDatasFlag {
		req.FieldDatas = builder.fieldDatas
	}
	return req
}

type ArchiveReportMeta struct {
	ReportId *string `json:"report_id,omitempty"` // 引用报表 ID

	ReportName *I18nMap `json:"report_name,omitempty"` // 引用报表name

	ArchiveRuleId *string `json:"archive_rule_id,omitempty"` // 归档报表规则id

	ArchiveRuleName *I18nMap `json:"archive_rule_name,omitempty"` // 归档报表name
}

type ArchiveReportMetaBuilder struct {
	reportId     string // 引用报表 ID
	reportIdFlag bool

	reportName     *I18nMap // 引用报表name
	reportNameFlag bool

	archiveRuleId     string // 归档报表规则id
	archiveRuleIdFlag bool

	archiveRuleName     *I18nMap // 归档报表name
	archiveRuleNameFlag bool
}

func NewArchiveReportMetaBuilder() *ArchiveReportMetaBuilder {
	builder := &ArchiveReportMetaBuilder{}
	return builder
}

// 引用报表 ID
//
// 示例值：7341290237441605652
func (builder *ArchiveReportMetaBuilder) ReportId(reportId string) *ArchiveReportMetaBuilder {
	builder.reportId = reportId
	builder.reportIdFlag = true
	return builder
}

// 引用报表name
//
// 示例值：月报汇总
func (builder *ArchiveReportMetaBuilder) ReportName(reportName *I18nMap) *ArchiveReportMetaBuilder {
	builder.reportName = reportName
	builder.reportNameFlag = true
	return builder
}

// 归档报表规则id
//
// 示例值：7341290237441605652
func (builder *ArchiveReportMetaBuilder) ArchiveRuleId(archiveRuleId string) *ArchiveReportMetaBuilder {
	builder.archiveRuleId = archiveRuleId
	builder.archiveRuleIdFlag = true
	return builder
}

// 归档报表name
//
// 示例值：归档全员
func (builder *ArchiveReportMetaBuilder) ArchiveRuleName(archiveRuleName *I18nMap) *ArchiveReportMetaBuilder {
	builder.archiveRuleName = archiveRuleName
	builder.archiveRuleNameFlag = true
	return builder
}

func (builder *ArchiveReportMetaBuilder) Build() *ArchiveReportMeta {
	req := &ArchiveReportMeta{}
	if builder.reportIdFlag {
		req.ReportId = &builder.reportId

	}
	if builder.reportNameFlag {
		req.ReportName = builder.reportName
	}
	if builder.archiveRuleIdFlag {
		req.ArchiveRuleId = &builder.archiveRuleId

	}
	if builder.archiveRuleNameFlag {
		req.ArchiveRuleName = builder.archiveRuleName
	}
	return req
}

type Area struct {
	Type *string `json:"type,omitempty"` // 区域类型

	Center *Coordinate `json:"center,omitempty"` // 中心点

	Radius *string `json:"radius,omitempty"` // 半径

	Coords []*Coordinate `json:"coords,omitempty"` //
}

type AreaBuilder struct {
	type_    string // 区域类型
	typeFlag bool

	center     *Coordinate // 中心点
	centerFlag bool

	radius     string // 半径
	radiusFlag bool

	coords     []*Coordinate //
	coordsFlag bool
}

func NewAreaBuilder() *AreaBuilder {
	builder := &AreaBuilder{}
	return builder
}

// 区域类型
//
// 示例值：
func (builder *AreaBuilder) Type(type_ string) *AreaBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

// 中心点
//
// 示例值：
func (builder *AreaBuilder) Center(center *Coordinate) *AreaBuilder {
	builder.center = center
	builder.centerFlag = true
	return builder
}

// 半径
//
// 示例值：
func (builder *AreaBuilder) Radius(radius string) *AreaBuilder {
	builder.radius = radius
	builder.radiusFlag = true
	return builder
}

//
//
// 示例值：
func (builder *AreaBuilder) Coords(coords []*Coordinate) *AreaBuilder {
	builder.coords = coords
	builder.coordsFlag = true
	return builder
}

func (builder *AreaBuilder) Build() *Area {
	req := &Area{}
	if builder.typeFlag {
		req.Type = &builder.type_

	}
	if builder.centerFlag {
		req.Center = builder.center
	}
	if builder.radiusFlag {
		req.Radius = &builder.radius

	}
	if builder.coordsFlag {
		req.Coords = builder.coords
	}
	return req
}

type ArrangeShiftGroup struct {
	ShiftGroupId *string `json:"shift_group_id,omitempty"` // 班组id

	GroupId *string `json:"group_id,omitempty"` // 考勤组id

	ShiftGroupName *string `json:"shift_group_name,omitempty"` // 班组名称
}

type ArrangeShiftGroupBuilder struct {
	shiftGroupId     string // 班组id
	shiftGroupIdFlag bool

	groupId     string // 考勤组id
	groupIdFlag bool

	shiftGroupName     string // 班组名称
	shiftGroupNameFlag bool
}

func NewArrangeShiftGroupBuilder() *ArrangeShiftGroupBuilder {
	builder := &ArrangeShiftGroupBuilder{}
	return builder
}

// 班组id
//
// 示例值：7071200888781537300
func (builder *ArrangeShiftGroupBuilder) ShiftGroupId(shiftGroupId string) *ArrangeShiftGroupBuilder {
	builder.shiftGroupId = shiftGroupId
	builder.shiftGroupIdFlag = true
	return builder
}

// 考勤组id
//
// 示例值：7171200888781537301
func (builder *ArrangeShiftGroupBuilder) GroupId(groupId string) *ArrangeShiftGroupBuilder {
	builder.groupId = groupId
	builder.groupIdFlag = true
	return builder
}

// 班组名称
//
// 示例值：班组-测试班组
func (builder *ArrangeShiftGroupBuilder) ShiftGroupName(shiftGroupName string) *ArrangeShiftGroupBuilder {
	builder.shiftGroupName = shiftGroupName
	builder.shiftGroupNameFlag = true
	return builder
}

func (builder *ArrangeShiftGroupBuilder) Build() *ArrangeShiftGroup {
	req := &ArrangeShiftGroup{}
	if builder.shiftGroupIdFlag {
		req.ShiftGroupId = &builder.shiftGroupId

	}
	if builder.groupIdFlag {
		req.GroupId = &builder.groupId

	}
	if builder.shiftGroupNameFlag {
		req.ShiftGroupName = &builder.shiftGroupName

	}
	return req
}

type ChildField struct {
	Code *string `json:"code,omitempty"` // 子字段编号

	Title *string `json:"title,omitempty"` // 子字段名称

	TimeUnit *string `json:"time_unit,omitempty"` // 时间单位
}

type ChildFieldBuilder struct {
	code     string // 子字段编号
	codeFlag bool

	title     string // 子字段名称
	titleFlag bool

	timeUnit     string // 时间单位
	timeUnitFlag bool
}

func NewChildFieldBuilder() *ChildFieldBuilder {
	builder := &ChildFieldBuilder{}
	return builder
}

// 子字段编号
//
// 示例值：50121
func (builder *ChildFieldBuilder) Code(code string) *ChildFieldBuilder {
	builder.code = code
	builder.codeFlag = true
	return builder
}

// 子字段名称
//
// 示例值：工号
func (builder *ChildFieldBuilder) Title(title string) *ChildFieldBuilder {
	builder.title = title
	builder.titleFlag = true
	return builder
}

// 时间单位
//
// 示例值：
func (builder *ChildFieldBuilder) TimeUnit(timeUnit string) *ChildFieldBuilder {
	builder.timeUnit = timeUnit
	builder.timeUnitFlag = true
	return builder
}

func (builder *ChildFieldBuilder) Build() *ChildField {
	req := &ChildField{}
	if builder.codeFlag {
		req.Code = &builder.code

	}
	if builder.titleFlag {
		req.Title = &builder.title

	}
	if builder.timeUnitFlag {
		req.TimeUnit = &builder.timeUnit

	}
	return req
}

type ChildItem struct {
	Code *string `json:"code,omitempty"` // 子标题编号

	Value *string `json:"value,omitempty"` // 开关字段，0：关闭，1：开启（非开关字段场景：code = 51501 可选值为1-6）

	Title *string `json:"title,omitempty"` // 子标题名称

	ColumnType *int `json:"column_type,omitempty"` // 列类型

	ReadOnly *bool `json:"read_only,omitempty"` // 是否只读

	MinValue *string `json:"min_value,omitempty"` // 最小值

	MaxValue *string `json:"max_value,omitempty"` // 最大值
}

type ChildItemBuilder struct {
	code     string // 子标题编号
	codeFlag bool

	value     string // 开关字段，0：关闭，1：开启（非开关字段场景：code = 51501 可选值为1-6）
	valueFlag bool

	title     string // 子标题名称
	titleFlag bool

	columnType     int // 列类型
	columnTypeFlag bool

	readOnly     bool // 是否只读
	readOnlyFlag bool

	minValue     string // 最小值
	minValueFlag bool

	maxValue     string // 最大值
	maxValueFlag bool
}

func NewChildItemBuilder() *ChildItemBuilder {
	builder := &ChildItemBuilder{}
	return builder
}

// 子标题编号
//
// 示例值：50101
func (builder *ChildItemBuilder) Code(code string) *ChildItemBuilder {
	builder.code = code
	builder.codeFlag = true
	return builder
}

// 开关字段，0：关闭，1：开启（非开关字段场景：code = 51501 可选值为1-6）
//
// 示例值：0
func (builder *ChildItemBuilder) Value(value string) *ChildItemBuilder {
	builder.value = value
	builder.valueFlag = true
	return builder
}

// 子标题名称
//
// 示例值：工号
func (builder *ChildItemBuilder) Title(title string) *ChildItemBuilder {
	builder.title = title
	builder.titleFlag = true
	return builder
}

// 列类型
//
// 示例值：
func (builder *ChildItemBuilder) ColumnType(columnType int) *ChildItemBuilder {
	builder.columnType = columnType
	builder.columnTypeFlag = true
	return builder
}

// 是否只读
//
// 示例值：
func (builder *ChildItemBuilder) ReadOnly(readOnly bool) *ChildItemBuilder {
	builder.readOnly = readOnly
	builder.readOnlyFlag = true
	return builder
}

// 最小值
//
// 示例值：
func (builder *ChildItemBuilder) MinValue(minValue string) *ChildItemBuilder {
	builder.minValue = minValue
	builder.minValueFlag = true
	return builder
}

// 最大值
//
// 示例值：
func (builder *ChildItemBuilder) MaxValue(maxValue string) *ChildItemBuilder {
	builder.maxValue = maxValue
	builder.maxValueFlag = true
	return builder
}

func (builder *ChildItemBuilder) Build() *ChildItem {
	req := &ChildItem{}
	if builder.codeFlag {
		req.Code = &builder.code

	}
	if builder.valueFlag {
		req.Value = &builder.value

	}
	if builder.titleFlag {
		req.Title = &builder.title

	}
	if builder.columnTypeFlag {
		req.ColumnType = &builder.columnType

	}
	if builder.readOnlyFlag {
		req.ReadOnly = &builder.readOnly

	}
	if builder.minValueFlag {
		req.MinValue = &builder.minValue

	}
	if builder.maxValueFlag {
		req.MaxValue = &builder.maxValue

	}
	return req
}

type Coordinate struct {
	Longitude *float64 `json:"longitude,omitempty"` // 经度

	Latitude *float64 `json:"latitude,omitempty"` // 纬度

	Accuracy *float64 `json:"accuracy,omitempty"` // 精度
}

type CoordinateBuilder struct {
	longitude     float64 // 经度
	longitudeFlag bool

	latitude     float64 // 纬度
	latitudeFlag bool

	accuracy     float64 // 精度
	accuracyFlag bool
}

func NewCoordinateBuilder() *CoordinateBuilder {
	builder := &CoordinateBuilder{}
	return builder
}

// 经度
//
// 示例值：
func (builder *CoordinateBuilder) Longitude(longitude float64) *CoordinateBuilder {
	builder.longitude = longitude
	builder.longitudeFlag = true
	return builder
}

// 纬度
//
// 示例值：
func (builder *CoordinateBuilder) Latitude(latitude float64) *CoordinateBuilder {
	builder.latitude = latitude
	builder.latitudeFlag = true
	return builder
}

// 精度
//
// 示例值：
func (builder *CoordinateBuilder) Accuracy(accuracy float64) *CoordinateBuilder {
	builder.accuracy = accuracy
	builder.accuracyFlag = true
	return builder
}

func (builder *CoordinateBuilder) Build() *Coordinate {
	req := &Coordinate{}
	if builder.longitudeFlag {
		req.Longitude = &builder.longitude

	}
	if builder.latitudeFlag {
		req.Latitude = &builder.latitude

	}
	if builder.accuracyFlag {
		req.Accuracy = &builder.accuracy

	}
	return req
}

type CreateBpmOutRecord struct {
	UserId *string `json:"user_id,omitempty"` // 发起外出审批的用户ID

	OutRecord *OutRecord `json:"out_record,omitempty"` // 外出数据

	OutReason *string `json:"out_reason,omitempty"` // 外出事由

	CustomFormData *string `json:"custom_form_data,omitempty"` // json string，BPM流程中自定义新增控件
}

type CreateBpmOutRecordBuilder struct {
	userId     string // 发起外出审批的用户ID
	userIdFlag bool

	outRecord     *OutRecord // 外出数据
	outRecordFlag bool

	outReason     string // 外出事由
	outReasonFlag bool

	customFormData     string // json string，BPM流程中自定义新增控件
	customFormDataFlag bool
}

func NewCreateBpmOutRecordBuilder() *CreateBpmOutRecordBuilder {
	builder := &CreateBpmOutRecordBuilder{}
	return builder
}

// 发起外出审批的用户ID
//
// 示例值：
func (builder *CreateBpmOutRecordBuilder) UserId(userId string) *CreateBpmOutRecordBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 外出数据
//
// 示例值：
func (builder *CreateBpmOutRecordBuilder) OutRecord(outRecord *OutRecord) *CreateBpmOutRecordBuilder {
	builder.outRecord = outRecord
	builder.outRecordFlag = true
	return builder
}

// 外出事由
//
// 示例值：临时外出
func (builder *CreateBpmOutRecordBuilder) OutReason(outReason string) *CreateBpmOutRecordBuilder {
	builder.outReason = outReason
	builder.outReasonFlag = true
	return builder
}

// json string，BPM流程中自定义新增控件
//
// 示例值："{\"attachments\":{\"null_value\":{}}}"
func (builder *CreateBpmOutRecordBuilder) CustomFormData(customFormData string) *CreateBpmOutRecordBuilder {
	builder.customFormData = customFormData
	builder.customFormDataFlag = true
	return builder
}

func (builder *CreateBpmOutRecordBuilder) Build() *CreateBpmOutRecord {
	req := &CreateBpmOutRecord{}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.outRecordFlag {
		req.OutRecord = builder.outRecord
	}
	if builder.outReasonFlag {
		req.OutReason = &builder.outReason

	}
	if builder.customFormDataFlag {
		req.CustomFormData = &builder.customFormData

	}
	return req
}

type CreateBpmRemedyRecords struct {
	UserId *string `json:"user_id,omitempty"` // 发起补卡审批的用户ID

	RemedyRecords []*RemedyRecord `json:"remedy_records,omitempty"` // 补卡列表-记录上限=10

	RemedyReason *string `json:"remedy_reason,omitempty"` // 补卡事由

	CustomFormData *string `json:"custom_form_data,omitempty"` // json string，BPM流程中自定义新增控件
}

type CreateBpmRemedyRecordsBuilder struct {
	userId     string // 发起补卡审批的用户ID
	userIdFlag bool

	remedyRecords     []*RemedyRecord // 补卡列表-记录上限=10
	remedyRecordsFlag bool

	remedyReason     string // 补卡事由
	remedyReasonFlag bool

	customFormData     string // json string，BPM流程中自定义新增控件
	customFormDataFlag bool
}

func NewCreateBpmRemedyRecordsBuilder() *CreateBpmRemedyRecordsBuilder {
	builder := &CreateBpmRemedyRecordsBuilder{}
	return builder
}

// 发起补卡审批的用户ID
//
// 示例值：0000000
func (builder *CreateBpmRemedyRecordsBuilder) UserId(userId string) *CreateBpmRemedyRecordsBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 补卡列表-记录上限=10
//
// 示例值：
func (builder *CreateBpmRemedyRecordsBuilder) RemedyRecords(remedyRecords []*RemedyRecord) *CreateBpmRemedyRecordsBuilder {
	builder.remedyRecords = remedyRecords
	builder.remedyRecordsFlag = true
	return builder
}

// 补卡事由
//
// 示例值：正常上班，忘记打卡
func (builder *CreateBpmRemedyRecordsBuilder) RemedyReason(remedyReason string) *CreateBpmRemedyRecordsBuilder {
	builder.remedyReason = remedyReason
	builder.remedyReasonFlag = true
	return builder
}

// json string，BPM流程中自定义新增控件
//
// 示例值：{"remedy_applies":{"record_value":{"values":{"remedy_records":{"list_value":{"values":[{"record_value":{"values":{"remedy_type":{"text_value":{"value":"补卡类型6"}}}}}]}}}}}}
func (builder *CreateBpmRemedyRecordsBuilder) CustomFormData(customFormData string) *CreateBpmRemedyRecordsBuilder {
	builder.customFormData = customFormData
	builder.customFormDataFlag = true
	return builder
}

func (builder *CreateBpmRemedyRecordsBuilder) Build() *CreateBpmRemedyRecords {
	req := &CreateBpmRemedyRecords{}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.remedyRecordsFlag {
		req.RemedyRecords = builder.remedyRecords
	}
	if builder.remedyReasonFlag {
		req.RemedyReason = &builder.remedyReason

	}
	if builder.customFormDataFlag {
		req.CustomFormData = &builder.customFormData

	}
	return req
}

type DepartmentId struct {
	DepartmentId *string `json:"department_id,omitempty"` //

	OpenDepartmentId *string `json:"open_department_id,omitempty"` //
}

type DepartmentIdBuilder struct {
	departmentId     string //
	departmentIdFlag bool

	openDepartmentId     string //
	openDepartmentIdFlag bool
}

func NewDepartmentIdBuilder() *DepartmentIdBuilder {
	builder := &DepartmentIdBuilder{}
	return builder
}

//
//
// 示例值：
func (builder *DepartmentIdBuilder) DepartmentId(departmentId string) *DepartmentIdBuilder {
	builder.departmentId = departmentId
	builder.departmentIdFlag = true
	return builder
}

//
//
// 示例值：
func (builder *DepartmentIdBuilder) OpenDepartmentId(openDepartmentId string) *DepartmentIdBuilder {
	builder.openDepartmentId = openDepartmentId
	builder.openDepartmentIdFlag = true
	return builder
}

func (builder *DepartmentIdBuilder) Build() *DepartmentId {
	req := &DepartmentId{}
	if builder.departmentIdFlag {
		req.DepartmentId = &builder.departmentId

	}
	if builder.openDepartmentIdFlag {
		req.OpenDepartmentId = &builder.openDepartmentId

	}
	return req
}

type DurationItem struct {
	Date *string `json:"date,omitempty"` // 日期

	Duration *float64 `json:"duration,omitempty"` // 加班时长

	Unit *int `json:"unit,omitempty"` // 加班单位

	SettlementType *int `json:"settlement_type,omitempty"` // 加班类型
}

type DurationItemBuilder struct {
	date     string // 日期
	dateFlag bool

	duration     float64 // 加班时长
	durationFlag bool

	unit     int // 加班单位
	unitFlag bool

	settlementType     int // 加班类型
	settlementTypeFlag bool
}

func NewDurationItemBuilder() *DurationItemBuilder {
	builder := &DurationItemBuilder{}
	return builder
}

// 日期
//
// 示例值：20231010
func (builder *DurationItemBuilder) Date(date string) *DurationItemBuilder {
	builder.date = date
	builder.dateFlag = true
	return builder
}

// 加班时长
//
// 示例值：20.0
func (builder *DurationItemBuilder) Duration(duration float64) *DurationItemBuilder {
	builder.duration = duration
	builder.durationFlag = true
	return builder
}

// 加班单位
//
// 示例值：1
func (builder *DurationItemBuilder) Unit(unit int) *DurationItemBuilder {
	builder.unit = unit
	builder.unitFlag = true
	return builder
}

// 加班类型
//
// 示例值：1
func (builder *DurationItemBuilder) SettlementType(settlementType int) *DurationItemBuilder {
	builder.settlementType = settlementType
	builder.settlementTypeFlag = true
	return builder
}

func (builder *DurationItemBuilder) Build() *DurationItem {
	req := &DurationItem{}
	if builder.dateFlag {
		req.Date = &builder.date

	}
	if builder.durationFlag {
		req.Duration = &builder.duration

	}
	if builder.unitFlag {
		req.Unit = &builder.unit

	}
	if builder.settlementTypeFlag {
		req.SettlementType = &builder.settlementType

	}
	return req
}

type ExportArchiveUserRecordReq struct {
	StartDate *string `json:"start_date,omitempty"` // 查询报表起始日期，格式yyyyMMdd，示例20240101

	EndDate *string `json:"end_date,omitempty"` // 查询报表结束日期，格式yyyyMMdd，示例20240101 -- 跨度不超过一个月

	UserIds []string `json:"user_ids,omitempty"` // 查询的 user_id列表。与employee_type对应
}

type ExportArchiveUserRecordReqBuilder struct {
	startDate     string // 查询报表起始日期，格式yyyyMMdd，示例20240101
	startDateFlag bool

	endDate     string // 查询报表结束日期，格式yyyyMMdd，示例20240101 -- 跨度不超过一个月
	endDateFlag bool

	userIds     []string // 查询的 user_id列表。与employee_type对应
	userIdsFlag bool
}

func NewExportArchiveUserRecordReqBuilder() *ExportArchiveUserRecordReqBuilder {
	builder := &ExportArchiveUserRecordReqBuilder{}
	return builder
}

// 查询报表起始日期，格式yyyyMMdd，示例20240101
//
// 示例值：20240101
func (builder *ExportArchiveUserRecordReqBuilder) StartDate(startDate string) *ExportArchiveUserRecordReqBuilder {
	builder.startDate = startDate
	builder.startDateFlag = true
	return builder
}

// 查询报表结束日期，格式yyyyMMdd，示例20240101 -- 跨度不超过一个月
//
// 示例值：20240105
func (builder *ExportArchiveUserRecordReqBuilder) EndDate(endDate string) *ExportArchiveUserRecordReqBuilder {
	builder.endDate = endDate
	builder.endDateFlag = true
	return builder
}

// 查询的 user_id列表。与employee_type对应
//
// 示例值：
func (builder *ExportArchiveUserRecordReqBuilder) UserIds(userIds []string) *ExportArchiveUserRecordReqBuilder {
	builder.userIds = userIds
	builder.userIdsFlag = true
	return builder
}

func (builder *ExportArchiveUserRecordReqBuilder) Build() *ExportArchiveUserRecordReq {
	req := &ExportArchiveUserRecordReq{}
	if builder.startDateFlag {
		req.StartDate = &builder.startDate

	}
	if builder.endDateFlag {
		req.EndDate = &builder.endDate

	}
	if builder.userIdsFlag {
		req.UserIds = builder.userIds
	}
	return req
}

type Field struct {
	Code *string `json:"code,omitempty"` // 字段编号

	Title *string `json:"title,omitempty"` // 字段名称

	ChildFields []*ChildField `json:"child_fields,omitempty"` // 子字段列表
}

type FieldBuilder struct {
	code     string // 字段编号
	codeFlag bool

	title     string // 字段名称
	titleFlag bool

	childFields     []*ChildField // 子字段列表
	childFieldsFlag bool
}

func NewFieldBuilder() *FieldBuilder {
	builder := &FieldBuilder{}
	return builder
}

// 字段编号
//
// 示例值：50121
func (builder *FieldBuilder) Code(code string) *FieldBuilder {
	builder.code = code
	builder.codeFlag = true
	return builder
}

// 字段名称
//
// 示例值：工号
func (builder *FieldBuilder) Title(title string) *FieldBuilder {
	builder.title = title
	builder.titleFlag = true
	return builder
}

// 子字段列表
//
// 示例值：
func (builder *FieldBuilder) ChildFields(childFields []*ChildField) *FieldBuilder {
	builder.childFields = childFields
	builder.childFieldsFlag = true
	return builder
}

func (builder *FieldBuilder) Build() *Field {
	req := &Field{}
	if builder.codeFlag {
		req.Code = &builder.code

	}
	if builder.titleFlag {
		req.Title = &builder.title

	}
	if builder.childFieldsFlag {
		req.ChildFields = builder.childFields
	}
	return req
}

type File struct {
	FileId *string `json:"file_id,omitempty"` // 文件 ID
}

type FileBuilder struct {
	fileId     string // 文件 ID
	fileIdFlag bool
}

func NewFileBuilder() *FileBuilder {
	builder := &FileBuilder{}
	return builder
}

// 文件 ID
//
// 示例值：6b30e7636a38861bbe02869c726a4612
func (builder *FileBuilder) FileId(fileId string) *FileBuilder {
	builder.fileId = fileId
	builder.fileIdFlag = true
	return builder
}

func (builder *FileBuilder) Build() *File {
	req := &File{}
	if builder.fileIdFlag {
		req.FileId = &builder.fileId

	}
	return req
}

type FilterItem struct {
	FilterType *string `json:"filter_type,omitempty"` // 筛选类型

	FilterIds []string `json:"filter_ids,omitempty"` // 筛选的ID
}

type FilterItemBuilder struct {
	filterType     string // 筛选类型
	filterTypeFlag bool

	filterIds     []string // 筛选的ID
	filterIdsFlag bool
}

func NewFilterItemBuilder() *FilterItemBuilder {
	builder := &FilterItemBuilder{}
	return builder
}

// 筛选类型
//
// 示例值：
func (builder *FilterItemBuilder) FilterType(filterType string) *FilterItemBuilder {
	builder.filterType = filterType
	builder.filterTypeFlag = true
	return builder
}

// 筛选的ID
//
// 示例值：
func (builder *FilterItemBuilder) FilterIds(filterIds []string) *FilterItemBuilder {
	builder.filterIds = filterIds
	builder.filterIdsFlag = true
	return builder
}

func (builder *FilterItemBuilder) Build() *FilterItem {
	req := &FilterItem{}
	if builder.filterTypeFlag {
		req.FilterType = &builder.filterType

	}
	if builder.filterIdsFlag {
		req.FilterIds = builder.filterIds
	}
	return req
}

type FlexibleRule struct {
	FlexibleEarlyMinutes *int `json:"flexible_early_minutes,omitempty"` // 下班最多可早走（上班早到几分钟，下班可早走几分钟）

	FlexibleLateMinutes *int `json:"flexible_late_minutes,omitempty"` // 上班最多可晚到（上班晚到几分钟，下班须晚走几分钟）
}

type FlexibleRuleBuilder struct {
	flexibleEarlyMinutes     int // 下班最多可早走（上班早到几分钟，下班可早走几分钟）
	flexibleEarlyMinutesFlag bool

	flexibleLateMinutes     int // 上班最多可晚到（上班晚到几分钟，下班须晚走几分钟）
	flexibleLateMinutesFlag bool
}

func NewFlexibleRuleBuilder() *FlexibleRuleBuilder {
	builder := &FlexibleRuleBuilder{}
	return builder
}

// 下班最多可早走（上班早到几分钟，下班可早走几分钟）
//
// 示例值：60
func (builder *FlexibleRuleBuilder) FlexibleEarlyMinutes(flexibleEarlyMinutes int) *FlexibleRuleBuilder {
	builder.flexibleEarlyMinutes = flexibleEarlyMinutes
	builder.flexibleEarlyMinutesFlag = true
	return builder
}

// 上班最多可晚到（上班晚到几分钟，下班须晚走几分钟）
//
// 示例值：60
func (builder *FlexibleRuleBuilder) FlexibleLateMinutes(flexibleLateMinutes int) *FlexibleRuleBuilder {
	builder.flexibleLateMinutes = flexibleLateMinutes
	builder.flexibleLateMinutesFlag = true
	return builder
}

func (builder *FlexibleRuleBuilder) Build() *FlexibleRule {
	req := &FlexibleRule{}
	if builder.flexibleEarlyMinutesFlag {
		req.FlexibleEarlyMinutes = &builder.flexibleEarlyMinutes

	}
	if builder.flexibleLateMinutesFlag {
		req.FlexibleLateMinutes = &builder.flexibleLateMinutes

	}
	return req
}

type FreeClockSetting struct {
	ClockMode *int `json:"clock_mode,omitempty"` // 打卡模式

	ClockInternalHhmm *int `json:"clock_internal_hhmm,omitempty"` // 最小打卡间隔
}

type FreeClockSettingBuilder struct {
	clockMode     int // 打卡模式
	clockModeFlag bool

	clockInternalHhmm     int // 最小打卡间隔
	clockInternalHhmmFlag bool
}

func NewFreeClockSettingBuilder() *FreeClockSettingBuilder {
	builder := &FreeClockSettingBuilder{}
	return builder
}

// 打卡模式
//
// 示例值：0
func (builder *FreeClockSettingBuilder) ClockMode(clockMode int) *FreeClockSettingBuilder {
	builder.clockMode = clockMode
	builder.clockModeFlag = true
	return builder
}

// 最小打卡间隔
//
// 示例值：100
func (builder *FreeClockSettingBuilder) ClockInternalHhmm(clockInternalHhmm int) *FreeClockSettingBuilder {
	builder.clockInternalHhmm = clockInternalHhmm
	builder.clockInternalHhmmFlag = true
	return builder
}

func (builder *FreeClockSettingBuilder) Build() *FreeClockSetting {
	req := &FreeClockSetting{}
	if builder.clockModeFlag {
		req.ClockMode = &builder.clockMode

	}
	if builder.clockInternalHhmmFlag {
		req.ClockInternalHhmm = &builder.clockInternalHhmm

	}
	return req
}

type FreePunchCfg struct {
	FreeStartTime *string `json:"free_start_time,omitempty"` // 自由班制打卡开始时间

	FreeEndTime *string `json:"free_end_time,omitempty"` // 自由班制打卡结束时间

	PunchDay *int `json:"punch_day,omitempty"` // 打卡的时间，为 7 位数字，每一位依次代表周一到周日，0 为不上班，1 为上班

	WorkDayNoPunchAsLack *bool `json:"work_day_no_punch_as_lack,omitempty"` // 工作日不打卡是否记为缺卡

	WorkHoursDemand *bool `json:"work_hours_demand,omitempty"` // 工作日出勤是否需满足时长要求

	WorkHours *int `json:"work_hours,omitempty"` // 每日工作时长（分钟),范围[0,1440]

	FreeClockSetting *FreeClockSetting `json:"free_clock_setting,omitempty"` // 自由班制的打卡配置
}

type FreePunchCfgBuilder struct {
	freeStartTime     string // 自由班制打卡开始时间
	freeStartTimeFlag bool

	freeEndTime     string // 自由班制打卡结束时间
	freeEndTimeFlag bool

	punchDay     int // 打卡的时间，为 7 位数字，每一位依次代表周一到周日，0 为不上班，1 为上班
	punchDayFlag bool

	workDayNoPunchAsLack     bool // 工作日不打卡是否记为缺卡
	workDayNoPunchAsLackFlag bool

	workHoursDemand     bool // 工作日出勤是否需满足时长要求
	workHoursDemandFlag bool

	workHours     int // 每日工作时长（分钟),范围[0,1440]
	workHoursFlag bool

	freeClockSetting     *FreeClockSetting // 自由班制的打卡配置
	freeClockSettingFlag bool
}

func NewFreePunchCfgBuilder() *FreePunchCfgBuilder {
	builder := &FreePunchCfgBuilder{}
	return builder
}

// 自由班制打卡开始时间
//
// 示例值：7:00
func (builder *FreePunchCfgBuilder) FreeStartTime(freeStartTime string) *FreePunchCfgBuilder {
	builder.freeStartTime = freeStartTime
	builder.freeStartTimeFlag = true
	return builder
}

// 自由班制打卡结束时间
//
// 示例值：18:00
func (builder *FreePunchCfgBuilder) FreeEndTime(freeEndTime string) *FreePunchCfgBuilder {
	builder.freeEndTime = freeEndTime
	builder.freeEndTimeFlag = true
	return builder
}

// 打卡的时间，为 7 位数字，每一位依次代表周一到周日，0 为不上班，1 为上班
//
// 示例值：1111100
func (builder *FreePunchCfgBuilder) PunchDay(punchDay int) *FreePunchCfgBuilder {
	builder.punchDay = punchDay
	builder.punchDayFlag = true
	return builder
}

// 工作日不打卡是否记为缺卡
//
// 示例值：true
func (builder *FreePunchCfgBuilder) WorkDayNoPunchAsLack(workDayNoPunchAsLack bool) *FreePunchCfgBuilder {
	builder.workDayNoPunchAsLack = workDayNoPunchAsLack
	builder.workDayNoPunchAsLackFlag = true
	return builder
}

// 工作日出勤是否需满足时长要求
//
// 示例值：false
func (builder *FreePunchCfgBuilder) WorkHoursDemand(workHoursDemand bool) *FreePunchCfgBuilder {
	builder.workHoursDemand = workHoursDemand
	builder.workHoursDemandFlag = true
	return builder
}

// 每日工作时长（分钟),范围[0,1440]
//
// 示例值：480
func (builder *FreePunchCfgBuilder) WorkHours(workHours int) *FreePunchCfgBuilder {
	builder.workHours = workHours
	builder.workHoursFlag = true
	return builder
}

// 自由班制的打卡配置
//
// 示例值：
func (builder *FreePunchCfgBuilder) FreeClockSetting(freeClockSetting *FreeClockSetting) *FreePunchCfgBuilder {
	builder.freeClockSetting = freeClockSetting
	builder.freeClockSettingFlag = true
	return builder
}

func (builder *FreePunchCfgBuilder) Build() *FreePunchCfg {
	req := &FreePunchCfg{}
	if builder.freeStartTimeFlag {
		req.FreeStartTime = &builder.freeStartTime

	}
	if builder.freeEndTimeFlag {
		req.FreeEndTime = &builder.freeEndTime

	}
	if builder.punchDayFlag {
		req.PunchDay = &builder.punchDay

	}
	if builder.workDayNoPunchAsLackFlag {
		req.WorkDayNoPunchAsLack = &builder.workDayNoPunchAsLack

	}
	if builder.workHoursDemandFlag {
		req.WorkHoursDemand = &builder.workHoursDemand

	}
	if builder.workHoursFlag {
		req.WorkHours = &builder.workHours

	}
	if builder.freeClockSettingFlag {
		req.FreeClockSetting = builder.freeClockSetting
	}
	return req
}

type Group struct {
	GroupId *string `json:"group_id,omitempty"` // 考勤组 ID（仅修改时提供）， 需要从“获取打卡结果”的接口中获取 groupId

	GroupName *string `json:"group_name,omitempty"` // 考勤组名称

	TimeZone *string `json:"time_zone,omitempty"` // 时区

	BindDeptIds []string `json:"bind_dept_ids,omitempty"` // 绑定的部门 ID

	ExceptDeptIds []string `json:"except_dept_ids,omitempty"` // 排除的部门 ID

	BindUserIds []string `json:"bind_user_ids,omitempty"` // 绑定的用户 ID

	ExceptUserIds []string `json:"except_user_ids,omitempty"` // 排除的用户 ID

	GroupLeaderIds []string `json:"group_leader_ids,omitempty"` // 考勤主负责人 ID 列表，必选字段（需至少拥有考勤组管理员权限）

	SubGroupLeaderIds []string `json:"sub_group_leader_ids,omitempty"` // 考勤子负责人 ID 列表

	AllowOutPunch *bool `json:"allow_out_punch,omitempty"` // 是否允许外勤打卡

	OutPunchNeedApproval *bool `json:"out_punch_need_approval,omitempty"` // 外勤打卡需审批（需要允许外勤打卡才能设置生效）

	OutPunchNeedPostApproval *bool `json:"out_punch_need_post_approval,omitempty"` // 外勤打卡需审批，先打卡后审批（需要允许外勤打卡才能设置生效）

	OutPunchNeedRemark *bool `json:"out_punch_need_remark,omitempty"` // 外勤打卡需填写备注（需要允许外勤打卡才能设置生效）

	OutPunchNeedPhoto *bool `json:"out_punch_need_photo,omitempty"` // 外勤打卡需拍照（需要允许外勤打卡才能设置生效）

	OutPunchAllowedHideAddr *bool `json:"out_punch_allowed_hide_addr,omitempty"` // 外勤打卡允许员工隐藏详细地址（需要允许外勤打卡才能设置生效）

	OutPunchAllowedAdjustAddr *bool `json:"out_punch_allowed_adjust_addr,omitempty"` // 外勤打卡允许微调地址（需要允许外勤打卡才能设置生效）

	AdjustRange *int `json:"adjust_range,omitempty"` // 微调范围，默认为 50 米

	AllowPcPunch *bool `json:"allow_pc_punch,omitempty"` // 是否允许 PC 端打卡

	AllowRemedy *bool `json:"allow_remedy,omitempty"` // 是否限制补卡

	RemedyLimit *bool `json:"remedy_limit,omitempty"` // 是否限制补卡次数

	RemedyLimitCount *int `json:"remedy_limit_count,omitempty"` // 补卡次数

	RemedyDateLimit *bool `json:"remedy_date_limit,omitempty"` // 是否限制补卡时间

	RemedyDateNum *int `json:"remedy_date_num,omitempty"` // 补卡时间，几天内补卡

	AllowRemedyTypeLack *bool `json:"allow_remedy_type_lack,omitempty"` // 允许缺卡补卡（需要允许补卡才能设置生效）

	AllowRemedyTypeLate *bool `json:"allow_remedy_type_late,omitempty"` // 允许迟到补卡（需要允许补卡才能设置生效）

	AllowRemedyTypeEarly *bool `json:"allow_remedy_type_early,omitempty"` // 允许早退补卡（需要允许补卡才能设置生效）

	AllowRemedyTypeNormal *bool `json:"allow_remedy_type_normal,omitempty"` // 允许正常补卡（需要允许补卡才能设置生效）

	ShowCumulativeTime *bool `json:"show_cumulative_time,omitempty"` // 是否展示累计时长

	ShowOverTime *bool `json:"show_over_time,omitempty"` // 是否展示加班时长

	HideStaffPunchTime *bool `json:"hide_staff_punch_time,omitempty"` // 是否隐藏员工打卡详情

	HideClockInRule *bool `json:"hide_clock_in_rule,omitempty"` // 是否隐藏打卡规则

	FacePunch *bool `json:"face_punch,omitempty"` // 是否开启人脸识别打卡

	FacePunchCfg *int `json:"face_punch_cfg,omitempty"` // 人脸识别打卡规则，1：每次打卡均需人脸识别，2：疑似作弊打卡时需要人脸识别

	FaceLiveNeedAction *bool `json:"face_live_need_action,omitempty"` // 人脸打卡规则， false：开启活体验证 true：0动作验证，仅在 face_punch_cfg = 1 时有效

	FaceDowngrade *bool `json:"face_downgrade,omitempty"` // 人脸识别失败时是否允许普通拍照打卡

	ReplaceBasicPic *bool `json:"replace_basic_pic,omitempty"` // 人脸识别失败时是否允许替换基准图片

	AntiCheatPunchConfig *AntiCheatConfig `json:"anti_cheat_punch_config,omitempty"` // 防作弊打卡配置

	Machines []*Machine `json:"machines,omitempty"` // 考勤机列表

	GpsRange *int `json:"gps_range,omitempty"` // GPS 打卡的有效范围（不建议使用）

	Locations []*Location `json:"locations,omitempty"` // 地址列表

	GroupType *int `json:"group_type,omitempty"` // 考勤类型，0：固定班制，2：排班制， 3：自由班制

	PunchDayShiftIds []string `json:"punch_day_shift_ids,omitempty"` // 固定班制必须填

	FreePunchCfg *FreePunchCfg `json:"free_punch_cfg,omitempty"` // 配置自由班制

	CalendarId *int `json:"calendar_id,omitempty"` // 国家日历  ID，0：不根据国家日历排休，1：中国大陆，2：美国，3：日本，4：印度，5：新加坡，默认 1

	NeedPunchSpecialDays []*PunchSpecialDateShift `json:"need_punch_special_days,omitempty"` // 必须打卡的特殊日期

	NoNeedPunchSpecialDays []*PunchSpecialDateShift `json:"no_need_punch_special_days,omitempty"` // 无需打卡的特殊日期

	WorkDayNoPunchAsLack *bool `json:"work_day_no_punch_as_lack,omitempty"` // 自由班制下工作日不打卡是否记为缺卡

	EffectNow *bool `json:"effect_now,omitempty"` // 是否立即生效，默认 false

	RemedyPeriodType *int `json:"remedy_period_type,omitempty"` // 补卡周期类型

	RemedyPeriodCustomDate *int `json:"remedy_period_custom_date,omitempty"` // 补卡自定义周期起始日期

	PunchType *int `json:"punch_type,omitempty"` // 打卡类型，位运算。1：GPS 打卡，2：Wi-Fi 打卡，4：考勤机打卡，8：IP 打卡

	EffectTime *string `json:"effect_time,omitempty"` // 生效时间，精确到秒的时间戳

	FixshiftEffectTime *string `json:"fixshift_effect_time,omitempty"` // 固定班次生效时间，精确到秒的时间戳

	MemberEffectTime *string `json:"member_effect_time,omitempty"` // 参加考勤的人员、部门变动生效时间，精确到秒的时间戳

	RestClockInNeedApproval *bool `json:"rest_clockIn_need_approval,omitempty"` // 休息日打卡需审批

	ClockInNeedPhoto *bool `json:"clockIn_need_photo,omitempty"` // 每次打卡均需拍照

	MemberStatusChange *MemberStatusChange `json:"member_status_change,omitempty"` // 人员异动打卡设置

	LeaveNeedPunch *bool `json:"leave_need_punch,omitempty"` // 请假离岗或返岗是否需打卡

	LeaveNeedPunchCfg *LeaveNeedPunchCfg `json:"leave_need_punch_cfg,omitempty"` // 请假离岗或返岗打卡规则

	GoOutNeedPunch *int `json:"go_out_need_punch,omitempty"` // 外出期间是否需打卡

	GoOutNeedPunchCfg *LeaveNeedPunchCfg `json:"go_out_need_punch_cfg,omitempty"` // 外出期间打卡规则

	TravelNeedPunch *int `json:"travel_need_punch,omitempty"` // 出差期间是否需打卡

	TravelNeedPunchCfg *LeaveNeedPunchCfg `json:"travel_need_punch_cfg,omitempty"` // 出差期间打卡规则

	NeedPunchMembers []*PunchMember `json:"need_punch_members,omitempty"` // 需要打卡的人员配置（新）

	NoNeedPunchMembers []*PunchMember `json:"no_need_punch_members,omitempty"` // 无需打卡的人员配置（新）

	SaveAutoChanges *bool `json:"save_auto_changes,omitempty"` // 是否直接保存可以自动变更的冲突规则

	OrgChangeAutoAdjust *bool `json:"org_change_auto_adjust,omitempty"` // 人员异动开关（人员组织架构变更后是否允许自动调整到该考勤组）

	BindDefaultDeptIds []string `json:"bind_default_dept_ids,omitempty"` // 默认出勤的部门id列表

	BindDefaultUserIds []string `json:"bind_default_user_ids,omitempty"` // 默认出勤的用户ID列表

	OvertimeClockCfg *OvertimeClockCfg `json:"overtime_clock_cfg,omitempty"` // 加班打卡规则

	NewCalendarId *string `json:"new_calendar_id,omitempty"` // 节假日id，（如果考勤组使用了自定义节假日，请用此参数传入节假日id）

	AllowApplyPunch *bool `json:"allow_apply_punch,omitempty"` // 定位不准时是否允许申请打卡

	ClockInAbnormalSettings *ClockInAbnormalSettings `json:"clock_in_abnormal_settings,omitempty"` // 异常卡豁免配置
}

type GroupBuilder struct {
	groupId     string // 考勤组 ID（仅修改时提供）， 需要从“获取打卡结果”的接口中获取 groupId
	groupIdFlag bool

	groupName     string // 考勤组名称
	groupNameFlag bool

	timeZone     string // 时区
	timeZoneFlag bool

	bindDeptIds     []string // 绑定的部门 ID
	bindDeptIdsFlag bool

	exceptDeptIds     []string // 排除的部门 ID
	exceptDeptIdsFlag bool

	bindUserIds     []string // 绑定的用户 ID
	bindUserIdsFlag bool

	exceptUserIds     []string // 排除的用户 ID
	exceptUserIdsFlag bool

	groupLeaderIds     []string // 考勤主负责人 ID 列表，必选字段（需至少拥有考勤组管理员权限）
	groupLeaderIdsFlag bool

	subGroupLeaderIds     []string // 考勤子负责人 ID 列表
	subGroupLeaderIdsFlag bool

	allowOutPunch     bool // 是否允许外勤打卡
	allowOutPunchFlag bool

	outPunchNeedApproval     bool // 外勤打卡需审批（需要允许外勤打卡才能设置生效）
	outPunchNeedApprovalFlag bool

	outPunchNeedPostApproval     bool // 外勤打卡需审批，先打卡后审批（需要允许外勤打卡才能设置生效）
	outPunchNeedPostApprovalFlag bool

	outPunchNeedRemark     bool // 外勤打卡需填写备注（需要允许外勤打卡才能设置生效）
	outPunchNeedRemarkFlag bool

	outPunchNeedPhoto     bool // 外勤打卡需拍照（需要允许外勤打卡才能设置生效）
	outPunchNeedPhotoFlag bool

	outPunchAllowedHideAddr     bool // 外勤打卡允许员工隐藏详细地址（需要允许外勤打卡才能设置生效）
	outPunchAllowedHideAddrFlag bool

	outPunchAllowedAdjustAddr     bool // 外勤打卡允许微调地址（需要允许外勤打卡才能设置生效）
	outPunchAllowedAdjustAddrFlag bool

	adjustRange     int // 微调范围，默认为 50 米
	adjustRangeFlag bool

	allowPcPunch     bool // 是否允许 PC 端打卡
	allowPcPunchFlag bool

	allowRemedy     bool // 是否限制补卡
	allowRemedyFlag bool

	remedyLimit     bool // 是否限制补卡次数
	remedyLimitFlag bool

	remedyLimitCount     int // 补卡次数
	remedyLimitCountFlag bool

	remedyDateLimit     bool // 是否限制补卡时间
	remedyDateLimitFlag bool

	remedyDateNum     int // 补卡时间，几天内补卡
	remedyDateNumFlag bool

	allowRemedyTypeLack     bool // 允许缺卡补卡（需要允许补卡才能设置生效）
	allowRemedyTypeLackFlag bool

	allowRemedyTypeLate     bool // 允许迟到补卡（需要允许补卡才能设置生效）
	allowRemedyTypeLateFlag bool

	allowRemedyTypeEarly     bool // 允许早退补卡（需要允许补卡才能设置生效）
	allowRemedyTypeEarlyFlag bool

	allowRemedyTypeNormal     bool // 允许正常补卡（需要允许补卡才能设置生效）
	allowRemedyTypeNormalFlag bool

	showCumulativeTime     bool // 是否展示累计时长
	showCumulativeTimeFlag bool

	showOverTime     bool // 是否展示加班时长
	showOverTimeFlag bool

	hideStaffPunchTime     bool // 是否隐藏员工打卡详情
	hideStaffPunchTimeFlag bool

	hideClockInRule     bool // 是否隐藏打卡规则
	hideClockInRuleFlag bool

	facePunch     bool // 是否开启人脸识别打卡
	facePunchFlag bool

	facePunchCfg     int // 人脸识别打卡规则，1：每次打卡均需人脸识别，2：疑似作弊打卡时需要人脸识别
	facePunchCfgFlag bool

	faceLiveNeedAction     bool // 人脸打卡规则， false：开启活体验证 true：0动作验证，仅在 face_punch_cfg = 1 时有效
	faceLiveNeedActionFlag bool

	faceDowngrade     bool // 人脸识别失败时是否允许普通拍照打卡
	faceDowngradeFlag bool

	replaceBasicPic     bool // 人脸识别失败时是否允许替换基准图片
	replaceBasicPicFlag bool

	antiCheatPunchConfig     *AntiCheatConfig // 防作弊打卡配置
	antiCheatPunchConfigFlag bool

	machines     []*Machine // 考勤机列表
	machinesFlag bool

	gpsRange     int // GPS 打卡的有效范围（不建议使用）
	gpsRangeFlag bool

	locations     []*Location // 地址列表
	locationsFlag bool

	groupType     int // 考勤类型，0：固定班制，2：排班制， 3：自由班制
	groupTypeFlag bool

	punchDayShiftIds     []string // 固定班制必须填
	punchDayShiftIdsFlag bool

	freePunchCfg     *FreePunchCfg // 配置自由班制
	freePunchCfgFlag bool

	calendarId     int // 国家日历  ID，0：不根据国家日历排休，1：中国大陆，2：美国，3：日本，4：印度，5：新加坡，默认 1
	calendarIdFlag bool

	needPunchSpecialDays     []*PunchSpecialDateShift // 必须打卡的特殊日期
	needPunchSpecialDaysFlag bool

	noNeedPunchSpecialDays     []*PunchSpecialDateShift // 无需打卡的特殊日期
	noNeedPunchSpecialDaysFlag bool

	workDayNoPunchAsLack     bool // 自由班制下工作日不打卡是否记为缺卡
	workDayNoPunchAsLackFlag bool

	effectNow     bool // 是否立即生效，默认 false
	effectNowFlag bool

	remedyPeriodType     int // 补卡周期类型
	remedyPeriodTypeFlag bool

	remedyPeriodCustomDate     int // 补卡自定义周期起始日期
	remedyPeriodCustomDateFlag bool

	punchType     int // 打卡类型，位运算。1：GPS 打卡，2：Wi-Fi 打卡，4：考勤机打卡，8：IP 打卡
	punchTypeFlag bool

	effectTime     string // 生效时间，精确到秒的时间戳
	effectTimeFlag bool

	fixshiftEffectTime     string // 固定班次生效时间，精确到秒的时间戳
	fixshiftEffectTimeFlag bool

	memberEffectTime     string // 参加考勤的人员、部门变动生效时间，精确到秒的时间戳
	memberEffectTimeFlag bool

	restClockInNeedApproval     bool // 休息日打卡需审批
	restClockInNeedApprovalFlag bool

	clockInNeedPhoto     bool // 每次打卡均需拍照
	clockInNeedPhotoFlag bool

	memberStatusChange     *MemberStatusChange // 人员异动打卡设置
	memberStatusChangeFlag bool

	leaveNeedPunch     bool // 请假离岗或返岗是否需打卡
	leaveNeedPunchFlag bool

	leaveNeedPunchCfg     *LeaveNeedPunchCfg // 请假离岗或返岗打卡规则
	leaveNeedPunchCfgFlag bool

	goOutNeedPunch     int // 外出期间是否需打卡
	goOutNeedPunchFlag bool

	goOutNeedPunchCfg     *LeaveNeedPunchCfg // 外出期间打卡规则
	goOutNeedPunchCfgFlag bool

	travelNeedPunch     int // 出差期间是否需打卡
	travelNeedPunchFlag bool

	travelNeedPunchCfg     *LeaveNeedPunchCfg // 出差期间打卡规则
	travelNeedPunchCfgFlag bool

	needPunchMembers     []*PunchMember // 需要打卡的人员配置（新）
	needPunchMembersFlag bool

	noNeedPunchMembers     []*PunchMember // 无需打卡的人员配置（新）
	noNeedPunchMembersFlag bool

	saveAutoChanges     bool // 是否直接保存可以自动变更的冲突规则
	saveAutoChangesFlag bool

	orgChangeAutoAdjust     bool // 人员异动开关（人员组织架构变更后是否允许自动调整到该考勤组）
	orgChangeAutoAdjustFlag bool

	bindDefaultDeptIds     []string // 默认出勤的部门id列表
	bindDefaultDeptIdsFlag bool

	bindDefaultUserIds     []string // 默认出勤的用户ID列表
	bindDefaultUserIdsFlag bool

	overtimeClockCfg     *OvertimeClockCfg // 加班打卡规则
	overtimeClockCfgFlag bool

	newCalendarId     string // 节假日id，（如果考勤组使用了自定义节假日，请用此参数传入节假日id）
	newCalendarIdFlag bool

	allowApplyPunch     bool // 定位不准时是否允许申请打卡
	allowApplyPunchFlag bool

	clockInAbnormalSettings     *ClockInAbnormalSettings // 异常卡豁免配置
	clockInAbnormalSettingsFlag bool
}

func NewGroupBuilder() *GroupBuilder {
	builder := &GroupBuilder{}
	return builder
}

// 考勤组 ID（仅修改时提供）， 需要从“获取打卡结果”的接口中获取 groupId
//
// 示例值：6919358128597097404
func (builder *GroupBuilder) GroupId(groupId string) *GroupBuilder {
	builder.groupId = groupId
	builder.groupIdFlag = true
	return builder
}

// 考勤组名称
//
// 示例值：开心考勤
func (builder *GroupBuilder) GroupName(groupName string) *GroupBuilder {
	builder.groupName = groupName
	builder.groupNameFlag = true
	return builder
}

// 时区
//
// 示例值：Asia/Shanghai
func (builder *GroupBuilder) TimeZone(timeZone string) *GroupBuilder {
	builder.timeZone = timeZone
	builder.timeZoneFlag = true
	return builder
}

// 绑定的部门 ID
//
// 示例值：od-fcb45c28a45311afd440b7869541fce8
func (builder *GroupBuilder) BindDeptIds(bindDeptIds []string) *GroupBuilder {
	builder.bindDeptIds = bindDeptIds
	builder.bindDeptIdsFlag = true
	return builder
}

// 排除的部门 ID
//
// 示例值：od-fcb45c28a45311afd440b7869541fce8
func (builder *GroupBuilder) ExceptDeptIds(exceptDeptIds []string) *GroupBuilder {
	builder.exceptDeptIds = exceptDeptIds
	builder.exceptDeptIdsFlag = true
	return builder
}

// 绑定的用户 ID
//
// 示例值：52aa1fa1
func (builder *GroupBuilder) BindUserIds(bindUserIds []string) *GroupBuilder {
	builder.bindUserIds = bindUserIds
	builder.bindUserIdsFlag = true
	return builder
}

// 排除的用户 ID
//
// 示例值：52aa1fa1
func (builder *GroupBuilder) ExceptUserIds(exceptUserIds []string) *GroupBuilder {
	builder.exceptUserIds = exceptUserIds
	builder.exceptUserIdsFlag = true
	return builder
}

// 考勤主负责人 ID 列表，必选字段（需至少拥有考勤组管理员权限）
//
// 示例值：2bg4a9be
func (builder *GroupBuilder) GroupLeaderIds(groupLeaderIds []string) *GroupBuilder {
	builder.groupLeaderIds = groupLeaderIds
	builder.groupLeaderIdsFlag = true
	return builder
}

// 考勤子负责人 ID 列表
//
// 示例值：52aa1fa1
func (builder *GroupBuilder) SubGroupLeaderIds(subGroupLeaderIds []string) *GroupBuilder {
	builder.subGroupLeaderIds = subGroupLeaderIds
	builder.subGroupLeaderIdsFlag = true
	return builder
}

// 是否允许外勤打卡
//
// 示例值：true
func (builder *GroupBuilder) AllowOutPunch(allowOutPunch bool) *GroupBuilder {
	builder.allowOutPunch = allowOutPunch
	builder.allowOutPunchFlag = true
	return builder
}

// 外勤打卡需审批（需要允许外勤打卡才能设置生效）
//
// 示例值：true
func (builder *GroupBuilder) OutPunchNeedApproval(outPunchNeedApproval bool) *GroupBuilder {
	builder.outPunchNeedApproval = outPunchNeedApproval
	builder.outPunchNeedApprovalFlag = true
	return builder
}

// 外勤打卡需审批，先打卡后审批（需要允许外勤打卡才能设置生效）
//
// 示例值：true
func (builder *GroupBuilder) OutPunchNeedPostApproval(outPunchNeedPostApproval bool) *GroupBuilder {
	builder.outPunchNeedPostApproval = outPunchNeedPostApproval
	builder.outPunchNeedPostApprovalFlag = true
	return builder
}

// 外勤打卡需填写备注（需要允许外勤打卡才能设置生效）
//
// 示例值：true
func (builder *GroupBuilder) OutPunchNeedRemark(outPunchNeedRemark bool) *GroupBuilder {
	builder.outPunchNeedRemark = outPunchNeedRemark
	builder.outPunchNeedRemarkFlag = true
	return builder
}

// 外勤打卡需拍照（需要允许外勤打卡才能设置生效）
//
// 示例值：true
func (builder *GroupBuilder) OutPunchNeedPhoto(outPunchNeedPhoto bool) *GroupBuilder {
	builder.outPunchNeedPhoto = outPunchNeedPhoto
	builder.outPunchNeedPhotoFlag = true
	return builder
}

// 外勤打卡允许员工隐藏详细地址（需要允许外勤打卡才能设置生效）
//
// 示例值：true
func (builder *GroupBuilder) OutPunchAllowedHideAddr(outPunchAllowedHideAddr bool) *GroupBuilder {
	builder.outPunchAllowedHideAddr = outPunchAllowedHideAddr
	builder.outPunchAllowedHideAddrFlag = true
	return builder
}

// 外勤打卡允许微调地址（需要允许外勤打卡才能设置生效）
//
// 示例值：true
func (builder *GroupBuilder) OutPunchAllowedAdjustAddr(outPunchAllowedAdjustAddr bool) *GroupBuilder {
	builder.outPunchAllowedAdjustAddr = outPunchAllowedAdjustAddr
	builder.outPunchAllowedAdjustAddrFlag = true
	return builder
}

// 微调范围，默认为 50 米
//
// 示例值：50
func (builder *GroupBuilder) AdjustRange(adjustRange int) *GroupBuilder {
	builder.adjustRange = adjustRange
	builder.adjustRangeFlag = true
	return builder
}

// 是否允许 PC 端打卡
//
// 示例值：true
func (builder *GroupBuilder) AllowPcPunch(allowPcPunch bool) *GroupBuilder {
	builder.allowPcPunch = allowPcPunch
	builder.allowPcPunchFlag = true
	return builder
}

// 是否限制补卡
//
// 示例值：true
func (builder *GroupBuilder) AllowRemedy(allowRemedy bool) *GroupBuilder {
	builder.allowRemedy = allowRemedy
	builder.allowRemedyFlag = true
	return builder
}

// 是否限制补卡次数
//
// 示例值：true
func (builder *GroupBuilder) RemedyLimit(remedyLimit bool) *GroupBuilder {
	builder.remedyLimit = remedyLimit
	builder.remedyLimitFlag = true
	return builder
}

// 补卡次数
//
// 示例值：3
func (builder *GroupBuilder) RemedyLimitCount(remedyLimitCount int) *GroupBuilder {
	builder.remedyLimitCount = remedyLimitCount
	builder.remedyLimitCountFlag = true
	return builder
}

// 是否限制补卡时间
//
// 示例值：true
func (builder *GroupBuilder) RemedyDateLimit(remedyDateLimit bool) *GroupBuilder {
	builder.remedyDateLimit = remedyDateLimit
	builder.remedyDateLimitFlag = true
	return builder
}

// 补卡时间，几天内补卡
//
// 示例值：3
func (builder *GroupBuilder) RemedyDateNum(remedyDateNum int) *GroupBuilder {
	builder.remedyDateNum = remedyDateNum
	builder.remedyDateNumFlag = true
	return builder
}

// 允许缺卡补卡（需要允许补卡才能设置生效）
//
// 示例值：true
func (builder *GroupBuilder) AllowRemedyTypeLack(allowRemedyTypeLack bool) *GroupBuilder {
	builder.allowRemedyTypeLack = allowRemedyTypeLack
	builder.allowRemedyTypeLackFlag = true
	return builder
}

// 允许迟到补卡（需要允许补卡才能设置生效）
//
// 示例值：true
func (builder *GroupBuilder) AllowRemedyTypeLate(allowRemedyTypeLate bool) *GroupBuilder {
	builder.allowRemedyTypeLate = allowRemedyTypeLate
	builder.allowRemedyTypeLateFlag = true
	return builder
}

// 允许早退补卡（需要允许补卡才能设置生效）
//
// 示例值：true
func (builder *GroupBuilder) AllowRemedyTypeEarly(allowRemedyTypeEarly bool) *GroupBuilder {
	builder.allowRemedyTypeEarly = allowRemedyTypeEarly
	builder.allowRemedyTypeEarlyFlag = true
	return builder
}

// 允许正常补卡（需要允许补卡才能设置生效）
//
// 示例值：true
func (builder *GroupBuilder) AllowRemedyTypeNormal(allowRemedyTypeNormal bool) *GroupBuilder {
	builder.allowRemedyTypeNormal = allowRemedyTypeNormal
	builder.allowRemedyTypeNormalFlag = true
	return builder
}

// 是否展示累计时长
//
// 示例值：true
func (builder *GroupBuilder) ShowCumulativeTime(showCumulativeTime bool) *GroupBuilder {
	builder.showCumulativeTime = showCumulativeTime
	builder.showCumulativeTimeFlag = true
	return builder
}

// 是否展示加班时长
//
// 示例值：true
func (builder *GroupBuilder) ShowOverTime(showOverTime bool) *GroupBuilder {
	builder.showOverTime = showOverTime
	builder.showOverTimeFlag = true
	return builder
}

// 是否隐藏员工打卡详情
//
// 示例值：true
func (builder *GroupBuilder) HideStaffPunchTime(hideStaffPunchTime bool) *GroupBuilder {
	builder.hideStaffPunchTime = hideStaffPunchTime
	builder.hideStaffPunchTimeFlag = true
	return builder
}

// 是否隐藏打卡规则
//
// 示例值：false
func (builder *GroupBuilder) HideClockInRule(hideClockInRule bool) *GroupBuilder {
	builder.hideClockInRule = hideClockInRule
	builder.hideClockInRuleFlag = true
	return builder
}

// 是否开启人脸识别打卡
//
// 示例值：true
func (builder *GroupBuilder) FacePunch(facePunch bool) *GroupBuilder {
	builder.facePunch = facePunch
	builder.facePunchFlag = true
	return builder
}

// 人脸识别打卡规则，1：每次打卡均需人脸识别，2：疑似作弊打卡时需要人脸识别
//
// 示例值：1
func (builder *GroupBuilder) FacePunchCfg(facePunchCfg int) *GroupBuilder {
	builder.facePunchCfg = facePunchCfg
	builder.facePunchCfgFlag = true
	return builder
}

// 人脸打卡规则， false：开启活体验证 true：0动作验证，仅在 face_punch_cfg = 1 时有效
//
// 示例值：false
func (builder *GroupBuilder) FaceLiveNeedAction(faceLiveNeedAction bool) *GroupBuilder {
	builder.faceLiveNeedAction = faceLiveNeedAction
	builder.faceLiveNeedActionFlag = true
	return builder
}

// 人脸识别失败时是否允许普通拍照打卡
//
// 示例值：true
func (builder *GroupBuilder) FaceDowngrade(faceDowngrade bool) *GroupBuilder {
	builder.faceDowngrade = faceDowngrade
	builder.faceDowngradeFlag = true
	return builder
}

// 人脸识别失败时是否允许替换基准图片
//
// 示例值：true
func (builder *GroupBuilder) ReplaceBasicPic(replaceBasicPic bool) *GroupBuilder {
	builder.replaceBasicPic = replaceBasicPic
	builder.replaceBasicPicFlag = true
	return builder
}

// 防作弊打卡配置
//
// 示例值：
func (builder *GroupBuilder) AntiCheatPunchConfig(antiCheatPunchConfig *AntiCheatConfig) *GroupBuilder {
	builder.antiCheatPunchConfig = antiCheatPunchConfig
	builder.antiCheatPunchConfigFlag = true
	return builder
}

// 考勤机列表
//
// 示例值：
func (builder *GroupBuilder) Machines(machines []*Machine) *GroupBuilder {
	builder.machines = machines
	builder.machinesFlag = true
	return builder
}

// GPS 打卡的有效范围（不建议使用）
//
// 示例值：300
func (builder *GroupBuilder) GpsRange(gpsRange int) *GroupBuilder {
	builder.gpsRange = gpsRange
	builder.gpsRangeFlag = true
	return builder
}

// 地址列表
//
// 示例值：
func (builder *GroupBuilder) Locations(locations []*Location) *GroupBuilder {
	builder.locations = locations
	builder.locationsFlag = true
	return builder
}

// 考勤类型，0：固定班制，2：排班制， 3：自由班制
//
// 示例值：0
func (builder *GroupBuilder) GroupType(groupType int) *GroupBuilder {
	builder.groupType = groupType
	builder.groupTypeFlag = true
	return builder
}

// 固定班制必须填
//
// 示例值：6921319402260496386
func (builder *GroupBuilder) PunchDayShiftIds(punchDayShiftIds []string) *GroupBuilder {
	builder.punchDayShiftIds = punchDayShiftIds
	builder.punchDayShiftIdsFlag = true
	return builder
}

// 配置自由班制
//
// 示例值：
func (builder *GroupBuilder) FreePunchCfg(freePunchCfg *FreePunchCfg) *GroupBuilder {
	builder.freePunchCfg = freePunchCfg
	builder.freePunchCfgFlag = true
	return builder
}

// 国家日历  ID，0：不根据国家日历排休，1：中国大陆，2：美国，3：日本，4：印度，5：新加坡，默认 1
//
// 示例值：1
func (builder *GroupBuilder) CalendarId(calendarId int) *GroupBuilder {
	builder.calendarId = calendarId
	builder.calendarIdFlag = true
	return builder
}

// 必须打卡的特殊日期
//
// 示例值：
func (builder *GroupBuilder) NeedPunchSpecialDays(needPunchSpecialDays []*PunchSpecialDateShift) *GroupBuilder {
	builder.needPunchSpecialDays = needPunchSpecialDays
	builder.needPunchSpecialDaysFlag = true
	return builder
}

// 无需打卡的特殊日期
//
// 示例值：
func (builder *GroupBuilder) NoNeedPunchSpecialDays(noNeedPunchSpecialDays []*PunchSpecialDateShift) *GroupBuilder {
	builder.noNeedPunchSpecialDays = noNeedPunchSpecialDays
	builder.noNeedPunchSpecialDaysFlag = true
	return builder
}

// 自由班制下工作日不打卡是否记为缺卡
//
// 示例值：true
func (builder *GroupBuilder) WorkDayNoPunchAsLack(workDayNoPunchAsLack bool) *GroupBuilder {
	builder.workDayNoPunchAsLack = workDayNoPunchAsLack
	builder.workDayNoPunchAsLackFlag = true
	return builder
}

// 是否立即生效，默认 false
//
// 示例值：true
func (builder *GroupBuilder) EffectNow(effectNow bool) *GroupBuilder {
	builder.effectNow = effectNow
	builder.effectNowFlag = true
	return builder
}

// 补卡周期类型
//
// 示例值：0
func (builder *GroupBuilder) RemedyPeriodType(remedyPeriodType int) *GroupBuilder {
	builder.remedyPeriodType = remedyPeriodType
	builder.remedyPeriodTypeFlag = true
	return builder
}

// 补卡自定义周期起始日期
//
// 示例值：1
func (builder *GroupBuilder) RemedyPeriodCustomDate(remedyPeriodCustomDate int) *GroupBuilder {
	builder.remedyPeriodCustomDate = remedyPeriodCustomDate
	builder.remedyPeriodCustomDateFlag = true
	return builder
}

// 打卡类型，位运算。1：GPS 打卡，2：Wi-Fi 打卡，4：考勤机打卡，8：IP 打卡
//
// 示例值：1
func (builder *GroupBuilder) PunchType(punchType int) *GroupBuilder {
	builder.punchType = punchType
	builder.punchTypeFlag = true
	return builder
}

// 生效时间，精确到秒的时间戳
//
// 示例值：1611476284
func (builder *GroupBuilder) EffectTime(effectTime string) *GroupBuilder {
	builder.effectTime = effectTime
	builder.effectTimeFlag = true
	return builder
}

// 固定班次生效时间，精确到秒的时间戳
//
// 示例值：1611476284
func (builder *GroupBuilder) FixshiftEffectTime(fixshiftEffectTime string) *GroupBuilder {
	builder.fixshiftEffectTime = fixshiftEffectTime
	builder.fixshiftEffectTimeFlag = true
	return builder
}

// 参加考勤的人员、部门变动生效时间，精确到秒的时间戳
//
// 示例值：1611476284
func (builder *GroupBuilder) MemberEffectTime(memberEffectTime string) *GroupBuilder {
	builder.memberEffectTime = memberEffectTime
	builder.memberEffectTimeFlag = true
	return builder
}

// 休息日打卡需审批
//
// 示例值：true
func (builder *GroupBuilder) RestClockInNeedApproval(restClockInNeedApproval bool) *GroupBuilder {
	builder.restClockInNeedApproval = restClockInNeedApproval
	builder.restClockInNeedApprovalFlag = true
	return builder
}

// 每次打卡均需拍照
//
// 示例值：true
func (builder *GroupBuilder) ClockInNeedPhoto(clockInNeedPhoto bool) *GroupBuilder {
	builder.clockInNeedPhoto = clockInNeedPhoto
	builder.clockInNeedPhotoFlag = true
	return builder
}

// 人员异动打卡设置
//
// 示例值：
func (builder *GroupBuilder) MemberStatusChange(memberStatusChange *MemberStatusChange) *GroupBuilder {
	builder.memberStatusChange = memberStatusChange
	builder.memberStatusChangeFlag = true
	return builder
}

// 请假离岗或返岗是否需打卡
//
// 示例值：false
func (builder *GroupBuilder) LeaveNeedPunch(leaveNeedPunch bool) *GroupBuilder {
	builder.leaveNeedPunch = leaveNeedPunch
	builder.leaveNeedPunchFlag = true
	return builder
}

// 请假离岗或返岗打卡规则
//
// 示例值：
func (builder *GroupBuilder) LeaveNeedPunchCfg(leaveNeedPunchCfg *LeaveNeedPunchCfg) *GroupBuilder {
	builder.leaveNeedPunchCfg = leaveNeedPunchCfg
	builder.leaveNeedPunchCfgFlag = true
	return builder
}

// 外出期间是否需打卡
//
// 示例值：0
func (builder *GroupBuilder) GoOutNeedPunch(goOutNeedPunch int) *GroupBuilder {
	builder.goOutNeedPunch = goOutNeedPunch
	builder.goOutNeedPunchFlag = true
	return builder
}

// 外出期间打卡规则
//
// 示例值：
func (builder *GroupBuilder) GoOutNeedPunchCfg(goOutNeedPunchCfg *LeaveNeedPunchCfg) *GroupBuilder {
	builder.goOutNeedPunchCfg = goOutNeedPunchCfg
	builder.goOutNeedPunchCfgFlag = true
	return builder
}

// 出差期间是否需打卡
//
// 示例值：0
func (builder *GroupBuilder) TravelNeedPunch(travelNeedPunch int) *GroupBuilder {
	builder.travelNeedPunch = travelNeedPunch
	builder.travelNeedPunchFlag = true
	return builder
}

// 出差期间打卡规则
//
// 示例值：
func (builder *GroupBuilder) TravelNeedPunchCfg(travelNeedPunchCfg *LeaveNeedPunchCfg) *GroupBuilder {
	builder.travelNeedPunchCfg = travelNeedPunchCfg
	builder.travelNeedPunchCfgFlag = true
	return builder
}

// 需要打卡的人员配置（新）
//
// 示例值：
func (builder *GroupBuilder) NeedPunchMembers(needPunchMembers []*PunchMember) *GroupBuilder {
	builder.needPunchMembers = needPunchMembers
	builder.needPunchMembersFlag = true
	return builder
}

// 无需打卡的人员配置（新）
//
// 示例值：
func (builder *GroupBuilder) NoNeedPunchMembers(noNeedPunchMembers []*PunchMember) *GroupBuilder {
	builder.noNeedPunchMembers = noNeedPunchMembers
	builder.noNeedPunchMembersFlag = true
	return builder
}

// 是否直接保存可以自动变更的冲突规则
//
// 示例值：false
func (builder *GroupBuilder) SaveAutoChanges(saveAutoChanges bool) *GroupBuilder {
	builder.saveAutoChanges = saveAutoChanges
	builder.saveAutoChangesFlag = true
	return builder
}

// 人员异动开关（人员组织架构变更后是否允许自动调整到该考勤组）
//
// 示例值：false
func (builder *GroupBuilder) OrgChangeAutoAdjust(orgChangeAutoAdjust bool) *GroupBuilder {
	builder.orgChangeAutoAdjust = orgChangeAutoAdjust
	builder.orgChangeAutoAdjustFlag = true
	return builder
}

// 默认出勤的部门id列表
//
// 示例值：
func (builder *GroupBuilder) BindDefaultDeptIds(bindDefaultDeptIds []string) *GroupBuilder {
	builder.bindDefaultDeptIds = bindDefaultDeptIds
	builder.bindDefaultDeptIdsFlag = true
	return builder
}

// 默认出勤的用户ID列表
//
// 示例值：
func (builder *GroupBuilder) BindDefaultUserIds(bindDefaultUserIds []string) *GroupBuilder {
	builder.bindDefaultUserIds = bindDefaultUserIds
	builder.bindDefaultUserIdsFlag = true
	return builder
}

// 加班打卡规则
//
// 示例值：
func (builder *GroupBuilder) OvertimeClockCfg(overtimeClockCfg *OvertimeClockCfg) *GroupBuilder {
	builder.overtimeClockCfg = overtimeClockCfg
	builder.overtimeClockCfgFlag = true
	return builder
}

// 节假日id，（如果考勤组使用了自定义节假日，请用此参数传入节假日id）
//
// 示例值：通过查询考勤组接口获取的new_calendar_id，例如7302191700771358252
func (builder *GroupBuilder) NewCalendarId(newCalendarId string) *GroupBuilder {
	builder.newCalendarId = newCalendarId
	builder.newCalendarIdFlag = true
	return builder
}

// 定位不准时是否允许申请打卡
//
// 示例值：true
func (builder *GroupBuilder) AllowApplyPunch(allowApplyPunch bool) *GroupBuilder {
	builder.allowApplyPunch = allowApplyPunch
	builder.allowApplyPunchFlag = true
	return builder
}

// 异常卡豁免配置
//
// 示例值：
func (builder *GroupBuilder) ClockInAbnormalSettings(clockInAbnormalSettings *ClockInAbnormalSettings) *GroupBuilder {
	builder.clockInAbnormalSettings = clockInAbnormalSettings
	builder.clockInAbnormalSettingsFlag = true
	return builder
}

func (builder *GroupBuilder) Build() *Group {
	req := &Group{}
	if builder.groupIdFlag {
		req.GroupId = &builder.groupId

	}
	if builder.groupNameFlag {
		req.GroupName = &builder.groupName

	}
	if builder.timeZoneFlag {
		req.TimeZone = &builder.timeZone

	}
	if builder.bindDeptIdsFlag {
		req.BindDeptIds = builder.bindDeptIds
	}
	if builder.exceptDeptIdsFlag {
		req.ExceptDeptIds = builder.exceptDeptIds
	}
	if builder.bindUserIdsFlag {
		req.BindUserIds = builder.bindUserIds
	}
	if builder.exceptUserIdsFlag {
		req.ExceptUserIds = builder.exceptUserIds
	}
	if builder.groupLeaderIdsFlag {
		req.GroupLeaderIds = builder.groupLeaderIds
	}
	if builder.subGroupLeaderIdsFlag {
		req.SubGroupLeaderIds = builder.subGroupLeaderIds
	}
	if builder.allowOutPunchFlag {
		req.AllowOutPunch = &builder.allowOutPunch

	}
	if builder.outPunchNeedApprovalFlag {
		req.OutPunchNeedApproval = &builder.outPunchNeedApproval

	}
	if builder.outPunchNeedPostApprovalFlag {
		req.OutPunchNeedPostApproval = &builder.outPunchNeedPostApproval

	}
	if builder.outPunchNeedRemarkFlag {
		req.OutPunchNeedRemark = &builder.outPunchNeedRemark

	}
	if builder.outPunchNeedPhotoFlag {
		req.OutPunchNeedPhoto = &builder.outPunchNeedPhoto

	}
	if builder.outPunchAllowedHideAddrFlag {
		req.OutPunchAllowedHideAddr = &builder.outPunchAllowedHideAddr

	}
	if builder.outPunchAllowedAdjustAddrFlag {
		req.OutPunchAllowedAdjustAddr = &builder.outPunchAllowedAdjustAddr

	}
	if builder.adjustRangeFlag {
		req.AdjustRange = &builder.adjustRange

	}
	if builder.allowPcPunchFlag {
		req.AllowPcPunch = &builder.allowPcPunch

	}
	if builder.allowRemedyFlag {
		req.AllowRemedy = &builder.allowRemedy

	}
	if builder.remedyLimitFlag {
		req.RemedyLimit = &builder.remedyLimit

	}
	if builder.remedyLimitCountFlag {
		req.RemedyLimitCount = &builder.remedyLimitCount

	}
	if builder.remedyDateLimitFlag {
		req.RemedyDateLimit = &builder.remedyDateLimit

	}
	if builder.remedyDateNumFlag {
		req.RemedyDateNum = &builder.remedyDateNum

	}
	if builder.allowRemedyTypeLackFlag {
		req.AllowRemedyTypeLack = &builder.allowRemedyTypeLack

	}
	if builder.allowRemedyTypeLateFlag {
		req.AllowRemedyTypeLate = &builder.allowRemedyTypeLate

	}
	if builder.allowRemedyTypeEarlyFlag {
		req.AllowRemedyTypeEarly = &builder.allowRemedyTypeEarly

	}
	if builder.allowRemedyTypeNormalFlag {
		req.AllowRemedyTypeNormal = &builder.allowRemedyTypeNormal

	}
	if builder.showCumulativeTimeFlag {
		req.ShowCumulativeTime = &builder.showCumulativeTime

	}
	if builder.showOverTimeFlag {
		req.ShowOverTime = &builder.showOverTime

	}
	if builder.hideStaffPunchTimeFlag {
		req.HideStaffPunchTime = &builder.hideStaffPunchTime

	}
	if builder.hideClockInRuleFlag {
		req.HideClockInRule = &builder.hideClockInRule

	}
	if builder.facePunchFlag {
		req.FacePunch = &builder.facePunch

	}
	if builder.facePunchCfgFlag {
		req.FacePunchCfg = &builder.facePunchCfg

	}
	if builder.faceLiveNeedActionFlag {
		req.FaceLiveNeedAction = &builder.faceLiveNeedAction

	}
	if builder.faceDowngradeFlag {
		req.FaceDowngrade = &builder.faceDowngrade

	}
	if builder.replaceBasicPicFlag {
		req.ReplaceBasicPic = &builder.replaceBasicPic

	}
	if builder.antiCheatPunchConfigFlag {
		req.AntiCheatPunchConfig = builder.antiCheatPunchConfig
	}
	if builder.machinesFlag {
		req.Machines = builder.machines
	}
	if builder.gpsRangeFlag {
		req.GpsRange = &builder.gpsRange

	}
	if builder.locationsFlag {
		req.Locations = builder.locations
	}
	if builder.groupTypeFlag {
		req.GroupType = &builder.groupType

	}
	if builder.punchDayShiftIdsFlag {
		req.PunchDayShiftIds = builder.punchDayShiftIds
	}
	if builder.freePunchCfgFlag {
		req.FreePunchCfg = builder.freePunchCfg
	}
	if builder.calendarIdFlag {
		req.CalendarId = &builder.calendarId

	}
	if builder.needPunchSpecialDaysFlag {
		req.NeedPunchSpecialDays = builder.needPunchSpecialDays
	}
	if builder.noNeedPunchSpecialDaysFlag {
		req.NoNeedPunchSpecialDays = builder.noNeedPunchSpecialDays
	}
	if builder.workDayNoPunchAsLackFlag {
		req.WorkDayNoPunchAsLack = &builder.workDayNoPunchAsLack

	}
	if builder.effectNowFlag {
		req.EffectNow = &builder.effectNow

	}
	if builder.remedyPeriodTypeFlag {
		req.RemedyPeriodType = &builder.remedyPeriodType

	}
	if builder.remedyPeriodCustomDateFlag {
		req.RemedyPeriodCustomDate = &builder.remedyPeriodCustomDate

	}
	if builder.punchTypeFlag {
		req.PunchType = &builder.punchType

	}
	if builder.effectTimeFlag {
		req.EffectTime = &builder.effectTime

	}
	if builder.fixshiftEffectTimeFlag {
		req.FixshiftEffectTime = &builder.fixshiftEffectTime

	}
	if builder.memberEffectTimeFlag {
		req.MemberEffectTime = &builder.memberEffectTime

	}
	if builder.restClockInNeedApprovalFlag {
		req.RestClockInNeedApproval = &builder.restClockInNeedApproval

	}
	if builder.clockInNeedPhotoFlag {
		req.ClockInNeedPhoto = &builder.clockInNeedPhoto

	}
	if builder.memberStatusChangeFlag {
		req.MemberStatusChange = builder.memberStatusChange
	}
	if builder.leaveNeedPunchFlag {
		req.LeaveNeedPunch = &builder.leaveNeedPunch

	}
	if builder.leaveNeedPunchCfgFlag {
		req.LeaveNeedPunchCfg = builder.leaveNeedPunchCfg
	}
	if builder.goOutNeedPunchFlag {
		req.GoOutNeedPunch = &builder.goOutNeedPunch

	}
	if builder.goOutNeedPunchCfgFlag {
		req.GoOutNeedPunchCfg = builder.goOutNeedPunchCfg
	}
	if builder.travelNeedPunchFlag {
		req.TravelNeedPunch = &builder.travelNeedPunch

	}
	if builder.travelNeedPunchCfgFlag {
		req.TravelNeedPunchCfg = builder.travelNeedPunchCfg
	}
	if builder.needPunchMembersFlag {
		req.NeedPunchMembers = builder.needPunchMembers
	}
	if builder.noNeedPunchMembersFlag {
		req.NoNeedPunchMembers = builder.noNeedPunchMembers
	}
	if builder.saveAutoChangesFlag {
		req.SaveAutoChanges = &builder.saveAutoChanges

	}
	if builder.orgChangeAutoAdjustFlag {
		req.OrgChangeAutoAdjust = &builder.orgChangeAutoAdjust

	}
	if builder.bindDefaultDeptIdsFlag {
		req.BindDefaultDeptIds = builder.bindDefaultDeptIds
	}
	if builder.bindDefaultUserIdsFlag {
		req.BindDefaultUserIds = builder.bindDefaultUserIds
	}
	if builder.overtimeClockCfgFlag {
		req.OvertimeClockCfg = builder.overtimeClockCfg
	}
	if builder.newCalendarIdFlag {
		req.NewCalendarId = &builder.newCalendarId

	}
	if builder.allowApplyPunchFlag {
		req.AllowApplyPunch = &builder.allowApplyPunch

	}
	if builder.clockInAbnormalSettingsFlag {
		req.ClockInAbnormalSettings = builder.clockInAbnormalSettings
	}
	return req
}

type GroupMeta struct {
	GroupId *string `json:"group_id,omitempty"` // 考勤组 ID

	GroupName *string `json:"group_name,omitempty"` // 考勤组名称
}

type GroupMetaBuilder struct {
	groupId     string // 考勤组 ID
	groupIdFlag bool

	groupName     string // 考勤组名称
	groupNameFlag bool
}

func NewGroupMetaBuilder() *GroupMetaBuilder {
	builder := &GroupMetaBuilder{}
	return builder
}

// 考勤组 ID
//
// 示例值：6919358128597097404
func (builder *GroupMetaBuilder) GroupId(groupId string) *GroupMetaBuilder {
	builder.groupId = groupId
	builder.groupIdFlag = true
	return builder
}

// 考勤组名称
//
// 示例值：考勤组1
func (builder *GroupMetaBuilder) GroupName(groupName string) *GroupMetaBuilder {
	builder.groupName = groupName
	builder.groupNameFlag = true
	return builder
}

func (builder *GroupMetaBuilder) Build() *GroupMeta {
	req := &GroupMeta{}
	if builder.groupIdFlag {
		req.GroupId = &builder.groupId

	}
	if builder.groupNameFlag {
		req.GroupName = &builder.groupName

	}
	return req
}

type I18nMap struct {
	Zh *string `json:"zh,omitempty"` // 中文名称

	En *string `json:"en,omitempty"` // 英文名称

	Ja *string `json:"ja,omitempty"` // 日文名称
}

type I18nMapBuilder struct {
	zh     string // 中文名称
	zhFlag bool

	en     string // 英文名称
	enFlag bool

	ja     string // 日文名称
	jaFlag bool
}

func NewI18nMapBuilder() *I18nMapBuilder {
	builder := &I18nMapBuilder{}
	return builder
}

// 中文名称
//
// 示例值：1
func (builder *I18nMapBuilder) Zh(zh string) *I18nMapBuilder {
	builder.zh = zh
	builder.zhFlag = true
	return builder
}

// 英文名称
//
// 示例值：alice
func (builder *I18nMapBuilder) En(en string) *I18nMapBuilder {
	builder.en = en
	builder.enFlag = true
	return builder
}

// 日文名称
//
// 示例值：1
func (builder *I18nMapBuilder) Ja(ja string) *I18nMapBuilder {
	builder.ja = ja
	builder.jaFlag = true
	return builder
}

func (builder *I18nMapBuilder) Build() *I18nMap {
	req := &I18nMap{}
	if builder.zhFlag {
		req.Zh = &builder.zh

	}
	if builder.enFlag {
		req.En = &builder.en

	}
	if builder.jaFlag {
		req.Ja = &builder.ja

	}
	return req
}

type I18nNames struct {
	Ch *string `json:"ch,omitempty"` // 中文描述

	En *string `json:"en,omitempty"` // 英语描述

	Ja *string `json:"ja,omitempty"` // 日语描述
}

type I18nNamesBuilder struct {
	ch     string // 中文描述
	chFlag bool

	en     string // 英语描述
	enFlag bool

	ja     string // 日语描述
	jaFlag bool
}

func NewI18nNamesBuilder() *I18nNamesBuilder {
	builder := &I18nNamesBuilder{}
	return builder
}

// 中文描述
//
// 示例值：中文描述
func (builder *I18nNamesBuilder) Ch(ch string) *I18nNamesBuilder {
	builder.ch = ch
	builder.chFlag = true
	return builder
}

// 英语描述
//
// 示例值：English description
func (builder *I18nNamesBuilder) En(en string) *I18nNamesBuilder {
	builder.en = en
	builder.enFlag = true
	return builder
}

// 日语描述
//
// 示例值：日本語の説明
func (builder *I18nNamesBuilder) Ja(ja string) *I18nNamesBuilder {
	builder.ja = ja
	builder.jaFlag = true
	return builder
}

func (builder *I18nNamesBuilder) Build() *I18nNames {
	req := &I18nNames{}
	if builder.chFlag {
		req.Ch = &builder.ch

	}
	if builder.enFlag {
		req.En = &builder.en

	}
	if builder.jaFlag {
		req.Ja = &builder.ja

	}
	return req
}

type I18nResource struct {
	Text *string `json:"text,omitempty"` // 文本

	Local *string `json:"local,omitempty"` // 语言类型

	IsDefault *bool `json:"is_default,omitempty"` // 是否默认
}

type I18nResourceBuilder struct {
	text     string // 文本
	textFlag bool

	local     string // 语言类型
	localFlag bool

	isDefault     bool // 是否默认
	isDefaultFlag bool
}

func NewI18nResourceBuilder() *I18nResourceBuilder {
	builder := &I18nResourceBuilder{}
	return builder
}

// 文本
//
// 示例值：日期
func (builder *I18nResourceBuilder) Text(text string) *I18nResourceBuilder {
	builder.text = text
	builder.textFlag = true
	return builder
}

// 语言类型
//
// 示例值：zh
func (builder *I18nResourceBuilder) Local(local string) *I18nResourceBuilder {
	builder.local = local
	builder.localFlag = true
	return builder
}

// 是否默认
//
// 示例值：true
func (builder *I18nResourceBuilder) IsDefault(isDefault bool) *I18nResourceBuilder {
	builder.isDefault = isDefault
	builder.isDefaultFlag = true
	return builder
}

func (builder *I18nResourceBuilder) Build() *I18nResource {
	req := &I18nResource{}
	if builder.textFlag {
		req.Text = &builder.text

	}
	if builder.localFlag {
		req.Local = &builder.local

	}
	if builder.isDefaultFlag {
		req.IsDefault = &builder.isDefault

	}
	return req
}

type Item struct {
	Code *string `json:"code,omitempty"` // 标题编号

	Title *string `json:"title,omitempty"` // 标题名称

	ChildItems []*ChildItem `json:"child_items,omitempty"` // 子标题
}

type ItemBuilder struct {
	code     string // 标题编号
	codeFlag bool

	title     string // 标题名称
	titleFlag bool

	childItems     []*ChildItem // 子标题
	childItemsFlag bool
}

func NewItemBuilder() *ItemBuilder {
	builder := &ItemBuilder{}
	return builder
}

// 标题编号
//
// 示例值：522
func (builder *ItemBuilder) Code(code string) *ItemBuilder {
	builder.code = code
	builder.codeFlag = true
	return builder
}

// 标题名称
//
// 示例值：基本信息
func (builder *ItemBuilder) Title(title string) *ItemBuilder {
	builder.title = title
	builder.titleFlag = true
	return builder
}

// 子标题
//
// 示例值：
func (builder *ItemBuilder) ChildItems(childItems []*ChildItem) *ItemBuilder {
	builder.childItems = childItems
	builder.childItemsFlag = true
	return builder
}

func (builder *ItemBuilder) Build() *Item {
	req := &Item{}
	if builder.codeFlag {
		req.Code = &builder.code

	}
	if builder.titleFlag {
		req.Title = &builder.title

	}
	if builder.childItemsFlag {
		req.ChildItems = builder.childItems
	}
	return req
}

type LangText struct {
	Lang *string `json:"lang,omitempty"` // 语言码

	Value *string `json:"value,omitempty"` // 语言码对应的文本
}

type LangTextBuilder struct {
	lang     string // 语言码
	langFlag bool

	value     string // 语言码对应的文本
	valueFlag bool
}

func NewLangTextBuilder() *LangTextBuilder {
	builder := &LangTextBuilder{}
	return builder
}

// 语言码
//
// 示例值：cn_zh
func (builder *LangTextBuilder) Lang(lang string) *LangTextBuilder {
	builder.lang = lang
	builder.langFlag = true
	return builder
}

// 语言码对应的文本
//
// 示例值：test
func (builder *LangTextBuilder) Value(value string) *LangTextBuilder {
	builder.value = value
	builder.valueFlag = true
	return builder
}

func (builder *LangTextBuilder) Build() *LangText {
	req := &LangText{}
	if builder.langFlag {
		req.Lang = &builder.lang

	}
	if builder.valueFlag {
		req.Value = &builder.value

	}
	return req
}

type LateOffLateOnRule struct {
	LateOffMinutes *int `json:"late_off_minutes,omitempty"` // 晚走多久

	LateOnMinutes *int `json:"late_on_minutes,omitempty"` // 晚到多久
}

type LateOffLateOnRuleBuilder struct {
	lateOffMinutes     int // 晚走多久
	lateOffMinutesFlag bool

	lateOnMinutes     int // 晚到多久
	lateOnMinutesFlag bool
}

func NewLateOffLateOnRuleBuilder() *LateOffLateOnRuleBuilder {
	builder := &LateOffLateOnRuleBuilder{}
	return builder
}

// 晚走多久
//
// 示例值：60
func (builder *LateOffLateOnRuleBuilder) LateOffMinutes(lateOffMinutes int) *LateOffLateOnRuleBuilder {
	builder.lateOffMinutes = lateOffMinutes
	builder.lateOffMinutesFlag = true
	return builder
}

// 晚到多久
//
// 示例值：30
func (builder *LateOffLateOnRuleBuilder) LateOnMinutes(lateOnMinutes int) *LateOffLateOnRuleBuilder {
	builder.lateOnMinutes = lateOnMinutes
	builder.lateOnMinutesFlag = true
	return builder
}

func (builder *LateOffLateOnRuleBuilder) Build() *LateOffLateOnRule {
	req := &LateOffLateOnRule{}
	if builder.lateOffMinutesFlag {
		req.LateOffMinutes = &builder.lateOffMinutes

	}
	if builder.lateOnMinutesFlag {
		req.LateOnMinutes = &builder.lateOnMinutes

	}
	return req
}

type LateOffLateOnSetting struct {
	LateOffBaseOnTimeType *int `json:"late_off_base_on_time_type,omitempty"` // 当日晚走时间计算规则

	LateOnBaseOnTimeType *int `json:"late_on_base_on_time_type,omitempty"` // 次日晚到时间计算规则
}

type LateOffLateOnSettingBuilder struct {
	lateOffBaseOnTimeType     int // 当日晚走时间计算规则
	lateOffBaseOnTimeTypeFlag bool

	lateOnBaseOnTimeType     int // 次日晚到时间计算规则
	lateOnBaseOnTimeTypeFlag bool
}

func NewLateOffLateOnSettingBuilder() *LateOffLateOnSettingBuilder {
	builder := &LateOffLateOnSettingBuilder{}
	return builder
}

// 当日晚走时间计算规则
//
// 示例值：0
func (builder *LateOffLateOnSettingBuilder) LateOffBaseOnTimeType(lateOffBaseOnTimeType int) *LateOffLateOnSettingBuilder {
	builder.lateOffBaseOnTimeType = lateOffBaseOnTimeType
	builder.lateOffBaseOnTimeTypeFlag = true
	return builder
}

// 次日晚到时间计算规则
//
// 示例值：0
func (builder *LateOffLateOnSettingBuilder) LateOnBaseOnTimeType(lateOnBaseOnTimeType int) *LateOffLateOnSettingBuilder {
	builder.lateOnBaseOnTimeType = lateOnBaseOnTimeType
	builder.lateOnBaseOnTimeTypeFlag = true
	return builder
}

func (builder *LateOffLateOnSettingBuilder) Build() *LateOffLateOnSetting {
	req := &LateOffLateOnSetting{}
	if builder.lateOffBaseOnTimeTypeFlag {
		req.LateOffBaseOnTimeType = &builder.lateOffBaseOnTimeType

	}
	if builder.lateOnBaseOnTimeTypeFlag {
		req.LateOnBaseOnTimeType = &builder.lateOnBaseOnTimeType

	}
	return req
}

type LeaveAccrualRecord struct {
	Id *string `json:"id,omitempty"` // 授予记录唯一ID

	EmploymentId *string `json:"employment_id,omitempty"` // 员工ID

	LeaveTypeId *string `json:"leave_type_id,omitempty"` // 假期类型ID

	GrantingQuantity *string `json:"granting_quantity,omitempty"` // 授予数量

	GrantingUnit *int `json:"granting_unit,omitempty"` // 授予单位，1表示天，2表示小时

	EffectiveDate *string `json:"effective_date,omitempty"` // 生效日期，格式"2020-01-01"

	ExpirationDate *string `json:"expiration_date,omitempty"` // 失效日期，格式"2020-01-01"

	GrantedBy *int `json:"granted_by,omitempty"` // 授予来源，1：系统授予；2：手动授予；3：外部系统授予

	Reason []*LangText `json:"reason,omitempty"` // 授予原因

	CreatedAt *string `json:"created_at,omitempty"` // 授予记录的创建时间，unix时间戳

	CreatedBy *string `json:"created_by,omitempty"` // 授予记录的创建人的ID

	UpdatedAt *string `json:"updated_at,omitempty"` // 授予记录的更新时间，unix时间戳

	UpdatedBy *string `json:"updated_by,omitempty"` // 授予记录的更新人的ID

	SectionType *int `json:"section_type,omitempty"` // 是否参与折算
}

type LeaveAccrualRecordBuilder struct {
	id     string // 授予记录唯一ID
	idFlag bool

	employmentId     string // 员工ID
	employmentIdFlag bool

	leaveTypeId     string // 假期类型ID
	leaveTypeIdFlag bool

	grantingQuantity     string // 授予数量
	grantingQuantityFlag bool

	grantingUnit     int // 授予单位，1表示天，2表示小时
	grantingUnitFlag bool

	effectiveDate     string // 生效日期，格式"2020-01-01"
	effectiveDateFlag bool

	expirationDate     string // 失效日期，格式"2020-01-01"
	expirationDateFlag bool

	grantedBy     int // 授予来源，1：系统授予；2：手动授予；3：外部系统授予
	grantedByFlag bool

	reason     []*LangText // 授予原因
	reasonFlag bool

	createdAt     string // 授予记录的创建时间，unix时间戳
	createdAtFlag bool

	createdBy     string // 授予记录的创建人的ID
	createdByFlag bool

	updatedAt     string // 授予记录的更新时间，unix时间戳
	updatedAtFlag bool

	updatedBy     string // 授予记录的更新人的ID
	updatedByFlag bool

	sectionType     int // 是否参与折算
	sectionTypeFlag bool
}

func NewLeaveAccrualRecordBuilder() *LeaveAccrualRecordBuilder {
	builder := &LeaveAccrualRecordBuilder{}
	return builder
}

// 授予记录唯一ID
//
// 示例值：1
func (builder *LeaveAccrualRecordBuilder) Id(id string) *LeaveAccrualRecordBuilder {
	builder.id = id
	builder.idFlag = true
	return builder
}

// 员工ID
//
// 示例值：1
func (builder *LeaveAccrualRecordBuilder) EmploymentId(employmentId string) *LeaveAccrualRecordBuilder {
	builder.employmentId = employmentId
	builder.employmentIdFlag = true
	return builder
}

// 假期类型ID
//
// 示例值：1
func (builder *LeaveAccrualRecordBuilder) LeaveTypeId(leaveTypeId string) *LeaveAccrualRecordBuilder {
	builder.leaveTypeId = leaveTypeId
	builder.leaveTypeIdFlag = true
	return builder
}

// 授予数量
//
// 示例值：1
func (builder *LeaveAccrualRecordBuilder) GrantingQuantity(grantingQuantity string) *LeaveAccrualRecordBuilder {
	builder.grantingQuantity = grantingQuantity
	builder.grantingQuantityFlag = true
	return builder
}

// 授予单位，1表示天，2表示小时
//
// 示例值：1
func (builder *LeaveAccrualRecordBuilder) GrantingUnit(grantingUnit int) *LeaveAccrualRecordBuilder {
	builder.grantingUnit = grantingUnit
	builder.grantingUnitFlag = true
	return builder
}

// 生效日期，格式"2020-01-01"
//
// 示例值：2020-01-01
func (builder *LeaveAccrualRecordBuilder) EffectiveDate(effectiveDate string) *LeaveAccrualRecordBuilder {
	builder.effectiveDate = effectiveDate
	builder.effectiveDateFlag = true
	return builder
}

// 失效日期，格式"2020-01-01"
//
// 示例值：2020-01-01
func (builder *LeaveAccrualRecordBuilder) ExpirationDate(expirationDate string) *LeaveAccrualRecordBuilder {
	builder.expirationDate = expirationDate
	builder.expirationDateFlag = true
	return builder
}

// 授予来源，1：系统授予；2：手动授予；3：外部系统授予
//
// 示例值：1
func (builder *LeaveAccrualRecordBuilder) GrantedBy(grantedBy int) *LeaveAccrualRecordBuilder {
	builder.grantedBy = grantedBy
	builder.grantedByFlag = true
	return builder
}

// 授予原因
//
// 示例值：
func (builder *LeaveAccrualRecordBuilder) Reason(reason []*LangText) *LeaveAccrualRecordBuilder {
	builder.reason = reason
	builder.reasonFlag = true
	return builder
}

// 授予记录的创建时间，unix时间戳
//
// 示例值：1
func (builder *LeaveAccrualRecordBuilder) CreatedAt(createdAt string) *LeaveAccrualRecordBuilder {
	builder.createdAt = createdAt
	builder.createdAtFlag = true
	return builder
}

// 授予记录的创建人的ID
//
// 示例值：1
func (builder *LeaveAccrualRecordBuilder) CreatedBy(createdBy string) *LeaveAccrualRecordBuilder {
	builder.createdBy = createdBy
	builder.createdByFlag = true
	return builder
}

// 授予记录的更新时间，unix时间戳
//
// 示例值：1
func (builder *LeaveAccrualRecordBuilder) UpdatedAt(updatedAt string) *LeaveAccrualRecordBuilder {
	builder.updatedAt = updatedAt
	builder.updatedAtFlag = true
	return builder
}

// 授予记录的更新人的ID
//
// 示例值：1
func (builder *LeaveAccrualRecordBuilder) UpdatedBy(updatedBy string) *LeaveAccrualRecordBuilder {
	builder.updatedBy = updatedBy
	builder.updatedByFlag = true
	return builder
}

// 是否参与折算
//
// 示例值：1
func (builder *LeaveAccrualRecordBuilder) SectionType(sectionType int) *LeaveAccrualRecordBuilder {
	builder.sectionType = sectionType
	builder.sectionTypeFlag = true
	return builder
}

func (builder *LeaveAccrualRecordBuilder) Build() *LeaveAccrualRecord {
	req := &LeaveAccrualRecord{}
	if builder.idFlag {
		req.Id = &builder.id

	}
	if builder.employmentIdFlag {
		req.EmploymentId = &builder.employmentId

	}
	if builder.leaveTypeIdFlag {
		req.LeaveTypeId = &builder.leaveTypeId

	}
	if builder.grantingQuantityFlag {
		req.GrantingQuantity = &builder.grantingQuantity

	}
	if builder.grantingUnitFlag {
		req.GrantingUnit = &builder.grantingUnit

	}
	if builder.effectiveDateFlag {
		req.EffectiveDate = &builder.effectiveDate

	}
	if builder.expirationDateFlag {
		req.ExpirationDate = &builder.expirationDate

	}
	if builder.grantedByFlag {
		req.GrantedBy = &builder.grantedBy

	}
	if builder.reasonFlag {
		req.Reason = builder.reason
	}
	if builder.createdAtFlag {
		req.CreatedAt = &builder.createdAt

	}
	if builder.createdByFlag {
		req.CreatedBy = &builder.createdBy

	}
	if builder.updatedAtFlag {
		req.UpdatedAt = &builder.updatedAt

	}
	if builder.updatedByFlag {
		req.UpdatedBy = &builder.updatedBy

	}
	if builder.sectionTypeFlag {
		req.SectionType = &builder.sectionType

	}
	return req
}

type LeaveEmployExpireRecord struct {
	Id *string `json:"id,omitempty"` // record id

	EmploymentId *string `json:"employment_id,omitempty"` // 员工ID

	LeaveTypeId *string `json:"leave_type_id,omitempty"` // 假期类型ID

	GrantingQuantity *string `json:"granting_quantity,omitempty"` // 授予余额数量

	LeftGrantingQuantity *string `json:"left_granting_quantity,omitempty"` // 授予数量 扣减完后的授予数量

	GrantingUnit *int `json:"granting_unit,omitempty"` // 授予单位，1表示天，2表示小时

	EffectiveDate *string `json:"effective_date,omitempty"` // 生效日期，格式"2020-01-01"

	ExpirationDate *string `json:"expiration_date,omitempty"` // 失效日期，格式"2020-01-01"

	Reason []*LangText `json:"reason,omitempty"` // 授予原因

	IsUpdateByExternal *bool `json:"is_update_by_external,omitempty"` // 是否已经被外部系统更改过

	AccrualSource *int `json:"accrual_source,omitempty"` // 授予来源

	LeaveSubTypeId *string `json:"leave_sub_type_id,omitempty"` // 假期子类型id

	SectionType *int `json:"section_type,omitempty"` // 是否参与清算
}

type LeaveEmployExpireRecordBuilder struct {
	id     string // record id
	idFlag bool

	employmentId     string // 员工ID
	employmentIdFlag bool

	leaveTypeId     string // 假期类型ID
	leaveTypeIdFlag bool

	grantingQuantity     string // 授予余额数量
	grantingQuantityFlag bool

	leftGrantingQuantity     string // 授予数量 扣减完后的授予数量
	leftGrantingQuantityFlag bool

	grantingUnit     int // 授予单位，1表示天，2表示小时
	grantingUnitFlag bool

	effectiveDate     string // 生效日期，格式"2020-01-01"
	effectiveDateFlag bool

	expirationDate     string // 失效日期，格式"2020-01-01"
	expirationDateFlag bool

	reason     []*LangText // 授予原因
	reasonFlag bool

	isUpdateByExternal     bool // 是否已经被外部系统更改过
	isUpdateByExternalFlag bool

	accrualSource     int // 授予来源
	accrualSourceFlag bool

	leaveSubTypeId     string // 假期子类型id
	leaveSubTypeIdFlag bool

	sectionType     int // 是否参与清算
	sectionTypeFlag bool
}

func NewLeaveEmployExpireRecordBuilder() *LeaveEmployExpireRecordBuilder {
	builder := &LeaveEmployExpireRecordBuilder{}
	return builder
}

// record id
//
// 示例值：1
func (builder *LeaveEmployExpireRecordBuilder) Id(id string) *LeaveEmployExpireRecordBuilder {
	builder.id = id
	builder.idFlag = true
	return builder
}

// 员工ID
//
// 示例值：1
func (builder *LeaveEmployExpireRecordBuilder) EmploymentId(employmentId string) *LeaveEmployExpireRecordBuilder {
	builder.employmentId = employmentId
	builder.employmentIdFlag = true
	return builder
}

// 假期类型ID
//
// 示例值：1
func (builder *LeaveEmployExpireRecordBuilder) LeaveTypeId(leaveTypeId string) *LeaveEmployExpireRecordBuilder {
	builder.leaveTypeId = leaveTypeId
	builder.leaveTypeIdFlag = true
	return builder
}

// 授予余额数量
//
// 示例值：1
func (builder *LeaveEmployExpireRecordBuilder) GrantingQuantity(grantingQuantity string) *LeaveEmployExpireRecordBuilder {
	builder.grantingQuantity = grantingQuantity
	builder.grantingQuantityFlag = true
	return builder
}

// 授予数量 扣减完后的授予数量
//
// 示例值：1
func (builder *LeaveEmployExpireRecordBuilder) LeftGrantingQuantity(leftGrantingQuantity string) *LeaveEmployExpireRecordBuilder {
	builder.leftGrantingQuantity = leftGrantingQuantity
	builder.leftGrantingQuantityFlag = true
	return builder
}

// 授予单位，1表示天，2表示小时
//
// 示例值：1
func (builder *LeaveEmployExpireRecordBuilder) GrantingUnit(grantingUnit int) *LeaveEmployExpireRecordBuilder {
	builder.grantingUnit = grantingUnit
	builder.grantingUnitFlag = true
	return builder
}

// 生效日期，格式"2020-01-01"
//
// 示例值：2020-01-01
func (builder *LeaveEmployExpireRecordBuilder) EffectiveDate(effectiveDate string) *LeaveEmployExpireRecordBuilder {
	builder.effectiveDate = effectiveDate
	builder.effectiveDateFlag = true
	return builder
}

// 失效日期，格式"2020-01-01"
//
// 示例值：2020-01-01
func (builder *LeaveEmployExpireRecordBuilder) ExpirationDate(expirationDate string) *LeaveEmployExpireRecordBuilder {
	builder.expirationDate = expirationDate
	builder.expirationDateFlag = true
	return builder
}

// 授予原因
//
// 示例值：
func (builder *LeaveEmployExpireRecordBuilder) Reason(reason []*LangText) *LeaveEmployExpireRecordBuilder {
	builder.reason = reason
	builder.reasonFlag = true
	return builder
}

// 是否已经被外部系统更改过
//
// 示例值：true
func (builder *LeaveEmployExpireRecordBuilder) IsUpdateByExternal(isUpdateByExternal bool) *LeaveEmployExpireRecordBuilder {
	builder.isUpdateByExternal = isUpdateByExternal
	builder.isUpdateByExternalFlag = true
	return builder
}

// 授予来源
//
// 示例值：1
func (builder *LeaveEmployExpireRecordBuilder) AccrualSource(accrualSource int) *LeaveEmployExpireRecordBuilder {
	builder.accrualSource = accrualSource
	builder.accrualSourceFlag = true
	return builder
}

// 假期子类型id
//
// 示例值：1
func (builder *LeaveEmployExpireRecordBuilder) LeaveSubTypeId(leaveSubTypeId string) *LeaveEmployExpireRecordBuilder {
	builder.leaveSubTypeId = leaveSubTypeId
	builder.leaveSubTypeIdFlag = true
	return builder
}

// 是否参与清算
//
// 示例值：1
func (builder *LeaveEmployExpireRecordBuilder) SectionType(sectionType int) *LeaveEmployExpireRecordBuilder {
	builder.sectionType = sectionType
	builder.sectionTypeFlag = true
	return builder
}

func (builder *LeaveEmployExpireRecordBuilder) Build() *LeaveEmployExpireRecord {
	req := &LeaveEmployExpireRecord{}
	if builder.idFlag {
		req.Id = &builder.id

	}
	if builder.employmentIdFlag {
		req.EmploymentId = &builder.employmentId

	}
	if builder.leaveTypeIdFlag {
		req.LeaveTypeId = &builder.leaveTypeId

	}
	if builder.grantingQuantityFlag {
		req.GrantingQuantity = &builder.grantingQuantity

	}
	if builder.leftGrantingQuantityFlag {
		req.LeftGrantingQuantity = &builder.leftGrantingQuantity

	}
	if builder.grantingUnitFlag {
		req.GrantingUnit = &builder.grantingUnit

	}
	if builder.effectiveDateFlag {
		req.EffectiveDate = &builder.effectiveDate

	}
	if builder.expirationDateFlag {
		req.ExpirationDate = &builder.expirationDate

	}
	if builder.reasonFlag {
		req.Reason = builder.reason
	}
	if builder.isUpdateByExternalFlag {
		req.IsUpdateByExternal = &builder.isUpdateByExternal

	}
	if builder.accrualSourceFlag {
		req.AccrualSource = &builder.accrualSource

	}
	if builder.leaveSubTypeIdFlag {
		req.LeaveSubTypeId = &builder.leaveSubTypeId

	}
	if builder.sectionTypeFlag {
		req.SectionType = &builder.sectionType

	}
	return req
}

type LeaveNeedPunchCfg struct {
	LateMinutesAsLate *int `json:"late_minutes_as_late,omitempty"` // 晚到超过多久记为迟到

	LateMinutesAsLack *int `json:"late_minutes_as_lack,omitempty"` // 晚到超过多久记为缺卡

	EarlyMinutesAsEarly *int `json:"early_minutes_as_early,omitempty"` // 早走超过多久记为早退

	EarlyMinutesAsLack *int `json:"early_minutes_as_lack,omitempty"` // 早走超过多久记为缺卡

	NotDuringShift *bool `json:"not_during_shift,omitempty"` // 非班中离返岗。为true时，不产生班中离返岗
}

type LeaveNeedPunchCfgBuilder struct {
	lateMinutesAsLate     int // 晚到超过多久记为迟到
	lateMinutesAsLateFlag bool

	lateMinutesAsLack     int // 晚到超过多久记为缺卡
	lateMinutesAsLackFlag bool

	earlyMinutesAsEarly     int // 早走超过多久记为早退
	earlyMinutesAsEarlyFlag bool

	earlyMinutesAsLack     int // 早走超过多久记为缺卡
	earlyMinutesAsLackFlag bool

	notDuringShift     bool // 非班中离返岗。为true时，不产生班中离返岗
	notDuringShiftFlag bool
}

func NewLeaveNeedPunchCfgBuilder() *LeaveNeedPunchCfgBuilder {
	builder := &LeaveNeedPunchCfgBuilder{}
	return builder
}

// 晚到超过多久记为迟到
//
// 示例值：0
func (builder *LeaveNeedPunchCfgBuilder) LateMinutesAsLate(lateMinutesAsLate int) *LeaveNeedPunchCfgBuilder {
	builder.lateMinutesAsLate = lateMinutesAsLate
	builder.lateMinutesAsLateFlag = true
	return builder
}

// 晚到超过多久记为缺卡
//
// 示例值：0
func (builder *LeaveNeedPunchCfgBuilder) LateMinutesAsLack(lateMinutesAsLack int) *LeaveNeedPunchCfgBuilder {
	builder.lateMinutesAsLack = lateMinutesAsLack
	builder.lateMinutesAsLackFlag = true
	return builder
}

// 早走超过多久记为早退
//
// 示例值：0
func (builder *LeaveNeedPunchCfgBuilder) EarlyMinutesAsEarly(earlyMinutesAsEarly int) *LeaveNeedPunchCfgBuilder {
	builder.earlyMinutesAsEarly = earlyMinutesAsEarly
	builder.earlyMinutesAsEarlyFlag = true
	return builder
}

// 早走超过多久记为缺卡
//
// 示例值：0
func (builder *LeaveNeedPunchCfgBuilder) EarlyMinutesAsLack(earlyMinutesAsLack int) *LeaveNeedPunchCfgBuilder {
	builder.earlyMinutesAsLack = earlyMinutesAsLack
	builder.earlyMinutesAsLackFlag = true
	return builder
}

// 非班中离返岗。为true时，不产生班中离返岗
//
// 示例值：false
func (builder *LeaveNeedPunchCfgBuilder) NotDuringShift(notDuringShift bool) *LeaveNeedPunchCfgBuilder {
	builder.notDuringShift = notDuringShift
	builder.notDuringShiftFlag = true
	return builder
}

func (builder *LeaveNeedPunchCfgBuilder) Build() *LeaveNeedPunchCfg {
	req := &LeaveNeedPunchCfg{}
	if builder.lateMinutesAsLateFlag {
		req.LateMinutesAsLate = &builder.lateMinutesAsLate

	}
	if builder.lateMinutesAsLackFlag {
		req.LateMinutesAsLack = &builder.lateMinutesAsLack

	}
	if builder.earlyMinutesAsEarlyFlag {
		req.EarlyMinutesAsEarly = &builder.earlyMinutesAsEarly

	}
	if builder.earlyMinutesAsLackFlag {
		req.EarlyMinutesAsLack = &builder.earlyMinutesAsLack

	}
	if builder.notDuringShiftFlag {
		req.NotDuringShift = &builder.notDuringShift

	}
	return req
}

type Location struct {
	LocationId *string `json:"location_id,omitempty"` // 地址 ID

	LocationName *string `json:"location_name,omitempty"` // 地址名称

	LocationType *int `json:"location_type,omitempty"` // 地址类型，1：GPS，2：Wi-Fi，8：IP

	Latitude *float64 `json:"latitude,omitempty"` // 地址纬度

	Longitude *float64 `json:"longitude,omitempty"` // 地址经度

	Ssid *string `json:"ssid,omitempty"` // Wi-Fi 名称

	Bssid *string `json:"bssid,omitempty"` // Wi-Fi 的 MAC 地址

	MapType *int `json:"map_type,omitempty"` // 地图类型，1：高德， 2：谷歌

	Address *string `json:"address,omitempty"` // 地址名称

	Ip *string `json:"ip,omitempty"` // IP 地址

	Feature *string `json:"feature,omitempty"` // 额外信息，例如：运营商信息

	GpsRange *int `json:"gps_range,omitempty"` // GPS 打卡的有效范围
}

type LocationBuilder struct {
	locationId     string // 地址 ID
	locationIdFlag bool

	locationName     string // 地址名称
	locationNameFlag bool

	locationType     int // 地址类型，1：GPS，2：Wi-Fi，8：IP
	locationTypeFlag bool

	latitude     float64 // 地址纬度
	latitudeFlag bool

	longitude     float64 // 地址经度
	longitudeFlag bool

	ssid     string // Wi-Fi 名称
	ssidFlag bool

	bssid     string // Wi-Fi 的 MAC 地址
	bssidFlag bool

	mapType     int // 地图类型，1：高德， 2：谷歌
	mapTypeFlag bool

	address     string // 地址名称
	addressFlag bool

	ip     string // IP 地址
	ipFlag bool

	feature     string // 额外信息，例如：运营商信息
	featureFlag bool

	gpsRange     int // GPS 打卡的有效范围
	gpsRangeFlag bool
}

func NewLocationBuilder() *LocationBuilder {
	builder := &LocationBuilder{}
	return builder
}

// 地址 ID
//
// 示例值：6921213751454744578
func (builder *LocationBuilder) LocationId(locationId string) *LocationBuilder {
	builder.locationId = locationId
	builder.locationIdFlag = true
	return builder
}

// 地址名称
//
// 示例值：浙江省杭州市余杭区五常街道木桥头西溪八方城
func (builder *LocationBuilder) LocationName(locationName string) *LocationBuilder {
	builder.locationName = locationName
	builder.locationNameFlag = true
	return builder
}

// 地址类型，1：GPS，2：Wi-Fi，8：IP
//
// 示例值：1
func (builder *LocationBuilder) LocationType(locationType int) *LocationBuilder {
	builder.locationType = locationType
	builder.locationTypeFlag = true
	return builder
}

// 地址纬度
//
// 示例值：30.28994
func (builder *LocationBuilder) Latitude(latitude float64) *LocationBuilder {
	builder.latitude = latitude
	builder.latitudeFlag = true
	return builder
}

// 地址经度
//
// 示例值：120.04509
func (builder *LocationBuilder) Longitude(longitude float64) *LocationBuilder {
	builder.longitude = longitude
	builder.longitudeFlag = true
	return builder
}

// Wi-Fi 名称
//
// 示例值：TP-Link-af12ca
func (builder *LocationBuilder) Ssid(ssid string) *LocationBuilder {
	builder.ssid = ssid
	builder.ssidFlag = true
	return builder
}

// Wi-Fi 的 MAC 地址
//
// 示例值：08:00:20:0A:8C:6D
func (builder *LocationBuilder) Bssid(bssid string) *LocationBuilder {
	builder.bssid = bssid
	builder.bssidFlag = true
	return builder
}

// 地图类型，1：高德， 2：谷歌
//
// 示例值：1
func (builder *LocationBuilder) MapType(mapType int) *LocationBuilder {
	builder.mapType = mapType
	builder.mapTypeFlag = true
	return builder
}

// 地址名称
//
// 示例值：北京市海淀区中航广场
func (builder *LocationBuilder) Address(address string) *LocationBuilder {
	builder.address = address
	builder.addressFlag = true
	return builder
}

// IP 地址
//
// 示例值：122.224.123.146
func (builder *LocationBuilder) Ip(ip string) *LocationBuilder {
	builder.ip = ip
	builder.ipFlag = true
	return builder
}

// 额外信息，例如：运营商信息
//
// 示例值：中国电信
func (builder *LocationBuilder) Feature(feature string) *LocationBuilder {
	builder.feature = feature
	builder.featureFlag = true
	return builder
}

// GPS 打卡的有效范围
//
// 示例值：300
func (builder *LocationBuilder) GpsRange(gpsRange int) *LocationBuilder {
	builder.gpsRange = gpsRange
	builder.gpsRangeFlag = true
	return builder
}

func (builder *LocationBuilder) Build() *Location {
	req := &Location{}
	if builder.locationIdFlag {
		req.LocationId = &builder.locationId

	}
	if builder.locationNameFlag {
		req.LocationName = &builder.locationName

	}
	if builder.locationTypeFlag {
		req.LocationType = &builder.locationType

	}
	if builder.latitudeFlag {
		req.Latitude = &builder.latitude

	}
	if builder.longitudeFlag {
		req.Longitude = &builder.longitude

	}
	if builder.ssidFlag {
		req.Ssid = &builder.ssid

	}
	if builder.bssidFlag {
		req.Bssid = &builder.bssid

	}
	if builder.mapTypeFlag {
		req.MapType = &builder.mapType

	}
	if builder.addressFlag {
		req.Address = &builder.address

	}
	if builder.ipFlag {
		req.Ip = &builder.ip

	}
	if builder.featureFlag {
		req.Feature = &builder.feature

	}
	if builder.gpsRangeFlag {
		req.GpsRange = &builder.gpsRange

	}
	return req
}

type LocationInfo struct {
	Status *int `json:"status,omitempty"` // 开关状态

	Geofences []*Area `json:"geofences,omitempty"` //
}

type LocationInfoBuilder struct {
	status     int // 开关状态
	statusFlag bool

	geofences     []*Area //
	geofencesFlag bool
}

func NewLocationInfoBuilder() *LocationInfoBuilder {
	builder := &LocationInfoBuilder{}
	return builder
}

// 开关状态
//
// 示例值：
func (builder *LocationInfoBuilder) Status(status int) *LocationInfoBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

//
//
// 示例值：
func (builder *LocationInfoBuilder) Geofences(geofences []*Area) *LocationInfoBuilder {
	builder.geofences = geofences
	builder.geofencesFlag = true
	return builder
}

func (builder *LocationInfoBuilder) Build() *LocationInfo {
	req := &LocationInfo{}
	if builder.statusFlag {
		req.Status = &builder.status

	}
	if builder.geofencesFlag {
		req.Geofences = builder.geofences
	}
	return req
}

type LocationInfoEvent struct {
	Coord *Coordinate `json:"coord,omitempty"` //
}

type LocationInfoEventBuilder struct {
	coord     *Coordinate //
	coordFlag bool
}

func NewLocationInfoEventBuilder() *LocationInfoEventBuilder {
	builder := &LocationInfoEventBuilder{}
	return builder
}

//
//
// 示例值：
func (builder *LocationInfoEventBuilder) Coord(coord *Coordinate) *LocationInfoEventBuilder {
	builder.coord = coord
	builder.coordFlag = true
	return builder
}

func (builder *LocationInfoEventBuilder) Build() *LocationInfoEvent {
	req := &LocationInfoEvent{}
	if builder.coordFlag {
		req.Coord = builder.coord
	}
	return req
}

type LocationRecord struct {
	UserId *UserId `json:"user_id,omitempty"` // 用户id

	Timestamp *string `json:"timestamp,omitempty"` // 时间点

	Location *LocationInfoEvent `json:"location,omitempty"` // 位置信息

	Wifi *WifiInfoEvent `json:"wifi,omitempty"` // wifi信息

	RuleSnapshotId *string `json:"rule_snapshot_id,omitempty"` // 规则快照id

	Type *string `json:"type,omitempty"` // 事件类型

	ScanWifiList []*ScanWifiInfo `json:"scan_wifi_list,omitempty"` // 附近的wifi设备列表

	DeviceId *string `json:"device_id,omitempty"` // 上报事件的设备ID

	ClientInfo *string `json:"client_info,omitempty"` //
}

type LocationRecordBuilder struct {
	userId     *UserId // 用户id
	userIdFlag bool

	timestamp     string // 时间点
	timestampFlag bool

	location     *LocationInfoEvent // 位置信息
	locationFlag bool

	wifi     *WifiInfoEvent // wifi信息
	wifiFlag bool

	ruleSnapshotId     string // 规则快照id
	ruleSnapshotIdFlag bool

	type_    string // 事件类型
	typeFlag bool

	scanWifiList     []*ScanWifiInfo // 附近的wifi设备列表
	scanWifiListFlag bool

	deviceId     string // 上报事件的设备ID
	deviceIdFlag bool

	clientInfo     string //
	clientInfoFlag bool
}

func NewLocationRecordBuilder() *LocationRecordBuilder {
	builder := &LocationRecordBuilder{}
	return builder
}

// 用户id
//
// 示例值：
func (builder *LocationRecordBuilder) UserId(userId *UserId) *LocationRecordBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 时间点
//
// 示例值：
func (builder *LocationRecordBuilder) Timestamp(timestamp string) *LocationRecordBuilder {
	builder.timestamp = timestamp
	builder.timestampFlag = true
	return builder
}

// 位置信息
//
// 示例值：
func (builder *LocationRecordBuilder) Location(location *LocationInfoEvent) *LocationRecordBuilder {
	builder.location = location
	builder.locationFlag = true
	return builder
}

// wifi信息
//
// 示例值：
func (builder *LocationRecordBuilder) Wifi(wifi *WifiInfoEvent) *LocationRecordBuilder {
	builder.wifi = wifi
	builder.wifiFlag = true
	return builder
}

// 规则快照id
//
// 示例值：
func (builder *LocationRecordBuilder) RuleSnapshotId(ruleSnapshotId string) *LocationRecordBuilder {
	builder.ruleSnapshotId = ruleSnapshotId
	builder.ruleSnapshotIdFlag = true
	return builder
}

// 事件类型
//
// 示例值：
func (builder *LocationRecordBuilder) Type(type_ string) *LocationRecordBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

// 附近的wifi设备列表
//
// 示例值：
func (builder *LocationRecordBuilder) ScanWifiList(scanWifiList []*ScanWifiInfo) *LocationRecordBuilder {
	builder.scanWifiList = scanWifiList
	builder.scanWifiListFlag = true
	return builder
}

// 上报事件的设备ID
//
// 示例值：
func (builder *LocationRecordBuilder) DeviceId(deviceId string) *LocationRecordBuilder {
	builder.deviceId = deviceId
	builder.deviceIdFlag = true
	return builder
}

//
//
// 示例值：
func (builder *LocationRecordBuilder) ClientInfo(clientInfo string) *LocationRecordBuilder {
	builder.clientInfo = clientInfo
	builder.clientInfoFlag = true
	return builder
}

func (builder *LocationRecordBuilder) Build() *LocationRecord {
	req := &LocationRecord{}
	if builder.userIdFlag {
		req.UserId = builder.userId
	}
	if builder.timestampFlag {
		req.Timestamp = &builder.timestamp

	}
	if builder.locationFlag {
		req.Location = builder.location
	}
	if builder.wifiFlag {
		req.Wifi = builder.wifi
	}
	if builder.ruleSnapshotIdFlag {
		req.RuleSnapshotId = &builder.ruleSnapshotId

	}
	if builder.typeFlag {
		req.Type = &builder.type_

	}
	if builder.scanWifiListFlag {
		req.ScanWifiList = builder.scanWifiList
	}
	if builder.deviceIdFlag {
		req.DeviceId = &builder.deviceId

	}
	if builder.clientInfoFlag {
		req.ClientInfo = &builder.clientInfo

	}
	return req
}

type LocationSetting struct {
	Location *LocationInfo `json:"location,omitempty"` // 位置配置

	Wifi *WifiInfo `json:"wifi,omitempty"` // wifi配置

	UserId *string `json:"user_id,omitempty"` //
}

type LocationSettingBuilder struct {
	location     *LocationInfo // 位置配置
	locationFlag bool

	wifi     *WifiInfo // wifi配置
	wifiFlag bool

	userId     string //
	userIdFlag bool
}

func NewLocationSettingBuilder() *LocationSettingBuilder {
	builder := &LocationSettingBuilder{}
	return builder
}

// 位置配置
//
// 示例值：
func (builder *LocationSettingBuilder) Location(location *LocationInfo) *LocationSettingBuilder {
	builder.location = location
	builder.locationFlag = true
	return builder
}

// wifi配置
//
// 示例值：
func (builder *LocationSettingBuilder) Wifi(wifi *WifiInfo) *LocationSettingBuilder {
	builder.wifi = wifi
	builder.wifiFlag = true
	return builder
}

//
//
// 示例值：
func (builder *LocationSettingBuilder) UserId(userId string) *LocationSettingBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

func (builder *LocationSettingBuilder) Build() *LocationSetting {
	req := &LocationSetting{}
	if builder.locationFlag {
		req.Location = builder.location
	}
	if builder.wifiFlag {
		req.Wifi = builder.wifi
	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	return req
}

type Machine struct {
	MachineSn *string `json:"machine_sn,omitempty"` // 考勤机序列号

	MachineName *string `json:"machine_name,omitempty"` // 考勤机名称
}

type MachineBuilder struct {
	machineSn     string // 考勤机序列号
	machineSnFlag bool

	machineName     string // 考勤机名称
	machineNameFlag bool
}

func NewMachineBuilder() *MachineBuilder {
	builder := &MachineBuilder{}
	return builder
}

// 考勤机序列号
//
// 示例值：FS0701
func (builder *MachineBuilder) MachineSn(machineSn string) *MachineBuilder {
	builder.machineSn = machineSn
	builder.machineSnFlag = true
	return builder
}

// 考勤机名称
//
// 示例值：创实 9 楼
func (builder *MachineBuilder) MachineName(machineName string) *MachineBuilder {
	builder.machineName = machineName
	builder.machineNameFlag = true
	return builder
}

func (builder *MachineBuilder) Build() *Machine {
	req := &Machine{}
	if builder.machineSnFlag {
		req.MachineSn = &builder.machineSn

	}
	if builder.machineNameFlag {
		req.MachineName = &builder.machineName

	}
	return req
}

type MemberStatusChange struct {
	OnboardingOnNoNeedPunch *bool `json:"onboarding_on_no_need_punch,omitempty"` // 是否入职日上班无需打卡

	OnboardingOffNoNeedPunch *bool `json:"onboarding_off_no_need_punch,omitempty"` // 是否入职日下班无需打卡

	OffboardingOnNoNeedPunch *bool `json:"offboarding_on_no_need_punch,omitempty"` // 是否离职日上班无需打卡

	OffboardingOffNoNeedPunch *bool `json:"offboarding_off_no_need_punch,omitempty"` // 是否离职日下班无需打卡
}

type MemberStatusChangeBuilder struct {
	onboardingOnNoNeedPunch     bool // 是否入职日上班无需打卡
	onboardingOnNoNeedPunchFlag bool

	onboardingOffNoNeedPunch     bool // 是否入职日下班无需打卡
	onboardingOffNoNeedPunchFlag bool

	offboardingOnNoNeedPunch     bool // 是否离职日上班无需打卡
	offboardingOnNoNeedPunchFlag bool

	offboardingOffNoNeedPunch     bool // 是否离职日下班无需打卡
	offboardingOffNoNeedPunchFlag bool
}

func NewMemberStatusChangeBuilder() *MemberStatusChangeBuilder {
	builder := &MemberStatusChangeBuilder{}
	return builder
}

// 是否入职日上班无需打卡
//
// 示例值：false
func (builder *MemberStatusChangeBuilder) OnboardingOnNoNeedPunch(onboardingOnNoNeedPunch bool) *MemberStatusChangeBuilder {
	builder.onboardingOnNoNeedPunch = onboardingOnNoNeedPunch
	builder.onboardingOnNoNeedPunchFlag = true
	return builder
}

// 是否入职日下班无需打卡
//
// 示例值：false
func (builder *MemberStatusChangeBuilder) OnboardingOffNoNeedPunch(onboardingOffNoNeedPunch bool) *MemberStatusChangeBuilder {
	builder.onboardingOffNoNeedPunch = onboardingOffNoNeedPunch
	builder.onboardingOffNoNeedPunchFlag = true
	return builder
}

// 是否离职日上班无需打卡
//
// 示例值：false
func (builder *MemberStatusChangeBuilder) OffboardingOnNoNeedPunch(offboardingOnNoNeedPunch bool) *MemberStatusChangeBuilder {
	builder.offboardingOnNoNeedPunch = offboardingOnNoNeedPunch
	builder.offboardingOnNoNeedPunchFlag = true
	return builder
}

// 是否离职日下班无需打卡
//
// 示例值：false
func (builder *MemberStatusChangeBuilder) OffboardingOffNoNeedPunch(offboardingOffNoNeedPunch bool) *MemberStatusChangeBuilder {
	builder.offboardingOffNoNeedPunch = offboardingOffNoNeedPunch
	builder.offboardingOffNoNeedPunchFlag = true
	return builder
}

func (builder *MemberStatusChangeBuilder) Build() *MemberStatusChange {
	req := &MemberStatusChange{}
	if builder.onboardingOnNoNeedPunchFlag {
		req.OnboardingOnNoNeedPunch = &builder.onboardingOnNoNeedPunch

	}
	if builder.onboardingOffNoNeedPunchFlag {
		req.OnboardingOffNoNeedPunch = &builder.onboardingOffNoNeedPunch

	}
	if builder.offboardingOnNoNeedPunchFlag {
		req.OffboardingOnNoNeedPunch = &builder.offboardingOnNoNeedPunch

	}
	if builder.offboardingOffNoNeedPunchFlag {
		req.OffboardingOffNoNeedPunch = &builder.offboardingOffNoNeedPunch

	}
	return req
}

type NormalLeaveBalance struct {
	BalanceId *string `json:"balance_id,omitempty"` // 假期授予记录ID

	UserId *string `json:"user_id,omitempty"` // 用户ID

	LeaveTypeId *string `json:"leave_type_id,omitempty"` // 假期ID

	Quota *string `json:"quota,omitempty"` // 剩余余额

	GrantQuota *string `json:"grant_quota,omitempty"` // 授予额度

	UsedQuota *string `json:"used_quota,omitempty"` // 使用额度

	Unit *string `json:"unit,omitempty"` // 单位

	SubType *string `json:"sub_type,omitempty"` // 子类型

	ExpireTime *int `json:"expire_time,omitempty"` // 有效期结束时间

	EffectiveTime *int `json:"effective_time,omitempty"` // 有效期开始时间

	GrantSource *string `json:"grant_source,omitempty"` // 来源

	Status *string `json:"status,omitempty"` // 状态

	Desc *string `json:"desc,omitempty"` // 备注

	PlanTargetQuota *string `json:"plan_target_quota,omitempty"` // 逐日发放数量

	PlanEndTime *int `json:"plan_end_time,omitempty"` // 逐日发放结束时间

	GrantDaily *bool `json:"grant_daily,omitempty"` // 是否逐日发放
}

type NormalLeaveBalanceBuilder struct {
	balanceId     string // 假期授予记录ID
	balanceIdFlag bool

	userId     string // 用户ID
	userIdFlag bool

	leaveTypeId     string // 假期ID
	leaveTypeIdFlag bool

	quota     string // 剩余余额
	quotaFlag bool

	grantQuota     string // 授予额度
	grantQuotaFlag bool

	usedQuota     string // 使用额度
	usedQuotaFlag bool

	unit     string // 单位
	unitFlag bool

	subType     string // 子类型
	subTypeFlag bool

	expireTime     int // 有效期结束时间
	expireTimeFlag bool

	effectiveTime     int // 有效期开始时间
	effectiveTimeFlag bool

	grantSource     string // 来源
	grantSourceFlag bool

	status     string // 状态
	statusFlag bool

	desc     string // 备注
	descFlag bool

	planTargetQuota     string // 逐日发放数量
	planTargetQuotaFlag bool

	planEndTime     int // 逐日发放结束时间
	planEndTimeFlag bool

	grantDaily     bool // 是否逐日发放
	grantDailyFlag bool
}

func NewNormalLeaveBalanceBuilder() *NormalLeaveBalanceBuilder {
	builder := &NormalLeaveBalanceBuilder{}
	return builder
}

// 假期授予记录ID
//
// 示例值：7476427589584551938
func (builder *NormalLeaveBalanceBuilder) BalanceId(balanceId string) *NormalLeaveBalanceBuilder {
	builder.balanceId = balanceId
	builder.balanceIdFlag = true
	return builder
}

// 用户ID
//
// 示例值：
func (builder *NormalLeaveBalanceBuilder) UserId(userId string) *NormalLeaveBalanceBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 假期ID
//
// 示例值：7476427589584551938
func (builder *NormalLeaveBalanceBuilder) LeaveTypeId(leaveTypeId string) *NormalLeaveBalanceBuilder {
	builder.leaveTypeId = leaveTypeId
	builder.leaveTypeIdFlag = true
	return builder
}

// 剩余余额
//
// 示例值：1.54
func (builder *NormalLeaveBalanceBuilder) Quota(quota string) *NormalLeaveBalanceBuilder {
	builder.quota = quota
	builder.quotaFlag = true
	return builder
}

// 授予额度
//
// 示例值：1.66
func (builder *NormalLeaveBalanceBuilder) GrantQuota(grantQuota string) *NormalLeaveBalanceBuilder {
	builder.grantQuota = grantQuota
	builder.grantQuotaFlag = true
	return builder
}

// 使用额度
//
// 示例值：0.12
func (builder *NormalLeaveBalanceBuilder) UsedQuota(usedQuota string) *NormalLeaveBalanceBuilder {
	builder.usedQuota = usedQuota
	builder.usedQuotaFlag = true
	return builder
}

// 单位
//
// 示例值：day
func (builder *NormalLeaveBalanceBuilder) Unit(unit string) *NormalLeaveBalanceBuilder {
	builder.unit = unit
	builder.unitFlag = true
	return builder
}

// 子类型
//
// 示例值：normal
func (builder *NormalLeaveBalanceBuilder) SubType(subType string) *NormalLeaveBalanceBuilder {
	builder.subType = subType
	builder.subTypeFlag = true
	return builder
}

// 有效期结束时间
//
// 示例值：1757330769
func (builder *NormalLeaveBalanceBuilder) ExpireTime(expireTime int) *NormalLeaveBalanceBuilder {
	builder.expireTime = expireTime
	builder.expireTimeFlag = true
	return builder
}

// 有效期开始时间
//
// 示例值：1757330769
func (builder *NormalLeaveBalanceBuilder) EffectiveTime(effectiveTime int) *NormalLeaveBalanceBuilder {
	builder.effectiveTime = effectiveTime
	builder.effectiveTimeFlag = true
	return builder
}

// 来源
//
// 示例值：system
func (builder *NormalLeaveBalanceBuilder) GrantSource(grantSource string) *NormalLeaveBalanceBuilder {
	builder.grantSource = grantSource
	builder.grantSourceFlag = true
	return builder
}

// 状态
//
// 示例值：active
func (builder *NormalLeaveBalanceBuilder) Status(status string) *NormalLeaveBalanceBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

// 备注
//
// 示例值：补发假期
func (builder *NormalLeaveBalanceBuilder) Desc(desc string) *NormalLeaveBalanceBuilder {
	builder.desc = desc
	builder.descFlag = true
	return builder
}

// 逐日发放数量
//
// 示例值：1.66
func (builder *NormalLeaveBalanceBuilder) PlanTargetQuota(planTargetQuota string) *NormalLeaveBalanceBuilder {
	builder.planTargetQuota = planTargetQuota
	builder.planTargetQuotaFlag = true
	return builder
}

// 逐日发放结束时间
//
// 示例值：1757330769
func (builder *NormalLeaveBalanceBuilder) PlanEndTime(planEndTime int) *NormalLeaveBalanceBuilder {
	builder.planEndTime = planEndTime
	builder.planEndTimeFlag = true
	return builder
}

// 是否逐日发放
//
// 示例值：true
func (builder *NormalLeaveBalanceBuilder) GrantDaily(grantDaily bool) *NormalLeaveBalanceBuilder {
	builder.grantDaily = grantDaily
	builder.grantDailyFlag = true
	return builder
}

func (builder *NormalLeaveBalanceBuilder) Build() *NormalLeaveBalance {
	req := &NormalLeaveBalance{}
	if builder.balanceIdFlag {
		req.BalanceId = &builder.balanceId

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.leaveTypeIdFlag {
		req.LeaveTypeId = &builder.leaveTypeId

	}
	if builder.quotaFlag {
		req.Quota = &builder.quota

	}
	if builder.grantQuotaFlag {
		req.GrantQuota = &builder.grantQuota

	}
	if builder.usedQuotaFlag {
		req.UsedQuota = &builder.usedQuota

	}
	if builder.unitFlag {
		req.Unit = &builder.unit

	}
	if builder.subTypeFlag {
		req.SubType = &builder.subType

	}
	if builder.expireTimeFlag {
		req.ExpireTime = &builder.expireTime

	}
	if builder.effectiveTimeFlag {
		req.EffectiveTime = &builder.effectiveTime

	}
	if builder.grantSourceFlag {
		req.GrantSource = &builder.grantSource

	}
	if builder.statusFlag {
		req.Status = &builder.status

	}
	if builder.descFlag {
		req.Desc = &builder.desc

	}
	if builder.planTargetQuotaFlag {
		req.PlanTargetQuota = &builder.planTargetQuota

	}
	if builder.planEndTimeFlag {
		req.PlanEndTime = &builder.planEndTime

	}
	if builder.grantDailyFlag {
		req.GrantDaily = &builder.grantDaily

	}
	return req
}

type NormalLeaveType struct {
	LeaveTypeId *string `json:"leave_type_id,omitempty"` // 假期类型ID

	Names []*I18nResource `json:"names,omitempty"` // 假期类型多语言名称

	IsBalanceUsed *bool `json:"is_balance_used,omitempty"` // 是否限额

	IsActive *bool `json:"is_active,omitempty"` // 是否启用
}

type NormalLeaveTypeBuilder struct {
	leaveTypeId     string // 假期类型ID
	leaveTypeIdFlag bool

	names     []*I18nResource // 假期类型多语言名称
	namesFlag bool

	isBalanceUsed     bool // 是否限额
	isBalanceUsedFlag bool

	isActive     bool // 是否启用
	isActiveFlag bool
}

func NewNormalLeaveTypeBuilder() *NormalLeaveTypeBuilder {
	builder := &NormalLeaveTypeBuilder{}
	return builder
}

// 假期类型ID
//
// 示例值：7476427589584551938
func (builder *NormalLeaveTypeBuilder) LeaveTypeId(leaveTypeId string) *NormalLeaveTypeBuilder {
	builder.leaveTypeId = leaveTypeId
	builder.leaveTypeIdFlag = true
	return builder
}

// 假期类型多语言名称
//
// 示例值：
func (builder *NormalLeaveTypeBuilder) Names(names []*I18nResource) *NormalLeaveTypeBuilder {
	builder.names = names
	builder.namesFlag = true
	return builder
}

// 是否限额
//
// 示例值：
func (builder *NormalLeaveTypeBuilder) IsBalanceUsed(isBalanceUsed bool) *NormalLeaveTypeBuilder {
	builder.isBalanceUsed = isBalanceUsed
	builder.isBalanceUsedFlag = true
	return builder
}

// 是否启用
//
// 示例值：
func (builder *NormalLeaveTypeBuilder) IsActive(isActive bool) *NormalLeaveTypeBuilder {
	builder.isActive = isActive
	builder.isActiveFlag = true
	return builder
}

func (builder *NormalLeaveTypeBuilder) Build() *NormalLeaveType {
	req := &NormalLeaveType{}
	if builder.leaveTypeIdFlag {
		req.LeaveTypeId = &builder.leaveTypeId

	}
	if builder.namesFlag {
		req.Names = builder.names
	}
	if builder.isBalanceUsedFlag {
		req.IsBalanceUsed = &builder.isBalanceUsed

	}
	if builder.isActiveFlag {
		req.IsActive = &builder.isActive

	}
	return req
}

type NormalLeaveUserAccount struct {
	UserId *string `json:"user_id,omitempty"` // 用户ID

	LeaveTypeId *string `json:"leave_type_id,omitempty"` // 假期ID

	Quota *string `json:"quota,omitempty"` // 数量(保留两位小数)

	Unit *string `json:"unit,omitempty"` // 单位

	SubTypeAccounts []*UserSubTypeAccount `json:"sub_type_accounts,omitempty"` // 子类型账户

	Balances []*NormalLeaveBalance `json:"balances,omitempty"` // 假期余额详情
}

type NormalLeaveUserAccountBuilder struct {
	userId     string // 用户ID
	userIdFlag bool

	leaveTypeId     string // 假期ID
	leaveTypeIdFlag bool

	quota     string // 数量(保留两位小数)
	quotaFlag bool

	unit     string // 单位
	unitFlag bool

	subTypeAccounts     []*UserSubTypeAccount // 子类型账户
	subTypeAccountsFlag bool

	balances     []*NormalLeaveBalance // 假期余额详情
	balancesFlag bool
}

func NewNormalLeaveUserAccountBuilder() *NormalLeaveUserAccountBuilder {
	builder := &NormalLeaveUserAccountBuilder{}
	return builder
}

// 用户ID
//
// 示例值：
func (builder *NormalLeaveUserAccountBuilder) UserId(userId string) *NormalLeaveUserAccountBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 假期ID
//
// 示例值：7476427589584551938
func (builder *NormalLeaveUserAccountBuilder) LeaveTypeId(leaveTypeId string) *NormalLeaveUserAccountBuilder {
	builder.leaveTypeId = leaveTypeId
	builder.leaveTypeIdFlag = true
	return builder
}

// 数量(保留两位小数)
//
// 示例值：1.53
func (builder *NormalLeaveUserAccountBuilder) Quota(quota string) *NormalLeaveUserAccountBuilder {
	builder.quota = quota
	builder.quotaFlag = true
	return builder
}

// 单位
//
// 示例值：day
func (builder *NormalLeaveUserAccountBuilder) Unit(unit string) *NormalLeaveUserAccountBuilder {
	builder.unit = unit
	builder.unitFlag = true
	return builder
}

// 子类型账户
//
// 示例值：
func (builder *NormalLeaveUserAccountBuilder) SubTypeAccounts(subTypeAccounts []*UserSubTypeAccount) *NormalLeaveUserAccountBuilder {
	builder.subTypeAccounts = subTypeAccounts
	builder.subTypeAccountsFlag = true
	return builder
}

// 假期余额详情
//
// 示例值：
func (builder *NormalLeaveUserAccountBuilder) Balances(balances []*NormalLeaveBalance) *NormalLeaveUserAccountBuilder {
	builder.balances = balances
	builder.balancesFlag = true
	return builder
}

func (builder *NormalLeaveUserAccountBuilder) Build() *NormalLeaveUserAccount {
	req := &NormalLeaveUserAccount{}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.leaveTypeIdFlag {
		req.LeaveTypeId = &builder.leaveTypeId

	}
	if builder.quotaFlag {
		req.Quota = &builder.quota

	}
	if builder.unitFlag {
		req.Unit = &builder.unit

	}
	if builder.subTypeAccountsFlag {
		req.SubTypeAccounts = builder.subTypeAccounts
	}
	if builder.balancesFlag {
		req.Balances = builder.balances
	}
	return req
}

type NormalLeaveUserFirstWorkTime struct {
	UserId *string `json:"user_id,omitempty"` // 用户ID列表(用户id类型 open_id/union_id/user_id)

	FirstWorkTime *int `json:"first_work_time,omitempty"` // 首次工作时间时间戳(休假展示和使用精确到天，国内取东八，海外0时区)
}

type NormalLeaveUserFirstWorkTimeBuilder struct {
	userId     string // 用户ID列表(用户id类型 open_id/union_id/user_id)
	userIdFlag bool

	firstWorkTime     int // 首次工作时间时间戳(休假展示和使用精确到天，国内取东八，海外0时区)
	firstWorkTimeFlag bool
}

func NewNormalLeaveUserFirstWorkTimeBuilder() *NormalLeaveUserFirstWorkTimeBuilder {
	builder := &NormalLeaveUserFirstWorkTimeBuilder{}
	return builder
}

// 用户ID列表(用户id类型 open_id/union_id/user_id)
//
// 示例值：
func (builder *NormalLeaveUserFirstWorkTimeBuilder) UserId(userId string) *NormalLeaveUserFirstWorkTimeBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 首次工作时间时间戳(休假展示和使用精确到天，国内取东八，海外0时区)
//
// 示例值：1757330769
func (builder *NormalLeaveUserFirstWorkTimeBuilder) FirstWorkTime(firstWorkTime int) *NormalLeaveUserFirstWorkTimeBuilder {
	builder.firstWorkTime = firstWorkTime
	builder.firstWorkTimeFlag = true
	return builder
}

func (builder *NormalLeaveUserFirstWorkTimeBuilder) Build() *NormalLeaveUserFirstWorkTime {
	req := &NormalLeaveUserFirstWorkTime{}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.firstWorkTimeFlag {
		req.FirstWorkTime = &builder.firstWorkTime

	}
	return req
}

type OpenApplyTimeRange struct {
	OvertimeAttributionDate *string `json:"overtime_attribution_date,omitempty"` // 加班所属日期

	TimeRange *OvertimeTimeRange `json:"time_range,omitempty"` // 时段信息
}

type OpenApplyTimeRangeBuilder struct {
	overtimeAttributionDate     string // 加班所属日期
	overtimeAttributionDateFlag bool

	timeRange     *OvertimeTimeRange // 时段信息
	timeRangeFlag bool
}

func NewOpenApplyTimeRangeBuilder() *OpenApplyTimeRangeBuilder {
	builder := &OpenApplyTimeRangeBuilder{}
	return builder
}

// 加班所属日期
//
// 示例值：2023-09-25
func (builder *OpenApplyTimeRangeBuilder) OvertimeAttributionDate(overtimeAttributionDate string) *OpenApplyTimeRangeBuilder {
	builder.overtimeAttributionDate = overtimeAttributionDate
	builder.overtimeAttributionDateFlag = true
	return builder
}

// 时段信息
//
// 示例值：
func (builder *OpenApplyTimeRangeBuilder) TimeRange(timeRange *OvertimeTimeRange) *OpenApplyTimeRangeBuilder {
	builder.timeRange = timeRange
	builder.timeRangeFlag = true
	return builder
}

func (builder *OpenApplyTimeRangeBuilder) Build() *OpenApplyTimeRange {
	req := &OpenApplyTimeRange{}
	if builder.overtimeAttributionDateFlag {
		req.OvertimeAttributionDate = &builder.overtimeAttributionDate

	}
	if builder.timeRangeFlag {
		req.TimeRange = builder.timeRange
	}
	return req
}

type OutRecord struct {
	DurationUnit *string `json:"duration_unit,omitempty"` // 外出时间单位，枚举值hour,half_day,day

	StartTime *OutTime `json:"start_time,omitempty"` // 外出开始时间

	EndTime *OutTime `json:"end_time,omitempty"` // 外出结束时间
}

type OutRecordBuilder struct {
	durationUnit     string // 外出时间单位，枚举值hour,half_day,day
	durationUnitFlag bool

	startTime     *OutTime // 外出开始时间
	startTimeFlag bool

	endTime     *OutTime // 外出结束时间
	endTimeFlag bool
}

func NewOutRecordBuilder() *OutRecordBuilder {
	builder := &OutRecordBuilder{}
	return builder
}

// 外出时间单位，枚举值hour,half_day,day
//
// 示例值：hour
func (builder *OutRecordBuilder) DurationUnit(durationUnit string) *OutRecordBuilder {
	builder.durationUnit = durationUnit
	builder.durationUnitFlag = true
	return builder
}

// 外出开始时间
//
// 示例值：
func (builder *OutRecordBuilder) StartTime(startTime *OutTime) *OutRecordBuilder {
	builder.startTime = startTime
	builder.startTimeFlag = true
	return builder
}

// 外出结束时间
//
// 示例值：
func (builder *OutRecordBuilder) EndTime(endTime *OutTime) *OutRecordBuilder {
	builder.endTime = endTime
	builder.endTimeFlag = true
	return builder
}

func (builder *OutRecordBuilder) Build() *OutRecord {
	req := &OutRecord{}
	if builder.durationUnitFlag {
		req.DurationUnit = &builder.durationUnit

	}
	if builder.startTimeFlag {
		req.StartTime = builder.startTime
	}
	if builder.endTimeFlag {
		req.EndTime = builder.endTime
	}
	return req
}

type OutTime struct {
	Datetime *string `json:"datetime,omitempty"` // 时间，时间格式为yyyy-MM-dd HH:mm

	DayType *string `json:"day_type,omitempty"` // 外出半天类型，枚举值：morning，afternoon，当外出时间单位为half_day时生效
}

type OutTimeBuilder struct {
	datetime     string // 时间，时间格式为yyyy-MM-dd HH:mm
	datetimeFlag bool

	dayType     string // 外出半天类型，枚举值：morning，afternoon，当外出时间单位为half_day时生效
	dayTypeFlag bool
}

func NewOutTimeBuilder() *OutTimeBuilder {
	builder := &OutTimeBuilder{}
	return builder
}

// 时间，时间格式为yyyy-MM-dd HH:mm
//
// 示例值：2025-01-01 09:00
func (builder *OutTimeBuilder) Datetime(datetime string) *OutTimeBuilder {
	builder.datetime = datetime
	builder.datetimeFlag = true
	return builder
}

// 外出半天类型，枚举值：morning，afternoon，当外出时间单位为half_day时生效
//
// 示例值：morning
func (builder *OutTimeBuilder) DayType(dayType string) *OutTimeBuilder {
	builder.dayType = dayType
	builder.dayTypeFlag = true
	return builder
}

func (builder *OutTimeBuilder) Build() *OutTime {
	req := &OutTime{}
	if builder.datetimeFlag {
		req.Datetime = &builder.datetime

	}
	if builder.dayTypeFlag {
		req.DayType = &builder.dayType

	}
	return req
}

type OvertimeApplyDetail struct {
	UserId *string `json:"user_id,omitempty"` // 加班明细用户ID(根据date_type_id)

	Date *string `json:"date,omitempty"` // 加班日期

	DateType *int `json:"date_type,omitempty"` // 日期类型

	Duration *string `json:"duration,omitempty"` // 加班时长，两位小数

	Unit *int `json:"unit,omitempty"` // 加班单位

	IsTimeBank *bool `json:"is_time_bank,omitempty"` // 是否是综合工时

	UpdateTime *string `json:"update_time,omitempty"` // 添加更新数据时间
}

type OvertimeApplyDetailBuilder struct {
	userId     string // 加班明细用户ID(根据date_type_id)
	userIdFlag bool

	date     string // 加班日期
	dateFlag bool

	dateType     int // 日期类型
	dateTypeFlag bool

	duration     string // 加班时长，两位小数
	durationFlag bool

	unit     int // 加班单位
	unitFlag bool

	isTimeBank     bool // 是否是综合工时
	isTimeBankFlag bool

	updateTime     string // 添加更新数据时间
	updateTimeFlag bool
}

func NewOvertimeApplyDetailBuilder() *OvertimeApplyDetailBuilder {
	builder := &OvertimeApplyDetailBuilder{}
	return builder
}

// 加班明细用户ID(根据date_type_id)
//
// 示例值：7271137794704015379
func (builder *OvertimeApplyDetailBuilder) UserId(userId string) *OvertimeApplyDetailBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 加班日期
//
// 示例值：2006-01-02
func (builder *OvertimeApplyDetailBuilder) Date(date string) *OvertimeApplyDetailBuilder {
	builder.date = date
	builder.dateFlag = true
	return builder
}

// 日期类型
//
// 示例值：1
func (builder *OvertimeApplyDetailBuilder) DateType(dateType int) *OvertimeApplyDetailBuilder {
	builder.dateType = dateType
	builder.dateTypeFlag = true
	return builder
}

// 加班时长，两位小数
//
// 示例值：0.5
func (builder *OvertimeApplyDetailBuilder) Duration(duration string) *OvertimeApplyDetailBuilder {
	builder.duration = duration
	builder.durationFlag = true
	return builder
}

// 加班单位
//
// 示例值：1
func (builder *OvertimeApplyDetailBuilder) Unit(unit int) *OvertimeApplyDetailBuilder {
	builder.unit = unit
	builder.unitFlag = true
	return builder
}

// 是否是综合工时
//
// 示例值：false
func (builder *OvertimeApplyDetailBuilder) IsTimeBank(isTimeBank bool) *OvertimeApplyDetailBuilder {
	builder.isTimeBank = isTimeBank
	builder.isTimeBankFlag = true
	return builder
}

// 添加更新数据时间
//
// 示例值：2023-12-31 12:00:00
func (builder *OvertimeApplyDetailBuilder) UpdateTime(updateTime string) *OvertimeApplyDetailBuilder {
	builder.updateTime = updateTime
	builder.updateTimeFlag = true
	return builder
}

func (builder *OvertimeApplyDetailBuilder) Build() *OvertimeApplyDetail {
	req := &OvertimeApplyDetail{}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.dateFlag {
		req.Date = &builder.date

	}
	if builder.dateTypeFlag {
		req.DateType = &builder.dateType

	}
	if builder.durationFlag {
		req.Duration = &builder.duration

	}
	if builder.unitFlag {
		req.Unit = &builder.unit

	}
	if builder.isTimeBankFlag {
		req.IsTimeBank = &builder.isTimeBank

	}
	if builder.updateTimeFlag {
		req.UpdateTime = &builder.updateTime

	}
	return req
}

type OvertimeApproval struct {
	UserId *string `json:"user_id,omitempty"` // 用户id

	StartTime *string `json:"start_time,omitempty"` // 加班开始时间

	EndTime *string `json:"end_time,omitempty"` // 加班结束时间

	CreateTime *string `json:"create_time,omitempty"` // 审批单创建时间

	ApprovalDailyDetails []*ApprovalDailyDetail `json:"approval_daily_details,omitempty"` // 审批单每日加班详情

	Status *int `json:"status,omitempty"` // 审批单状态
}

type OvertimeApprovalBuilder struct {
	userId     string // 用户id
	userIdFlag bool

	startTime     string // 加班开始时间
	startTimeFlag bool

	endTime     string // 加班结束时间
	endTimeFlag bool

	createTime     string // 审批单创建时间
	createTimeFlag bool

	approvalDailyDetails     []*ApprovalDailyDetail // 审批单每日加班详情
	approvalDailyDetailsFlag bool

	status     int // 审批单状态
	statusFlag bool
}

func NewOvertimeApprovalBuilder() *OvertimeApprovalBuilder {
	builder := &OvertimeApprovalBuilder{}
	return builder
}

// 用户id
//
// 示例值：
func (builder *OvertimeApprovalBuilder) UserId(userId string) *OvertimeApprovalBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 加班开始时间
//
// 示例值：2024-10-21 15:15
func (builder *OvertimeApprovalBuilder) StartTime(startTime string) *OvertimeApprovalBuilder {
	builder.startTime = startTime
	builder.startTimeFlag = true
	return builder
}

// 加班结束时间
//
// 示例值：2024-10-22 15:15
func (builder *OvertimeApprovalBuilder) EndTime(endTime string) *OvertimeApprovalBuilder {
	builder.endTime = endTime
	builder.endTimeFlag = true
	return builder
}

// 审批单创建时间
//
// 示例值：2024-10-22 15:15
func (builder *OvertimeApprovalBuilder) CreateTime(createTime string) *OvertimeApprovalBuilder {
	builder.createTime = createTime
	builder.createTimeFlag = true
	return builder
}

// 审批单每日加班详情
//
// 示例值：
func (builder *OvertimeApprovalBuilder) ApprovalDailyDetails(approvalDailyDetails []*ApprovalDailyDetail) *OvertimeApprovalBuilder {
	builder.approvalDailyDetails = approvalDailyDetails
	builder.approvalDailyDetailsFlag = true
	return builder
}

// 审批单状态
//
// 示例值：0
func (builder *OvertimeApprovalBuilder) Status(status int) *OvertimeApprovalBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

func (builder *OvertimeApprovalBuilder) Build() *OvertimeApproval {
	req := &OvertimeApproval{}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.startTimeFlag {
		req.StartTime = &builder.startTime

	}
	if builder.endTimeFlag {
		req.EndTime = &builder.endTime

	}
	if builder.createTimeFlag {
		req.CreateTime = &builder.createTime

	}
	if builder.approvalDailyDetailsFlag {
		req.ApprovalDailyDetails = builder.approvalDailyDetails
	}
	if builder.statusFlag {
		req.Status = &builder.status

	}
	return req
}

type OvertimeClockCfg struct {
	AllowPunchApproval *bool `json:"allow_punch_approval,omitempty"` // 是否允许在非打卡时段申请打卡（仅灰度租户可用）

	NeedClockOverTimeStartAndEnd *bool `json:"need_clock_over_time_start_and_end,omitempty"` // 加班开始和结束需打卡(需灰度)
}

type OvertimeClockCfgBuilder struct {
	allowPunchApproval     bool // 是否允许在非打卡时段申请打卡（仅灰度租户可用）
	allowPunchApprovalFlag bool

	needClockOverTimeStartAndEnd     bool // 加班开始和结束需打卡(需灰度)
	needClockOverTimeStartAndEndFlag bool
}

func NewOvertimeClockCfgBuilder() *OvertimeClockCfgBuilder {
	builder := &OvertimeClockCfgBuilder{}
	return builder
}

// 是否允许在非打卡时段申请打卡（仅灰度租户可用）
//
// 示例值：false
func (builder *OvertimeClockCfgBuilder) AllowPunchApproval(allowPunchApproval bool) *OvertimeClockCfgBuilder {
	builder.allowPunchApproval = allowPunchApproval
	builder.allowPunchApprovalFlag = true
	return builder
}

// 加班开始和结束需打卡(需灰度)
//
// 示例值：false
func (builder *OvertimeClockCfgBuilder) NeedClockOverTimeStartAndEnd(needClockOverTimeStartAndEnd bool) *OvertimeClockCfgBuilder {
	builder.needClockOverTimeStartAndEnd = needClockOverTimeStartAndEnd
	builder.needClockOverTimeStartAndEndFlag = true
	return builder
}

func (builder *OvertimeClockCfgBuilder) Build() *OvertimeClockCfg {
	req := &OvertimeClockCfg{}
	if builder.allowPunchApprovalFlag {
		req.AllowPunchApproval = &builder.allowPunchApproval

	}
	if builder.needClockOverTimeStartAndEndFlag {
		req.NeedClockOverTimeStartAndEnd = &builder.needClockOverTimeStartAndEnd

	}
	return req
}

type OvertimeDetail struct {
	Id *string `json:"id,omitempty"` // 加班明细ID

	UserId *string `json:"user_id,omitempty"` // 加班明细用户ID(根据date_type_id)

	StartTime *string `json:"start_time,omitempty"` // 加班开始时间格式（2006-01-02 00:00:00,无时区信息，参照时区是提交时候的时区）

	EndTime *string `json:"end_time,omitempty"` // 加班结束时间（2006-01-02 00:00:00,无时区信息，参照时区是提交时候的时区）

	Duration *string `json:"duration,omitempty"` // 加班时长，两位小数

	Unit *int `json:"unit,omitempty"` // 加班单位

	DateType *int `json:"date_type,omitempty"` // 日期类型

	SettleType *int `json:"settle_type,omitempty"` // 结算方式

	EffectiveTime *string `json:"effective_time,omitempty"` // 生效时间时间戳

	ProgressStartTime *string `json:"progress_start_time,omitempty"` // 流程开始时间戳

	Date *string `json:"date,omitempty"` // 加班日期

	UpdateTime *string `json:"update_time,omitempty"` // 数据更新时间

	IsTimeBank *bool `json:"is_time_bank,omitempty"` // 是否是综合工时产生的加班明细

	InstanceId *string `json:"instance_id,omitempty"` // 加班明细对应的审批单ID，如果为空代表改加班明细不是审批转入的

	OvertimeApprovalStatus *int `json:"overtime_approval_status,omitempty"` // 加班明细对应的审批状态
}

type OvertimeDetailBuilder struct {
	id     string // 加班明细ID
	idFlag bool

	userId     string // 加班明细用户ID(根据date_type_id)
	userIdFlag bool

	startTime     string // 加班开始时间格式（2006-01-02 00:00:00,无时区信息，参照时区是提交时候的时区）
	startTimeFlag bool

	endTime     string // 加班结束时间（2006-01-02 00:00:00,无时区信息，参照时区是提交时候的时区）
	endTimeFlag bool

	duration     string // 加班时长，两位小数
	durationFlag bool

	unit     int // 加班单位
	unitFlag bool

	dateType     int // 日期类型
	dateTypeFlag bool

	settleType     int // 结算方式
	settleTypeFlag bool

	effectiveTime     string // 生效时间时间戳
	effectiveTimeFlag bool

	progressStartTime     string // 流程开始时间戳
	progressStartTimeFlag bool

	date     string // 加班日期
	dateFlag bool

	updateTime     string // 数据更新时间
	updateTimeFlag bool

	isTimeBank     bool // 是否是综合工时产生的加班明细
	isTimeBankFlag bool

	instanceId     string // 加班明细对应的审批单ID，如果为空代表改加班明细不是审批转入的
	instanceIdFlag bool

	overtimeApprovalStatus     int // 加班明细对应的审批状态
	overtimeApprovalStatusFlag bool
}

func NewOvertimeDetailBuilder() *OvertimeDetailBuilder {
	builder := &OvertimeDetailBuilder{}
	return builder
}

// 加班明细ID
//
// 示例值：1
func (builder *OvertimeDetailBuilder) Id(id string) *OvertimeDetailBuilder {
	builder.id = id
	builder.idFlag = true
	return builder
}

// 加班明细用户ID(根据date_type_id)
//
// 示例值：7271137794704015379
func (builder *OvertimeDetailBuilder) UserId(userId string) *OvertimeDetailBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 加班开始时间格式（2006-01-02 00:00:00,无时区信息，参照时区是提交时候的时区）
//
// 示例值：2006-01-02 00:00:00
func (builder *OvertimeDetailBuilder) StartTime(startTime string) *OvertimeDetailBuilder {
	builder.startTime = startTime
	builder.startTimeFlag = true
	return builder
}

// 加班结束时间（2006-01-02 00:00:00,无时区信息，参照时区是提交时候的时区）
//
// 示例值：2006-01-02 00:00:00
func (builder *OvertimeDetailBuilder) EndTime(endTime string) *OvertimeDetailBuilder {
	builder.endTime = endTime
	builder.endTimeFlag = true
	return builder
}

// 加班时长，两位小数
//
// 示例值：0.5
func (builder *OvertimeDetailBuilder) Duration(duration string) *OvertimeDetailBuilder {
	builder.duration = duration
	builder.durationFlag = true
	return builder
}

// 加班单位
//
// 示例值：1
func (builder *OvertimeDetailBuilder) Unit(unit int) *OvertimeDetailBuilder {
	builder.unit = unit
	builder.unitFlag = true
	return builder
}

// 日期类型
//
// 示例值：1
func (builder *OvertimeDetailBuilder) DateType(dateType int) *OvertimeDetailBuilder {
	builder.dateType = dateType
	builder.dateTypeFlag = true
	return builder
}

// 结算方式
//
// 示例值：1
func (builder *OvertimeDetailBuilder) SettleType(settleType int) *OvertimeDetailBuilder {
	builder.settleType = settleType
	builder.settleTypeFlag = true
	return builder
}

// 生效时间时间戳
//
// 示例值：1694592064
func (builder *OvertimeDetailBuilder) EffectiveTime(effectiveTime string) *OvertimeDetailBuilder {
	builder.effectiveTime = effectiveTime
	builder.effectiveTimeFlag = true
	return builder
}

// 流程开始时间戳
//
// 示例值：1694592064
func (builder *OvertimeDetailBuilder) ProgressStartTime(progressStartTime string) *OvertimeDetailBuilder {
	builder.progressStartTime = progressStartTime
	builder.progressStartTimeFlag = true
	return builder
}

// 加班日期
//
// 示例值：2006-01-02
func (builder *OvertimeDetailBuilder) Date(date string) *OvertimeDetailBuilder {
	builder.date = date
	builder.dateFlag = true
	return builder
}

// 数据更新时间
//
// 示例值：2023-12-31
func (builder *OvertimeDetailBuilder) UpdateTime(updateTime string) *OvertimeDetailBuilder {
	builder.updateTime = updateTime
	builder.updateTimeFlag = true
	return builder
}

// 是否是综合工时产生的加班明细
//
// 示例值：false
func (builder *OvertimeDetailBuilder) IsTimeBank(isTimeBank bool) *OvertimeDetailBuilder {
	builder.isTimeBank = isTimeBank
	builder.isTimeBankFlag = true
	return builder
}

// 加班明细对应的审批单ID，如果为空代表改加班明细不是审批转入的
//
// 示例值：1234
func (builder *OvertimeDetailBuilder) InstanceId(instanceId string) *OvertimeDetailBuilder {
	builder.instanceId = instanceId
	builder.instanceIdFlag = true
	return builder
}

// 加班明细对应的审批状态
//
// 示例值：0
func (builder *OvertimeDetailBuilder) OvertimeApprovalStatus(overtimeApprovalStatus int) *OvertimeDetailBuilder {
	builder.overtimeApprovalStatus = overtimeApprovalStatus
	builder.overtimeApprovalStatusFlag = true
	return builder
}

func (builder *OvertimeDetailBuilder) Build() *OvertimeDetail {
	req := &OvertimeDetail{}
	if builder.idFlag {
		req.Id = &builder.id

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.startTimeFlag {
		req.StartTime = &builder.startTime

	}
	if builder.endTimeFlag {
		req.EndTime = &builder.endTime

	}
	if builder.durationFlag {
		req.Duration = &builder.duration

	}
	if builder.unitFlag {
		req.Unit = &builder.unit

	}
	if builder.dateTypeFlag {
		req.DateType = &builder.dateType

	}
	if builder.settleTypeFlag {
		req.SettleType = &builder.settleType

	}
	if builder.effectiveTimeFlag {
		req.EffectiveTime = &builder.effectiveTime

	}
	if builder.progressStartTimeFlag {
		req.ProgressStartTime = &builder.progressStartTime

	}
	if builder.dateFlag {
		req.Date = &builder.date

	}
	if builder.updateTimeFlag {
		req.UpdateTime = &builder.updateTime

	}
	if builder.isTimeBankFlag {
		req.IsTimeBank = &builder.isTimeBank

	}
	if builder.instanceIdFlag {
		req.InstanceId = &builder.instanceId

	}
	if builder.overtimeApprovalStatusFlag {
		req.OvertimeApprovalStatus = &builder.overtimeApprovalStatus

	}
	return req
}

type OvertimeRule struct {
	OnOvertime *string `json:"on_overtime,omitempty"` // 加班上班时间

	OffOvertime *string `json:"off_overtime,omitempty"` // 加班下班时间
}

type OvertimeRuleBuilder struct {
	onOvertime     string // 加班上班时间
	onOvertimeFlag bool

	offOvertime     string // 加班下班时间
	offOvertimeFlag bool
}

func NewOvertimeRuleBuilder() *OvertimeRuleBuilder {
	builder := &OvertimeRuleBuilder{}
	return builder
}

// 加班上班时间
//
// 示例值：9：00
func (builder *OvertimeRuleBuilder) OnOvertime(onOvertime string) *OvertimeRuleBuilder {
	builder.onOvertime = onOvertime
	builder.onOvertimeFlag = true
	return builder
}

// 加班下班时间
//
// 示例值：18：00， 第二天凌晨2点， 26：00
func (builder *OvertimeRuleBuilder) OffOvertime(offOvertime string) *OvertimeRuleBuilder {
	builder.offOvertime = offOvertime
	builder.offOvertimeFlag = true
	return builder
}

func (builder *OvertimeRuleBuilder) Build() *OvertimeRule {
	req := &OvertimeRule{}
	if builder.onOvertimeFlag {
		req.OnOvertime = &builder.onOvertime

	}
	if builder.offOvertimeFlag {
		req.OffOvertime = &builder.offOvertime

	}
	return req
}

type OvertimeTimeRange struct {
	StartTime *string `json:"start_time,omitempty"` // 开始时间

	EndTime *string `json:"end_time,omitempty"` // 结束时间
}

type OvertimeTimeRangeBuilder struct {
	startTime     string // 开始时间
	startTimeFlag bool

	endTime     string // 结束时间
	endTimeFlag bool
}

func NewOvertimeTimeRangeBuilder() *OvertimeTimeRangeBuilder {
	builder := &OvertimeTimeRangeBuilder{}
	return builder
}

// 开始时间
//
// 示例值：2023-09-25 07:00:00
func (builder *OvertimeTimeRangeBuilder) StartTime(startTime string) *OvertimeTimeRangeBuilder {
	builder.startTime = startTime
	builder.startTimeFlag = true
	return builder
}

// 结束时间
//
// 示例值：2023-09-25 23:30:00
func (builder *OvertimeTimeRangeBuilder) EndTime(endTime string) *OvertimeTimeRangeBuilder {
	builder.endTime = endTime
	builder.endTimeFlag = true
	return builder
}

func (builder *OvertimeTimeRangeBuilder) Build() *OvertimeTimeRange {
	req := &OvertimeTimeRange{}
	if builder.startTimeFlag {
		req.StartTime = &builder.startTime

	}
	if builder.endTimeFlag {
		req.EndTime = &builder.endTime

	}
	return req
}

type PunchMember struct {
	RuleScopeType *int `json:"rule_scope_type,omitempty"` // 圈人方式：0 无 1全部 2自定义

	ScopeGroupList *ScopeGroup `json:"scope_group_list,omitempty"` // 圈人规则列表
}

type PunchMemberBuilder struct {
	ruleScopeType     int // 圈人方式：0 无 1全部 2自定义
	ruleScopeTypeFlag bool

	scopeGroupList     *ScopeGroup // 圈人规则列表
	scopeGroupListFlag bool
}

func NewPunchMemberBuilder() *PunchMemberBuilder {
	builder := &PunchMemberBuilder{}
	return builder
}

// 圈人方式：0 无 1全部 2自定义
//
// 示例值：0
func (builder *PunchMemberBuilder) RuleScopeType(ruleScopeType int) *PunchMemberBuilder {
	builder.ruleScopeType = ruleScopeType
	builder.ruleScopeTypeFlag = true
	return builder
}

// 圈人规则列表
//
// 示例值：
func (builder *PunchMemberBuilder) ScopeGroupList(scopeGroupList *ScopeGroup) *PunchMemberBuilder {
	builder.scopeGroupList = scopeGroupList
	builder.scopeGroupListFlag = true
	return builder
}

func (builder *PunchMemberBuilder) Build() *PunchMember {
	req := &PunchMember{}
	if builder.ruleScopeTypeFlag {
		req.RuleScopeType = &builder.ruleScopeType

	}
	if builder.scopeGroupListFlag {
		req.ScopeGroupList = builder.scopeGroupList
	}
	return req
}

type PunchSpecialDateShift struct {
	PunchDay *int `json:"punch_day,omitempty"` // 打卡日期

	ShiftId *string `json:"shift_id,omitempty"` // 班次 ID
}

type PunchSpecialDateShiftBuilder struct {
	punchDay     int // 打卡日期
	punchDayFlag bool

	shiftId     string // 班次 ID
	shiftIdFlag bool
}

func NewPunchSpecialDateShiftBuilder() *PunchSpecialDateShiftBuilder {
	builder := &PunchSpecialDateShiftBuilder{}
	return builder
}

// 打卡日期
//
// 示例值：20190101
func (builder *PunchSpecialDateShiftBuilder) PunchDay(punchDay int) *PunchSpecialDateShiftBuilder {
	builder.punchDay = punchDay
	builder.punchDayFlag = true
	return builder
}

// 班次 ID
//
// 示例值：6919668827865513935
func (builder *PunchSpecialDateShiftBuilder) ShiftId(shiftId string) *PunchSpecialDateShiftBuilder {
	builder.shiftId = shiftId
	builder.shiftIdFlag = true
	return builder
}

func (builder *PunchSpecialDateShiftBuilder) Build() *PunchSpecialDateShift {
	req := &PunchSpecialDateShift{}
	if builder.punchDayFlag {
		req.PunchDay = &builder.punchDay

	}
	if builder.shiftIdFlag {
		req.ShiftId = &builder.shiftId

	}
	return req
}

type PunchTimeRule struct {
	OnTime *string `json:"on_time,omitempty"` // 上班时间

	OffTime *string `json:"off_time,omitempty"` // 下班时间

	LateMinutesAsLate *int `json:"late_minutes_as_late,omitempty"` // 晚到多久记为迟到

	LateMinutesAsLack *int `json:"late_minutes_as_lack,omitempty"` // 晚到多久记为缺卡

	OnAdvanceMinutes *int `json:"on_advance_minutes,omitempty"` // 最早多久可打上班卡

	EarlyMinutesAsEarly *int `json:"early_minutes_as_early,omitempty"` // 早退多久记为早退

	EarlyMinutesAsLack *int `json:"early_minutes_as_lack,omitempty"` // 早退多久记为缺卡

	OffDelayMinutes *int `json:"off_delay_minutes,omitempty"` // 最晚多久可打下班卡

	LateMinutesAsSeriousLate *int `json:"late_minutes_as_serious_late,omitempty"` // 晚到多久记为严重迟到

	NoNeedOn *bool `json:"no_need_on,omitempty"` // 不需要打上班卡

	NoNeedOff *bool `json:"no_need_off,omitempty"` // 不需要打下班卡
}

type PunchTimeRuleBuilder struct {
	onTime     string // 上班时间
	onTimeFlag bool

	offTime     string // 下班时间
	offTimeFlag bool

	lateMinutesAsLate     int // 晚到多久记为迟到
	lateMinutesAsLateFlag bool

	lateMinutesAsLack     int // 晚到多久记为缺卡
	lateMinutesAsLackFlag bool

	onAdvanceMinutes     int // 最早多久可打上班卡
	onAdvanceMinutesFlag bool

	earlyMinutesAsEarly     int // 早退多久记为早退
	earlyMinutesAsEarlyFlag bool

	earlyMinutesAsLack     int // 早退多久记为缺卡
	earlyMinutesAsLackFlag bool

	offDelayMinutes     int // 最晚多久可打下班卡
	offDelayMinutesFlag bool

	lateMinutesAsSeriousLate     int // 晚到多久记为严重迟到
	lateMinutesAsSeriousLateFlag bool

	noNeedOn     bool // 不需要打上班卡
	noNeedOnFlag bool

	noNeedOff     bool // 不需要打下班卡
	noNeedOffFlag bool
}

func NewPunchTimeRuleBuilder() *PunchTimeRuleBuilder {
	builder := &PunchTimeRuleBuilder{}
	return builder
}

// 上班时间
//
// 示例值：9:00
func (builder *PunchTimeRuleBuilder) OnTime(onTime string) *PunchTimeRuleBuilder {
	builder.onTime = onTime
	builder.onTimeFlag = true
	return builder
}

// 下班时间
//
// 示例值：18:00， 第二天凌晨2点， 26:00
func (builder *PunchTimeRuleBuilder) OffTime(offTime string) *PunchTimeRuleBuilder {
	builder.offTime = offTime
	builder.offTimeFlag = true
	return builder
}

// 晚到多久记为迟到
//
// 示例值：30
func (builder *PunchTimeRuleBuilder) LateMinutesAsLate(lateMinutesAsLate int) *PunchTimeRuleBuilder {
	builder.lateMinutesAsLate = lateMinutesAsLate
	builder.lateMinutesAsLateFlag = true
	return builder
}

// 晚到多久记为缺卡
//
// 示例值：60
func (builder *PunchTimeRuleBuilder) LateMinutesAsLack(lateMinutesAsLack int) *PunchTimeRuleBuilder {
	builder.lateMinutesAsLack = lateMinutesAsLack
	builder.lateMinutesAsLackFlag = true
	return builder
}

// 最早多久可打上班卡
//
// 示例值：60
func (builder *PunchTimeRuleBuilder) OnAdvanceMinutes(onAdvanceMinutes int) *PunchTimeRuleBuilder {
	builder.onAdvanceMinutes = onAdvanceMinutes
	builder.onAdvanceMinutesFlag = true
	return builder
}

// 早退多久记为早退
//
// 示例值：30
func (builder *PunchTimeRuleBuilder) EarlyMinutesAsEarly(earlyMinutesAsEarly int) *PunchTimeRuleBuilder {
	builder.earlyMinutesAsEarly = earlyMinutesAsEarly
	builder.earlyMinutesAsEarlyFlag = true
	return builder
}

// 早退多久记为缺卡
//
// 示例值：60
func (builder *PunchTimeRuleBuilder) EarlyMinutesAsLack(earlyMinutesAsLack int) *PunchTimeRuleBuilder {
	builder.earlyMinutesAsLack = earlyMinutesAsLack
	builder.earlyMinutesAsLackFlag = true
	return builder
}

// 最晚多久可打下班卡
//
// 示例值：60
func (builder *PunchTimeRuleBuilder) OffDelayMinutes(offDelayMinutes int) *PunchTimeRuleBuilder {
	builder.offDelayMinutes = offDelayMinutes
	builder.offDelayMinutesFlag = true
	return builder
}

// 晚到多久记为严重迟到
//
// 示例值：40
func (builder *PunchTimeRuleBuilder) LateMinutesAsSeriousLate(lateMinutesAsSeriousLate int) *PunchTimeRuleBuilder {
	builder.lateMinutesAsSeriousLate = lateMinutesAsSeriousLate
	builder.lateMinutesAsSeriousLateFlag = true
	return builder
}

// 不需要打上班卡
//
// 示例值：true
func (builder *PunchTimeRuleBuilder) NoNeedOn(noNeedOn bool) *PunchTimeRuleBuilder {
	builder.noNeedOn = noNeedOn
	builder.noNeedOnFlag = true
	return builder
}

// 不需要打下班卡
//
// 示例值：true
func (builder *PunchTimeRuleBuilder) NoNeedOff(noNeedOff bool) *PunchTimeRuleBuilder {
	builder.noNeedOff = noNeedOff
	builder.noNeedOffFlag = true
	return builder
}

func (builder *PunchTimeRuleBuilder) Build() *PunchTimeRule {
	req := &PunchTimeRule{}
	if builder.onTimeFlag {
		req.OnTime = &builder.onTime

	}
	if builder.offTimeFlag {
		req.OffTime = &builder.offTime

	}
	if builder.lateMinutesAsLateFlag {
		req.LateMinutesAsLate = &builder.lateMinutesAsLate

	}
	if builder.lateMinutesAsLackFlag {
		req.LateMinutesAsLack = &builder.lateMinutesAsLack

	}
	if builder.onAdvanceMinutesFlag {
		req.OnAdvanceMinutes = &builder.onAdvanceMinutes

	}
	if builder.earlyMinutesAsEarlyFlag {
		req.EarlyMinutesAsEarly = &builder.earlyMinutesAsEarly

	}
	if builder.earlyMinutesAsLackFlag {
		req.EarlyMinutesAsLack = &builder.earlyMinutesAsLack

	}
	if builder.offDelayMinutesFlag {
		req.OffDelayMinutes = &builder.offDelayMinutes

	}
	if builder.lateMinutesAsSeriousLateFlag {
		req.LateMinutesAsSeriousLate = &builder.lateMinutesAsSeriousLate

	}
	if builder.noNeedOnFlag {
		req.NoNeedOn = &builder.noNeedOn

	}
	if builder.noNeedOffFlag {
		req.NoNeedOff = &builder.noNeedOff

	}
	return req
}

type PunchTimeSimpleRule struct {
	OnTime *string `json:"on_time,omitempty"` // 上班时间

	OffTime *string `json:"off_time,omitempty"` // 下班时间
}

type PunchTimeSimpleRuleBuilder struct {
	onTime     string // 上班时间
	onTimeFlag bool

	offTime     string // 下班时间
	offTimeFlag bool
}

func NewPunchTimeSimpleRuleBuilder() *PunchTimeSimpleRuleBuilder {
	builder := &PunchTimeSimpleRuleBuilder{}
	return builder
}

// 上班时间
//
// 示例值：9：00
func (builder *PunchTimeSimpleRuleBuilder) OnTime(onTime string) *PunchTimeSimpleRuleBuilder {
	builder.onTime = onTime
	builder.onTimeFlag = true
	return builder
}

// 下班时间
//
// 示例值：18：00， 第二天凌晨2点， 26：00
func (builder *PunchTimeSimpleRuleBuilder) OffTime(offTime string) *PunchTimeSimpleRuleBuilder {
	builder.offTime = offTime
	builder.offTimeFlag = true
	return builder
}

func (builder *PunchTimeSimpleRuleBuilder) Build() *PunchTimeSimpleRule {
	req := &PunchTimeSimpleRule{}
	if builder.onTimeFlag {
		req.OnTime = &builder.onTime

	}
	if builder.offTimeFlag {
		req.OffTime = &builder.offTime

	}
	return req
}

type RegionPlace struct {
	RegionLevel *string `json:"region_level,omitempty"` // 地理位置的等级 国家｜省｜市｜区 一共四个级别

	RegionId *string `json:"region_id,omitempty"` // 地理位置的id，从标准地理库获取
}

type RegionPlaceBuilder struct {
	regionLevel     string // 地理位置的等级 国家｜省｜市｜区 一共四个级别
	regionLevelFlag bool

	regionId     string // 地理位置的id，从标准地理库获取
	regionIdFlag bool
}

func NewRegionPlaceBuilder() *RegionPlaceBuilder {
	builder := &RegionPlaceBuilder{}
	return builder
}

// 地理位置的等级 国家｜省｜市｜区 一共四个级别
//
// 示例值：l1
func (builder *RegionPlaceBuilder) RegionLevel(regionLevel string) *RegionPlaceBuilder {
	builder.regionLevel = regionLevel
	builder.regionLevelFlag = true
	return builder
}

// 地理位置的id，从标准地理库获取
//
// 示例值：6863333418483058189
func (builder *RegionPlaceBuilder) RegionId(regionId string) *RegionPlaceBuilder {
	builder.regionId = regionId
	builder.regionIdFlag = true
	return builder
}

func (builder *RegionPlaceBuilder) Build() *RegionPlace {
	req := &RegionPlace{}
	if builder.regionLevelFlag {
		req.RegionLevel = &builder.regionLevel

	}
	if builder.regionIdFlag {
		req.RegionId = &builder.regionId

	}
	return req
}

type RemedyRecord struct {
	RemedyDate *string `json:"remedy_date,omitempty"` // 补卡日期，示例20250202

	PunchNo *int `json:"punch_no,omitempty"` // 第几次上下班，0：第 1 次上下班，1：第 2 次上下班，2：第 3 次上下班，3：第 4 次上下班，4：第 5 次上下班，5：第 6 次上下班

	WorkType *int `json:"work_type,omitempty"` // 上班 / 下班，1：上班，2：下班

	RemedyTime *string `json:"remedy_time,omitempty"` // 补卡时间，时间格式为yyyy-MM-dd HH:mm
}

type RemedyRecordBuilder struct {
	remedyDate     string // 补卡日期，示例20250202
	remedyDateFlag bool

	punchNo     int // 第几次上下班，0：第 1 次上下班，1：第 2 次上下班，2：第 3 次上下班，3：第 4 次上下班，4：第 5 次上下班，5：第 6 次上下班
	punchNoFlag bool

	workType     int // 上班 / 下班，1：上班，2：下班
	workTypeFlag bool

	remedyTime     string // 补卡时间，时间格式为yyyy-MM-dd HH:mm
	remedyTimeFlag bool
}

func NewRemedyRecordBuilder() *RemedyRecordBuilder {
	builder := &RemedyRecordBuilder{}
	return builder
}

// 补卡日期，示例20250202
//
// 示例值：20250202
func (builder *RemedyRecordBuilder) RemedyDate(remedyDate string) *RemedyRecordBuilder {
	builder.remedyDate = remedyDate
	builder.remedyDateFlag = true
	return builder
}

// 第几次上下班，0：第 1 次上下班，1：第 2 次上下班，2：第 3 次上下班，3：第 4 次上下班，4：第 5 次上下班，5：第 6 次上下班
//
// 示例值：0
func (builder *RemedyRecordBuilder) PunchNo(punchNo int) *RemedyRecordBuilder {
	builder.punchNo = punchNo
	builder.punchNoFlag = true
	return builder
}

// 上班 / 下班，1：上班，2：下班
//
// 示例值：1
func (builder *RemedyRecordBuilder) WorkType(workType int) *RemedyRecordBuilder {
	builder.workType = workType
	builder.workTypeFlag = true
	return builder
}

// 补卡时间，时间格式为yyyy-MM-dd HH:mm
//
// 示例值：2025-03-10 09:00
func (builder *RemedyRecordBuilder) RemedyTime(remedyTime string) *RemedyRecordBuilder {
	builder.remedyTime = remedyTime
	builder.remedyTimeFlag = true
	return builder
}

func (builder *RemedyRecordBuilder) Build() *RemedyRecord {
	req := &RemedyRecord{}
	if builder.remedyDateFlag {
		req.RemedyDate = &builder.remedyDate

	}
	if builder.punchNoFlag {
		req.PunchNo = &builder.punchNo

	}
	if builder.workTypeFlag {
		req.WorkType = &builder.workType

	}
	if builder.remedyTimeFlag {
		req.RemedyTime = &builder.remedyTime

	}
	return req
}

type ReportData struct {
	UserId *string `json:"user_id,omitempty"` // 用户ID

	FieldData map[string]*ReportValue `json:"field_data,omitempty"` // 字段对应的zhi
}

type ReportDataBuilder struct {
	userId     string // 用户ID
	userIdFlag bool

	fieldData     map[string]*ReportValue // 字段对应的zhi
	fieldDataFlag bool
}

func NewReportDataBuilder() *ReportDataBuilder {
	builder := &ReportDataBuilder{}
	return builder
}

// 用户ID
//
// 示例值：
func (builder *ReportDataBuilder) UserId(userId string) *ReportDataBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 字段对应的zhi
//
// 示例值：
func (builder *ReportDataBuilder) FieldData(fieldData map[string]*ReportValue) *ReportDataBuilder {
	builder.fieldData = fieldData
	builder.fieldDataFlag = true
	return builder
}

func (builder *ReportDataBuilder) Build() *ReportData {
	req := &ReportData{}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.fieldDataFlag {
		req.FieldData = builder.fieldData
	}
	return req
}

type ReportField struct {
	Code *string `json:"code,omitempty"` // 列簇编

	Title *string `json:"title,omitempty"` // 字段标题

	IsCalculable *bool `json:"is_calculable,omitempty"` // 是否可计算

	FieldId *string `json:"field_id,omitempty"` // 归档模版字段id

	SubFields *string `json:"sub_fields,omitempty"` // 子字段列表

	I18nName []*I18nResource `json:"i18n_name,omitempty"` // 多语言字段名称
}

type ReportFieldBuilder struct {
	code     string // 列簇编
	codeFlag bool

	title     string // 字段标题
	titleFlag bool

	isCalculable     bool // 是否可计算
	isCalculableFlag bool

	fieldId     string // 归档模版字段id
	fieldIdFlag bool

	subFields     string // 子字段列表
	subFieldsFlag bool

	i18nName     []*I18nResource // 多语言字段名称
	i18nNameFlag bool
}

func NewReportFieldBuilder() *ReportFieldBuilder {
	builder := &ReportFieldBuilder{}
	return builder
}

// 列簇编
//
// 示例值：fasfa
func (builder *ReportFieldBuilder) Code(code string) *ReportFieldBuilder {
	builder.code = code
	builder.codeFlag = true
	return builder
}

// 字段标题
//
// 示例值：日期
func (builder *ReportFieldBuilder) Title(title string) *ReportFieldBuilder {
	builder.title = title
	builder.titleFlag = true
	return builder
}

// 是否可计算
//
// 示例值：true
func (builder *ReportFieldBuilder) IsCalculable(isCalculable bool) *ReportFieldBuilder {
	builder.isCalculable = isCalculable
	builder.isCalculableFlag = true
	return builder
}

// 归档模版字段id
//
// 示例值：addsacja
func (builder *ReportFieldBuilder) FieldId(fieldId string) *ReportFieldBuilder {
	builder.fieldId = fieldId
	builder.fieldIdFlag = true
	return builder
}

// 子字段列表
//
// 示例值：[{"file_id":"11","code":"111"}]
func (builder *ReportFieldBuilder) SubFields(subFields string) *ReportFieldBuilder {
	builder.subFields = subFields
	builder.subFieldsFlag = true
	return builder
}

// 多语言字段名称
//
// 示例值：
func (builder *ReportFieldBuilder) I18nName(i18nName []*I18nResource) *ReportFieldBuilder {
	builder.i18nName = i18nName
	builder.i18nNameFlag = true
	return builder
}

func (builder *ReportFieldBuilder) Build() *ReportField {
	req := &ReportField{}
	if builder.codeFlag {
		req.Code = &builder.code

	}
	if builder.titleFlag {
		req.Title = &builder.title

	}
	if builder.isCalculableFlag {
		req.IsCalculable = &builder.isCalculable

	}
	if builder.fieldIdFlag {
		req.FieldId = &builder.fieldId

	}
	if builder.subFieldsFlag {
		req.SubFields = &builder.subFields

	}
	if builder.i18nNameFlag {
		req.I18nName = builder.i18nName
	}
	return req
}

type ReportRow struct {
	Name *string `json:"name,omitempty"` // 用户姓名

	UserId *string `json:"user_id,omitempty"` // 用户ID

	ColumnMap *string `json:"column_map,omitempty"` // json string。map结构，key为列名（filed_id），value 为具体的值结构(column_value)
}

type ReportRowBuilder struct {
	name     string // 用户姓名
	nameFlag bool

	userId     string // 用户ID
	userIdFlag bool

	columnMap     string // json string。map结构，key为列名（filed_id），value 为具体的值结构(column_value)
	columnMapFlag bool
}

func NewReportRowBuilder() *ReportRowBuilder {
	builder := &ReportRowBuilder{}
	return builder
}

// 用户姓名
//
// 示例值：张三
func (builder *ReportRowBuilder) Name(name string) *ReportRowBuilder {
	builder.name = name
	builder.nameFlag = true
	return builder
}

// 用户ID
//
// 示例值：293719827389172931
func (builder *ReportRowBuilder) UserId(userId string) *ReportRowBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// json string。map结构，key为列名（filed_id），value 为具体的值结构(column_value)
//
// 示例值：{"ewqeq":{"code":"1212","value":"bkebqk"}}
func (builder *ReportRowBuilder) ColumnMap(columnMap string) *ReportRowBuilder {
	builder.columnMap = columnMap
	builder.columnMapFlag = true
	return builder
}

func (builder *ReportRowBuilder) Build() *ReportRow {
	req := &ReportRow{}
	if builder.nameFlag {
		req.Name = &builder.name

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.columnMapFlag {
		req.ColumnMap = &builder.columnMap

	}
	return req
}

type ReportValue struct {
	Value *string `json:"value,omitempty"` // 结果值

	FieldId *string `json:"field_id,omitempty"` // 字段ID
}

type ReportValueBuilder struct {
	value     string // 结果值
	valueFlag bool

	fieldId     string // 字段ID
	fieldIdFlag bool
}

func NewReportValueBuilder() *ReportValueBuilder {
	builder := &ReportValueBuilder{}
	return builder
}

// 结果值
//
// 示例值：1
func (builder *ReportValueBuilder) Value(value string) *ReportValueBuilder {
	builder.value = value
	builder.valueFlag = true
	return builder
}

// 字段ID
//
// 示例值：1
func (builder *ReportValueBuilder) FieldId(fieldId string) *ReportValueBuilder {
	builder.fieldId = fieldId
	builder.fieldIdFlag = true
	return builder
}

func (builder *ReportValueBuilder) Build() *ReportValue {
	req := &ReportValue{}
	if builder.valueFlag {
		req.Value = &builder.value

	}
	if builder.fieldIdFlag {
		req.FieldId = &builder.fieldId

	}
	return req
}

type RestRule struct {
	RestBeginTime *string `json:"rest_begin_time,omitempty"` // 休息开始

	RestEndTime *string `json:"rest_end_time,omitempty"` // 休息结束
}

type RestRuleBuilder struct {
	restBeginTime     string // 休息开始
	restBeginTimeFlag bool

	restEndTime     string // 休息结束
	restEndTimeFlag bool
}

func NewRestRuleBuilder() *RestRuleBuilder {
	builder := &RestRuleBuilder{}
	return builder
}

// 休息开始
//
// 示例值：13:00
func (builder *RestRuleBuilder) RestBeginTime(restBeginTime string) *RestRuleBuilder {
	builder.restBeginTime = restBeginTime
	builder.restBeginTimeFlag = true
	return builder
}

// 休息结束
//
// 示例值：14:00
func (builder *RestRuleBuilder) RestEndTime(restEndTime string) *RestRuleBuilder {
	builder.restEndTime = restEndTime
	builder.restEndTimeFlag = true
	return builder
}

func (builder *RestRuleBuilder) Build() *RestRule {
	req := &RestRule{}
	if builder.restBeginTimeFlag {
		req.RestBeginTime = &builder.restBeginTime

	}
	if builder.restEndTimeFlag {
		req.RestEndTime = &builder.restEndTime

	}
	return req
}

type RestTimeFlexibleConfig struct {
	NeedFlexible *bool `json:"need_flexible,omitempty"` // 是否有弹性

	LateMins *int `json:"late_mins,omitempty"` // 向后弹的时间
}

type RestTimeFlexibleConfigBuilder struct {
	needFlexible     bool // 是否有弹性
	needFlexibleFlag bool

	lateMins     int // 向后弹的时间
	lateMinsFlag bool
}

func NewRestTimeFlexibleConfigBuilder() *RestTimeFlexibleConfigBuilder {
	builder := &RestTimeFlexibleConfigBuilder{}
	return builder
}

// 是否有弹性
//
// 示例值：false
func (builder *RestTimeFlexibleConfigBuilder) NeedFlexible(needFlexible bool) *RestTimeFlexibleConfigBuilder {
	builder.needFlexible = needFlexible
	builder.needFlexibleFlag = true
	return builder
}

// 向后弹的时间
//
// 示例值：0
func (builder *RestTimeFlexibleConfigBuilder) LateMins(lateMins int) *RestTimeFlexibleConfigBuilder {
	builder.lateMins = lateMins
	builder.lateMinsFlag = true
	return builder
}

func (builder *RestTimeFlexibleConfigBuilder) Build() *RestTimeFlexibleConfig {
	req := &RestTimeFlexibleConfig{}
	if builder.needFlexibleFlag {
		req.NeedFlexible = &builder.needFlexible

	}
	if builder.lateMinsFlag {
		req.LateMins = &builder.lateMins

	}
	return req
}

type ScanWifiInfo struct {
	Ssid *string `json:"ssid,omitempty"` //

	Bssid *string `json:"bssid,omitempty"` //
}

type ScanWifiInfoBuilder struct {
	ssid     string //
	ssidFlag bool

	bssid     string //
	bssidFlag bool
}

func NewScanWifiInfoBuilder() *ScanWifiInfoBuilder {
	builder := &ScanWifiInfoBuilder{}
	return builder
}

//
//
// 示例值：
func (builder *ScanWifiInfoBuilder) Ssid(ssid string) *ScanWifiInfoBuilder {
	builder.ssid = ssid
	builder.ssidFlag = true
	return builder
}

//
//
// 示例值：
func (builder *ScanWifiInfoBuilder) Bssid(bssid string) *ScanWifiInfoBuilder {
	builder.bssid = bssid
	builder.bssidFlag = true
	return builder
}

func (builder *ScanWifiInfoBuilder) Build() *ScanWifiInfo {
	req := &ScanWifiInfo{}
	if builder.ssidFlag {
		req.Ssid = &builder.ssid

	}
	if builder.bssidFlag {
		req.Bssid = &builder.bssid

	}
	return req
}

type Schedule struct {
	GroupId *string `json:"group_id,omitempty"` // 考勤组名称

	Shifts []string `json:"shifts,omitempty"` // 班次列表
}

type ScheduleBuilder struct {
	groupId     string // 考勤组名称
	groupIdFlag bool

	shifts     []string // 班次列表
	shiftsFlag bool
}

func NewScheduleBuilder() *ScheduleBuilder {
	builder := &ScheduleBuilder{}
	return builder
}

// 考勤组名称
//
// 示例值：6919358778597097404
func (builder *ScheduleBuilder) GroupId(groupId string) *ScheduleBuilder {
	builder.groupId = groupId
	builder.groupIdFlag = true
	return builder
}

// 班次列表
//
// 示例值：
func (builder *ScheduleBuilder) Shifts(shifts []string) *ScheduleBuilder {
	builder.shifts = shifts
	builder.shiftsFlag = true
	return builder
}

func (builder *ScheduleBuilder) Build() *Schedule {
	req := &Schedule{}
	if builder.groupIdFlag {
		req.GroupId = &builder.groupId

	}
	if builder.shiftsFlag {
		req.Shifts = builder.shifts
	}
	return req
}

type ScopeGroup struct {
	ScopeValueType *int `json:"scope_value_type,omitempty"` // 类型： 1: 部门 2：人员 3:国家地区 4:员工类型 5:工作城市 6:职级 7:序列 8:职务（企业版）9:工时制度（企业版） 100:自定义字段（企业版）

	OperationType *int `json:"operation_type,omitempty"` // 范围类型（是否包含）

	Right []*ScopeValue `json:"right,omitempty"` // 如果是人员/部门类型 不需要使用该字段

	MemberIds []string `json:"member_ids,omitempty"` // 部门/人员id列表（具体类型根据scope_value_type判断）

	CustomFieldID *string `json:"custom_field_ID,omitempty"` // 企业版自定义字段唯一键 ID, 需要从飞书人事那边获取

	CustomFieldObjType *string `json:"custom_field_obj_type,omitempty"` // 企业版自定义字段对象类型  "employment":主数据对象，员工雇佣信息 , "person":主数据对象，个人
}

type ScopeGroupBuilder struct {
	scopeValueType     int // 类型： 1: 部门 2：人员 3:国家地区 4:员工类型 5:工作城市 6:职级 7:序列 8:职务（企业版）9:工时制度（企业版） 100:自定义字段（企业版）
	scopeValueTypeFlag bool

	operationType     int // 范围类型（是否包含）
	operationTypeFlag bool

	right     []*ScopeValue // 如果是人员/部门类型 不需要使用该字段
	rightFlag bool

	memberIds     []string // 部门/人员id列表（具体类型根据scope_value_type判断）
	memberIdsFlag bool

	customFieldID     string // 企业版自定义字段唯一键 ID, 需要从飞书人事那边获取
	customFieldIDFlag bool

	customFieldObjType     string // 企业版自定义字段对象类型  "employment":主数据对象，员工雇佣信息 , "person":主数据对象，个人
	customFieldObjTypeFlag bool
}

func NewScopeGroupBuilder() *ScopeGroupBuilder {
	builder := &ScopeGroupBuilder{}
	return builder
}

// 类型： 1: 部门 2：人员 3:国家地区 4:员工类型 5:工作城市 6:职级 7:序列 8:职务（企业版）9:工时制度（企业版） 100:自定义字段（企业版）
//
// 示例值：1
func (builder *ScopeGroupBuilder) ScopeValueType(scopeValueType int) *ScopeGroupBuilder {
	builder.scopeValueType = scopeValueType
	builder.scopeValueTypeFlag = true
	return builder
}

// 范围类型（是否包含）
//
// 示例值：1
func (builder *ScopeGroupBuilder) OperationType(operationType int) *ScopeGroupBuilder {
	builder.operationType = operationType
	builder.operationTypeFlag = true
	return builder
}

// 如果是人员/部门类型 不需要使用该字段
//
// 示例值：
func (builder *ScopeGroupBuilder) Right(right []*ScopeValue) *ScopeGroupBuilder {
	builder.right = right
	builder.rightFlag = true
	return builder
}

// 部门/人员id列表（具体类型根据scope_value_type判断）
//
// 示例值：
func (builder *ScopeGroupBuilder) MemberIds(memberIds []string) *ScopeGroupBuilder {
	builder.memberIds = memberIds
	builder.memberIdsFlag = true
	return builder
}

// 企业版自定义字段唯一键 ID, 需要从飞书人事那边获取
//
// 示例值：123213123
func (builder *ScopeGroupBuilder) CustomFieldID(customFieldID string) *ScopeGroupBuilder {
	builder.customFieldID = customFieldID
	builder.customFieldIDFlag = true
	return builder
}

// 企业版自定义字段对象类型  "employment":主数据对象，员工雇佣信息 , "person":主数据对象，个人
//
// 示例值：employment
func (builder *ScopeGroupBuilder) CustomFieldObjType(customFieldObjType string) *ScopeGroupBuilder {
	builder.customFieldObjType = customFieldObjType
	builder.customFieldObjTypeFlag = true
	return builder
}

func (builder *ScopeGroupBuilder) Build() *ScopeGroup {
	req := &ScopeGroup{}
	if builder.scopeValueTypeFlag {
		req.ScopeValueType = &builder.scopeValueType

	}
	if builder.operationTypeFlag {
		req.OperationType = &builder.operationType

	}
	if builder.rightFlag {
		req.Right = builder.right
	}
	if builder.memberIdsFlag {
		req.MemberIds = builder.memberIds
	}
	if builder.customFieldIDFlag {
		req.CustomFieldID = &builder.customFieldID

	}
	if builder.customFieldObjTypeFlag {
		req.CustomFieldObjType = &builder.customFieldObjType

	}
	return req
}

type ScopeValue struct {
	Key *string `json:"key,omitempty"` //  标识Key

	Name *string `json:"name,omitempty"` // 名称
}

type ScopeValueBuilder struct {
	key     string //  标识Key
	keyFlag bool

	name     string // 名称
	nameFlag bool
}

func NewScopeValueBuilder() *ScopeValueBuilder {
	builder := &ScopeValueBuilder{}
	return builder
}

//  标识Key
//
// 示例值：CH
func (builder *ScopeValueBuilder) Key(key string) *ScopeValueBuilder {
	builder.key = key
	builder.keyFlag = true
	return builder
}

// 名称
//
// 示例值：中国大陆
func (builder *ScopeValueBuilder) Name(name string) *ScopeValueBuilder {
	builder.name = name
	builder.nameFlag = true
	return builder
}

func (builder *ScopeValueBuilder) Build() *ScopeValue {
	req := &ScopeValue{}
	if builder.keyFlag {
		req.Key = &builder.key

	}
	if builder.nameFlag {
		req.Name = &builder.name

	}
	return req
}

type Shift struct {
	ShiftId *string `json:"shift_id,omitempty"` // 班次 ID

	ShiftName *string `json:"shift_name,omitempty"` // 班次名称

	PunchTimes *int `json:"punch_times,omitempty"` // 打卡次数

	SubShiftLeaderIds []string `json:"sub_shift_leader_ids,omitempty"` // 排班组子负责人id列表

	IsFlexible *bool `json:"is_flexible,omitempty"` // 是否弹性打卡

	FlexibleMinutes *int `json:"flexible_minutes,omitempty"` // 弹性打卡时间，设置【上班最多可晚到】与【下班最多可早走】时间，如果不设置flexible_rule则生效

	FlexibleRule []*FlexibleRule `json:"flexible_rule,omitempty"` // 弹性打卡时间设置

	NoNeedOff *bool `json:"no_need_off,omitempty"` // 不需要打下班卡

	PunchTimeRule []*PunchTimeRule `json:"punch_time_rule,omitempty"` // 打卡规则

	LateOffLateOnRule []*LateOffLateOnRule `json:"late_off_late_on_rule,omitempty"` // 晚走晚到规则

	RestTimeRule []*RestRule `json:"rest_time_rule,omitempty"` // 休息规则

	OvertimeRule []*OvertimeRule `json:"overtime_rule,omitempty"` // 打卡规则

	DayType *int `json:"day_type,omitempty"` // 日期类型，【是否弹性打卡 = ture】时，不可设置为“休息日”  可选值：1：工作日 2：休息日	 示例值：（默认值）1

	OvertimeRestTimeRule []*RestRule `json:"overtime_rest_time_rule,omitempty"` // 班外休息规则

	LateMinutesAsSeriousLate *int `json:"late_minutes_as_serious_late,omitempty"` // 晚到多久记为严重迟到（优先级比原有字段高）

	ShiftMiddleTimeRule *ShiftMiddleTimeRule `json:"shift_middle_time_rule,omitempty"` // 半天分割规则

	ShiftAttendanceTimeConfig *ShiftAttendanceTimeConfig `json:"shift_attendance_time_config,omitempty"` // 应出勤配置

	LateOffLateOnSetting *LateOffLateOnSetting `json:"late_off_late_on_setting,omitempty"` // 晚走次日晚到配置规则

	Id *string `json:"id,omitempty"` // 班次id(更新班次时需要传递)

	RestTimeFlexibleConfigs []*RestTimeFlexibleConfig `json:"rest_time_flexible_configs,omitempty"` // 休息弹性设置
}

type ShiftBuilder struct {
	shiftId     string // 班次 ID
	shiftIdFlag bool

	shiftName     string // 班次名称
	shiftNameFlag bool

	punchTimes     int // 打卡次数
	punchTimesFlag bool

	subShiftLeaderIds     []string // 排班组子负责人id列表
	subShiftLeaderIdsFlag bool

	isFlexible     bool // 是否弹性打卡
	isFlexibleFlag bool

	flexibleMinutes     int // 弹性打卡时间，设置【上班最多可晚到】与【下班最多可早走】时间，如果不设置flexible_rule则生效
	flexibleMinutesFlag bool

	flexibleRule     []*FlexibleRule // 弹性打卡时间设置
	flexibleRuleFlag bool

	noNeedOff     bool // 不需要打下班卡
	noNeedOffFlag bool

	punchTimeRule     []*PunchTimeRule // 打卡规则
	punchTimeRuleFlag bool

	lateOffLateOnRule     []*LateOffLateOnRule // 晚走晚到规则
	lateOffLateOnRuleFlag bool

	restTimeRule     []*RestRule // 休息规则
	restTimeRuleFlag bool

	overtimeRule     []*OvertimeRule // 打卡规则
	overtimeRuleFlag bool

	dayType     int // 日期类型，【是否弹性打卡 = ture】时，不可设置为“休息日”  可选值：1：工作日 2：休息日	 示例值：（默认值）1
	dayTypeFlag bool

	overtimeRestTimeRule     []*RestRule // 班外休息规则
	overtimeRestTimeRuleFlag bool

	lateMinutesAsSeriousLate     int // 晚到多久记为严重迟到（优先级比原有字段高）
	lateMinutesAsSeriousLateFlag bool

	shiftMiddleTimeRule     *ShiftMiddleTimeRule // 半天分割规则
	shiftMiddleTimeRuleFlag bool

	shiftAttendanceTimeConfig     *ShiftAttendanceTimeConfig // 应出勤配置
	shiftAttendanceTimeConfigFlag bool

	lateOffLateOnSetting     *LateOffLateOnSetting // 晚走次日晚到配置规则
	lateOffLateOnSettingFlag bool

	id     string // 班次id(更新班次时需要传递)
	idFlag bool

	restTimeFlexibleConfigs     []*RestTimeFlexibleConfig // 休息弹性设置
	restTimeFlexibleConfigsFlag bool
}

func NewShiftBuilder() *ShiftBuilder {
	builder := &ShiftBuilder{}
	return builder
}

// 班次 ID
//
// 示例值：6919358778597097404
func (builder *ShiftBuilder) ShiftId(shiftId string) *ShiftBuilder {
	builder.shiftId = shiftId
	builder.shiftIdFlag = true
	return builder
}

// 班次名称
//
// 示例值：早班
func (builder *ShiftBuilder) ShiftName(shiftName string) *ShiftBuilder {
	builder.shiftName = shiftName
	builder.shiftNameFlag = true
	return builder
}

// 打卡次数
//
// 示例值：1
func (builder *ShiftBuilder) PunchTimes(punchTimes int) *ShiftBuilder {
	builder.punchTimes = punchTimes
	builder.punchTimesFlag = true
	return builder
}

// 排班组子负责人id列表
//
// 示例值：
func (builder *ShiftBuilder) SubShiftLeaderIds(subShiftLeaderIds []string) *ShiftBuilder {
	builder.subShiftLeaderIds = subShiftLeaderIds
	builder.subShiftLeaderIdsFlag = true
	return builder
}

// 是否弹性打卡
//
// 示例值：false
func (builder *ShiftBuilder) IsFlexible(isFlexible bool) *ShiftBuilder {
	builder.isFlexible = isFlexible
	builder.isFlexibleFlag = true
	return builder
}

// 弹性打卡时间，设置【上班最多可晚到】与【下班最多可早走】时间，如果不设置flexible_rule则生效
//
// 示例值：60
func (builder *ShiftBuilder) FlexibleMinutes(flexibleMinutes int) *ShiftBuilder {
	builder.flexibleMinutes = flexibleMinutes
	builder.flexibleMinutesFlag = true
	return builder
}

// 弹性打卡时间设置
//
// 示例值：
func (builder *ShiftBuilder) FlexibleRule(flexibleRule []*FlexibleRule) *ShiftBuilder {
	builder.flexibleRule = flexibleRule
	builder.flexibleRuleFlag = true
	return builder
}

// 不需要打下班卡
//
// 示例值：true
func (builder *ShiftBuilder) NoNeedOff(noNeedOff bool) *ShiftBuilder {
	builder.noNeedOff = noNeedOff
	builder.noNeedOffFlag = true
	return builder
}

// 打卡规则
//
// 示例值：
func (builder *ShiftBuilder) PunchTimeRule(punchTimeRule []*PunchTimeRule) *ShiftBuilder {
	builder.punchTimeRule = punchTimeRule
	builder.punchTimeRuleFlag = true
	return builder
}

// 晚走晚到规则
//
// 示例值：
func (builder *ShiftBuilder) LateOffLateOnRule(lateOffLateOnRule []*LateOffLateOnRule) *ShiftBuilder {
	builder.lateOffLateOnRule = lateOffLateOnRule
	builder.lateOffLateOnRuleFlag = true
	return builder
}

// 休息规则
//
// 示例值：
func (builder *ShiftBuilder) RestTimeRule(restTimeRule []*RestRule) *ShiftBuilder {
	builder.restTimeRule = restTimeRule
	builder.restTimeRuleFlag = true
	return builder
}

// 打卡规则
//
// 示例值：
func (builder *ShiftBuilder) OvertimeRule(overtimeRule []*OvertimeRule) *ShiftBuilder {
	builder.overtimeRule = overtimeRule
	builder.overtimeRuleFlag = true
	return builder
}

// 日期类型，【是否弹性打卡 = ture】时，不可设置为“休息日”  可选值：1：工作日 2：休息日	 示例值：（默认值）1
//
// 示例值：1
func (builder *ShiftBuilder) DayType(dayType int) *ShiftBuilder {
	builder.dayType = dayType
	builder.dayTypeFlag = true
	return builder
}

// 班外休息规则
//
// 示例值：
func (builder *ShiftBuilder) OvertimeRestTimeRule(overtimeRestTimeRule []*RestRule) *ShiftBuilder {
	builder.overtimeRestTimeRule = overtimeRestTimeRule
	builder.overtimeRestTimeRuleFlag = true
	return builder
}

// 晚到多久记为严重迟到（优先级比原有字段高）
//
// 示例值：40
func (builder *ShiftBuilder) LateMinutesAsSeriousLate(lateMinutesAsSeriousLate int) *ShiftBuilder {
	builder.lateMinutesAsSeriousLate = lateMinutesAsSeriousLate
	builder.lateMinutesAsSeriousLateFlag = true
	return builder
}

// 半天分割规则
//
// 示例值：
func (builder *ShiftBuilder) ShiftMiddleTimeRule(shiftMiddleTimeRule *ShiftMiddleTimeRule) *ShiftBuilder {
	builder.shiftMiddleTimeRule = shiftMiddleTimeRule
	builder.shiftMiddleTimeRuleFlag = true
	return builder
}

// 应出勤配置
//
// 示例值：
func (builder *ShiftBuilder) ShiftAttendanceTimeConfig(shiftAttendanceTimeConfig *ShiftAttendanceTimeConfig) *ShiftBuilder {
	builder.shiftAttendanceTimeConfig = shiftAttendanceTimeConfig
	builder.shiftAttendanceTimeConfigFlag = true
	return builder
}

// 晚走次日晚到配置规则
//
// 示例值：
func (builder *ShiftBuilder) LateOffLateOnSetting(lateOffLateOnSetting *LateOffLateOnSetting) *ShiftBuilder {
	builder.lateOffLateOnSetting = lateOffLateOnSetting
	builder.lateOffLateOnSettingFlag = true
	return builder
}

// 班次id(更新班次时需要传递)
//
// 示例值：6919358778597097404
func (builder *ShiftBuilder) Id(id string) *ShiftBuilder {
	builder.id = id
	builder.idFlag = true
	return builder
}

// 休息弹性设置
//
// 示例值：
func (builder *ShiftBuilder) RestTimeFlexibleConfigs(restTimeFlexibleConfigs []*RestTimeFlexibleConfig) *ShiftBuilder {
	builder.restTimeFlexibleConfigs = restTimeFlexibleConfigs
	builder.restTimeFlexibleConfigsFlag = true
	return builder
}

func (builder *ShiftBuilder) Build() *Shift {
	req := &Shift{}
	if builder.shiftIdFlag {
		req.ShiftId = &builder.shiftId

	}
	if builder.shiftNameFlag {
		req.ShiftName = &builder.shiftName

	}
	if builder.punchTimesFlag {
		req.PunchTimes = &builder.punchTimes

	}
	if builder.subShiftLeaderIdsFlag {
		req.SubShiftLeaderIds = builder.subShiftLeaderIds
	}
	if builder.isFlexibleFlag {
		req.IsFlexible = &builder.isFlexible

	}
	if builder.flexibleMinutesFlag {
		req.FlexibleMinutes = &builder.flexibleMinutes

	}
	if builder.flexibleRuleFlag {
		req.FlexibleRule = builder.flexibleRule
	}
	if builder.noNeedOffFlag {
		req.NoNeedOff = &builder.noNeedOff

	}
	if builder.punchTimeRuleFlag {
		req.PunchTimeRule = builder.punchTimeRule
	}
	if builder.lateOffLateOnRuleFlag {
		req.LateOffLateOnRule = builder.lateOffLateOnRule
	}
	if builder.restTimeRuleFlag {
		req.RestTimeRule = builder.restTimeRule
	}
	if builder.overtimeRuleFlag {
		req.OvertimeRule = builder.overtimeRule
	}
	if builder.dayTypeFlag {
		req.DayType = &builder.dayType

	}
	if builder.overtimeRestTimeRuleFlag {
		req.OvertimeRestTimeRule = builder.overtimeRestTimeRule
	}
	if builder.lateMinutesAsSeriousLateFlag {
		req.LateMinutesAsSeriousLate = &builder.lateMinutesAsSeriousLate

	}
	if builder.shiftMiddleTimeRuleFlag {
		req.ShiftMiddleTimeRule = builder.shiftMiddleTimeRule
	}
	if builder.shiftAttendanceTimeConfigFlag {
		req.ShiftAttendanceTimeConfig = builder.shiftAttendanceTimeConfig
	}
	if builder.lateOffLateOnSettingFlag {
		req.LateOffLateOnSetting = builder.lateOffLateOnSetting
	}
	if builder.idFlag {
		req.Id = &builder.id

	}
	if builder.restTimeFlexibleConfigsFlag {
		req.RestTimeFlexibleConfigs = builder.restTimeFlexibleConfigs
	}
	return req
}

type ShiftAttendanceTimeConfig struct {
	AttendanceTime *float64 `json:"attendance_time,omitempty"` // 应出勤时长

	OnAttendanceTime *float64 `json:"on_attendance_time,omitempty"` // 上半天应出勤时长

	OffAttendanceTime *float64 `json:"off_attendance_time,omitempty"` // 下半天应出勤时长
}

type ShiftAttendanceTimeConfigBuilder struct {
	attendanceTime     float64 // 应出勤时长
	attendanceTimeFlag bool

	onAttendanceTime     float64 // 上半天应出勤时长
	onAttendanceTimeFlag bool

	offAttendanceTime     float64 // 下半天应出勤时长
	offAttendanceTimeFlag bool
}

func NewShiftAttendanceTimeConfigBuilder() *ShiftAttendanceTimeConfigBuilder {
	builder := &ShiftAttendanceTimeConfigBuilder{}
	return builder
}

// 应出勤时长
//
// 示例值：1
func (builder *ShiftAttendanceTimeConfigBuilder) AttendanceTime(attendanceTime float64) *ShiftAttendanceTimeConfigBuilder {
	builder.attendanceTime = attendanceTime
	builder.attendanceTimeFlag = true
	return builder
}

// 上半天应出勤时长
//
// 示例值：1
func (builder *ShiftAttendanceTimeConfigBuilder) OnAttendanceTime(onAttendanceTime float64) *ShiftAttendanceTimeConfigBuilder {
	builder.onAttendanceTime = onAttendanceTime
	builder.onAttendanceTimeFlag = true
	return builder
}

// 下半天应出勤时长
//
// 示例值：1
func (builder *ShiftAttendanceTimeConfigBuilder) OffAttendanceTime(offAttendanceTime float64) *ShiftAttendanceTimeConfigBuilder {
	builder.offAttendanceTime = offAttendanceTime
	builder.offAttendanceTimeFlag = true
	return builder
}

func (builder *ShiftAttendanceTimeConfigBuilder) Build() *ShiftAttendanceTimeConfig {
	req := &ShiftAttendanceTimeConfig{}
	if builder.attendanceTimeFlag {
		req.AttendanceTime = &builder.attendanceTime

	}
	if builder.onAttendanceTimeFlag {
		req.OnAttendanceTime = &builder.onAttendanceTime

	}
	if builder.offAttendanceTimeFlag {
		req.OffAttendanceTime = &builder.offAttendanceTime

	}
	return req
}

type ShiftGroupUser struct {
	ShiftGroupId *string `json:"shift_group_id,omitempty"` // 班组ID

	UserId *string `json:"user_id,omitempty"` // 用户ID，根据传参user_id_type确定
}

type ShiftGroupUserBuilder struct {
	shiftGroupId     string // 班组ID
	shiftGroupIdFlag bool

	userId     string // 用户ID，根据传参user_id_type确定
	userIdFlag bool
}

func NewShiftGroupUserBuilder() *ShiftGroupUserBuilder {
	builder := &ShiftGroupUserBuilder{}
	return builder
}

// 班组ID
//
// 示例值：7275180303583281171
func (builder *ShiftGroupUserBuilder) ShiftGroupId(shiftGroupId string) *ShiftGroupUserBuilder {
	builder.shiftGroupId = shiftGroupId
	builder.shiftGroupIdFlag = true
	return builder
}

// 用户ID，根据传参user_id_type确定
//
// 示例值：52aa1fa1
func (builder *ShiftGroupUserBuilder) UserId(userId string) *ShiftGroupUserBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

func (builder *ShiftGroupUserBuilder) Build() *ShiftGroupUser {
	req := &ShiftGroupUser{}
	if builder.shiftGroupIdFlag {
		req.ShiftGroupId = &builder.shiftGroupId

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	return req
}

type ShiftMiddleTimeRule struct {
	MiddleTimeType *int `json:"middle_time_type,omitempty"` // 半天分割类型

	FixedMiddleTime *string `json:"fixed_middle_time,omitempty"` // 固定分割时间点（middle_time_type 为 3 时有效）
}

type ShiftMiddleTimeRuleBuilder struct {
	middleTimeType     int // 半天分割类型
	middleTimeTypeFlag bool

	fixedMiddleTime     string // 固定分割时间点（middle_time_type 为 3 时有效）
	fixedMiddleTimeFlag bool
}

func NewShiftMiddleTimeRuleBuilder() *ShiftMiddleTimeRuleBuilder {
	builder := &ShiftMiddleTimeRuleBuilder{}
	return builder
}

// 半天分割类型
//
// 示例值：0
func (builder *ShiftMiddleTimeRuleBuilder) MiddleTimeType(middleTimeType int) *ShiftMiddleTimeRuleBuilder {
	builder.middleTimeType = middleTimeType
	builder.middleTimeTypeFlag = true
	return builder
}

// 固定分割时间点（middle_time_type 为 3 时有效）
//
// 示例值：12:00
func (builder *ShiftMiddleTimeRuleBuilder) FixedMiddleTime(fixedMiddleTime string) *ShiftMiddleTimeRuleBuilder {
	builder.fixedMiddleTime = fixedMiddleTime
	builder.fixedMiddleTimeFlag = true
	return builder
}

func (builder *ShiftMiddleTimeRuleBuilder) Build() *ShiftMiddleTimeRule {
	req := &ShiftMiddleTimeRule{}
	if builder.middleTimeTypeFlag {
		req.MiddleTimeType = &builder.middleTimeType

	}
	if builder.fixedMiddleTimeFlag {
		req.FixedMiddleTime = &builder.fixedMiddleTime

	}
	return req
}

type StatisticsField struct {
	FieldId *string `json:"field_id,omitempty"` // 字段ID

	FieldContent *string `json:"field_content,omitempty"` // 字段公式

	Title *string `json:"title,omitempty"` // 字段名称

	FieldDesc *string `json:"field_desc,omitempty"` // 字段描述
}

type StatisticsFieldBuilder struct {
	fieldId     string // 字段ID
	fieldIdFlag bool

	fieldContent     string // 字段公式
	fieldContentFlag bool

	title     string // 字段名称
	titleFlag bool

	fieldDesc     string // 字段描述
	fieldDescFlag bool
}

func NewStatisticsFieldBuilder() *StatisticsFieldBuilder {
	builder := &StatisticsFieldBuilder{}
	return builder
}

// 字段ID
//
// 示例值：1111111
func (builder *StatisticsFieldBuilder) FieldId(fieldId string) *StatisticsFieldBuilder {
	builder.fieldId = fieldId
	builder.fieldIdFlag = true
	return builder
}

// 字段公式
//
// 示例值：1
func (builder *StatisticsFieldBuilder) FieldContent(fieldContent string) *StatisticsFieldBuilder {
	builder.fieldContent = fieldContent
	builder.fieldContentFlag = true
	return builder
}

// 字段名称
//
// 示例值：计薪天数
func (builder *StatisticsFieldBuilder) Title(title string) *StatisticsFieldBuilder {
	builder.title = title
	builder.titleFlag = true
	return builder
}

// 字段描述
//
// 示例值：测试
func (builder *StatisticsFieldBuilder) FieldDesc(fieldDesc string) *StatisticsFieldBuilder {
	builder.fieldDesc = fieldDesc
	builder.fieldDescFlag = true
	return builder
}

func (builder *StatisticsFieldBuilder) Build() *StatisticsField {
	req := &StatisticsField{}
	if builder.fieldIdFlag {
		req.FieldId = &builder.fieldId

	}
	if builder.fieldContentFlag {
		req.FieldContent = &builder.fieldContent

	}
	if builder.titleFlag {
		req.Title = &builder.title

	}
	if builder.fieldDescFlag {
		req.FieldDesc = &builder.fieldDesc

	}
	return req
}

type StatusChange struct {
	Index *int `json:"index,omitempty"` //

	BeforeStatus *string `json:"before_status,omitempty"` //

	CurrentStatus *string `json:"current_status,omitempty"` //

	BeforeSupplement *string `json:"before_supplement,omitempty"` //

	CurrentSupplement *string `json:"current_supplement,omitempty"` //

	WorkType *string `json:"work_type,omitempty"` //
}

type StatusChangeBuilder struct {
	index     int //
	indexFlag bool

	beforeStatus     string //
	beforeStatusFlag bool

	currentStatus     string //
	currentStatusFlag bool

	beforeSupplement     string //
	beforeSupplementFlag bool

	currentSupplement     string //
	currentSupplementFlag bool

	workType     string //
	workTypeFlag bool
}

func NewStatusChangeBuilder() *StatusChangeBuilder {
	builder := &StatusChangeBuilder{}
	return builder
}

//
//
// 示例值：
func (builder *StatusChangeBuilder) Index(index int) *StatusChangeBuilder {
	builder.index = index
	builder.indexFlag = true
	return builder
}

//
//
// 示例值：
func (builder *StatusChangeBuilder) BeforeStatus(beforeStatus string) *StatusChangeBuilder {
	builder.beforeStatus = beforeStatus
	builder.beforeStatusFlag = true
	return builder
}

//
//
// 示例值：
func (builder *StatusChangeBuilder) CurrentStatus(currentStatus string) *StatusChangeBuilder {
	builder.currentStatus = currentStatus
	builder.currentStatusFlag = true
	return builder
}

//
//
// 示例值：
func (builder *StatusChangeBuilder) BeforeSupplement(beforeSupplement string) *StatusChangeBuilder {
	builder.beforeSupplement = beforeSupplement
	builder.beforeSupplementFlag = true
	return builder
}

//
//
// 示例值：
func (builder *StatusChangeBuilder) CurrentSupplement(currentSupplement string) *StatusChangeBuilder {
	builder.currentSupplement = currentSupplement
	builder.currentSupplementFlag = true
	return builder
}

//
//
// 示例值：
func (builder *StatusChangeBuilder) WorkType(workType string) *StatusChangeBuilder {
	builder.workType = workType
	builder.workTypeFlag = true
	return builder
}

func (builder *StatusChangeBuilder) Build() *StatusChange {
	req := &StatusChange{}
	if builder.indexFlag {
		req.Index = &builder.index

	}
	if builder.beforeStatusFlag {
		req.BeforeStatus = &builder.beforeStatus

	}
	if builder.currentStatusFlag {
		req.CurrentStatus = &builder.currentStatus

	}
	if builder.beforeSupplementFlag {
		req.BeforeSupplement = &builder.beforeSupplement

	}
	if builder.currentSupplementFlag {
		req.CurrentSupplement = &builder.currentSupplement

	}
	if builder.workTypeFlag {
		req.WorkType = &builder.workType

	}
	return req
}

type TaskResult struct {
	CheckInRecordId *string `json:"check_in_record_id,omitempty"` // 上班打卡记录 ID

	CheckInRecord *UserFlow `json:"check_in_record,omitempty"` // 上班打卡记录

	CheckOutRecordId *string `json:"check_out_record_id,omitempty"` // 下班打卡记录 ID

	CheckOutRecord *UserFlow `json:"check_out_record,omitempty"` // 下班打卡记录

	CheckInResult *string `json:"check_in_result,omitempty"` // 上班打卡结果

	CheckOutResult *string `json:"check_out_result,omitempty"` // 下班打卡结果

	CheckInResultSupplement *string `json:"check_in_result_supplement,omitempty"` // 上班打卡结果补充

	CheckOutResultSupplement *string `json:"check_out_result_supplement,omitempty"` // 下班打卡结果补充

	CheckInShiftTime *string `json:"check_in_shift_time,omitempty"` // 上班打卡时间

	CheckOutShiftTime *string `json:"check_out_shift_time,omitempty"` // 下班打卡时间

	TaskShiftType *int `json:"task_shift_type,omitempty"` // 班次类型，0正常，1加班班次
}

type TaskResultBuilder struct {
	checkInRecordId     string // 上班打卡记录 ID
	checkInRecordIdFlag bool

	checkInRecord     *UserFlow // 上班打卡记录
	checkInRecordFlag bool

	checkOutRecordId     string // 下班打卡记录 ID
	checkOutRecordIdFlag bool

	checkOutRecord     *UserFlow // 下班打卡记录
	checkOutRecordFlag bool

	checkInResult     string // 上班打卡结果
	checkInResultFlag bool

	checkOutResult     string // 下班打卡结果
	checkOutResultFlag bool

	checkInResultSupplement     string // 上班打卡结果补充
	checkInResultSupplementFlag bool

	checkOutResultSupplement     string // 下班打卡结果补充
	checkOutResultSupplementFlag bool

	checkInShiftTime     string // 上班打卡时间
	checkInShiftTimeFlag bool

	checkOutShiftTime     string // 下班打卡时间
	checkOutShiftTimeFlag bool

	taskShiftType     int // 班次类型，0正常，1加班班次
	taskShiftTypeFlag bool
}

func NewTaskResultBuilder() *TaskResultBuilder {
	builder := &TaskResultBuilder{}
	return builder
}

// 上班打卡记录 ID
//
// 示例值：6709359313699356941
func (builder *TaskResultBuilder) CheckInRecordId(checkInRecordId string) *TaskResultBuilder {
	builder.checkInRecordId = checkInRecordId
	builder.checkInRecordIdFlag = true
	return builder
}

// 上班打卡记录
//
// 示例值：
func (builder *TaskResultBuilder) CheckInRecord(checkInRecord *UserFlow) *TaskResultBuilder {
	builder.checkInRecord = checkInRecord
	builder.checkInRecordFlag = true
	return builder
}

// 下班打卡记录 ID
//
// 示例值：6709359313699356942
func (builder *TaskResultBuilder) CheckOutRecordId(checkOutRecordId string) *TaskResultBuilder {
	builder.checkOutRecordId = checkOutRecordId
	builder.checkOutRecordIdFlag = true
	return builder
}

// 下班打卡记录
//
// 示例值：
func (builder *TaskResultBuilder) CheckOutRecord(checkOutRecord *UserFlow) *TaskResultBuilder {
	builder.checkOutRecord = checkOutRecord
	builder.checkOutRecordFlag = true
	return builder
}

// 上班打卡结果
//
// 示例值：SystemCheck
func (builder *TaskResultBuilder) CheckInResult(checkInResult string) *TaskResultBuilder {
	builder.checkInResult = checkInResult
	builder.checkInResultFlag = true
	return builder
}

// 下班打卡结果
//
// 示例值：SystemCheck
func (builder *TaskResultBuilder) CheckOutResult(checkOutResult string) *TaskResultBuilder {
	builder.checkOutResult = checkOutResult
	builder.checkOutResultFlag = true
	return builder
}

// 上班打卡结果补充
//
// 示例值：None
func (builder *TaskResultBuilder) CheckInResultSupplement(checkInResultSupplement string) *TaskResultBuilder {
	builder.checkInResultSupplement = checkInResultSupplement
	builder.checkInResultSupplementFlag = true
	return builder
}

// 下班打卡结果补充
//
// 示例值：None
func (builder *TaskResultBuilder) CheckOutResultSupplement(checkOutResultSupplement string) *TaskResultBuilder {
	builder.checkOutResultSupplement = checkOutResultSupplement
	builder.checkOutResultSupplementFlag = true
	return builder
}

// 上班打卡时间
//
// 示例值：1609722000
func (builder *TaskResultBuilder) CheckInShiftTime(checkInShiftTime string) *TaskResultBuilder {
	builder.checkInShiftTime = checkInShiftTime
	builder.checkInShiftTimeFlag = true
	return builder
}

// 下班打卡时间
//
// 示例值：1609754400
func (builder *TaskResultBuilder) CheckOutShiftTime(checkOutShiftTime string) *TaskResultBuilder {
	builder.checkOutShiftTime = checkOutShiftTime
	builder.checkOutShiftTimeFlag = true
	return builder
}

// 班次类型，0正常，1加班班次
//
// 示例值：0
func (builder *TaskResultBuilder) TaskShiftType(taskShiftType int) *TaskResultBuilder {
	builder.taskShiftType = taskShiftType
	builder.taskShiftTypeFlag = true
	return builder
}

func (builder *TaskResultBuilder) Build() *TaskResult {
	req := &TaskResult{}
	if builder.checkInRecordIdFlag {
		req.CheckInRecordId = &builder.checkInRecordId

	}
	if builder.checkInRecordFlag {
		req.CheckInRecord = builder.checkInRecord
	}
	if builder.checkOutRecordIdFlag {
		req.CheckOutRecordId = &builder.checkOutRecordId

	}
	if builder.checkOutRecordFlag {
		req.CheckOutRecord = builder.checkOutRecord
	}
	if builder.checkInResultFlag {
		req.CheckInResult = &builder.checkInResult

	}
	if builder.checkOutResultFlag {
		req.CheckOutResult = &builder.checkOutResult

	}
	if builder.checkInResultSupplementFlag {
		req.CheckInResultSupplement = &builder.checkInResultSupplement

	}
	if builder.checkOutResultSupplementFlag {
		req.CheckOutResultSupplement = &builder.checkOutResultSupplement

	}
	if builder.checkInShiftTimeFlag {
		req.CheckInShiftTime = &builder.checkInShiftTime

	}
	if builder.checkOutShiftTimeFlag {
		req.CheckOutShiftTime = &builder.checkOutShiftTime

	}
	if builder.taskShiftTypeFlag {
		req.TaskShiftType = &builder.taskShiftType

	}
	return req
}

type TimeRange struct {
	StartTimeStamp *int `json:"start_time_stamp,omitempty"` // 开始时间

	EndTimeStamp *int `json:"end_time_stamp,omitempty"` // 结束时间
}

type TimeRangeBuilder struct {
	startTimeStamp     int // 开始时间
	startTimeStampFlag bool

	endTimeStamp     int // 结束时间
	endTimeStampFlag bool
}

func NewTimeRangeBuilder() *TimeRangeBuilder {
	builder := &TimeRangeBuilder{}
	return builder
}

// 开始时间
//
// 示例值：1751385600
func (builder *TimeRangeBuilder) StartTimeStamp(startTimeStamp int) *TimeRangeBuilder {
	builder.startTimeStamp = startTimeStamp
	builder.startTimeStampFlag = true
	return builder
}

// 结束时间
//
// 示例值：1751385600
func (builder *TimeRangeBuilder) EndTimeStamp(endTimeStamp int) *TimeRangeBuilder {
	builder.endTimeStamp = endTimeStamp
	builder.endTimeStampFlag = true
	return builder
}

func (builder *TimeRangeBuilder) Build() *TimeRange {
	req := &TimeRange{}
	if builder.startTimeStampFlag {
		req.StartTimeStamp = &builder.startTimeStamp

	}
	if builder.endTimeStampFlag {
		req.EndTimeStamp = &builder.endTimeStamp

	}
	return req
}

type TimeRangeList struct {
	Day *int `json:"day,omitempty"` // 日期day

	TimeRanges []*TimeRange `json:"time_ranges,omitempty"` // 时间范围，是一个list
}

type TimeRangeListBuilder struct {
	day     int // 日期day
	dayFlag bool

	timeRanges     []*TimeRange // 时间范围，是一个list
	timeRangesFlag bool
}

func NewTimeRangeListBuilder() *TimeRangeListBuilder {
	builder := &TimeRangeListBuilder{}
	return builder
}

// 日期day
//
// 示例值：20220501
func (builder *TimeRangeListBuilder) Day(day int) *TimeRangeListBuilder {
	builder.day = day
	builder.dayFlag = true
	return builder
}

// 时间范围，是一个list
//
// 示例值：
func (builder *TimeRangeListBuilder) TimeRanges(timeRanges []*TimeRange) *TimeRangeListBuilder {
	builder.timeRanges = timeRanges
	builder.timeRangesFlag = true
	return builder
}

func (builder *TimeRangeListBuilder) Build() *TimeRangeList {
	req := &TimeRangeList{}
	if builder.dayFlag {
		req.Day = &builder.day

	}
	if builder.timeRangesFlag {
		req.TimeRanges = builder.timeRanges
	}
	return req
}

type UserAllowedRemedy struct {
	UserId *string `json:"user_id,omitempty"` // 用户 ID

	RemedyDate *int `json:"remedy_date,omitempty"` // 补卡日期

	IsFreePunch *bool `json:"is_free_punch,omitempty"` // 是否为自由班次，若为自由班次，则不用选择考虑第几次上下班，直接选择补卡时间即可

	PunchNo *int `json:"punch_no,omitempty"` // 第几次上下班，0：第 1 次上下班，1：第 2 次上下班，2：第 3 次上下班

	WorkType *int `json:"work_type,omitempty"` // 上班 / 下班，1：上班，2：下班

	PunchStatus *string `json:"punch_status,omitempty"` // 打卡状态，Early：早退，Late：迟到，Lack：缺卡

	NormalPunchTime *string `json:"normal_punch_time,omitempty"` // 正常的应打卡时间，时间格式为 yyyy-MM-dd HH:mm

	RemedyStartTime *string `json:"remedy_start_time,omitempty"` // 可选的补卡时间的最小值，时间格式为 yyyy-MM-dd HH:mm

	RemedyEndTime *string `json:"remedy_end_time,omitempty"` // 可选的补卡时间的最大值，时间格式为 yyyy-MM-dd HH:mm
}

type UserAllowedRemedyBuilder struct {
	userId     string // 用户 ID
	userIdFlag bool

	remedyDate     int // 补卡日期
	remedyDateFlag bool

	isFreePunch     bool // 是否为自由班次，若为自由班次，则不用选择考虑第几次上下班，直接选择补卡时间即可
	isFreePunchFlag bool

	punchNo     int // 第几次上下班，0：第 1 次上下班，1：第 2 次上下班，2：第 3 次上下班
	punchNoFlag bool

	workType     int // 上班 / 下班，1：上班，2：下班
	workTypeFlag bool

	punchStatus     string // 打卡状态，Early：早退，Late：迟到，Lack：缺卡
	punchStatusFlag bool

	normalPunchTime     string // 正常的应打卡时间，时间格式为 yyyy-MM-dd HH:mm
	normalPunchTimeFlag bool

	remedyStartTime     string // 可选的补卡时间的最小值，时间格式为 yyyy-MM-dd HH:mm
	remedyStartTimeFlag bool

	remedyEndTime     string // 可选的补卡时间的最大值，时间格式为 yyyy-MM-dd HH:mm
	remedyEndTimeFlag bool
}

func NewUserAllowedRemedyBuilder() *UserAllowedRemedyBuilder {
	builder := &UserAllowedRemedyBuilder{}
	return builder
}

// 用户 ID
//
// 示例值：abd754f7
func (builder *UserAllowedRemedyBuilder) UserId(userId string) *UserAllowedRemedyBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 补卡日期
//
// 示例值：20210104
func (builder *UserAllowedRemedyBuilder) RemedyDate(remedyDate int) *UserAllowedRemedyBuilder {
	builder.remedyDate = remedyDate
	builder.remedyDateFlag = true
	return builder
}

// 是否为自由班次，若为自由班次，则不用选择考虑第几次上下班，直接选择补卡时间即可
//
// 示例值：false
func (builder *UserAllowedRemedyBuilder) IsFreePunch(isFreePunch bool) *UserAllowedRemedyBuilder {
	builder.isFreePunch = isFreePunch
	builder.isFreePunchFlag = true
	return builder
}

// 第几次上下班，0：第 1 次上下班，1：第 2 次上下班，2：第 3 次上下班
//
// 示例值：0
func (builder *UserAllowedRemedyBuilder) PunchNo(punchNo int) *UserAllowedRemedyBuilder {
	builder.punchNo = punchNo
	builder.punchNoFlag = true
	return builder
}

// 上班 / 下班，1：上班，2：下班
//
// 示例值：1
func (builder *UserAllowedRemedyBuilder) WorkType(workType int) *UserAllowedRemedyBuilder {
	builder.workType = workType
	builder.workTypeFlag = true
	return builder
}

// 打卡状态，Early：早退，Late：迟到，Lack：缺卡
//
// 示例值：Lack
func (builder *UserAllowedRemedyBuilder) PunchStatus(punchStatus string) *UserAllowedRemedyBuilder {
	builder.punchStatus = punchStatus
	builder.punchStatusFlag = true
	return builder
}

// 正常的应打卡时间，时间格式为 yyyy-MM-dd HH:mm
//
// 示例值：2021-07-01 09:00
func (builder *UserAllowedRemedyBuilder) NormalPunchTime(normalPunchTime string) *UserAllowedRemedyBuilder {
	builder.normalPunchTime = normalPunchTime
	builder.normalPunchTimeFlag = true
	return builder
}

// 可选的补卡时间的最小值，时间格式为 yyyy-MM-dd HH:mm
//
// 示例值：2021-07-01 08:00
func (builder *UserAllowedRemedyBuilder) RemedyStartTime(remedyStartTime string) *UserAllowedRemedyBuilder {
	builder.remedyStartTime = remedyStartTime
	builder.remedyStartTimeFlag = true
	return builder
}

// 可选的补卡时间的最大值，时间格式为 yyyy-MM-dd HH:mm
//
// 示例值：2021-07-01 10:00
func (builder *UserAllowedRemedyBuilder) RemedyEndTime(remedyEndTime string) *UserAllowedRemedyBuilder {
	builder.remedyEndTime = remedyEndTime
	builder.remedyEndTimeFlag = true
	return builder
}

func (builder *UserAllowedRemedyBuilder) Build() *UserAllowedRemedy {
	req := &UserAllowedRemedy{}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.remedyDateFlag {
		req.RemedyDate = &builder.remedyDate

	}
	if builder.isFreePunchFlag {
		req.IsFreePunch = &builder.isFreePunch

	}
	if builder.punchNoFlag {
		req.PunchNo = &builder.punchNo

	}
	if builder.workTypeFlag {
		req.WorkType = &builder.workType

	}
	if builder.punchStatusFlag {
		req.PunchStatus = &builder.punchStatus

	}
	if builder.normalPunchTimeFlag {
		req.NormalPunchTime = &builder.normalPunchTime

	}
	if builder.remedyStartTimeFlag {
		req.RemedyStartTime = &builder.remedyStartTime

	}
	if builder.remedyEndTimeFlag {
		req.RemedyEndTime = &builder.remedyEndTime

	}
	return req
}

type UserApproval struct {
	UserId *string `json:"user_id,omitempty"` // 审批用户 ID

	Date *string `json:"date,omitempty"` // 审批作用日期

	Outs []*UserOut `json:"outs,omitempty"` // 外出信息

	Leaves []*UserLeave `json:"leaves,omitempty"` // 请假信息

	OvertimeWorks []*UserOvertimeWork `json:"overtime_works,omitempty"` // 加班信息

	Trips []*UserTrip `json:"trips,omitempty"` // 出差信息

	TimeZone *string `json:"time_zone,omitempty"` // 计算时间所用的时区信息，为空是0时区
}

type UserApprovalBuilder struct {
	userId     string // 审批用户 ID
	userIdFlag bool

	date     string // 审批作用日期
	dateFlag bool

	outs     []*UserOut // 外出信息
	outsFlag bool

	leaves     []*UserLeave // 请假信息
	leavesFlag bool

	overtimeWorks     []*UserOvertimeWork // 加班信息
	overtimeWorksFlag bool

	trips     []*UserTrip // 出差信息
	tripsFlag bool

	timeZone     string // 计算时间所用的时区信息，为空是0时区
	timeZoneFlag bool
}

func NewUserApprovalBuilder() *UserApprovalBuilder {
	builder := &UserApprovalBuilder{}
	return builder
}

// 审批用户 ID
//
// 示例值：abd754f7
func (builder *UserApprovalBuilder) UserId(userId string) *UserApprovalBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 审批作用日期
//
// 示例值：20210104
func (builder *UserApprovalBuilder) Date(date string) *UserApprovalBuilder {
	builder.date = date
	builder.dateFlag = true
	return builder
}

// 外出信息
//
// 示例值：
func (builder *UserApprovalBuilder) Outs(outs []*UserOut) *UserApprovalBuilder {
	builder.outs = outs
	builder.outsFlag = true
	return builder
}

// 请假信息
//
// 示例值：
func (builder *UserApprovalBuilder) Leaves(leaves []*UserLeave) *UserApprovalBuilder {
	builder.leaves = leaves
	builder.leavesFlag = true
	return builder
}

// 加班信息
//
// 示例值：
func (builder *UserApprovalBuilder) OvertimeWorks(overtimeWorks []*UserOvertimeWork) *UserApprovalBuilder {
	builder.overtimeWorks = overtimeWorks
	builder.overtimeWorksFlag = true
	return builder
}

// 出差信息
//
// 示例值：
func (builder *UserApprovalBuilder) Trips(trips []*UserTrip) *UserApprovalBuilder {
	builder.trips = trips
	builder.tripsFlag = true
	return builder
}

// 计算时间所用的时区信息，为空是0时区
//
// 示例值：Asia/Shanghai
func (builder *UserApprovalBuilder) TimeZone(timeZone string) *UserApprovalBuilder {
	builder.timeZone = timeZone
	builder.timeZoneFlag = true
	return builder
}

func (builder *UserApprovalBuilder) Build() *UserApproval {
	req := &UserApproval{}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.dateFlag {
		req.Date = &builder.date

	}
	if builder.outsFlag {
		req.Outs = builder.outs
	}
	if builder.leavesFlag {
		req.Leaves = builder.leaves
	}
	if builder.overtimeWorksFlag {
		req.OvertimeWorks = builder.overtimeWorks
	}
	if builder.tripsFlag {
		req.Trips = builder.trips
	}
	if builder.timeZoneFlag {
		req.TimeZone = &builder.timeZone

	}
	return req
}

type UserArrangeShiftGroup struct {
	UserId *string `json:"user_id,omitempty"` // 用户id

	ShiftGroup *ArrangeShiftGroup `json:"shift_group,omitempty"` // 班组
}

type UserArrangeShiftGroupBuilder struct {
	userId     string // 用户id
	userIdFlag bool

	shiftGroup     *ArrangeShiftGroup // 班组
	shiftGroupFlag bool
}

func NewUserArrangeShiftGroupBuilder() *UserArrangeShiftGroupBuilder {
	builder := &UserArrangeShiftGroupBuilder{}
	return builder
}

// 用户id
//
// 示例值：e1234123
func (builder *UserArrangeShiftGroupBuilder) UserId(userId string) *UserArrangeShiftGroupBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 班组
//
// 示例值：
func (builder *UserArrangeShiftGroupBuilder) ShiftGroup(shiftGroup *ArrangeShiftGroup) *UserArrangeShiftGroupBuilder {
	builder.shiftGroup = shiftGroup
	builder.shiftGroupFlag = true
	return builder
}

func (builder *UserArrangeShiftGroupBuilder) Build() *UserArrangeShiftGroup {
	req := &UserArrangeShiftGroup{}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.shiftGroupFlag {
		req.ShiftGroup = builder.shiftGroup
	}
	return req
}

type UserBase struct {
	UserId *string `json:"user_id,omitempty"` // 用户 ID

	DepartmentIds []string `json:"department_ids,omitempty"` // 该用户所属部门 ID 列表
}

type UserBaseBuilder struct {
	userId     string // 用户 ID
	userIdFlag bool

	departmentIds     []string // 该用户所属部门 ID 列表
	departmentIdsFlag bool
}

func NewUserBaseBuilder() *UserBaseBuilder {
	builder := &UserBaseBuilder{}
	return builder
}

// 用户 ID
//
// 示例值：5874663B
func (builder *UserBaseBuilder) UserId(userId string) *UserBaseBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 该用户所属部门 ID 列表
//
// 示例值：
func (builder *UserBaseBuilder) DepartmentIds(departmentIds []string) *UserBaseBuilder {
	builder.departmentIds = departmentIds
	builder.departmentIdsFlag = true
	return builder
}

func (builder *UserBaseBuilder) Build() *UserBase {
	req := &UserBase{}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.departmentIdsFlag {
		req.DepartmentIds = builder.departmentIds
	}
	return req
}

type UserDailyShift struct {
	GroupId *string `json:"group_id,omitempty"` // 考勤组 ID，获取方式：1）[创建或修改考勤组](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/group/create) 2）[按名称查询考勤组](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/group/search) 3）[获取打卡结果](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_task/query)

	ShiftId *string `json:"shift_id,omitempty"` // 班次 ID，获取方式：1）[按名称查询班次](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/shift/query) 2）[创建班次](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/shift/create)

	Month *int `json:"month,omitempty"` // 月份

	UserId *string `json:"user_id,omitempty"` // 用户 ID

	DayNo *int `json:"day_no,omitempty"` // 日期

	IsClearSchedule *bool `json:"is_clear_schedule,omitempty"` // 是否清空班次 (此字段优先于 shift_id，若为true ，shift_id 将失效)
}

type UserDailyShiftBuilder struct {
	groupId     string // 考勤组 ID，获取方式：1）[创建或修改考勤组](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/group/create) 2）[按名称查询考勤组](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/group/search) 3）[获取打卡结果](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_task/query)
	groupIdFlag bool

	shiftId     string // 班次 ID，获取方式：1）[按名称查询班次](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/shift/query) 2）[创建班次](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/shift/create)
	shiftIdFlag bool

	month     int // 月份
	monthFlag bool

	userId     string // 用户 ID
	userIdFlag bool

	dayNo     int // 日期
	dayNoFlag bool

	isClearSchedule     bool // 是否清空班次 (此字段优先于 shift_id，若为true ，shift_id 将失效)
	isClearScheduleFlag bool
}

func NewUserDailyShiftBuilder() *UserDailyShiftBuilder {
	builder := &UserDailyShiftBuilder{}
	return builder
}

// 考勤组 ID，获取方式：1）[创建或修改考勤组](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/group/create) 2）[按名称查询考勤组](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/group/search) 3）[获取打卡结果](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_task/query)
//
// 示例值：6737202939523236110
func (builder *UserDailyShiftBuilder) GroupId(groupId string) *UserDailyShiftBuilder {
	builder.groupId = groupId
	builder.groupIdFlag = true
	return builder
}

// 班次 ID，获取方式：1）[按名称查询班次](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/shift/query) 2）[创建班次](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/shift/create)
//
// 示例值：6753520403404030215
func (builder *UserDailyShiftBuilder) ShiftId(shiftId string) *UserDailyShiftBuilder {
	builder.shiftId = shiftId
	builder.shiftIdFlag = true
	return builder
}

// 月份
//
// 示例值：202101
func (builder *UserDailyShiftBuilder) Month(month int) *UserDailyShiftBuilder {
	builder.month = month
	builder.monthFlag = true
	return builder
}

// 用户 ID
//
// 示例值：abd754f7
func (builder *UserDailyShiftBuilder) UserId(userId string) *UserDailyShiftBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 日期
//
// 示例值：21
func (builder *UserDailyShiftBuilder) DayNo(dayNo int) *UserDailyShiftBuilder {
	builder.dayNo = dayNo
	builder.dayNoFlag = true
	return builder
}

// 是否清空班次 (此字段优先于 shift_id，若为true ，shift_id 将失效)
//
// 示例值：true
func (builder *UserDailyShiftBuilder) IsClearSchedule(isClearSchedule bool) *UserDailyShiftBuilder {
	builder.isClearSchedule = isClearSchedule
	builder.isClearScheduleFlag = true
	return builder
}

func (builder *UserDailyShiftBuilder) Build() *UserDailyShift {
	req := &UserDailyShift{}
	if builder.groupIdFlag {
		req.GroupId = &builder.groupId

	}
	if builder.shiftIdFlag {
		req.ShiftId = &builder.shiftId

	}
	if builder.monthFlag {
		req.Month = &builder.month

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.dayNoFlag {
		req.DayNo = &builder.dayNo

	}
	if builder.isClearScheduleFlag {
		req.IsClearSchedule = &builder.isClearSchedule

	}
	return req
}

type UserFlow struct {
	UserId *string `json:"user_id,omitempty"` // 用户 ID

	CreatorId *string `json:"creator_id,omitempty"` // 记录创建者 ID

	LocationName *string `json:"location_name,omitempty"` // 打卡位置名称信息

	CheckTime *string `json:"check_time,omitempty"` // 打卡时间，精确到秒的时间戳

	Comment *string `json:"comment,omitempty"` // 打卡备注

	RecordId *string `json:"record_id,omitempty"` // 打卡记录 ID

	Longitude *float64 `json:"longitude,omitempty"` // 打卡经度

	Latitude *float64 `json:"latitude,omitempty"` // 打卡纬度

	Ssid *string `json:"ssid,omitempty"` // 打卡 Wi-Fi 的 SSID

	Bssid *string `json:"bssid,omitempty"` // 打卡 Wi-Fi 的 MAC 地址

	IsField *bool `json:"is_field,omitempty"` // 是否为外勤打卡

	IsWifi *bool `json:"is_wifi,omitempty"` // 是否为 Wi-Fi 打卡

	Type *int `json:"type,omitempty"` // 记录生成方式

	PhotoUrls []string `json:"photo_urls,omitempty"` // 打卡照片列表

	DeviceId *string `json:"device_id,omitempty"` // 打卡设备ID

	CheckResult *string `json:"check_result,omitempty"` // 打卡结果

	ExternalId *string `json:"external_id,omitempty"` // 用户导入的外部打卡记录ID

	IdempotentId *string `json:"idempotent_id,omitempty"` // 唯一幂等键

	CreateTime *string `json:"create_time,omitempty"` // 创建时间
}

type UserFlowBuilder struct {
	userId     string // 用户 ID
	userIdFlag bool

	creatorId     string // 记录创建者 ID
	creatorIdFlag bool

	locationName     string // 打卡位置名称信息
	locationNameFlag bool

	checkTime     string // 打卡时间，精确到秒的时间戳
	checkTimeFlag bool

	comment     string // 打卡备注
	commentFlag bool

	recordId     string // 打卡记录 ID
	recordIdFlag bool

	longitude     float64 // 打卡经度
	longitudeFlag bool

	latitude     float64 // 打卡纬度
	latitudeFlag bool

	ssid     string // 打卡 Wi-Fi 的 SSID
	ssidFlag bool

	bssid     string // 打卡 Wi-Fi 的 MAC 地址
	bssidFlag bool

	isField     bool // 是否为外勤打卡
	isFieldFlag bool

	isWifi     bool // 是否为 Wi-Fi 打卡
	isWifiFlag bool

	type_    int // 记录生成方式
	typeFlag bool

	photoUrls     []string // 打卡照片列表
	photoUrlsFlag bool

	deviceId     string // 打卡设备ID
	deviceIdFlag bool

	checkResult     string // 打卡结果
	checkResultFlag bool

	externalId     string // 用户导入的外部打卡记录ID
	externalIdFlag bool

	idempotentId     string // 唯一幂等键
	idempotentIdFlag bool

	createTime     string // 创建时间
	createTimeFlag bool
}

func NewUserFlowBuilder() *UserFlowBuilder {
	builder := &UserFlowBuilder{}
	return builder
}

// 用户 ID
//
// 示例值：abd754f7
func (builder *UserFlowBuilder) UserId(userId string) *UserFlowBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 记录创建者 ID
//
// 示例值：abd754f7
func (builder *UserFlowBuilder) CreatorId(creatorId string) *UserFlowBuilder {
	builder.creatorId = creatorId
	builder.creatorIdFlag = true
	return builder
}

// 打卡位置名称信息
//
// 示例值：西溪八方城
func (builder *UserFlowBuilder) LocationName(locationName string) *UserFlowBuilder {
	builder.locationName = locationName
	builder.locationNameFlag = true
	return builder
}

// 打卡时间，精确到秒的时间戳
//
// 示例值：1611476284
func (builder *UserFlowBuilder) CheckTime(checkTime string) *UserFlowBuilder {
	builder.checkTime = checkTime
	builder.checkTimeFlag = true
	return builder
}

// 打卡备注
//
// 示例值：上班打卡
func (builder *UserFlowBuilder) Comment(comment string) *UserFlowBuilder {
	builder.comment = comment
	builder.commentFlag = true
	return builder
}

// 打卡记录 ID
//
// 示例值：6709359313699356941
func (builder *UserFlowBuilder) RecordId(recordId string) *UserFlowBuilder {
	builder.recordId = recordId
	builder.recordIdFlag = true
	return builder
}

// 打卡经度
//
// 示例值：30.28991
func (builder *UserFlowBuilder) Longitude(longitude float64) *UserFlowBuilder {
	builder.longitude = longitude
	builder.longitudeFlag = true
	return builder
}

// 打卡纬度
//
// 示例值：120.04513
func (builder *UserFlowBuilder) Latitude(latitude float64) *UserFlowBuilder {
	builder.latitude = latitude
	builder.latitudeFlag = true
	return builder
}

// 打卡 Wi-Fi 的 SSID
//
// 示例值：b0:b8:67:5c:1d:72
func (builder *UserFlowBuilder) Ssid(ssid string) *UserFlowBuilder {
	builder.ssid = ssid
	builder.ssidFlag = true
	return builder
}

// 打卡 Wi-Fi 的 MAC 地址
//
// 示例值：b0:b8:67:5c:1d:72
func (builder *UserFlowBuilder) Bssid(bssid string) *UserFlowBuilder {
	builder.bssid = bssid
	builder.bssidFlag = true
	return builder
}

// 是否为外勤打卡
//
// 示例值：true
func (builder *UserFlowBuilder) IsField(isField bool) *UserFlowBuilder {
	builder.isField = isField
	builder.isFieldFlag = true
	return builder
}

// 是否为 Wi-Fi 打卡
//
// 示例值：true
func (builder *UserFlowBuilder) IsWifi(isWifi bool) *UserFlowBuilder {
	builder.isWifi = isWifi
	builder.isWifiFlag = true
	return builder
}

// 记录生成方式
//
// 示例值：在开放平台调用时，此参数无效，内部值始终是7
func (builder *UserFlowBuilder) Type(type_ int) *UserFlowBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

// 打卡照片列表
//
// 示例值：https://time.clockin.biz/manage/download/6840389754748502021
func (builder *UserFlowBuilder) PhotoUrls(photoUrls []string) *UserFlowBuilder {
	builder.photoUrls = photoUrls
	builder.photoUrlsFlag = true
	return builder
}

// 打卡设备ID
//
// 示例值：（只支持小程序打卡，导入时无效）99e0609ee053448596502691a81428654d7ded64c7bd85acd982d26b3636c37d
func (builder *UserFlowBuilder) DeviceId(deviceId string) *UserFlowBuilder {
	builder.deviceId = deviceId
	builder.deviceIdFlag = true
	return builder
}

// 打卡结果
//
// 示例值：Invalid
func (builder *UserFlowBuilder) CheckResult(checkResult string) *UserFlowBuilder {
	builder.checkResult = checkResult
	builder.checkResultFlag = true
	return builder
}

// 用户导入的外部打卡记录ID
//
// 示例值：record_123
func (builder *UserFlowBuilder) ExternalId(externalId string) *UserFlowBuilder {
	builder.externalId = externalId
	builder.externalIdFlag = true
	return builder
}

// 唯一幂等键
//
// 示例值：****_***
func (builder *UserFlowBuilder) IdempotentId(idempotentId string) *UserFlowBuilder {
	builder.idempotentId = idempotentId
	builder.idempotentIdFlag = true
	return builder
}

// 创建时间
//
// 示例值：
func (builder *UserFlowBuilder) CreateTime(createTime string) *UserFlowBuilder {
	builder.createTime = createTime
	builder.createTimeFlag = true
	return builder
}

func (builder *UserFlowBuilder) Build() *UserFlow {
	req := &UserFlow{}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.creatorIdFlag {
		req.CreatorId = &builder.creatorId

	}
	if builder.locationNameFlag {
		req.LocationName = &builder.locationName

	}
	if builder.checkTimeFlag {
		req.CheckTime = &builder.checkTime

	}
	if builder.commentFlag {
		req.Comment = &builder.comment

	}
	if builder.recordIdFlag {
		req.RecordId = &builder.recordId

	}
	if builder.longitudeFlag {
		req.Longitude = &builder.longitude

	}
	if builder.latitudeFlag {
		req.Latitude = &builder.latitude

	}
	if builder.ssidFlag {
		req.Ssid = &builder.ssid

	}
	if builder.bssidFlag {
		req.Bssid = &builder.bssid

	}
	if builder.isFieldFlag {
		req.IsField = &builder.isField

	}
	if builder.isWifiFlag {
		req.IsWifi = &builder.isWifi

	}
	if builder.typeFlag {
		req.Type = &builder.type_

	}
	if builder.photoUrlsFlag {
		req.PhotoUrls = builder.photoUrls
	}
	if builder.deviceIdFlag {
		req.DeviceId = &builder.deviceId

	}
	if builder.checkResultFlag {
		req.CheckResult = &builder.checkResult

	}
	if builder.externalIdFlag {
		req.ExternalId = &builder.externalId

	}
	if builder.idempotentIdFlag {
		req.IdempotentId = &builder.idempotentId

	}
	if builder.createTimeFlag {
		req.CreateTime = &builder.createTime

	}
	return req
}

type UserId struct {
	UserId *string `json:"user_id,omitempty"` //

	OpenId *string `json:"open_id,omitempty"` //

	UnionId *string `json:"union_id,omitempty"` //
}

type UserIdBuilder struct {
	userId     string //
	userIdFlag bool

	openId     string //
	openIdFlag bool

	unionId     string //
	unionIdFlag bool
}

func NewUserIdBuilder() *UserIdBuilder {
	builder := &UserIdBuilder{}
	return builder
}

//
//
// 示例值：
func (builder *UserIdBuilder) UserId(userId string) *UserIdBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

//
//
// 示例值：
func (builder *UserIdBuilder) OpenId(openId string) *UserIdBuilder {
	builder.openId = openId
	builder.openIdFlag = true
	return builder
}

//
//
// 示例值：
func (builder *UserIdBuilder) UnionId(unionId string) *UserIdBuilder {
	builder.unionId = unionId
	builder.unionIdFlag = true
	return builder
}

func (builder *UserIdBuilder) Build() *UserId {
	req := &UserId{}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.openIdFlag {
		req.OpenId = &builder.openId

	}
	if builder.unionIdFlag {
		req.UnionId = &builder.unionId

	}
	return req
}

type UserLeave struct {
	ApprovalId *string `json:"approval_id,omitempty"` // 审批实例 ID

	UniqId *string `json:"uniq_id,omitempty"` // 假期类型唯一 ID，代表一种假期类型，长度小于 14

	Unit *int `json:"unit,omitempty"` // 假期时长单位

	Interval *int `json:"interval,omitempty"` // 假期时长（单位：秒），暂未开放提供，待后续提供

	StartTime *string `json:"start_time,omitempty"` // 开始时间，时间格式为 yyyy-MM-dd HH:mm:ss

	EndTime *string `json:"end_time,omitempty"` // 结束时间，时间格式为 yyyy-MM-dd HH:mm:ss

	I18nNames *I18nNames `json:"i18n_names,omitempty"` // 假期多语言展示，格式为 map，key 为 ["ch"、"en"、"ja"]，其中 ch 代表中文、en 代表英语、ja 代表日语

	DefaultLocale *string `json:"default_locale,omitempty"` // 默认语言类型，由于飞书客户端支持中、英、日三种语言，当用户切换语言时，如果假期名称没有所对应的语言，会使用默认语言的名称

	Reason *string `json:"reason,omitempty"` // 请假理由，必选字段

	ApprovePassTime *string `json:"approve_pass_time,omitempty"` // 审批通过时间，时间格式为 yyyy-MM-dd HH:mm:ss

	ApproveApplyTime *string `json:"approve_apply_time,omitempty"` // 审批申请时间，时间格式为 yyyy-MM-dd HH:mm:ss

	IdempotentId *string `json:"idempotent_id,omitempty"` // 唯一幂等键

	LeaveDetailRangeObjs []*TimeRangeList `json:"leave_detail_range_objs,omitempty"` // 根据班次计算出来的请假具体时间，格式为list
}

type UserLeaveBuilder struct {
	approvalId     string // 审批实例 ID
	approvalIdFlag bool

	uniqId     string // 假期类型唯一 ID，代表一种假期类型，长度小于 14
	uniqIdFlag bool

	unit     int // 假期时长单位
	unitFlag bool

	interval     int // 假期时长（单位：秒），暂未开放提供，待后续提供
	intervalFlag bool

	startTime     string // 开始时间，时间格式为 yyyy-MM-dd HH:mm:ss
	startTimeFlag bool

	endTime     string // 结束时间，时间格式为 yyyy-MM-dd HH:mm:ss
	endTimeFlag bool

	i18nNames     *I18nNames // 假期多语言展示，格式为 map，key 为 ["ch"、"en"、"ja"]，其中 ch 代表中文、en 代表英语、ja 代表日语
	i18nNamesFlag bool

	defaultLocale     string // 默认语言类型，由于飞书客户端支持中、英、日三种语言，当用户切换语言时，如果假期名称没有所对应的语言，会使用默认语言的名称
	defaultLocaleFlag bool

	reason     string // 请假理由，必选字段
	reasonFlag bool

	approvePassTime     string // 审批通过时间，时间格式为 yyyy-MM-dd HH:mm:ss
	approvePassTimeFlag bool

	approveApplyTime     string // 审批申请时间，时间格式为 yyyy-MM-dd HH:mm:ss
	approveApplyTimeFlag bool

	idempotentId     string // 唯一幂等键
	idempotentIdFlag bool

	leaveDetailRangeObjs     []*TimeRangeList // 根据班次计算出来的请假具体时间，格式为list
	leaveDetailRangeObjsFlag bool
}

func NewUserLeaveBuilder() *UserLeaveBuilder {
	builder := &UserLeaveBuilder{}
	return builder
}

// 审批实例 ID
//
// 示例值：6737202939523236113
func (builder *UserLeaveBuilder) ApprovalId(approvalId string) *UserLeaveBuilder {
	builder.approvalId = approvalId
	builder.approvalIdFlag = true
	return builder
}

// 假期类型唯一 ID，代表一种假期类型，长度小于 14
//
// 示例值：6852582717813440527
func (builder *UserLeaveBuilder) UniqId(uniqId string) *UserLeaveBuilder {
	builder.uniqId = uniqId
	builder.uniqIdFlag = true
	return builder
}

// 假期时长单位
//
// 示例值：1
func (builder *UserLeaveBuilder) Unit(unit int) *UserLeaveBuilder {
	builder.unit = unit
	builder.unitFlag = true
	return builder
}

// 假期时长（单位：秒），暂未开放提供，待后续提供
//
// 示例值：28800
func (builder *UserLeaveBuilder) Interval(interval int) *UserLeaveBuilder {
	builder.interval = interval
	builder.intervalFlag = true
	return builder
}

// 开始时间，时间格式为 yyyy-MM-dd HH:mm:ss
//
// 示例值：2021-01-04 09:00:00
func (builder *UserLeaveBuilder) StartTime(startTime string) *UserLeaveBuilder {
	builder.startTime = startTime
	builder.startTimeFlag = true
	return builder
}

// 结束时间，时间格式为 yyyy-MM-dd HH:mm:ss
//
// 示例值：2021-01-04 19:00:00
func (builder *UserLeaveBuilder) EndTime(endTime string) *UserLeaveBuilder {
	builder.endTime = endTime
	builder.endTimeFlag = true
	return builder
}

// 假期多语言展示，格式为 map，key 为 ["ch"、"en"、"ja"]，其中 ch 代表中文、en 代表英语、ja 代表日语
//
// 示例值：
func (builder *UserLeaveBuilder) I18nNames(i18nNames *I18nNames) *UserLeaveBuilder {
	builder.i18nNames = i18nNames
	builder.i18nNamesFlag = true
	return builder
}

// 默认语言类型，由于飞书客户端支持中、英、日三种语言，当用户切换语言时，如果假期名称没有所对应的语言，会使用默认语言的名称
//
// 示例值：ch
func (builder *UserLeaveBuilder) DefaultLocale(defaultLocale string) *UserLeaveBuilder {
	builder.defaultLocale = defaultLocale
	builder.defaultLocaleFlag = true
	return builder
}

// 请假理由，必选字段
//
// 示例值：家里有事
func (builder *UserLeaveBuilder) Reason(reason string) *UserLeaveBuilder {
	builder.reason = reason
	builder.reasonFlag = true
	return builder
}

// 审批通过时间，时间格式为 yyyy-MM-dd HH:mm:ss
//
// 示例值：2021-01-04 12:00:00
func (builder *UserLeaveBuilder) ApprovePassTime(approvePassTime string) *UserLeaveBuilder {
	builder.approvePassTime = approvePassTime
	builder.approvePassTimeFlag = true
	return builder
}

// 审批申请时间，时间格式为 yyyy-MM-dd HH:mm:ss
//
// 示例值：2021-01-04 11:00:00
func (builder *UserLeaveBuilder) ApproveApplyTime(approveApplyTime string) *UserLeaveBuilder {
	builder.approveApplyTime = approveApplyTime
	builder.approveApplyTimeFlag = true
	return builder
}

// 唯一幂等键
//
// 示例值：1233432312
func (builder *UserLeaveBuilder) IdempotentId(idempotentId string) *UserLeaveBuilder {
	builder.idempotentId = idempotentId
	builder.idempotentIdFlag = true
	return builder
}

// 根据班次计算出来的请假具体时间，格式为list
//
// 示例值：
func (builder *UserLeaveBuilder) LeaveDetailRangeObjs(leaveDetailRangeObjs []*TimeRangeList) *UserLeaveBuilder {
	builder.leaveDetailRangeObjs = leaveDetailRangeObjs
	builder.leaveDetailRangeObjsFlag = true
	return builder
}

func (builder *UserLeaveBuilder) Build() *UserLeave {
	req := &UserLeave{}
	if builder.approvalIdFlag {
		req.ApprovalId = &builder.approvalId

	}
	if builder.uniqIdFlag {
		req.UniqId = &builder.uniqId

	}
	if builder.unitFlag {
		req.Unit = &builder.unit

	}
	if builder.intervalFlag {
		req.Interval = &builder.interval

	}
	if builder.startTimeFlag {
		req.StartTime = &builder.startTime

	}
	if builder.endTimeFlag {
		req.EndTime = &builder.endTime

	}
	if builder.i18nNamesFlag {
		req.I18nNames = builder.i18nNames
	}
	if builder.defaultLocaleFlag {
		req.DefaultLocale = &builder.defaultLocale

	}
	if builder.reasonFlag {
		req.Reason = &builder.reason

	}
	if builder.approvePassTimeFlag {
		req.ApprovePassTime = &builder.approvePassTime

	}
	if builder.approveApplyTimeFlag {
		req.ApproveApplyTime = &builder.approveApplyTime

	}
	if builder.idempotentIdFlag {
		req.IdempotentId = &builder.idempotentId

	}
	if builder.leaveDetailRangeObjsFlag {
		req.LeaveDetailRangeObjs = builder.leaveDetailRangeObjs
	}
	return req
}

type UserNormalLeaveType struct {
	UserId *string `json:"user_id,omitempty"` // 用户ID列表(用户id类型 open_id/union_id/user_id)

	LeaveTypeIds []string `json:"leave_type_ids,omitempty"` // 适用假期范围的假期ID
}

type UserNormalLeaveTypeBuilder struct {
	userId     string // 用户ID列表(用户id类型 open_id/union_id/user_id)
	userIdFlag bool

	leaveTypeIds     []string // 适用假期范围的假期ID
	leaveTypeIdsFlag bool
}

func NewUserNormalLeaveTypeBuilder() *UserNormalLeaveTypeBuilder {
	builder := &UserNormalLeaveTypeBuilder{}
	return builder
}

// 用户ID列表(用户id类型 open_id/union_id/user_id)
//
// 示例值：
func (builder *UserNormalLeaveTypeBuilder) UserId(userId string) *UserNormalLeaveTypeBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 适用假期范围的假期ID
//
// 示例值：
func (builder *UserNormalLeaveTypeBuilder) LeaveTypeIds(leaveTypeIds []string) *UserNormalLeaveTypeBuilder {
	builder.leaveTypeIds = leaveTypeIds
	builder.leaveTypeIdsFlag = true
	return builder
}

func (builder *UserNormalLeaveTypeBuilder) Build() *UserNormalLeaveType {
	req := &UserNormalLeaveType{}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.leaveTypeIdsFlag {
		req.LeaveTypeIds = builder.leaveTypeIds
	}
	return req
}

type UserOut struct {
	ApprovalId *string `json:"approval_id,omitempty"` // 审批实例 ID

	UniqId *string `json:"uniq_id,omitempty"` // 外出类型唯一 ID，代表一种假期类型，长度小于 14

	Unit *int `json:"unit,omitempty"` // 外出时长单位

	Interval *int `json:"interval,omitempty"` // 外出时长（单位：秒）

	StartTime *string `json:"start_time,omitempty"` // 开始时间，时间格式为 yyyy-MM-dd HH:mm:ss

	EndTime *string `json:"end_time,omitempty"` // 结束时间，时间格式为 yyyy-MM-dd HH:mm:ss

	I18nNames *I18nNames `json:"i18n_names,omitempty"` // 外出多语言展示，格式为 map，key 为 ["ch"、"en"、"ja"]，其中 ch 代表中文、en 代表英语、ja 代表日语

	DefaultLocale *string `json:"default_locale,omitempty"` // 默认语言类型，由于飞书客户端支持中、英、日三种语言，当用户切换语言时，如果假期名称没有所对应的语言，会使用默认语言的名称

	Reason *string `json:"reason,omitempty"` // 外出理由

	ApprovePassTime *string `json:"approve_pass_time,omitempty"` // 审批通过时间

	ApproveApplyTime *string `json:"approve_apply_time,omitempty"` // 审批申请时间

	IdempotentId *string `json:"idempotent_id,omitempty"` // 唯一幂等键

	CorrectProcessId []string `json:"correct_process_id,omitempty"` // 更正流程实例 ID

	CancelProcessId []string `json:"cancel_process_id,omitempty"` // 撤销流程实例 ID

	ProcessId []string `json:"process_id,omitempty"` // 发起流程实例 ID
}

type UserOutBuilder struct {
	approvalId     string // 审批实例 ID
	approvalIdFlag bool

	uniqId     string // 外出类型唯一 ID，代表一种假期类型，长度小于 14
	uniqIdFlag bool

	unit     int // 外出时长单位
	unitFlag bool

	interval     int // 外出时长（单位：秒）
	intervalFlag bool

	startTime     string // 开始时间，时间格式为 yyyy-MM-dd HH:mm:ss
	startTimeFlag bool

	endTime     string // 结束时间，时间格式为 yyyy-MM-dd HH:mm:ss
	endTimeFlag bool

	i18nNames     *I18nNames // 外出多语言展示，格式为 map，key 为 ["ch"、"en"、"ja"]，其中 ch 代表中文、en 代表英语、ja 代表日语
	i18nNamesFlag bool

	defaultLocale     string // 默认语言类型，由于飞书客户端支持中、英、日三种语言，当用户切换语言时，如果假期名称没有所对应的语言，会使用默认语言的名称
	defaultLocaleFlag bool

	reason     string // 外出理由
	reasonFlag bool

	approvePassTime     string // 审批通过时间
	approvePassTimeFlag bool

	approveApplyTime     string // 审批申请时间
	approveApplyTimeFlag bool

	idempotentId     string // 唯一幂等键
	idempotentIdFlag bool

	correctProcessId     []string // 更正流程实例 ID
	correctProcessIdFlag bool

	cancelProcessId     []string // 撤销流程实例 ID
	cancelProcessIdFlag bool

	processId     []string // 发起流程实例 ID
	processIdFlag bool
}

func NewUserOutBuilder() *UserOutBuilder {
	builder := &UserOutBuilder{}
	return builder
}

// 审批实例 ID
//
// 示例值：6737202939523236113
func (builder *UserOutBuilder) ApprovalId(approvalId string) *UserOutBuilder {
	builder.approvalId = approvalId
	builder.approvalIdFlag = true
	return builder
}

// 外出类型唯一 ID，代表一种假期类型，长度小于 14
//
// 示例值：9496E43696967658A512969523E89870
func (builder *UserOutBuilder) UniqId(uniqId string) *UserOutBuilder {
	builder.uniqId = uniqId
	builder.uniqIdFlag = true
	return builder
}

// 外出时长单位
//
// 示例值：1
func (builder *UserOutBuilder) Unit(unit int) *UserOutBuilder {
	builder.unit = unit
	builder.unitFlag = true
	return builder
}

// 外出时长（单位：秒）
//
// 示例值：28800
func (builder *UserOutBuilder) Interval(interval int) *UserOutBuilder {
	builder.interval = interval
	builder.intervalFlag = true
	return builder
}

// 开始时间，时间格式为 yyyy-MM-dd HH:mm:ss
//
// 示例值：2021-01-04 09:00:00
func (builder *UserOutBuilder) StartTime(startTime string) *UserOutBuilder {
	builder.startTime = startTime
	builder.startTimeFlag = true
	return builder
}

// 结束时间，时间格式为 yyyy-MM-dd HH:mm:ss
//
// 示例值：2021-01-04 19:00:00
func (builder *UserOutBuilder) EndTime(endTime string) *UserOutBuilder {
	builder.endTime = endTime
	builder.endTimeFlag = true
	return builder
}

// 外出多语言展示，格式为 map，key 为 ["ch"、"en"、"ja"]，其中 ch 代表中文、en 代表英语、ja 代表日语
//
// 示例值：
func (builder *UserOutBuilder) I18nNames(i18nNames *I18nNames) *UserOutBuilder {
	builder.i18nNames = i18nNames
	builder.i18nNamesFlag = true
	return builder
}

// 默认语言类型，由于飞书客户端支持中、英、日三种语言，当用户切换语言时，如果假期名称没有所对应的语言，会使用默认语言的名称
//
// 示例值：ch
func (builder *UserOutBuilder) DefaultLocale(defaultLocale string) *UserOutBuilder {
	builder.defaultLocale = defaultLocale
	builder.defaultLocaleFlag = true
	return builder
}

// 外出理由
//
// 示例值：外出办事
func (builder *UserOutBuilder) Reason(reason string) *UserOutBuilder {
	builder.reason = reason
	builder.reasonFlag = true
	return builder
}

// 审批通过时间
//
// 示例值：2021-01-04 12:00:00
func (builder *UserOutBuilder) ApprovePassTime(approvePassTime string) *UserOutBuilder {
	builder.approvePassTime = approvePassTime
	builder.approvePassTimeFlag = true
	return builder
}

// 审批申请时间
//
// 示例值：2021-01-04 11:00:00
func (builder *UserOutBuilder) ApproveApplyTime(approveApplyTime string) *UserOutBuilder {
	builder.approveApplyTime = approveApplyTime
	builder.approveApplyTimeFlag = true
	return builder
}

// 唯一幂等键
//
// 示例值：1233432312
func (builder *UserOutBuilder) IdempotentId(idempotentId string) *UserOutBuilder {
	builder.idempotentId = idempotentId
	builder.idempotentIdFlag = true
	return builder
}

// 更正流程实例 ID
//
// 示例值：
func (builder *UserOutBuilder) CorrectProcessId(correctProcessId []string) *UserOutBuilder {
	builder.correctProcessId = correctProcessId
	builder.correctProcessIdFlag = true
	return builder
}

// 撤销流程实例 ID
//
// 示例值：
func (builder *UserOutBuilder) CancelProcessId(cancelProcessId []string) *UserOutBuilder {
	builder.cancelProcessId = cancelProcessId
	builder.cancelProcessIdFlag = true
	return builder
}

// 发起流程实例 ID
//
// 示例值：
func (builder *UserOutBuilder) ProcessId(processId []string) *UserOutBuilder {
	builder.processId = processId
	builder.processIdFlag = true
	return builder
}

func (builder *UserOutBuilder) Build() *UserOut {
	req := &UserOut{}
	if builder.approvalIdFlag {
		req.ApprovalId = &builder.approvalId

	}
	if builder.uniqIdFlag {
		req.UniqId = &builder.uniqId

	}
	if builder.unitFlag {
		req.Unit = &builder.unit

	}
	if builder.intervalFlag {
		req.Interval = &builder.interval

	}
	if builder.startTimeFlag {
		req.StartTime = &builder.startTime

	}
	if builder.endTimeFlag {
		req.EndTime = &builder.endTime

	}
	if builder.i18nNamesFlag {
		req.I18nNames = builder.i18nNames
	}
	if builder.defaultLocaleFlag {
		req.DefaultLocale = &builder.defaultLocale

	}
	if builder.reasonFlag {
		req.Reason = &builder.reason

	}
	if builder.approvePassTimeFlag {
		req.ApprovePassTime = &builder.approvePassTime

	}
	if builder.approveApplyTimeFlag {
		req.ApproveApplyTime = &builder.approveApplyTime

	}
	if builder.idempotentIdFlag {
		req.IdempotentId = &builder.idempotentId

	}
	if builder.correctProcessIdFlag {
		req.CorrectProcessId = builder.correctProcessId
	}
	if builder.cancelProcessIdFlag {
		req.CancelProcessId = builder.cancelProcessId
	}
	if builder.processIdFlag {
		req.ProcessId = builder.processId
	}
	return req
}

type UserOvertimeWork struct {
	ApprovalId *string `json:"approval_id,omitempty"` // 审批实例 ID

	Duration *float64 `json:"duration,omitempty"` // 加班时长

	Unit *int `json:"unit,omitempty"` // 加班时长单位

	Category *int `json:"category,omitempty"` // 加班日期类型

	Type *int `json:"type,omitempty"` // 加班规则类型

	StartTime *string `json:"start_time,omitempty"` // 开始时间，时间格式为 yyyy-MM-dd HH:mm:ss

	EndTime *string `json:"end_time,omitempty"` // 结束时间，时间格式为 yyyy-MM-dd HH:mm:ss

	Reason *string `json:"reason,omitempty"` // 加班事由

	IdempotentId *string `json:"idempotent_id,omitempty"` // 唯一幂等键

	CorrectProcessId []string `json:"correct_process_id,omitempty"` // 更正流程实例 ID

	CancelProcessId []string `json:"cancel_process_id,omitempty"` // 撤销流程实例 ID

	ProcessId []string `json:"process_id,omitempty"` // 发起流程实例 ID
}

type UserOvertimeWorkBuilder struct {
	approvalId     string // 审批实例 ID
	approvalIdFlag bool

	duration     float64 // 加班时长
	durationFlag bool

	unit     int // 加班时长单位
	unitFlag bool

	category     int // 加班日期类型
	categoryFlag bool

	type_    int // 加班规则类型
	typeFlag bool

	startTime     string // 开始时间，时间格式为 yyyy-MM-dd HH:mm:ss
	startTimeFlag bool

	endTime     string // 结束时间，时间格式为 yyyy-MM-dd HH:mm:ss
	endTimeFlag bool

	reason     string // 加班事由
	reasonFlag bool

	idempotentId     string // 唯一幂等键
	idempotentIdFlag bool

	correctProcessId     []string // 更正流程实例 ID
	correctProcessIdFlag bool

	cancelProcessId     []string // 撤销流程实例 ID
	cancelProcessIdFlag bool

	processId     []string // 发起流程实例 ID
	processIdFlag bool
}

func NewUserOvertimeWorkBuilder() *UserOvertimeWorkBuilder {
	builder := &UserOvertimeWorkBuilder{}
	return builder
}

// 审批实例 ID
//
// 示例值：6737202939523236113
func (builder *UserOvertimeWorkBuilder) ApprovalId(approvalId string) *UserOvertimeWorkBuilder {
	builder.approvalId = approvalId
	builder.approvalIdFlag = true
	return builder
}

// 加班时长
//
// 示例值：1.5
func (builder *UserOvertimeWorkBuilder) Duration(duration float64) *UserOvertimeWorkBuilder {
	builder.duration = duration
	builder.durationFlag = true
	return builder
}

// 加班时长单位
//
// 示例值：1
func (builder *UserOvertimeWorkBuilder) Unit(unit int) *UserOvertimeWorkBuilder {
	builder.unit = unit
	builder.unitFlag = true
	return builder
}

// 加班日期类型
//
// 示例值：2
func (builder *UserOvertimeWorkBuilder) Category(category int) *UserOvertimeWorkBuilder {
	builder.category = category
	builder.categoryFlag = true
	return builder
}

// 加班规则类型
//
// 示例值：1
func (builder *UserOvertimeWorkBuilder) Type(type_ int) *UserOvertimeWorkBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

// 开始时间，时间格式为 yyyy-MM-dd HH:mm:ss
//
// 示例值：2021-01-09 09:00:00
func (builder *UserOvertimeWorkBuilder) StartTime(startTime string) *UserOvertimeWorkBuilder {
	builder.startTime = startTime
	builder.startTimeFlag = true
	return builder
}

// 结束时间，时间格式为 yyyy-MM-dd HH:mm:ss
//
// 示例值：2021-01-10 13:00:00
func (builder *UserOvertimeWorkBuilder) EndTime(endTime string) *UserOvertimeWorkBuilder {
	builder.endTime = endTime
	builder.endTimeFlag = true
	return builder
}

// 加班事由
//
// 示例值：推进项目进度
func (builder *UserOvertimeWorkBuilder) Reason(reason string) *UserOvertimeWorkBuilder {
	builder.reason = reason
	builder.reasonFlag = true
	return builder
}

// 唯一幂等键
//
// 示例值：1233432312
func (builder *UserOvertimeWorkBuilder) IdempotentId(idempotentId string) *UserOvertimeWorkBuilder {
	builder.idempotentId = idempotentId
	builder.idempotentIdFlag = true
	return builder
}

// 更正流程实例 ID
//
// 示例值：
func (builder *UserOvertimeWorkBuilder) CorrectProcessId(correctProcessId []string) *UserOvertimeWorkBuilder {
	builder.correctProcessId = correctProcessId
	builder.correctProcessIdFlag = true
	return builder
}

// 撤销流程实例 ID
//
// 示例值：
func (builder *UserOvertimeWorkBuilder) CancelProcessId(cancelProcessId []string) *UserOvertimeWorkBuilder {
	builder.cancelProcessId = cancelProcessId
	builder.cancelProcessIdFlag = true
	return builder
}

// 发起流程实例 ID
//
// 示例值：
func (builder *UserOvertimeWorkBuilder) ProcessId(processId []string) *UserOvertimeWorkBuilder {
	builder.processId = processId
	builder.processIdFlag = true
	return builder
}

func (builder *UserOvertimeWorkBuilder) Build() *UserOvertimeWork {
	req := &UserOvertimeWork{}
	if builder.approvalIdFlag {
		req.ApprovalId = &builder.approvalId

	}
	if builder.durationFlag {
		req.Duration = &builder.duration

	}
	if builder.unitFlag {
		req.Unit = &builder.unit

	}
	if builder.categoryFlag {
		req.Category = &builder.category

	}
	if builder.typeFlag {
		req.Type = &builder.type_

	}
	if builder.startTimeFlag {
		req.StartTime = &builder.startTime

	}
	if builder.endTimeFlag {
		req.EndTime = &builder.endTime

	}
	if builder.reasonFlag {
		req.Reason = &builder.reason

	}
	if builder.idempotentIdFlag {
		req.IdempotentId = &builder.idempotentId

	}
	if builder.correctProcessIdFlag {
		req.CorrectProcessId = builder.correctProcessId
	}
	if builder.cancelProcessIdFlag {
		req.CancelProcessId = builder.cancelProcessId
	}
	if builder.processIdFlag {
		req.ProcessId = builder.processId
	}
	return req
}

type UserSetting struct {
	UserId *string `json:"user_id,omitempty"` // 用户 ID

	FaceKey *string `json:"face_key,omitempty"` // 人脸照片文件 ID，获取方式：[文件上传](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/file/upload)

	FaceKeyUpdateTime *string `json:"face_key_update_time,omitempty"` // 人脸照片更新时间，精确到秒的时间戳
}

type UserSettingBuilder struct {
	userId     string // 用户 ID
	userIdFlag bool

	faceKey     string // 人脸照片文件 ID，获取方式：[文件上传](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/file/upload)
	faceKeyFlag bool

	faceKeyUpdateTime     string // 人脸照片更新时间，精确到秒的时间戳
	faceKeyUpdateTimeFlag bool
}

func NewUserSettingBuilder() *UserSettingBuilder {
	builder := &UserSettingBuilder{}
	return builder
}

// 用户 ID
//
// 示例值：abd754f7
func (builder *UserSettingBuilder) UserId(userId string) *UserSettingBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 人脸照片文件 ID，获取方式：[文件上传](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/file/upload)
//
// 示例值：xxxxxb306842b1c189bc5212eefxxxxx
func (builder *UserSettingBuilder) FaceKey(faceKey string) *UserSettingBuilder {
	builder.faceKey = faceKey
	builder.faceKeyFlag = true
	return builder
}

// 人脸照片更新时间，精确到秒的时间戳
//
// 示例值：1625681917
func (builder *UserSettingBuilder) FaceKeyUpdateTime(faceKeyUpdateTime string) *UserSettingBuilder {
	builder.faceKeyUpdateTime = faceKeyUpdateTime
	builder.faceKeyUpdateTimeFlag = true
	return builder
}

func (builder *UserSettingBuilder) Build() *UserSetting {
	req := &UserSetting{}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.faceKeyFlag {
		req.FaceKey = &builder.faceKey

	}
	if builder.faceKeyUpdateTimeFlag {
		req.FaceKeyUpdateTime = &builder.faceKeyUpdateTime

	}
	return req
}

type UserShiftGroupsList struct {
	ShiftGroupId *string `json:"shift_group_id,omitempty"` // 班组ID

	ShiftGroupName *string `json:"shift_group_name,omitempty"` // 班组名称

	GroupId *string `json:"group_id,omitempty"` // 考勤组ID

	UpdateTime *string `json:"update_time,omitempty"` // 班组的最后更新时间
}

type UserShiftGroupsListBuilder struct {
	shiftGroupId     string // 班组ID
	shiftGroupIdFlag bool

	shiftGroupName     string // 班组名称
	shiftGroupNameFlag bool

	groupId     string // 考勤组ID
	groupIdFlag bool

	updateTime     string // 班组的最后更新时间
	updateTimeFlag bool
}

func NewUserShiftGroupsListBuilder() *UserShiftGroupsListBuilder {
	builder := &UserShiftGroupsListBuilder{}
	return builder
}

// 班组ID
//
// 示例值：7301693071333261331
func (builder *UserShiftGroupsListBuilder) ShiftGroupId(shiftGroupId string) *UserShiftGroupsListBuilder {
	builder.shiftGroupId = shiftGroupId
	builder.shiftGroupIdFlag = true
	return builder
}

// 班组名称
//
// 示例值：飞书考勤班组
func (builder *UserShiftGroupsListBuilder) ShiftGroupName(shiftGroupName string) *UserShiftGroupsListBuilder {
	builder.shiftGroupName = shiftGroupName
	builder.shiftGroupNameFlag = true
	return builder
}

// 考勤组ID
//
// 示例值：7299769369813319699
func (builder *UserShiftGroupsListBuilder) GroupId(groupId string) *UserShiftGroupsListBuilder {
	builder.groupId = groupId
	builder.groupIdFlag = true
	return builder
}

// 班组的最后更新时间
//
// 示例值：2023-11-15 09:00:00
func (builder *UserShiftGroupsListBuilder) UpdateTime(updateTime string) *UserShiftGroupsListBuilder {
	builder.updateTime = updateTime
	builder.updateTimeFlag = true
	return builder
}

func (builder *UserShiftGroupsListBuilder) Build() *UserShiftGroupsList {
	req := &UserShiftGroupsList{}
	if builder.shiftGroupIdFlag {
		req.ShiftGroupId = &builder.shiftGroupId

	}
	if builder.shiftGroupNameFlag {
		req.ShiftGroupName = &builder.shiftGroupName

	}
	if builder.groupIdFlag {
		req.GroupId = &builder.groupId

	}
	if builder.updateTimeFlag {
		req.UpdateTime = &builder.updateTime

	}
	return req
}

type UserStatsData struct {
	Name *string `json:"name,omitempty"` // 用户姓名

	UserId *string `json:"user_id,omitempty"` // 用户 ID

	Datas []*UserStatsDataCell `json:"datas,omitempty"` // 用户的统计数据
}

type UserStatsDataBuilder struct {
	name     string // 用户姓名
	nameFlag bool

	userId     string // 用户 ID
	userIdFlag bool

	datas     []*UserStatsDataCell // 用户的统计数据
	datasFlag bool
}

func NewUserStatsDataBuilder() *UserStatsDataBuilder {
	builder := &UserStatsDataBuilder{}
	return builder
}

// 用户姓名
//
// 示例值：小李
func (builder *UserStatsDataBuilder) Name(name string) *UserStatsDataBuilder {
	builder.name = name
	builder.nameFlag = true
	return builder
}

// 用户 ID
//
// 示例值：ec8ddg56
func (builder *UserStatsDataBuilder) UserId(userId string) *UserStatsDataBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 用户的统计数据
//
// 示例值：
func (builder *UserStatsDataBuilder) Datas(datas []*UserStatsDataCell) *UserStatsDataBuilder {
	builder.datas = datas
	builder.datasFlag = true
	return builder
}

func (builder *UserStatsDataBuilder) Build() *UserStatsData {
	req := &UserStatsData{}
	if builder.nameFlag {
		req.Name = &builder.name

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.datasFlag {
		req.Datas = builder.datas
	}
	return req
}

type UserStatsDataCell struct {
	Code *string `json:"code,omitempty"` // 字段编号

	Value *string `json:"value,omitempty"` // 数据值

	Features []*UserStatsDataFeature `json:"features,omitempty"` // 数据属性

	Title *string `json:"title,omitempty"` // 字段标题

	DurationNum *UserStatsDataDuration `json:"duration_num,omitempty"` // 时长
}

type UserStatsDataCellBuilder struct {
	code     string // 字段编号
	codeFlag bool

	value     string // 数据值
	valueFlag bool

	features     []*UserStatsDataFeature // 数据属性
	featuresFlag bool

	title     string // 字段标题
	titleFlag bool

	durationNum     *UserStatsDataDuration // 时长
	durationNumFlag bool
}

func NewUserStatsDataCellBuilder() *UserStatsDataCellBuilder {
	builder := &UserStatsDataCellBuilder{}
	return builder
}

// 字段编号
//
// 示例值：50102
func (builder *UserStatsDataCellBuilder) Code(code string) *UserStatsDataCellBuilder {
	builder.code = code
	builder.codeFlag = true
	return builder
}

// 数据值
//
// 示例值：无需打卡(-), 无需打卡(-)
func (builder *UserStatsDataCellBuilder) Value(value string) *UserStatsDataCellBuilder {
	builder.value = value
	builder.valueFlag = true
	return builder
}

// 数据属性
//
// 示例值：
func (builder *UserStatsDataCellBuilder) Features(features []*UserStatsDataFeature) *UserStatsDataCellBuilder {
	builder.features = features
	builder.featuresFlag = true
	return builder
}

// 字段标题
//
// 示例值：姓名
func (builder *UserStatsDataCellBuilder) Title(title string) *UserStatsDataCellBuilder {
	builder.title = title
	builder.titleFlag = true
	return builder
}

// 时长
//
// 示例值：
func (builder *UserStatsDataCellBuilder) DurationNum(durationNum *UserStatsDataDuration) *UserStatsDataCellBuilder {
	builder.durationNum = durationNum
	builder.durationNumFlag = true
	return builder
}

func (builder *UserStatsDataCellBuilder) Build() *UserStatsDataCell {
	req := &UserStatsDataCell{}
	if builder.codeFlag {
		req.Code = &builder.code

	}
	if builder.valueFlag {
		req.Value = &builder.value

	}
	if builder.featuresFlag {
		req.Features = builder.features
	}
	if builder.titleFlag {
		req.Title = &builder.title

	}
	if builder.durationNumFlag {
		req.DurationNum = builder.durationNum
	}
	return req
}

type UserStatsDataDuration struct {
	Day *string `json:"day,omitempty"` // 天

	HalfDay *string `json:"half_day,omitempty"` // 半天

	Hour *string `json:"hour,omitempty"` // 小时

	HalfHour *string `json:"half_hour,omitempty"` // 半小时

	Minute *string `json:"minute,omitempty"` // 分钟
}

type UserStatsDataDurationBuilder struct {
	day     string // 天
	dayFlag bool

	halfDay     string // 半天
	halfDayFlag bool

	hour     string // 小时
	hourFlag bool

	halfHour     string // 半小时
	halfHourFlag bool

	minute     string // 分钟
	minuteFlag bool
}

func NewUserStatsDataDurationBuilder() *UserStatsDataDurationBuilder {
	builder := &UserStatsDataDurationBuilder{}
	return builder
}

// 天
//
// 示例值：1
func (builder *UserStatsDataDurationBuilder) Day(day string) *UserStatsDataDurationBuilder {
	builder.day = day
	builder.dayFlag = true
	return builder
}

// 半天
//
// 示例值：1
func (builder *UserStatsDataDurationBuilder) HalfDay(halfDay string) *UserStatsDataDurationBuilder {
	builder.halfDay = halfDay
	builder.halfDayFlag = true
	return builder
}

// 小时
//
// 示例值：1
func (builder *UserStatsDataDurationBuilder) Hour(hour string) *UserStatsDataDurationBuilder {
	builder.hour = hour
	builder.hourFlag = true
	return builder
}

// 半小时
//
// 示例值：1
func (builder *UserStatsDataDurationBuilder) HalfHour(halfHour string) *UserStatsDataDurationBuilder {
	builder.halfHour = halfHour
	builder.halfHourFlag = true
	return builder
}

// 分钟
//
// 示例值：1
func (builder *UserStatsDataDurationBuilder) Minute(minute string) *UserStatsDataDurationBuilder {
	builder.minute = minute
	builder.minuteFlag = true
	return builder
}

func (builder *UserStatsDataDurationBuilder) Build() *UserStatsDataDuration {
	req := &UserStatsDataDuration{}
	if builder.dayFlag {
		req.Day = &builder.day

	}
	if builder.halfDayFlag {
		req.HalfDay = &builder.halfDay

	}
	if builder.hourFlag {
		req.Hour = &builder.hour

	}
	if builder.halfHourFlag {
		req.HalfHour = &builder.halfHour

	}
	if builder.minuteFlag {
		req.Minute = &builder.minute

	}
	return req
}

type UserStatsDataFeature struct {
	Key *string `json:"key,omitempty"` // 统计数据列附加属性的名称

	Value *string `json:"value,omitempty"` // 统计数据列附加属性的值
}

type UserStatsDataFeatureBuilder struct {
	key     string // 统计数据列附加属性的名称
	keyFlag bool

	value     string // 统计数据列附加属性的值
	valueFlag bool
}

func NewUserStatsDataFeatureBuilder() *UserStatsDataFeatureBuilder {
	builder := &UserStatsDataFeatureBuilder{}
	return builder
}

// 统计数据列附加属性的名称
//
// 示例值：Abnormal
func (builder *UserStatsDataFeatureBuilder) Key(key string) *UserStatsDataFeatureBuilder {
	builder.key = key
	builder.keyFlag = true
	return builder
}

// 统计数据列附加属性的值
//
// 示例值：false
func (builder *UserStatsDataFeatureBuilder) Value(value string) *UserStatsDataFeatureBuilder {
	builder.value = value
	builder.valueFlag = true
	return builder
}

func (builder *UserStatsDataFeatureBuilder) Build() *UserStatsDataFeature {
	req := &UserStatsDataFeature{}
	if builder.keyFlag {
		req.Key = &builder.key

	}
	if builder.valueFlag {
		req.Value = &builder.value

	}
	return req
}

type UserStatsField struct {
	StatsType *string `json:"stats_type,omitempty"` // 统计类型

	UserId *string `json:"user_id,omitempty"` // 用户 ID

	Fields []*Field `json:"fields,omitempty"` // 字段列表
}

type UserStatsFieldBuilder struct {
	statsType     string // 统计类型
	statsTypeFlag bool

	userId     string // 用户 ID
	userIdFlag bool

	fields     []*Field // 字段列表
	fieldsFlag bool
}

func NewUserStatsFieldBuilder() *UserStatsFieldBuilder {
	builder := &UserStatsFieldBuilder{}
	return builder
}

// 统计类型
//
// 示例值：
func (builder *UserStatsFieldBuilder) StatsType(statsType string) *UserStatsFieldBuilder {
	builder.statsType = statsType
	builder.statsTypeFlag = true
	return builder
}

// 用户 ID
//
// 示例值：
func (builder *UserStatsFieldBuilder) UserId(userId string) *UserStatsFieldBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 字段列表
//
// 示例值：
func (builder *UserStatsFieldBuilder) Fields(fields []*Field) *UserStatsFieldBuilder {
	builder.fields = fields
	builder.fieldsFlag = true
	return builder
}

func (builder *UserStatsFieldBuilder) Build() *UserStatsField {
	req := &UserStatsField{}
	if builder.statsTypeFlag {
		req.StatsType = &builder.statsType

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.fieldsFlag {
		req.Fields = builder.fields
	}
	return req
}

type UserStatsView struct {
	ViewId *string `json:"view_id,omitempty"` // 视图 ID

	StatsType *string `json:"stats_type,omitempty"` // 视图类型

	UserId *string `json:"user_id,omitempty"` // 查询用户id，同【查询统计数据】、【查询统计设置】user_id

	Items []*Item `json:"items,omitempty"` // 用户设置字段
}

type UserStatsViewBuilder struct {
	viewId     string // 视图 ID
	viewIdFlag bool

	statsType     string // 视图类型
	statsTypeFlag bool

	userId     string // 查询用户id，同【查询统计数据】、【查询统计设置】user_id
	userIdFlag bool

	items     []*Item // 用户设置字段
	itemsFlag bool
}

func NewUserStatsViewBuilder() *UserStatsViewBuilder {
	builder := &UserStatsViewBuilder{}
	return builder
}

// 视图 ID
//
// 示例值：TmpZNU5qTTJORFF6T1RnNU5UTTNOakV6TWl0dGIyNTBhQT09
func (builder *UserStatsViewBuilder) ViewId(viewId string) *UserStatsViewBuilder {
	builder.viewId = viewId
	builder.viewIdFlag = true
	return builder
}

// 视图类型
//
// 示例值：month
func (builder *UserStatsViewBuilder) StatsType(statsType string) *UserStatsViewBuilder {
	builder.statsType = statsType
	builder.statsTypeFlag = true
	return builder
}

// 查询用户id，同【查询统计数据】、【查询统计设置】user_id
//
// 示例值：ec8ddg56
func (builder *UserStatsViewBuilder) UserId(userId string) *UserStatsViewBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 用户设置字段
//
// 示例值：
func (builder *UserStatsViewBuilder) Items(items []*Item) *UserStatsViewBuilder {
	builder.items = items
	builder.itemsFlag = true
	return builder
}

func (builder *UserStatsViewBuilder) Build() *UserStatsView {
	req := &UserStatsView{}
	if builder.viewIdFlag {
		req.ViewId = &builder.viewId

	}
	if builder.statsTypeFlag {
		req.StatsType = &builder.statsType

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.itemsFlag {
		req.Items = builder.items
	}
	return req
}

type UserSubTypeAccount struct {
	SubType *string `json:"sub_type,omitempty"` // 假期子类型

	Quota *string `json:"quota,omitempty"` // 假期子类型数量
}

type UserSubTypeAccountBuilder struct {
	subType     string // 假期子类型
	subTypeFlag bool

	quota     string // 假期子类型数量
	quotaFlag bool
}

func NewUserSubTypeAccountBuilder() *UserSubTypeAccountBuilder {
	builder := &UserSubTypeAccountBuilder{}
	return builder
}

// 假期子类型
//
// 示例值：normal
func (builder *UserSubTypeAccountBuilder) SubType(subType string) *UserSubTypeAccountBuilder {
	builder.subType = subType
	builder.subTypeFlag = true
	return builder
}

// 假期子类型数量
//
// 示例值：1.51
func (builder *UserSubTypeAccountBuilder) Quota(quota string) *UserSubTypeAccountBuilder {
	builder.quota = quota
	builder.quotaFlag = true
	return builder
}

func (builder *UserSubTypeAccountBuilder) Build() *UserSubTypeAccount {
	req := &UserSubTypeAccount{}
	if builder.subTypeFlag {
		req.SubType = &builder.subType

	}
	if builder.quotaFlag {
		req.Quota = &builder.quota

	}
	return req
}

type UserTask struct {
	ResultId *string `json:"result_id,omitempty"` // 打卡记录 ID

	UserId *string `json:"user_id,omitempty"` // 用户 ID

	EmployeeName *string `json:"employee_name,omitempty"` // 用户姓名

	Day *int `json:"day,omitempty"` // 日期

	GroupId *string `json:"group_id,omitempty"` // 考勤组 ID

	ShiftId *string `json:"shift_id,omitempty"` // 班次 ID

	Records []*TaskResult `json:"records,omitempty"` // 用户考勤记录
}

type UserTaskBuilder struct {
	resultId     string // 打卡记录 ID
	resultIdFlag bool

	userId     string // 用户 ID
	userIdFlag bool

	employeeName     string // 用户姓名
	employeeNameFlag bool

	day     int // 日期
	dayFlag bool

	groupId     string // 考勤组 ID
	groupIdFlag bool

	shiftId     string // 班次 ID
	shiftIdFlag bool

	records     []*TaskResult // 用户考勤记录
	recordsFlag bool
}

func NewUserTaskBuilder() *UserTaskBuilder {
	builder := &UserTaskBuilder{}
	return builder
}

// 打卡记录 ID
//
// 示例值：6709359313699356941
func (builder *UserTaskBuilder) ResultId(resultId string) *UserTaskBuilder {
	builder.resultId = resultId
	builder.resultIdFlag = true
	return builder
}

// 用户 ID
//
// 示例值：abd754f7
func (builder *UserTaskBuilder) UserId(userId string) *UserTaskBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 用户姓名
//
// 示例值：张三
func (builder *UserTaskBuilder) EmployeeName(employeeName string) *UserTaskBuilder {
	builder.employeeName = employeeName
	builder.employeeNameFlag = true
	return builder
}

// 日期
//
// 示例值：20190819
func (builder *UserTaskBuilder) Day(day int) *UserTaskBuilder {
	builder.day = day
	builder.dayFlag = true
	return builder
}

// 考勤组 ID
//
// 示例值：6737202939523236110
func (builder *UserTaskBuilder) GroupId(groupId string) *UserTaskBuilder {
	builder.groupId = groupId
	builder.groupIdFlag = true
	return builder
}

// 班次 ID
//
// 示例值：6753520403404030215
func (builder *UserTaskBuilder) ShiftId(shiftId string) *UserTaskBuilder {
	builder.shiftId = shiftId
	builder.shiftIdFlag = true
	return builder
}

// 用户考勤记录
//
// 示例值：
func (builder *UserTaskBuilder) Records(records []*TaskResult) *UserTaskBuilder {
	builder.records = records
	builder.recordsFlag = true
	return builder
}

func (builder *UserTaskBuilder) Build() *UserTask {
	req := &UserTask{}
	if builder.resultIdFlag {
		req.ResultId = &builder.resultId

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.employeeNameFlag {
		req.EmployeeName = &builder.employeeName

	}
	if builder.dayFlag {
		req.Day = &builder.day

	}
	if builder.groupIdFlag {
		req.GroupId = &builder.groupId

	}
	if builder.shiftIdFlag {
		req.ShiftId = &builder.shiftId

	}
	if builder.recordsFlag {
		req.Records = builder.records
	}
	return req
}

type UserTaskRemedy struct {
	UserId *string `json:"user_id,omitempty"` // 用户 ID

	RemedyDate *int `json:"remedy_date,omitempty"` // 补卡日期

	PunchNo *int `json:"punch_no,omitempty"` // 第几次上下班，0：第 1 次上下班，1：第 2 次上下班，2：第 3 次上下班，自由班制填 0

	WorkType *int `json:"work_type,omitempty"` // 上班 / 下班，1：上班，2：下班，自由班制填 0

	ApprovalId *string `json:"approval_id,omitempty"` // 审批 ID

	RemedyTime *string `json:"remedy_time,omitempty"` // 补卡时间，时间格式为 yyyy-MM-dd HH:mm

	Status *int `json:"status,omitempty"` // 补卡状态（默认为审批中）

	Reason *string `json:"reason,omitempty"` // 补卡原因

	Time *string `json:"time,omitempty"` // 补卡时间，精确到秒的时间戳

	TimeZone *string `json:"time_zone,omitempty"` // 补卡时考勤组时区

	CreateTime *string `json:"create_time,omitempty"` // 补卡发起时间，精确到秒的时间戳

	UpdateTime *string `json:"update_time,omitempty"` // 补卡状态更新时间，精确到秒的时间戳
}

type UserTaskRemedyBuilder struct {
	userId     string // 用户 ID
	userIdFlag bool

	remedyDate     int // 补卡日期
	remedyDateFlag bool

	punchNo     int // 第几次上下班，0：第 1 次上下班，1：第 2 次上下班，2：第 3 次上下班，自由班制填 0
	punchNoFlag bool

	workType     int // 上班 / 下班，1：上班，2：下班，自由班制填 0
	workTypeFlag bool

	approvalId     string // 审批 ID
	approvalIdFlag bool

	remedyTime     string // 补卡时间，时间格式为 yyyy-MM-dd HH:mm
	remedyTimeFlag bool

	status     int // 补卡状态（默认为审批中）
	statusFlag bool

	reason     string // 补卡原因
	reasonFlag bool

	time     string // 补卡时间，精确到秒的时间戳
	timeFlag bool

	timeZone     string // 补卡时考勤组时区
	timeZoneFlag bool

	createTime     string // 补卡发起时间，精确到秒的时间戳
	createTimeFlag bool

	updateTime     string // 补卡状态更新时间，精确到秒的时间戳
	updateTimeFlag bool
}

func NewUserTaskRemedyBuilder() *UserTaskRemedyBuilder {
	builder := &UserTaskRemedyBuilder{}
	return builder
}

// 用户 ID
//
// 示例值：abd754f7
func (builder *UserTaskRemedyBuilder) UserId(userId string) *UserTaskRemedyBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 补卡日期
//
// 示例值：20210701
func (builder *UserTaskRemedyBuilder) RemedyDate(remedyDate int) *UserTaskRemedyBuilder {
	builder.remedyDate = remedyDate
	builder.remedyDateFlag = true
	return builder
}

// 第几次上下班，0：第 1 次上下班，1：第 2 次上下班，2：第 3 次上下班，自由班制填 0
//
// 示例值：0
func (builder *UserTaskRemedyBuilder) PunchNo(punchNo int) *UserTaskRemedyBuilder {
	builder.punchNo = punchNo
	builder.punchNoFlag = true
	return builder
}

// 上班 / 下班，1：上班，2：下班，自由班制填 0
//
// 示例值：1
func (builder *UserTaskRemedyBuilder) WorkType(workType int) *UserTaskRemedyBuilder {
	builder.workType = workType
	builder.workTypeFlag = true
	return builder
}

// 审批 ID
//
// 示例值：6737202939523236113
func (builder *UserTaskRemedyBuilder) ApprovalId(approvalId string) *UserTaskRemedyBuilder {
	builder.approvalId = approvalId
	builder.approvalIdFlag = true
	return builder
}

// 补卡时间，时间格式为 yyyy-MM-dd HH:mm
//
// 示例值：2021-07-01 08:00
func (builder *UserTaskRemedyBuilder) RemedyTime(remedyTime string) *UserTaskRemedyBuilder {
	builder.remedyTime = remedyTime
	builder.remedyTimeFlag = true
	return builder
}

// 补卡状态（默认为审批中）
//
// 示例值：2
func (builder *UserTaskRemedyBuilder) Status(status int) *UserTaskRemedyBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

// 补卡原因
//
// 示例值：忘记打卡
func (builder *UserTaskRemedyBuilder) Reason(reason string) *UserTaskRemedyBuilder {
	builder.reason = reason
	builder.reasonFlag = true
	return builder
}

// 补卡时间，精确到秒的时间戳
//
// 示例值：1611476284
func (builder *UserTaskRemedyBuilder) Time(time string) *UserTaskRemedyBuilder {
	builder.time = time
	builder.timeFlag = true
	return builder
}

// 补卡时考勤组时区
//
// 示例值：Asia/Shanghai
func (builder *UserTaskRemedyBuilder) TimeZone(timeZone string) *UserTaskRemedyBuilder {
	builder.timeZone = timeZone
	builder.timeZoneFlag = true
	return builder
}

// 补卡发起时间，精确到秒的时间戳
//
// 示例值：1611476284
func (builder *UserTaskRemedyBuilder) CreateTime(createTime string) *UserTaskRemedyBuilder {
	builder.createTime = createTime
	builder.createTimeFlag = true
	return builder
}

// 补卡状态更新时间，精确到秒的时间戳
//
// 示例值：1611476284
func (builder *UserTaskRemedyBuilder) UpdateTime(updateTime string) *UserTaskRemedyBuilder {
	builder.updateTime = updateTime
	builder.updateTimeFlag = true
	return builder
}

func (builder *UserTaskRemedyBuilder) Build() *UserTaskRemedy {
	req := &UserTaskRemedy{}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.remedyDateFlag {
		req.RemedyDate = &builder.remedyDate

	}
	if builder.punchNoFlag {
		req.PunchNo = &builder.punchNo

	}
	if builder.workTypeFlag {
		req.WorkType = &builder.workType

	}
	if builder.approvalIdFlag {
		req.ApprovalId = &builder.approvalId

	}
	if builder.remedyTimeFlag {
		req.RemedyTime = &builder.remedyTime

	}
	if builder.statusFlag {
		req.Status = &builder.status

	}
	if builder.reasonFlag {
		req.Reason = &builder.reason

	}
	if builder.timeFlag {
		req.Time = &builder.time

	}
	if builder.timeZoneFlag {
		req.TimeZone = &builder.timeZone

	}
	if builder.createTimeFlag {
		req.CreateTime = &builder.createTime

	}
	if builder.updateTimeFlag {
		req.UpdateTime = &builder.updateTime

	}
	return req
}

type UserTmpDailyShift struct {
	GroupId *string `json:"group_id,omitempty"` // 考勤组 ID

	UserId *string `json:"user_id,omitempty"` // 用户 ID

	Date *int `json:"date,omitempty"` // 日期

	ShiftName *string `json:"shift_name,omitempty"` // 班次名称

	PunchTimeSimpleRules []*PunchTimeSimpleRule `json:"punch_time_simple_rules,omitempty"` // 打卡规则
}

type UserTmpDailyShiftBuilder struct {
	groupId     string // 考勤组 ID
	groupIdFlag bool

	userId     string // 用户 ID
	userIdFlag bool

	date     int // 日期
	dateFlag bool

	shiftName     string // 班次名称
	shiftNameFlag bool

	punchTimeSimpleRules     []*PunchTimeSimpleRule // 打卡规则
	punchTimeSimpleRulesFlag bool
}

func NewUserTmpDailyShiftBuilder() *UserTmpDailyShiftBuilder {
	builder := &UserTmpDailyShiftBuilder{}
	return builder
}

// 考勤组 ID
//
// 示例值：6737202939523236110
func (builder *UserTmpDailyShiftBuilder) GroupId(groupId string) *UserTmpDailyShiftBuilder {
	builder.groupId = groupId
	builder.groupIdFlag = true
	return builder
}

// 用户 ID
//
// 示例值：abd754f7
func (builder *UserTmpDailyShiftBuilder) UserId(userId string) *UserTmpDailyShiftBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 日期
//
// 示例值：20240120
func (builder *UserTmpDailyShiftBuilder) Date(date int) *UserTmpDailyShiftBuilder {
	builder.date = date
	builder.dateFlag = true
	return builder
}

// 班次名称
//
// 示例值：临时早班
func (builder *UserTmpDailyShiftBuilder) ShiftName(shiftName string) *UserTmpDailyShiftBuilder {
	builder.shiftName = shiftName
	builder.shiftNameFlag = true
	return builder
}

// 打卡规则
//
// 示例值：
func (builder *UserTmpDailyShiftBuilder) PunchTimeSimpleRules(punchTimeSimpleRules []*PunchTimeSimpleRule) *UserTmpDailyShiftBuilder {
	builder.punchTimeSimpleRules = punchTimeSimpleRules
	builder.punchTimeSimpleRulesFlag = true
	return builder
}

func (builder *UserTmpDailyShiftBuilder) Build() *UserTmpDailyShift {
	req := &UserTmpDailyShift{}
	if builder.groupIdFlag {
		req.GroupId = &builder.groupId

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.dateFlag {
		req.Date = &builder.date

	}
	if builder.shiftNameFlag {
		req.ShiftName = &builder.shiftName

	}
	if builder.punchTimeSimpleRulesFlag {
		req.PunchTimeSimpleRules = builder.punchTimeSimpleRules
	}
	return req
}

type UserTrip struct {
	ApprovalId *string `json:"approval_id,omitempty"` // 审批实例 ID

	StartTime *string `json:"start_time,omitempty"` // 开始时间，时间格式为 yyyy-MM-dd HH:mm:ss

	EndTime *string `json:"end_time,omitempty"` // 结束时间，时间格式为 yyyy-MM-dd HH:mm:ss

	Reason *string `json:"reason,omitempty"` // 出差理由

	ApprovePassTime *string `json:"approve_pass_time,omitempty"` // 审批通过时间，时间格式为 yyyy-MM-dd HH:mm:ss

	ApproveApplyTime *string `json:"approve_apply_time,omitempty"` // 审批申请时间，时间格式为 yyyy-MM-dd HH:mm:ss

	IdempotentId *string `json:"idempotent_id,omitempty"` // 唯一幂等键

	CorrectProcessId []string `json:"correct_process_id,omitempty"` // 更正流程实例 ID

	CancelProcessId []string `json:"cancel_process_id,omitempty"` // 撤销流程实例 ID

	ProcessId []string `json:"process_id,omitempty"` // 发起流程实例 ID

	Departure *RegionPlace `json:"departure,omitempty"` // 出发地（只有一个）

	Destinations []*RegionPlace `json:"destinations,omitempty"` // 目的地（可写多个）

	Transportation []int `json:"transportation,omitempty"` // 交通工具（1 飞机，2 火车，3 汽车，4 高铁/动车，5 船，6 其他）

	TripType *int `json:"trip_type,omitempty"` // 出差类型(1:单程 2:往返)

	Remarks *string `json:"remarks,omitempty"` // 出差备注
}

type UserTripBuilder struct {
	approvalId     string // 审批实例 ID
	approvalIdFlag bool

	startTime     string // 开始时间，时间格式为 yyyy-MM-dd HH:mm:ss
	startTimeFlag bool

	endTime     string // 结束时间，时间格式为 yyyy-MM-dd HH:mm:ss
	endTimeFlag bool

	reason     string // 出差理由
	reasonFlag bool

	approvePassTime     string // 审批通过时间，时间格式为 yyyy-MM-dd HH:mm:ss
	approvePassTimeFlag bool

	approveApplyTime     string // 审批申请时间，时间格式为 yyyy-MM-dd HH:mm:ss
	approveApplyTimeFlag bool

	idempotentId     string // 唯一幂等键
	idempotentIdFlag bool

	correctProcessId     []string // 更正流程实例 ID
	correctProcessIdFlag bool

	cancelProcessId     []string // 撤销流程实例 ID
	cancelProcessIdFlag bool

	processId     []string // 发起流程实例 ID
	processIdFlag bool

	departure     *RegionPlace // 出发地（只有一个）
	departureFlag bool

	destinations     []*RegionPlace // 目的地（可写多个）
	destinationsFlag bool

	transportation     []int // 交通工具（1 飞机，2 火车，3 汽车，4 高铁/动车，5 船，6 其他）
	transportationFlag bool

	tripType     int // 出差类型(1:单程 2:往返)
	tripTypeFlag bool

	remarks     string // 出差备注
	remarksFlag bool
}

func NewUserTripBuilder() *UserTripBuilder {
	builder := &UserTripBuilder{}
	return builder
}

// 审批实例 ID
//
// 示例值：6737202939523236113
func (builder *UserTripBuilder) ApprovalId(approvalId string) *UserTripBuilder {
	builder.approvalId = approvalId
	builder.approvalIdFlag = true
	return builder
}

// 开始时间，时间格式为 yyyy-MM-dd HH:mm:ss
//
// 示例值：2021-01-04 09:00:00
func (builder *UserTripBuilder) StartTime(startTime string) *UserTripBuilder {
	builder.startTime = startTime
	builder.startTimeFlag = true
	return builder
}

// 结束时间，时间格式为 yyyy-MM-dd HH:mm:ss
//
// 示例值：2021-01-04 19:00:00
func (builder *UserTripBuilder) EndTime(endTime string) *UserTripBuilder {
	builder.endTime = endTime
	builder.endTimeFlag = true
	return builder
}

// 出差理由
//
// 示例值：培训
func (builder *UserTripBuilder) Reason(reason string) *UserTripBuilder {
	builder.reason = reason
	builder.reasonFlag = true
	return builder
}

// 审批通过时间，时间格式为 yyyy-MM-dd HH:mm:ss
//
// 示例值：2021-01-04 12:00:00
func (builder *UserTripBuilder) ApprovePassTime(approvePassTime string) *UserTripBuilder {
	builder.approvePassTime = approvePassTime
	builder.approvePassTimeFlag = true
	return builder
}

// 审批申请时间，时间格式为 yyyy-MM-dd HH:mm:ss
//
// 示例值：2021-01-04 11:00:00
func (builder *UserTripBuilder) ApproveApplyTime(approveApplyTime string) *UserTripBuilder {
	builder.approveApplyTime = approveApplyTime
	builder.approveApplyTimeFlag = true
	return builder
}

// 唯一幂等键
//
// 示例值：1233432312
func (builder *UserTripBuilder) IdempotentId(idempotentId string) *UserTripBuilder {
	builder.idempotentId = idempotentId
	builder.idempotentIdFlag = true
	return builder
}

// 更正流程实例 ID
//
// 示例值：
func (builder *UserTripBuilder) CorrectProcessId(correctProcessId []string) *UserTripBuilder {
	builder.correctProcessId = correctProcessId
	builder.correctProcessIdFlag = true
	return builder
}

// 撤销流程实例 ID
//
// 示例值：
func (builder *UserTripBuilder) CancelProcessId(cancelProcessId []string) *UserTripBuilder {
	builder.cancelProcessId = cancelProcessId
	builder.cancelProcessIdFlag = true
	return builder
}

// 发起流程实例 ID
//
// 示例值：
func (builder *UserTripBuilder) ProcessId(processId []string) *UserTripBuilder {
	builder.processId = processId
	builder.processIdFlag = true
	return builder
}

// 出发地（只有一个）
//
// 示例值：
func (builder *UserTripBuilder) Departure(departure *RegionPlace) *UserTripBuilder {
	builder.departure = departure
	builder.departureFlag = true
	return builder
}

// 目的地（可写多个）
//
// 示例值：
func (builder *UserTripBuilder) Destinations(destinations []*RegionPlace) *UserTripBuilder {
	builder.destinations = destinations
	builder.destinationsFlag = true
	return builder
}

// 交通工具（1 飞机，2 火车，3 汽车，4 高铁/动车，5 船，6 其他）
//
// 示例值：
func (builder *UserTripBuilder) Transportation(transportation []int) *UserTripBuilder {
	builder.transportation = transportation
	builder.transportationFlag = true
	return builder
}

// 出差类型(1:单程 2:往返)
//
// 示例值：1
func (builder *UserTripBuilder) TripType(tripType int) *UserTripBuilder {
	builder.tripType = tripType
	builder.tripTypeFlag = true
	return builder
}

// 出差备注
//
// 示例值：出差备注
func (builder *UserTripBuilder) Remarks(remarks string) *UserTripBuilder {
	builder.remarks = remarks
	builder.remarksFlag = true
	return builder
}

func (builder *UserTripBuilder) Build() *UserTrip {
	req := &UserTrip{}
	if builder.approvalIdFlag {
		req.ApprovalId = &builder.approvalId

	}
	if builder.startTimeFlag {
		req.StartTime = &builder.startTime

	}
	if builder.endTimeFlag {
		req.EndTime = &builder.endTime

	}
	if builder.reasonFlag {
		req.Reason = &builder.reason

	}
	if builder.approvePassTimeFlag {
		req.ApprovePassTime = &builder.approvePassTime

	}
	if builder.approveApplyTimeFlag {
		req.ApproveApplyTime = &builder.approveApplyTime

	}
	if builder.idempotentIdFlag {
		req.IdempotentId = &builder.idempotentId

	}
	if builder.correctProcessIdFlag {
		req.CorrectProcessId = builder.correctProcessId
	}
	if builder.cancelProcessIdFlag {
		req.CancelProcessId = builder.cancelProcessId
	}
	if builder.processIdFlag {
		req.ProcessId = builder.processId
	}
	if builder.departureFlag {
		req.Departure = builder.departure
	}
	if builder.destinationsFlag {
		req.Destinations = builder.destinations
	}
	if builder.transportationFlag {
		req.Transportation = builder.transportation
	}
	if builder.tripTypeFlag {
		req.TripType = &builder.tripType

	}
	if builder.remarksFlag {
		req.Remarks = &builder.remarks

	}
	return req
}

type WifiInfo struct {
	Status *int `json:"status,omitempty"` //
}

type WifiInfoBuilder struct {
	status     int //
	statusFlag bool
}

func NewWifiInfoBuilder() *WifiInfoBuilder {
	builder := &WifiInfoBuilder{}
	return builder
}

//
//
// 示例值：
func (builder *WifiInfoBuilder) Status(status int) *WifiInfoBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

func (builder *WifiInfoBuilder) Build() *WifiInfo {
	req := &WifiInfo{}
	if builder.statusFlag {
		req.Status = &builder.status

	}
	return req
}

type WifiInfoEvent struct {
	Ssid *string `json:"ssid,omitempty"` //

	Bssid *string `json:"bssid,omitempty"` //

	Lastssid *string `json:"lastssid,omitempty"` //

	Lastbssid *string `json:"lastbssid,omitempty"` //
}

type WifiInfoEventBuilder struct {
	ssid     string //
	ssidFlag bool

	bssid     string //
	bssidFlag bool

	lastssid     string //
	lastssidFlag bool

	lastbssid     string //
	lastbssidFlag bool
}

func NewWifiInfoEventBuilder() *WifiInfoEventBuilder {
	builder := &WifiInfoEventBuilder{}
	return builder
}

//
//
// 示例值：
func (builder *WifiInfoEventBuilder) Ssid(ssid string) *WifiInfoEventBuilder {
	builder.ssid = ssid
	builder.ssidFlag = true
	return builder
}

//
//
// 示例值：
func (builder *WifiInfoEventBuilder) Bssid(bssid string) *WifiInfoEventBuilder {
	builder.bssid = bssid
	builder.bssidFlag = true
	return builder
}

//
//
// 示例值：
func (builder *WifiInfoEventBuilder) Lastssid(lastssid string) *WifiInfoEventBuilder {
	builder.lastssid = lastssid
	builder.lastssidFlag = true
	return builder
}

//
//
// 示例值：
func (builder *WifiInfoEventBuilder) Lastbssid(lastbssid string) *WifiInfoEventBuilder {
	builder.lastbssid = lastbssid
	builder.lastbssidFlag = true
	return builder
}

func (builder *WifiInfoEventBuilder) Build() *WifiInfoEvent {
	req := &WifiInfoEvent{}
	if builder.ssidFlag {
		req.Ssid = &builder.ssid

	}
	if builder.bssidFlag {
		req.Bssid = &builder.bssid

	}
	if builder.lastssidFlag {
		req.Lastssid = &builder.lastssid

	}
	if builder.lastbssidFlag {
		req.Lastbssid = &builder.lastbssid

	}
	return req
}

type WorkTime struct {
	WorkStartTime *string `json:"work_start_time,omitempty"` // 加班开始时间,时间格式为 yyyy-MM-dd HH:mm

	WorkEndTime *string `json:"work_end_time,omitempty"` // 加班结束时间,时间格式为 yyyy-MM-dd HH:mm

	SettlementType *string `json:"settlement_type,omitempty"` // 结算方式,overtime_pay:加班费;compensatory_leave:调休 假;records_only仅记录

	CheckFailReason *string `json:"check_fail_reason,omitempty"` // 请求校验错误原因

	OvertimeDate *string `json:"overtime_date,omitempty"` // 指定加班日期
}

type WorkTimeBuilder struct {
	workStartTime     string // 加班开始时间,时间格式为 yyyy-MM-dd HH:mm
	workStartTimeFlag bool

	workEndTime     string // 加班结束时间,时间格式为 yyyy-MM-dd HH:mm
	workEndTimeFlag bool

	settlementType     string // 结算方式,overtime_pay:加班费;compensatory_leave:调休 假;records_only仅记录
	settlementTypeFlag bool

	checkFailReason     string // 请求校验错误原因
	checkFailReasonFlag bool

	overtimeDate     string // 指定加班日期
	overtimeDateFlag bool
}

func NewWorkTimeBuilder() *WorkTimeBuilder {
	builder := &WorkTimeBuilder{}
	return builder
}

// 加班开始时间,时间格式为 yyyy-MM-dd HH:mm
//
// 示例值：2025-01-01 00:00
func (builder *WorkTimeBuilder) WorkStartTime(workStartTime string) *WorkTimeBuilder {
	builder.workStartTime = workStartTime
	builder.workStartTimeFlag = true
	return builder
}

// 加班结束时间,时间格式为 yyyy-MM-dd HH:mm
//
// 示例值：2025-01-01 00:00
func (builder *WorkTimeBuilder) WorkEndTime(workEndTime string) *WorkTimeBuilder {
	builder.workEndTime = workEndTime
	builder.workEndTimeFlag = true
	return builder
}

// 结算方式,overtime_pay:加班费;compensatory_leave:调休 假;records_only仅记录
//
// 示例值：overtime_pay
func (builder *WorkTimeBuilder) SettlementType(settlementType string) *WorkTimeBuilder {
	builder.settlementType = settlementType
	builder.settlementTypeFlag = true
	return builder
}

// 请求校验错误原因
//
// 示例值：校验没通过
func (builder *WorkTimeBuilder) CheckFailReason(checkFailReason string) *WorkTimeBuilder {
	builder.checkFailReason = checkFailReason
	builder.checkFailReasonFlag = true
	return builder
}

// 指定加班日期
//
// 示例值：2006-01-02
func (builder *WorkTimeBuilder) OvertimeDate(overtimeDate string) *WorkTimeBuilder {
	builder.overtimeDate = overtimeDate
	builder.overtimeDateFlag = true
	return builder
}

func (builder *WorkTimeBuilder) Build() *WorkTime {
	req := &WorkTime{}
	if builder.workStartTimeFlag {
		req.WorkStartTime = &builder.workStartTime

	}
	if builder.workEndTimeFlag {
		req.WorkEndTime = &builder.workEndTime

	}
	if builder.settlementTypeFlag {
		req.SettlementType = &builder.settlementType

	}
	if builder.checkFailReasonFlag {
		req.CheckFailReason = &builder.checkFailReason

	}
	if builder.overtimeDateFlag {
		req.OvertimeDate = &builder.overtimeDate

	}
	return req
}

type WorkTimeApplyData struct {
	CheckResult *int `json:"check_result,omitempty"` // 检查结果,0表示检查通过,-1为不通过

	CheckMessage *string `json:"check_message,omitempty"` // 检查结果描述

	ApprovalRecordId *string `json:"approval_record_id,omitempty"` // 流程 id

	CheckDetails []*WorkTime `json:"check_details,omitempty"` // 校验结果详情列表

	TimeZone *string `json:"time_zone,omitempty"` // 时区

	Reason *string `json:"reason,omitempty"` // 加班原因
}

type WorkTimeApplyDataBuilder struct {
	checkResult     int // 检查结果,0表示检查通过,-1为不通过
	checkResultFlag bool

	checkMessage     string // 检查结果描述
	checkMessageFlag bool

	approvalRecordId     string // 流程 id
	approvalRecordIdFlag bool

	checkDetails     []*WorkTime // 校验结果详情列表
	checkDetailsFlag bool

	timeZone     string // 时区
	timeZoneFlag bool

	reason     string // 加班原因
	reasonFlag bool
}

func NewWorkTimeApplyDataBuilder() *WorkTimeApplyDataBuilder {
	builder := &WorkTimeApplyDataBuilder{}
	return builder
}

// 检查结果,0表示检查通过,-1为不通过
//
// 示例值：0
func (builder *WorkTimeApplyDataBuilder) CheckResult(checkResult int) *WorkTimeApplyDataBuilder {
	builder.checkResult = checkResult
	builder.checkResultFlag = true
	return builder
}

// 检查结果描述
//
// 示例值：检查结果藐视
func (builder *WorkTimeApplyDataBuilder) CheckMessage(checkMessage string) *WorkTimeApplyDataBuilder {
	builder.checkMessage = checkMessage
	builder.checkMessageFlag = true
	return builder
}

// 流程 id
//
// 示例值：0
func (builder *WorkTimeApplyDataBuilder) ApprovalRecordId(approvalRecordId string) *WorkTimeApplyDataBuilder {
	builder.approvalRecordId = approvalRecordId
	builder.approvalRecordIdFlag = true
	return builder
}

// 校验结果详情列表
//
// 示例值：
func (builder *WorkTimeApplyDataBuilder) CheckDetails(checkDetails []*WorkTime) *WorkTimeApplyDataBuilder {
	builder.checkDetails = checkDetails
	builder.checkDetailsFlag = true
	return builder
}

// 时区
//
// 示例值：Asia/Shanghai
func (builder *WorkTimeApplyDataBuilder) TimeZone(timeZone string) *WorkTimeApplyDataBuilder {
	builder.timeZone = timeZone
	builder.timeZoneFlag = true
	return builder
}

// 加班原因
//
// 示例值：加班原因
func (builder *WorkTimeApplyDataBuilder) Reason(reason string) *WorkTimeApplyDataBuilder {
	builder.reason = reason
	builder.reasonFlag = true
	return builder
}

func (builder *WorkTimeApplyDataBuilder) Build() *WorkTimeApplyData {
	req := &WorkTimeApplyData{}
	if builder.checkResultFlag {
		req.CheckResult = &builder.checkResult

	}
	if builder.checkMessageFlag {
		req.CheckMessage = &builder.checkMessage

	}
	if builder.approvalRecordIdFlag {
		req.ApprovalRecordId = &builder.approvalRecordId

	}
	if builder.checkDetailsFlag {
		req.CheckDetails = builder.checkDetails
	}
	if builder.timeZoneFlag {
		req.TimeZone = &builder.timeZone

	}
	if builder.reasonFlag {
		req.Reason = &builder.reason

	}
	return req
}

type ProcessApprovalInfoReqBodyBuilder struct {
	approvalId     string // 审批实例 ID，获取方式：1）[获取审批通过数据](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_approval/query) 2）[写入审批结果](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_approval/create) 3）[通知补卡审批发起（补卡情况下）](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_task_remedy/create)
	approvalIdFlag bool

	approvalType     string // 审批类型，leave：请假，out：外出，overtime：加班，trip：出差，remedy：补卡
	approvalTypeFlag bool

	status     int // 审批状态，1：不通过，2：通过，4：撤销
	statusFlag bool
}

func NewProcessApprovalInfoReqBodyBuilder() *ProcessApprovalInfoReqBodyBuilder {
	builder := &ProcessApprovalInfoReqBodyBuilder{}
	return builder
}

// 审批实例 ID，获取方式：1）[获取审批通过数据](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_approval/query) 2）[写入审批结果](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_approval/create) 3）[通知补卡审批发起（补卡情况下）](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_task_remedy/create)
//
//示例值：6737202939523236113
func (builder *ProcessApprovalInfoReqBodyBuilder) ApprovalId(approvalId string) *ProcessApprovalInfoReqBodyBuilder {
	builder.approvalId = approvalId
	builder.approvalIdFlag = true
	return builder
}

// 审批类型，leave：请假，out：外出，overtime：加班，trip：出差，remedy：补卡
//
//示例值：remedy
func (builder *ProcessApprovalInfoReqBodyBuilder) ApprovalType(approvalType string) *ProcessApprovalInfoReqBodyBuilder {
	builder.approvalType = approvalType
	builder.approvalTypeFlag = true
	return builder
}

// 审批状态，1：不通过，2：通过，4：撤销
//
//示例值：4
func (builder *ProcessApprovalInfoReqBodyBuilder) Status(status int) *ProcessApprovalInfoReqBodyBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

func (builder *ProcessApprovalInfoReqBodyBuilder) Build() *ProcessApprovalInfoReqBody {
	req := &ProcessApprovalInfoReqBody{}
	if builder.approvalIdFlag {
		req.ApprovalId = &builder.approvalId
	}
	if builder.approvalTypeFlag {
		req.ApprovalType = &builder.approvalType
	}
	if builder.statusFlag {
		req.Status = &builder.status
	}
	return req
}

type ProcessApprovalInfoPathReqBodyBuilder struct {
	approvalId       string
	approvalIdFlag   bool
	approvalType     string
	approvalTypeFlag bool
	status           int
	statusFlag       bool
}

func NewProcessApprovalInfoPathReqBodyBuilder() *ProcessApprovalInfoPathReqBodyBuilder {
	builder := &ProcessApprovalInfoPathReqBodyBuilder{}
	return builder
}

// 审批实例 ID，获取方式：1）[获取审批通过数据](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_approval/query) 2）[写入审批结果](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_approval/create) 3）[通知补卡审批发起（补卡情况下）](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_task_remedy/create)
//
// 示例值：6737202939523236113
func (builder *ProcessApprovalInfoPathReqBodyBuilder) ApprovalId(approvalId string) *ProcessApprovalInfoPathReqBodyBuilder {
	builder.approvalId = approvalId
	builder.approvalIdFlag = true
	return builder
}

// 审批类型，leave：请假，out：外出，overtime：加班，trip：出差，remedy：补卡
//
// 示例值：remedy
func (builder *ProcessApprovalInfoPathReqBodyBuilder) ApprovalType(approvalType string) *ProcessApprovalInfoPathReqBodyBuilder {
	builder.approvalType = approvalType
	builder.approvalTypeFlag = true
	return builder
}

// 审批状态，1：不通过，2：通过，4：撤销
//
// 示例值：4
func (builder *ProcessApprovalInfoPathReqBodyBuilder) Status(status int) *ProcessApprovalInfoPathReqBodyBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

func (builder *ProcessApprovalInfoPathReqBodyBuilder) Build() (*ProcessApprovalInfoReqBody, error) {
	req := &ProcessApprovalInfoReqBody{}
	if builder.approvalIdFlag {
		req.ApprovalId = &builder.approvalId
	}
	if builder.approvalTypeFlag {
		req.ApprovalType = &builder.approvalType
	}
	if builder.statusFlag {
		req.Status = &builder.status
	}
	return req, nil
}

type ProcessApprovalInfoReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *ProcessApprovalInfoReqBody
}

func NewProcessApprovalInfoReqBuilder() *ProcessApprovalInfoReqBuilder {
	builder := &ProcessApprovalInfoReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 对于只使用飞书考勤系统而未使用飞书审批系统的企业，可以通过该接口更新写入飞书考勤系统中的三方系统审批状态，例如请假、加班、外出、出差、补卡等审批，状态包括通过、不通过、撤销等。
func (builder *ProcessApprovalInfoReqBuilder) Body(body *ProcessApprovalInfoReqBody) *ProcessApprovalInfoReqBuilder {
	builder.body = body
	return builder
}

func (builder *ProcessApprovalInfoReqBuilder) Build() *ProcessApprovalInfoReq {
	req := &ProcessApprovalInfoReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.Body = builder.body
	return req
}

type ProcessApprovalInfoReqBody struct {
	ApprovalId *string `json:"approval_id,omitempty"` // 审批实例 ID，获取方式：1）[获取审批通过数据](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_approval/query) 2）[写入审批结果](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_approval/create) 3）[通知补卡审批发起（补卡情况下）](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_task_remedy/create)

	ApprovalType *string `json:"approval_type,omitempty"` // 审批类型，leave：请假，out：外出，overtime：加班，trip：出差，remedy：补卡

	Status *int `json:"status,omitempty"` // 审批状态，1：不通过，2：通过，4：撤销
}

type ProcessApprovalInfoReq struct {
	apiReq *larkcore.ApiReq
	Body   *ProcessApprovalInfoReqBody `body:""`
}

type ProcessApprovalInfoRespData struct {
	ApprovalInfo *ApprovalInfo `json:"approval_info,omitempty"` // 审批信息
}

type ProcessApprovalInfoResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *ProcessApprovalInfoRespData `json:"data"` // 业务数据
}

func (resp *ProcessApprovalInfoResp) Success() bool {
	return resp.Code == 0
}

type DelReportArchiveRuleReqBodyBuilder struct {
	month     string // 月份
	monthFlag bool

	operatorId     string // 操作者ID
	operatorIdFlag bool

	archiveRuleId     string // 归档规则id
	archiveRuleIdFlag bool

	userIds     []string // 用户id
	userIdsFlag bool
}

func NewDelReportArchiveRuleReqBodyBuilder() *DelReportArchiveRuleReqBodyBuilder {
	builder := &DelReportArchiveRuleReqBodyBuilder{}
	return builder
}

// 月份
//
//示例值：202409
func (builder *DelReportArchiveRuleReqBodyBuilder) Month(month string) *DelReportArchiveRuleReqBodyBuilder {
	builder.month = month
	builder.monthFlag = true
	return builder
}

// 操作者ID
//
//示例值：a111xd
func (builder *DelReportArchiveRuleReqBodyBuilder) OperatorId(operatorId string) *DelReportArchiveRuleReqBodyBuilder {
	builder.operatorId = operatorId
	builder.operatorIdFlag = true
	return builder
}

// 归档规则id
//
//示例值：1
func (builder *DelReportArchiveRuleReqBodyBuilder) ArchiveRuleId(archiveRuleId string) *DelReportArchiveRuleReqBodyBuilder {
	builder.archiveRuleId = archiveRuleId
	builder.archiveRuleIdFlag = true
	return builder
}

// 用户id
//
//示例值：
func (builder *DelReportArchiveRuleReqBodyBuilder) UserIds(userIds []string) *DelReportArchiveRuleReqBodyBuilder {
	builder.userIds = userIds
	builder.userIdsFlag = true
	return builder
}

func (builder *DelReportArchiveRuleReqBodyBuilder) Build() *DelReportArchiveRuleReqBody {
	req := &DelReportArchiveRuleReqBody{}
	if builder.monthFlag {
		req.Month = &builder.month
	}
	if builder.operatorIdFlag {
		req.OperatorId = &builder.operatorId
	}
	if builder.archiveRuleIdFlag {
		req.ArchiveRuleId = &builder.archiveRuleId
	}
	if builder.userIdsFlag {
		req.UserIds = builder.userIds
	}
	return req
}

type DelReportArchiveRulePathReqBodyBuilder struct {
	month             string
	monthFlag         bool
	operatorId        string
	operatorIdFlag    bool
	archiveRuleId     string
	archiveRuleIdFlag bool
	userIds           []string
	userIdsFlag       bool
}

func NewDelReportArchiveRulePathReqBodyBuilder() *DelReportArchiveRulePathReqBodyBuilder {
	builder := &DelReportArchiveRulePathReqBodyBuilder{}
	return builder
}

// 月份
//
// 示例值：202409
func (builder *DelReportArchiveRulePathReqBodyBuilder) Month(month string) *DelReportArchiveRulePathReqBodyBuilder {
	builder.month = month
	builder.monthFlag = true
	return builder
}

// 操作者ID
//
// 示例值：a111xd
func (builder *DelReportArchiveRulePathReqBodyBuilder) OperatorId(operatorId string) *DelReportArchiveRulePathReqBodyBuilder {
	builder.operatorId = operatorId
	builder.operatorIdFlag = true
	return builder
}

// 归档规则id
//
// 示例值：1
func (builder *DelReportArchiveRulePathReqBodyBuilder) ArchiveRuleId(archiveRuleId string) *DelReportArchiveRulePathReqBodyBuilder {
	builder.archiveRuleId = archiveRuleId
	builder.archiveRuleIdFlag = true
	return builder
}

// 用户id
//
// 示例值：
func (builder *DelReportArchiveRulePathReqBodyBuilder) UserIds(userIds []string) *DelReportArchiveRulePathReqBodyBuilder {
	builder.userIds = userIds
	builder.userIdsFlag = true
	return builder
}

func (builder *DelReportArchiveRulePathReqBodyBuilder) Build() (*DelReportArchiveRuleReqBody, error) {
	req := &DelReportArchiveRuleReqBody{}
	if builder.monthFlag {
		req.Month = &builder.month
	}
	if builder.operatorIdFlag {
		req.OperatorId = &builder.operatorId
	}
	if builder.archiveRuleIdFlag {
		req.ArchiveRuleId = &builder.archiveRuleId
	}
	if builder.userIdsFlag {
		req.UserIds = builder.userIds
	}
	return req, nil
}

type DelReportArchiveRuleReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *DelReportArchiveRuleReqBody
}

func NewDelReportArchiveRuleReqBuilder() *DelReportArchiveRuleReqBuilder {
	builder := &DelReportArchiveRuleReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 员工工号类型
//
// 示例值：employee_id
func (builder *DelReportArchiveRuleReqBuilder) EmployeeType(employeeType string) *DelReportArchiveRuleReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

//
func (builder *DelReportArchiveRuleReqBuilder) Body(body *DelReportArchiveRuleReqBody) *DelReportArchiveRuleReqBuilder {
	builder.body = body
	return builder
}

func (builder *DelReportArchiveRuleReqBuilder) Build() *DelReportArchiveRuleReq {
	req := &DelReportArchiveRuleReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type DelReportArchiveRuleReqBody struct {
	Month *string `json:"month,omitempty"` // 月份

	OperatorId *string `json:"operator_id,omitempty"` // 操作者ID

	ArchiveRuleId *string `json:"archive_rule_id,omitempty"` // 归档规则id

	UserIds []string `json:"user_ids,omitempty"` // 用户id
}

type DelReportArchiveRuleReq struct {
	apiReq *larkcore.ApiReq
	Body   *DelReportArchiveRuleReqBody `body:""`
}

type DelReportArchiveRuleResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *DelReportArchiveRuleResp) Success() bool {
	return resp.Code == 0
}

type ListArchiveRuleReqBuilder struct {
	apiReq *larkcore.ApiReq
	limit  int // 最大返回多少记录，当使用迭代器访问时才有效
}

func NewListArchiveRuleReqBuilder() *ListArchiveRuleReqBuilder {
	builder := &ListArchiveRuleReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 最大返回多少记录，当使用迭代器访问时才有效
func (builder *ListArchiveRuleReqBuilder) Limit(limit int) *ListArchiveRuleReqBuilder {
	builder.limit = limit
	return builder
}

// 分页大小
//
// 示例值：10
func (builder *ListArchiveRuleReqBuilder) PageSize(pageSize int) *ListArchiveRuleReqBuilder {
	builder.apiReq.QueryParams.Set("page_size", fmt.Sprint(pageSize))
	return builder
}

// 分页标记，第一次请求不填，表示从头开始遍历；分页查询结果还有更多项时会同时返回新的 page_token，下次遍历可采用该 page_token 获取查询结果
//
// 示例值：xxx
func (builder *ListArchiveRuleReqBuilder) PageToken(pageToken string) *ListArchiveRuleReqBuilder {
	builder.apiReq.QueryParams.Set("page_token", fmt.Sprint(pageToken))
	return builder
}

func (builder *ListArchiveRuleReqBuilder) Build() *ListArchiveRuleReq {
	req := &ListArchiveRuleReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.Limit = builder.limit
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type ListArchiveRuleReq struct {
	apiReq *larkcore.ApiReq
	Limit  int // 最多返回多少记录，只有在使用迭代器访问时，才有效

}

type ListArchiveRuleRespData struct {
	Items []*ArchiveReportMeta `json:"items,omitempty"` // 分页查询结果项

	PageToken *string `json:"page_token,omitempty"` // 分页查询结果还有更多项时会同时返回新的 page_token，下次遍历可采用该 page_token 获取查询结果

	HasMore *bool `json:"has_more,omitempty"` // 是否有更多项
}

type ListArchiveRuleResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *ListArchiveRuleRespData `json:"data"` // 业务数据
}

func (resp *ListArchiveRuleResp) Success() bool {
	return resp.Code == 0
}

type UploadReportArchiveRuleReqBodyBuilder struct {
	month     string // 月份
	monthFlag bool

	operatorId     string // 操作者ID
	operatorIdFlag bool

	archiveReportDatas     []*ArchiveReportData // 归档报表内容(不超过50个)
	archiveReportDatasFlag bool

	archiveRuleId     string // 归档规则id
	archiveRuleIdFlag bool
}

func NewUploadReportArchiveRuleReqBodyBuilder() *UploadReportArchiveRuleReqBodyBuilder {
	builder := &UploadReportArchiveRuleReqBodyBuilder{}
	return builder
}

// 月份
//
//示例值：202409
func (builder *UploadReportArchiveRuleReqBodyBuilder) Month(month string) *UploadReportArchiveRuleReqBodyBuilder {
	builder.month = month
	builder.monthFlag = true
	return builder
}

// 操作者ID
//
//示例值：ax11d
func (builder *UploadReportArchiveRuleReqBodyBuilder) OperatorId(operatorId string) *UploadReportArchiveRuleReqBodyBuilder {
	builder.operatorId = operatorId
	builder.operatorIdFlag = true
	return builder
}

// 归档报表内容(不超过50个)
//
//示例值：
func (builder *UploadReportArchiveRuleReqBodyBuilder) ArchiveReportDatas(archiveReportDatas []*ArchiveReportData) *UploadReportArchiveRuleReqBodyBuilder {
	builder.archiveReportDatas = archiveReportDatas
	builder.archiveReportDatasFlag = true
	return builder
}

// 归档规则id
//
//示例值：1
func (builder *UploadReportArchiveRuleReqBodyBuilder) ArchiveRuleId(archiveRuleId string) *UploadReportArchiveRuleReqBodyBuilder {
	builder.archiveRuleId = archiveRuleId
	builder.archiveRuleIdFlag = true
	return builder
}

func (builder *UploadReportArchiveRuleReqBodyBuilder) Build() *UploadReportArchiveRuleReqBody {
	req := &UploadReportArchiveRuleReqBody{}
	if builder.monthFlag {
		req.Month = &builder.month
	}
	if builder.operatorIdFlag {
		req.OperatorId = &builder.operatorId
	}
	if builder.archiveReportDatasFlag {
		req.ArchiveReportDatas = builder.archiveReportDatas
	}
	if builder.archiveRuleIdFlag {
		req.ArchiveRuleId = &builder.archiveRuleId
	}
	return req
}

type UploadReportArchiveRulePathReqBodyBuilder struct {
	month                  string
	monthFlag              bool
	operatorId             string
	operatorIdFlag         bool
	archiveReportDatas     []*ArchiveReportData
	archiveReportDatasFlag bool
	archiveRuleId          string
	archiveRuleIdFlag      bool
}

func NewUploadReportArchiveRulePathReqBodyBuilder() *UploadReportArchiveRulePathReqBodyBuilder {
	builder := &UploadReportArchiveRulePathReqBodyBuilder{}
	return builder
}

// 月份
//
// 示例值：202409
func (builder *UploadReportArchiveRulePathReqBodyBuilder) Month(month string) *UploadReportArchiveRulePathReqBodyBuilder {
	builder.month = month
	builder.monthFlag = true
	return builder
}

// 操作者ID
//
// 示例值：ax11d
func (builder *UploadReportArchiveRulePathReqBodyBuilder) OperatorId(operatorId string) *UploadReportArchiveRulePathReqBodyBuilder {
	builder.operatorId = operatorId
	builder.operatorIdFlag = true
	return builder
}

// 归档报表内容(不超过50个)
//
// 示例值：
func (builder *UploadReportArchiveRulePathReqBodyBuilder) ArchiveReportDatas(archiveReportDatas []*ArchiveReportData) *UploadReportArchiveRulePathReqBodyBuilder {
	builder.archiveReportDatas = archiveReportDatas
	builder.archiveReportDatasFlag = true
	return builder
}

// 归档规则id
//
// 示例值：1
func (builder *UploadReportArchiveRulePathReqBodyBuilder) ArchiveRuleId(archiveRuleId string) *UploadReportArchiveRulePathReqBodyBuilder {
	builder.archiveRuleId = archiveRuleId
	builder.archiveRuleIdFlag = true
	return builder
}

func (builder *UploadReportArchiveRulePathReqBodyBuilder) Build() (*UploadReportArchiveRuleReqBody, error) {
	req := &UploadReportArchiveRuleReqBody{}
	if builder.monthFlag {
		req.Month = &builder.month
	}
	if builder.operatorIdFlag {
		req.OperatorId = &builder.operatorId
	}
	if builder.archiveReportDatasFlag {
		req.ArchiveReportDatas = builder.archiveReportDatas
	}
	if builder.archiveRuleIdFlag {
		req.ArchiveRuleId = &builder.archiveRuleId
	}
	return req, nil
}

type UploadReportArchiveRuleReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *UploadReportArchiveRuleReqBody
}

func NewUploadReportArchiveRuleReqBuilder() *UploadReportArchiveRuleReqBuilder {
	builder := &UploadReportArchiveRuleReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 用户 ID 的类型
//
// 示例值：employee_id
func (builder *UploadReportArchiveRuleReqBuilder) EmployeeType(employeeType string) *UploadReportArchiveRuleReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

//
func (builder *UploadReportArchiveRuleReqBuilder) Body(body *UploadReportArchiveRuleReqBody) *UploadReportArchiveRuleReqBuilder {
	builder.body = body
	return builder
}

func (builder *UploadReportArchiveRuleReqBuilder) Build() *UploadReportArchiveRuleReq {
	req := &UploadReportArchiveRuleReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type UploadReportArchiveRuleReqBody struct {
	Month *string `json:"month,omitempty"` // 月份

	OperatorId *string `json:"operator_id,omitempty"` // 操作者ID

	ArchiveReportDatas []*ArchiveReportData `json:"archive_report_datas,omitempty"` // 归档报表内容(不超过50个)

	ArchiveRuleId *string `json:"archive_rule_id,omitempty"` // 归档规则id
}

type UploadReportArchiveRuleReq struct {
	apiReq *larkcore.ApiReq
	Body   *UploadReportArchiveRuleReqBody `body:""`
}

type UploadReportArchiveRuleRespData struct {
	InvalidCode []string `json:"invalid_code,omitempty"` // 无效的code

	InvalidMemberId []string `json:"invalid_member_id,omitempty"` // 无效的member_id
}

type UploadReportArchiveRuleResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *UploadReportArchiveRuleRespData `json:"data"` // 业务数据
}

func (resp *UploadReportArchiveRuleResp) Success() bool {
	return resp.Code == 0
}

type UserStatsFieldsQueryArchiveRuleReqBodyBuilder struct {
	locale     string // 语言类型
	localeFlag bool

	month     string // 月份
	monthFlag bool

	archiveRuleId     string // 归档规则id
	archiveRuleIdFlag bool

	operatorId     string // 操作者id
	operatorIdFlag bool
}

func NewUserStatsFieldsQueryArchiveRuleReqBodyBuilder() *UserStatsFieldsQueryArchiveRuleReqBodyBuilder {
	builder := &UserStatsFieldsQueryArchiveRuleReqBodyBuilder{}
	return builder
}

// 语言类型
//
//示例值：zh
func (builder *UserStatsFieldsQueryArchiveRuleReqBodyBuilder) Locale(locale string) *UserStatsFieldsQueryArchiveRuleReqBodyBuilder {
	builder.locale = locale
	builder.localeFlag = true
	return builder
}

// 月份
//
//示例值：202409
func (builder *UserStatsFieldsQueryArchiveRuleReqBodyBuilder) Month(month string) *UserStatsFieldsQueryArchiveRuleReqBodyBuilder {
	builder.month = month
	builder.monthFlag = true
	return builder
}

// 归档规则id
//
//示例值：1
func (builder *UserStatsFieldsQueryArchiveRuleReqBodyBuilder) ArchiveRuleId(archiveRuleId string) *UserStatsFieldsQueryArchiveRuleReqBodyBuilder {
	builder.archiveRuleId = archiveRuleId
	builder.archiveRuleIdFlag = true
	return builder
}

// 操作者id
//
//示例值：ax8ud
func (builder *UserStatsFieldsQueryArchiveRuleReqBodyBuilder) OperatorId(operatorId string) *UserStatsFieldsQueryArchiveRuleReqBodyBuilder {
	builder.operatorId = operatorId
	builder.operatorIdFlag = true
	return builder
}

func (builder *UserStatsFieldsQueryArchiveRuleReqBodyBuilder) Build() *UserStatsFieldsQueryArchiveRuleReqBody {
	req := &UserStatsFieldsQueryArchiveRuleReqBody{}
	if builder.localeFlag {
		req.Locale = &builder.locale
	}
	if builder.monthFlag {
		req.Month = &builder.month
	}
	if builder.archiveRuleIdFlag {
		req.ArchiveRuleId = &builder.archiveRuleId
	}
	if builder.operatorIdFlag {
		req.OperatorId = &builder.operatorId
	}
	return req
}

type UserStatsFieldsQueryArchiveRulePathReqBodyBuilder struct {
	locale            string
	localeFlag        bool
	month             string
	monthFlag         bool
	archiveRuleId     string
	archiveRuleIdFlag bool
	operatorId        string
	operatorIdFlag    bool
}

func NewUserStatsFieldsQueryArchiveRulePathReqBodyBuilder() *UserStatsFieldsQueryArchiveRulePathReqBodyBuilder {
	builder := &UserStatsFieldsQueryArchiveRulePathReqBodyBuilder{}
	return builder
}

// 语言类型
//
// 示例值：zh
func (builder *UserStatsFieldsQueryArchiveRulePathReqBodyBuilder) Locale(locale string) *UserStatsFieldsQueryArchiveRulePathReqBodyBuilder {
	builder.locale = locale
	builder.localeFlag = true
	return builder
}

// 月份
//
// 示例值：202409
func (builder *UserStatsFieldsQueryArchiveRulePathReqBodyBuilder) Month(month string) *UserStatsFieldsQueryArchiveRulePathReqBodyBuilder {
	builder.month = month
	builder.monthFlag = true
	return builder
}

// 归档规则id
//
// 示例值：1
func (builder *UserStatsFieldsQueryArchiveRulePathReqBodyBuilder) ArchiveRuleId(archiveRuleId string) *UserStatsFieldsQueryArchiveRulePathReqBodyBuilder {
	builder.archiveRuleId = archiveRuleId
	builder.archiveRuleIdFlag = true
	return builder
}

// 操作者id
//
// 示例值：ax8ud
func (builder *UserStatsFieldsQueryArchiveRulePathReqBodyBuilder) OperatorId(operatorId string) *UserStatsFieldsQueryArchiveRulePathReqBodyBuilder {
	builder.operatorId = operatorId
	builder.operatorIdFlag = true
	return builder
}

func (builder *UserStatsFieldsQueryArchiveRulePathReqBodyBuilder) Build() (*UserStatsFieldsQueryArchiveRuleReqBody, error) {
	req := &UserStatsFieldsQueryArchiveRuleReqBody{}
	if builder.localeFlag {
		req.Locale = &builder.locale
	}
	if builder.monthFlag {
		req.Month = &builder.month
	}
	if builder.archiveRuleIdFlag {
		req.ArchiveRuleId = &builder.archiveRuleId
	}
	if builder.operatorIdFlag {
		req.OperatorId = &builder.operatorId
	}
	return req, nil
}

type UserStatsFieldsQueryArchiveRuleReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *UserStatsFieldsQueryArchiveRuleReqBody
}

func NewUserStatsFieldsQueryArchiveRuleReqBuilder() *UserStatsFieldsQueryArchiveRuleReqBuilder {
	builder := &UserStatsFieldsQueryArchiveRuleReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 用户 ID 的类型
//
// 示例值：employee_id
func (builder *UserStatsFieldsQueryArchiveRuleReqBuilder) EmployeeType(employeeType string) *UserStatsFieldsQueryArchiveRuleReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

//
func (builder *UserStatsFieldsQueryArchiveRuleReqBuilder) Body(body *UserStatsFieldsQueryArchiveRuleReqBody) *UserStatsFieldsQueryArchiveRuleReqBuilder {
	builder.body = body
	return builder
}

func (builder *UserStatsFieldsQueryArchiveRuleReqBuilder) Build() *UserStatsFieldsQueryArchiveRuleReq {
	req := &UserStatsFieldsQueryArchiveRuleReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type UserStatsFieldsQueryArchiveRuleReqBody struct {
	Locale *string `json:"locale,omitempty"` // 语言类型

	Month *string `json:"month,omitempty"` // 月份

	ArchiveRuleId *string `json:"archive_rule_id,omitempty"` // 归档规则id

	OperatorId *string `json:"operator_id,omitempty"` // 操作者id
}

type UserStatsFieldsQueryArchiveRuleReq struct {
	apiReq *larkcore.ApiReq
	Body   *UserStatsFieldsQueryArchiveRuleReqBody `body:""`
}

type UserStatsFieldsQueryArchiveRuleRespData struct {
	ArchiveReportFields []*ArchiveField `json:"archive_report_fields,omitempty"` // 统计数据表头
}

type UserStatsFieldsQueryArchiveRuleResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *UserStatsFieldsQueryArchiveRuleRespData `json:"data"` // 业务数据
}

func (resp *UserStatsFieldsQueryArchiveRuleResp) Success() bool {
	return resp.Code == 0
}

type DownloadFileReqBuilder struct {
	apiReq *larkcore.ApiReq
}

func NewDownloadFileReqBuilder() *DownloadFileReqBuilder {
	builder := &DownloadFileReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 文件 ID
//
// 示例值：xxxxxb306842b1c189bc5212eefxxxxx
func (builder *DownloadFileReqBuilder) FileId(fileId string) *DownloadFileReqBuilder {
	builder.apiReq.PathParams.Set("file_id", fmt.Sprint(fileId))
	return builder
}

func (builder *DownloadFileReqBuilder) Build() *DownloadFileReq {
	req := &DownloadFileReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	return req
}

type DownloadFileReq struct {
	apiReq *larkcore.ApiReq
}

type DownloadFileResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	File     io.Reader `json:"-"`
	FileName string    `json:"-"`
}

func (resp *DownloadFileResp) Success() bool {
	return resp.Code == 0
}

func (resp *DownloadFileResp) WriteFile(fileName string) error {
	bs, err := ioutil.ReadAll(resp.File)
	if err != nil {
		return err
	}

	err = ioutil.WriteFile(fileName, bs, 0666)
	if err != nil {
		return err
	}
	return nil
}

type UploadFileReqBodyBuilder struct {
	file     io.Reader // 文件内容
	fileFlag bool
}

func NewUploadFileReqBodyBuilder() *UploadFileReqBodyBuilder {
	builder := &UploadFileReqBodyBuilder{}
	return builder
}

// 文件内容
//
//示例值：二进制文件
func (builder *UploadFileReqBodyBuilder) File(file io.Reader) *UploadFileReqBodyBuilder {
	builder.file = file
	builder.fileFlag = true
	return builder
}

func (builder *UploadFileReqBodyBuilder) Build() *UploadFileReqBody {
	req := &UploadFileReqBody{}
	if builder.fileFlag {
		req.File = builder.file
	}
	return req
}

type UploadFilePathReqBodyBuilder struct {
	filePath     string // 文件内容
	filePathFlag bool
}

func NewUploadFilePathReqBodyBuilder() *UploadFilePathReqBodyBuilder {
	builder := &UploadFilePathReqBodyBuilder{}
	return builder
}

// 文件内容
//
// 示例值：二进制文件
func (builder *UploadFilePathReqBodyBuilder) FilePath(filePath string) *UploadFilePathReqBodyBuilder {
	builder.filePath = filePath
	builder.filePathFlag = true
	return builder
}

func (builder *UploadFilePathReqBodyBuilder) Build() (*UploadFileReqBody, error) {
	req := &UploadFileReqBody{}
	if builder.filePathFlag {
		data, err := larkcore.File2Bytes(builder.filePath)
		if err != nil {
			return nil, err
		}
		req.File = bytes.NewBuffer(data)
	}
	return req, nil
}

type UploadFileReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *UploadFileReqBody
}

func NewUploadFileReqBuilder() *UploadFileReqBuilder {
	builder := &UploadFileReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 带后缀的文件名
//
// 示例值：人脸照片.jpg
func (builder *UploadFileReqBuilder) FileName(fileName string) *UploadFileReqBuilder {
	builder.apiReq.QueryParams.Set("file_name", fmt.Sprint(fileName))
	return builder
}

// 上传文件并获取文件 ID，可用于“修改用户设置”接口中的 face_key 参数。
func (builder *UploadFileReqBuilder) Body(body *UploadFileReqBody) *UploadFileReqBuilder {
	builder.body = body
	return builder
}

func (builder *UploadFileReqBuilder) Build() *UploadFileReq {
	req := &UploadFileReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type UploadFileReqBody struct {
	File io.Reader `json:"file,omitempty"` // 文件内容
}

type UploadFileReq struct {
	apiReq *larkcore.ApiReq
	Body   *UploadFileReqBody `body:""`
}

type UploadFileRespData struct {
	File *File `json:"file,omitempty"` // 文件
}

type UploadFileResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *UploadFileRespData `json:"data"` // 业务数据
}

func (resp *UploadFileResp) Success() bool {
	return resp.Code == 0
}

type CreateGroupReqBodyBuilder struct {
	group     *Group // 6921319402260496386
	groupFlag bool

	operatorId     string // 操作人uid，如果您未操作[考勤管理后台“API 接入”流程](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/attendance-development-guidelines)，则此字段为必填字段
	operatorIdFlag bool
}

func NewCreateGroupReqBodyBuilder() *CreateGroupReqBodyBuilder {
	builder := &CreateGroupReqBodyBuilder{}
	return builder
}

// 6921319402260496386
//
//示例值：
func (builder *CreateGroupReqBodyBuilder) Group(group *Group) *CreateGroupReqBodyBuilder {
	builder.group = group
	builder.groupFlag = true
	return builder
}

// 操作人uid，如果您未操作[考勤管理后台“API 接入”流程](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/attendance-development-guidelines)，则此字段为必填字段
//
//示例值：dd31248a
func (builder *CreateGroupReqBodyBuilder) OperatorId(operatorId string) *CreateGroupReqBodyBuilder {
	builder.operatorId = operatorId
	builder.operatorIdFlag = true
	return builder
}

func (builder *CreateGroupReqBodyBuilder) Build() *CreateGroupReqBody {
	req := &CreateGroupReqBody{}
	if builder.groupFlag {
		req.Group = builder.group
	}
	if builder.operatorIdFlag {
		req.OperatorId = &builder.operatorId
	}
	return req
}

type CreateGroupPathReqBodyBuilder struct {
	group          *Group
	groupFlag      bool
	operatorId     string
	operatorIdFlag bool
}

func NewCreateGroupPathReqBodyBuilder() *CreateGroupPathReqBodyBuilder {
	builder := &CreateGroupPathReqBodyBuilder{}
	return builder
}

// 6921319402260496386
//
// 示例值：
func (builder *CreateGroupPathReqBodyBuilder) Group(group *Group) *CreateGroupPathReqBodyBuilder {
	builder.group = group
	builder.groupFlag = true
	return builder
}

// 操作人uid，如果您未操作[考勤管理后台“API 接入”流程](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/attendance-development-guidelines)，则此字段为必填字段
//
// 示例值：dd31248a
func (builder *CreateGroupPathReqBodyBuilder) OperatorId(operatorId string) *CreateGroupPathReqBodyBuilder {
	builder.operatorId = operatorId
	builder.operatorIdFlag = true
	return builder
}

func (builder *CreateGroupPathReqBodyBuilder) Build() (*CreateGroupReqBody, error) {
	req := &CreateGroupReqBody{}
	if builder.groupFlag {
		req.Group = builder.group
	}
	if builder.operatorIdFlag {
		req.OperatorId = &builder.operatorId
	}
	return req, nil
}

type CreateGroupReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *CreateGroupReqBody
}

func NewCreateGroupReqBuilder() *CreateGroupReqBuilder {
	builder := &CreateGroupReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 用户 ID 的类型
//
// 示例值：employee_id
func (builder *CreateGroupReqBuilder) EmployeeType(employeeType string) *CreateGroupReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 部门 ID 的类型
//
// 示例值：od-fcb45c28a45311afd441b8869541ece8
func (builder *CreateGroupReqBuilder) DeptType(deptType string) *CreateGroupReqBuilder {
	builder.apiReq.QueryParams.Set("dept_type", fmt.Sprint(deptType))
	return builder
}

// 考勤组，是对部门或者员工在某个特定场所及特定时间段内的出勤情况（包括上下班、迟到、早退、病假、婚假、丧假、公休、工作时间、加班情况等）的一种规则设定。;;通过设置考勤组，可以从部门、员工两个维度，来设定考勤方式、考勤时间、考勤地点等考勤规则。
func (builder *CreateGroupReqBuilder) Body(body *CreateGroupReqBody) *CreateGroupReqBuilder {
	builder.body = body
	return builder
}

func (builder *CreateGroupReqBuilder) Build() *CreateGroupReq {
	req := &CreateGroupReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type CreateGroupReqBody struct {
	Group *Group `json:"group,omitempty"` // 6921319402260496386

	OperatorId *string `json:"operator_id,omitempty"` // 操作人uid，如果您未操作[考勤管理后台“API 接入”流程](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/attendance-development-guidelines)，则此字段为必填字段
}

type CreateGroupReq struct {
	apiReq *larkcore.ApiReq
	Body   *CreateGroupReqBody `body:""`
}

type CreateGroupRespData struct {
	Group *Group `json:"group,omitempty"` // 6921319402260496386
}

type CreateGroupResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *CreateGroupRespData `json:"data"` // 业务数据
}

func (resp *CreateGroupResp) Success() bool {
	return resp.Code == 0
}

type DeleteGroupReqBuilder struct {
	apiReq *larkcore.ApiReq
}

func NewDeleteGroupReqBuilder() *DeleteGroupReqBuilder {
	builder := &DeleteGroupReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 考勤组 ID，获取方式：1）[创建或修改考勤组](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/group/create) 2）[按名称查询考勤组](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/group/search) 3）[获取打卡结果](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_task/query)
//
// 示例值：6919358128597097404
func (builder *DeleteGroupReqBuilder) GroupId(groupId string) *DeleteGroupReqBuilder {
	builder.apiReq.PathParams.Set("group_id", fmt.Sprint(groupId))
	return builder
}

func (builder *DeleteGroupReqBuilder) Build() *DeleteGroupReq {
	req := &DeleteGroupReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	return req
}

type DeleteGroupReq struct {
	apiReq *larkcore.ApiReq
}

type DeleteGroupResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *DeleteGroupResp) Success() bool {
	return resp.Code == 0
}

type GetGroupReqBuilder struct {
	apiReq *larkcore.ApiReq
}

func NewGetGroupReqBuilder() *GetGroupReqBuilder {
	builder := &GetGroupReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 考勤组 ID，获取方式：1）[创建或修改考勤组](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/group/create) 2）[按名称查询考勤组](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/group/search) 3）[获取打卡结果](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_task/query)
//
// 示例值：6919358128597097404
func (builder *GetGroupReqBuilder) GroupId(groupId string) *GetGroupReqBuilder {
	builder.apiReq.PathParams.Set("group_id", fmt.Sprint(groupId))
	return builder
}

// 用户 ID 的类型
//
// 示例值：employee_id
func (builder *GetGroupReqBuilder) EmployeeType(employeeType string) *GetGroupReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 部门 ID 的类型
//
// 示例值：od-fcb45c28a45311afd441b8869541ece8
func (builder *GetGroupReqBuilder) DeptType(deptType string) *GetGroupReqBuilder {
	builder.apiReq.QueryParams.Set("dept_type", fmt.Sprint(deptType))
	return builder
}

func (builder *GetGroupReqBuilder) Build() *GetGroupReq {
	req := &GetGroupReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type GetGroupReq struct {
	apiReq *larkcore.ApiReq
}

type GetGroupRespData struct {
	GroupId *string `json:"group_id,omitempty"` // 考勤组的Id， 需要从获取用户打卡结果信息的接口中获取groupId，修改考勤组时必填

	GroupName *string `json:"group_name,omitempty"` // 考勤组名称

	TimeZone *string `json:"time_zone,omitempty"` // 考勤组时区

	BindDeptIds []string `json:"bind_dept_ids,omitempty"` // 参加考勤的部门id列表

	ExceptDeptIds []string `json:"except_dept_ids,omitempty"` // 无需考勤的部门id列表

	BindUserIds []string `json:"bind_user_ids,omitempty"` // 参加考勤的人员id列表

	ExceptUserIds []string `json:"except_user_ids,omitempty"` // 参加考勤的人员id列表

	GroupLeaderIds []string `json:"group_leader_ids,omitempty"` // 考勤组主负责人id列表

	SubGroupLeaderIds []string `json:"sub_group_leader_ids,omitempty"` // 考勤组子负责人id列表

	AllowOutPunch *bool `json:"allow_out_punch,omitempty"` // 是否允许外勤打卡

	OutPunchNeedApproval *bool `json:"out_punch_need_approval,omitempty"` // 外勤打卡需审批，先审批后打卡（需要允许外勤打卡才能设置生效）

	OutPunchNeedPostApproval *bool `json:"out_punch_need_post_approval,omitempty"` // 外勤打卡需审批，先打卡后审批（需要允许外勤打卡才能设置生效）

	OutPunchNeedRemark *bool `json:"out_punch_need_remark,omitempty"` // 外勤打卡需填写备注（需要允许外勤打卡才能设置生效）

	OutPunchNeedPhoto *bool `json:"out_punch_need_photo,omitempty"` // 外勤打卡需拍照（需要允许外勤打卡才能设置生效）

	OutPunchAllowedHideAddr *bool `json:"out_punch_allowed_hide_addr,omitempty"` // 外勤打卡允许员工隐藏详细地址（需要允许外勤打卡才能设置生效）

	OutPunchAllowedAdjustAddr *bool `json:"out_punch_allowed_adjust_addr,omitempty"` // 外勤打卡允许微调地址（需要允许外勤打卡才能设置生效）

	AdjustRange *int `json:"adjust_range,omitempty"` // 微调范围，默认为 50 米

	AllowPcPunch *bool `json:"allow_pc_punch,omitempty"` // 是否允许pc打卡

	AllowRemedy *bool `json:"allow_remedy,omitempty"` // 是否允许补卡

	RemedyLimit *bool `json:"remedy_limit,omitempty"` // 补卡次数是否限制（需要允许补卡才能设置生效）

	RemedyLimitCount *int `json:"remedy_limit_count,omitempty"` // 补卡次数（需要允许补卡才能设置生效）

	RemedyDateLimit *bool `json:"remedy_date_limit,omitempty"` // 补卡时间是否限制（需要允许补卡才能设置生效）

	RemedyDateNum *int `json:"remedy_date_num,omitempty"` // 补卡时间,几天内可以发起补卡（需要允许补卡才能设置生效）

	AllowRemedyTypeLack *bool `json:"allow_remedy_type_lack,omitempty"` // 允许缺卡补卡（需要允许补卡才能设置生效）

	AllowRemedyTypeLate *bool `json:"allow_remedy_type_late,omitempty"` // 允许迟到补卡（需要允许补卡才能设置生效）

	AllowRemedyTypeEarly *bool `json:"allow_remedy_type_early,omitempty"` // 允许早退补卡（需要允许补卡才能设置生效）

	AllowRemedyTypeNormal *bool `json:"allow_remedy_type_normal,omitempty"` // 允许正常补卡（需要允许补卡才能设置生效）

	ShowCumulativeTime *bool `json:"show_cumulative_time,omitempty"` // 是否展示累计时长

	ShowOverTime *bool `json:"show_over_time,omitempty"` // 是否展示加班时长

	HideStaffPunchTime *bool `json:"hide_staff_punch_time,omitempty"` // 是否隐藏员工打卡详情

	HideClockInRule *bool `json:"hide_clock_in_rule,omitempty"` // 是否隐藏打卡规则

	FacePunch *bool `json:"face_punch,omitempty"` // 是否开启人脸打卡

	FacePunchCfg *int `json:"face_punch_cfg,omitempty"` // 人脸打卡规则， 1：每次打卡均需人脸识别 2：疑似需要

	FaceLiveNeedAction *bool `json:"face_live_need_action,omitempty"` // 人脸打卡规则， false：开启活体验证 true：0动作验证，仅在 face_punch_cfg = 1 时有效

	FaceDowngrade *bool `json:"face_downgrade,omitempty"` // 脸识别失败时允许普通拍照打卡

	ReplaceBasicPic *bool `json:"replace_basic_pic,omitempty"` // 是否允许替换基准图片

	AntiCheatPunchConfig *AntiCheatConfig `json:"anti_cheat_punch_config,omitempty"` // 防作弊打卡配置

	Machines []*Machine `json:"machines,omitempty"` // 考勤机信息

	GpsRange *int `json:"gps_range,omitempty"` // GPS打卡的地址范围

	Locations []*Location `json:"locations,omitempty"` // GPS打卡的地址信息

	GroupType *int `json:"group_type,omitempty"` // 考勤类型 0：固定考勤  2：排班考勤， 3：自由班次

	PunchDayShiftIds []string `json:"punch_day_shift_ids,omitempty"` // 固定班次必需填

	FreePunchCfg *FreePunchCfg `json:"free_punch_cfg,omitempty"` //

	CalendarId *int `json:"calendar_id,omitempty"` // 国家日历 id，（0：不根据国家日历休息, 1：中国，2：美国，3：日本，4：印度，5：新加坡），默认 1

	NeedPunchSpecialDays []*PunchSpecialDateShift `json:"need_punch_special_days,omitempty"` // 强制需要打卡的日期

	NoNeedPunchSpecialDays []*PunchSpecialDateShift `json:"no_need_punch_special_days,omitempty"` // 强制不需要打卡的日期

	WorkDayNoPunchAsLack *bool `json:"work_day_no_punch_as_lack,omitempty"` // 自由班次下工作日不打卡是否记为缺卡

	RemedyPeriodType *int `json:"remedy_period_type,omitempty"` // 补卡周期类型

	RemedyPeriodCustomDate *int `json:"remedy_period_custom_date,omitempty"` // 补卡自定义周期起始日期

	PunchType *int `json:"punch_type,omitempty"` // 打卡类型，位运算。1:GPS打卡；2:wifi打卡；4:考勤机打卡；8:IP打卡

	EffectTime *string `json:"effect_time,omitempty"` // 生效时间，精确到秒的时间戳

	FixshiftEffectTime *string `json:"fixshift_effect_time,omitempty"` // 固定班次生效时间，精确到秒的时间戳

	MemberEffectTime *string `json:"member_effect_time,omitempty"` // 参加考勤的人员、部门变动生效时间，精确到秒的时间戳

	RestClockInNeedApproval *bool `json:"rest_clockIn_need_approval,omitempty"` // 休息日打卡需审批

	ClockInNeedPhoto *bool `json:"clockIn_need_photo,omitempty"` // 每次打卡均需拍照

	MemberStatusChange *MemberStatusChange `json:"member_status_change,omitempty"` // 人员异动打卡设置

	LeaveNeedPunch *bool `json:"leave_need_punch,omitempty"` // 请假离岗或返岗是否需打卡

	LeaveNeedPunchCfg *LeaveNeedPunchCfg `json:"leave_need_punch_cfg,omitempty"` // 请假离岗或返岗打卡规则

	GoOutNeedPunch *int `json:"go_out_need_punch,omitempty"` // 外出期间是否需打卡

	GoOutNeedPunchCfg *LeaveNeedPunchCfg `json:"go_out_need_punch_cfg,omitempty"` // 外出期间打卡规则

	TravelNeedPunch *int `json:"travel_need_punch,omitempty"` // 出差期间是否需打卡

	TravelNeedPunchCfg *LeaveNeedPunchCfg `json:"travel_need_punch_cfg,omitempty"` // 出差期间打卡规则

	NeedPunchMembers []*PunchMember `json:"need_punch_members,omitempty"` // 需要打卡的人员配置（新）

	NoNeedPunchMembers []*PunchMember `json:"no_need_punch_members,omitempty"` // 无需打卡的人员配置（新）

	SaveAutoChanges *bool `json:"save_auto_changes,omitempty"` // 是否直接保存可以自动变更的冲突规则

	OrgChangeAutoAdjust *bool `json:"org_change_auto_adjust,omitempty"` // 人员异动开关（人员组织架构变更后是否允许自动调整到该考勤组）

	BindDefaultDeptIds []string `json:"bind_default_dept_ids,omitempty"` // 默认出勤的部门id列表

	BindDefaultUserIds []string `json:"bind_default_user_ids,omitempty"` // 默认出勤的用户ID列表

	OvertimeClockCfg *OvertimeClockCfg `json:"overtime_clock_cfg,omitempty"` // 加班打卡规则

	NewCalendarId *string `json:"new_calendar_id,omitempty"` // 节假日id，（如果考勤组使用了自定义节假日，请用此参数传入节假日id）

	AllowApplyPunch *bool `json:"allow_apply_punch,omitempty"` // 定位不准时是否允许申请打卡

	ClockInAbnormalSettings *ClockInAbnormalSettings `json:"clock_in_abnormal_settings,omitempty"` // 异常卡豁免配置
}

type GetGroupResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *GetGroupRespData `json:"data"` // 业务数据
}

func (resp *GetGroupResp) Success() bool {
	return resp.Code == 0
}

type ListGroupReqBuilder struct {
	apiReq *larkcore.ApiReq
	limit  int // 最大返回多少记录，当使用迭代器访问时才有效
}

func NewListGroupReqBuilder() *ListGroupReqBuilder {
	builder := &ListGroupReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 最大返回多少记录，当使用迭代器访问时才有效
func (builder *ListGroupReqBuilder) Limit(limit int) *ListGroupReqBuilder {
	builder.limit = limit
	return builder
}

// 分页大小
//
// 示例值：10
func (builder *ListGroupReqBuilder) PageSize(pageSize int) *ListGroupReqBuilder {
	builder.apiReq.QueryParams.Set("page_size", fmt.Sprint(pageSize))
	return builder
}

// 分页标记，第一次请求不填，表示从头开始遍历；分页查询结果还有更多项时会同时返回新的 page_token，下次遍历可采用该 page_token 获取查询结果
//
// 示例值：wgNOR1rmxogRvAsGl6CXlQ==
func (builder *ListGroupReqBuilder) PageToken(pageToken string) *ListGroupReqBuilder {
	builder.apiReq.QueryParams.Set("page_token", fmt.Sprint(pageToken))
	return builder
}

func (builder *ListGroupReqBuilder) Build() *ListGroupReq {
	req := &ListGroupReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.Limit = builder.limit
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type ListGroupReq struct {
	apiReq *larkcore.ApiReq
	Limit  int // 最多返回多少记录，只有在使用迭代器访问时，才有效

}

type ListGroupRespData struct {
	GroupList []*GroupMeta `json:"group_list,omitempty"` // 考勤组列表

	PageToken *string `json:"page_token,omitempty"` // 分页标记，当 has_more 为 true 时，会同时返回新的 page_token，否则不返回 page_token

	HasMore *bool `json:"has_more,omitempty"` // 是否还有更多项
}

type ListGroupResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *ListGroupRespData `json:"data"` // 业务数据
}

func (resp *ListGroupResp) Success() bool {
	return resp.Code == 0
}

type ListUserGroupReqBuilder struct {
	apiReq *larkcore.ApiReq
}

func NewListUserGroupReqBuilder() *ListUserGroupReqBuilder {
	builder := &ListUserGroupReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 考勤组id
//
// 示例值：6919358128597097404
func (builder *ListUserGroupReqBuilder) GroupId(groupId string) *ListUserGroupReqBuilder {
	builder.apiReq.PathParams.Set("group_id", fmt.Sprint(groupId))
	return builder
}

// 用户 ID 的类型
//
// 示例值：employee_id
func (builder *ListUserGroupReqBuilder) EmployeeType(employeeType string) *ListUserGroupReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 部门 ID 的类型
//
// 示例值：open_id
func (builder *ListUserGroupReqBuilder) DeptType(deptType string) *ListUserGroupReqBuilder {
	builder.apiReq.QueryParams.Set("dept_type", fmt.Sprint(deptType))
	return builder
}

// 分页大小
//
// 示例值：10
func (builder *ListUserGroupReqBuilder) PageSize(pageSize int) *ListUserGroupReqBuilder {
	builder.apiReq.QueryParams.Set("page_size", fmt.Sprint(pageSize))
	return builder
}

// 第一次请求不填，表示从头开始遍历；分页查询结果还有更多项时会同时返回新的 page_token，下次遍历可采用该 page_token 获取查询结果
//
// 示例值：92xKiuWrBCSweSZJBSTpag%3D%3D
func (builder *ListUserGroupReqBuilder) PageToken(pageToken string) *ListUserGroupReqBuilder {
	builder.apiReq.QueryParams.Set("page_token", fmt.Sprint(pageToken))
	return builder
}

// 打卡类型
//
// 示例值：1
func (builder *ListUserGroupReqBuilder) MemberClockType(memberClockType int) *ListUserGroupReqBuilder {
	builder.apiReq.QueryParams.Set("member_clock_type", fmt.Sprint(memberClockType))
	return builder
}

func (builder *ListUserGroupReqBuilder) Build() *ListUserGroupReq {
	req := &ListUserGroupReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type ListUserGroupReq struct {
	apiReq *larkcore.ApiReq
}

type ListUserGroupRespData struct {
	Users []*UserBase `json:"users,omitempty"` // 考勤组成员列表

	PageToken *string `json:"page_token,omitempty"` // 分页标记，当 has_more 为 true 时，会同时返回新的 page_token，否则不返回 page_token

	HasMore *bool `json:"has_more,omitempty"` // 是否还有更多项
}

type ListUserGroupResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *ListUserGroupRespData `json:"data"` // 业务数据
}

func (resp *ListUserGroupResp) Success() bool {
	return resp.Code == 0
}

type SearchGroupReqBodyBuilder struct {
	groupName     string // 考勤组名称
	groupNameFlag bool

	exactlyMatched     bool // 是否精准匹配，默认为false:模糊匹配; true:精准匹配
	exactlyMatchedFlag bool
}

func NewSearchGroupReqBodyBuilder() *SearchGroupReqBodyBuilder {
	builder := &SearchGroupReqBodyBuilder{}
	return builder
}

// 考勤组名称
//
//示例值：考勤组1
func (builder *SearchGroupReqBodyBuilder) GroupName(groupName string) *SearchGroupReqBodyBuilder {
	builder.groupName = groupName
	builder.groupNameFlag = true
	return builder
}

func (builder *SearchGroupReqBodyBuilder) Build() *SearchGroupReqBody {
	req := &SearchGroupReqBody{}
	if builder.groupNameFlag {
		req.GroupName = &builder.groupName
	}
	return req
}

type SearchGroupPathReqBodyBuilder struct {
	groupName          string
	groupNameFlag      bool
	exactlyMatched     bool
	exactlyMatchedFlag bool
}

func NewSearchGroupPathReqBodyBuilder() *SearchGroupPathReqBodyBuilder {
	builder := &SearchGroupPathReqBodyBuilder{}
	return builder
}

// 考勤组名称
//
// 示例值：考勤组1
func (builder *SearchGroupPathReqBodyBuilder) GroupName(groupName string) *SearchGroupPathReqBodyBuilder {
	builder.groupName = groupName
	builder.groupNameFlag = true
	return builder
}

func (builder *SearchGroupPathReqBodyBuilder) Build() (*SearchGroupReqBody, error) {
	req := &SearchGroupReqBody{}
	if builder.groupNameFlag {
		req.GroupName = &builder.groupName
	}
	return req, nil
}

type SearchGroupReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *SearchGroupReqBody
}

func NewSearchGroupReqBuilder() *SearchGroupReqBuilder {
	builder := &SearchGroupReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 按考勤组名称查询考勤组摘要信息。查询条件支持名称精确匹配和模糊匹配两种方式。查询结果按考勤组修改时间 desc 排序，且最大记录数为 10 条。
func (builder *SearchGroupReqBuilder) Body(body *SearchGroupReqBody) *SearchGroupReqBuilder {
	builder.body = body
	return builder
}

func (builder *SearchGroupReqBuilder) Build() *SearchGroupReq {
	req := &SearchGroupReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.Body = builder.body
	return req
}

type SearchGroupReqBody struct {
	GroupName *string `json:"group_name,omitempty"` // 考勤组名称

	ExactlyMatched *bool `json:"exactly_matched,omitempty"` // 是否精准匹配，默认为false:模糊匹配; true:精准匹配
}

type SearchGroupReq struct {
	apiReq *larkcore.ApiReq
	Body   *SearchGroupReqBody `body:""`
}

type SearchGroupRespData struct {
	GroupList []*GroupMeta `json:"group_list,omitempty"` // 考勤组列表
}

type SearchGroupResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *SearchGroupRespData `json:"data"` // 业务数据
}

func (resp *SearchGroupResp) Success() bool {
	return resp.Code == 0
}

type PatchLeaveAccrualRecordReqBodyBuilder struct {
	leaveGrantingRecordId     string // 授予记录的唯一ID
	leaveGrantingRecordIdFlag bool

	employmentId     string // 员工ID
	employmentIdFlag bool

	leaveTypeId     string // 假期类型ID
	leaveTypeIdFlag bool

	reason     []*LangText // 修改授予记录原因
	reasonFlag bool

	timeOffset     int // 时间偏移，东八区：480	8*60
	timeOffsetFlag bool

	expirationDate     string // 失效日期，格式"2020-01-01"
	expirationDateFlag bool

	quantity     string // 修改source 余额
	quantityFlag bool

	sectionType     int // 是否参与清算
	sectionTypeFlag bool
}

func NewPatchLeaveAccrualRecordReqBodyBuilder() *PatchLeaveAccrualRecordReqBodyBuilder {
	builder := &PatchLeaveAccrualRecordReqBodyBuilder{}
	return builder
}

// 授予记录的唯一ID
//
//示例值：1
func (builder *PatchLeaveAccrualRecordReqBodyBuilder) LeaveGrantingRecordId(leaveGrantingRecordId string) *PatchLeaveAccrualRecordReqBodyBuilder {
	builder.leaveGrantingRecordId = leaveGrantingRecordId
	builder.leaveGrantingRecordIdFlag = true
	return builder
}

// 员工ID
//
//示例值：1
func (builder *PatchLeaveAccrualRecordReqBodyBuilder) EmploymentId(employmentId string) *PatchLeaveAccrualRecordReqBodyBuilder {
	builder.employmentId = employmentId
	builder.employmentIdFlag = true
	return builder
}

// 假期类型ID
//
//示例值：1
func (builder *PatchLeaveAccrualRecordReqBodyBuilder) LeaveTypeId(leaveTypeId string) *PatchLeaveAccrualRecordReqBodyBuilder {
	builder.leaveTypeId = leaveTypeId
	builder.leaveTypeIdFlag = true
	return builder
}

// 修改授予记录原因
//
//示例值：
func (builder *PatchLeaveAccrualRecordReqBodyBuilder) Reason(reason []*LangText) *PatchLeaveAccrualRecordReqBodyBuilder {
	builder.reason = reason
	builder.reasonFlag = true
	return builder
}

// 时间偏移，东八区：480	8*60
//
//示例值：480
func (builder *PatchLeaveAccrualRecordReqBodyBuilder) TimeOffset(timeOffset int) *PatchLeaveAccrualRecordReqBodyBuilder {
	builder.timeOffset = timeOffset
	builder.timeOffsetFlag = true
	return builder
}

// 失效日期，格式"2020-01-01"
//
//示例值：2020-01-01
func (builder *PatchLeaveAccrualRecordReqBodyBuilder) ExpirationDate(expirationDate string) *PatchLeaveAccrualRecordReqBodyBuilder {
	builder.expirationDate = expirationDate
	builder.expirationDateFlag = true
	return builder
}

// 修改source 余额
//
//示例值：1
func (builder *PatchLeaveAccrualRecordReqBodyBuilder) Quantity(quantity string) *PatchLeaveAccrualRecordReqBodyBuilder {
	builder.quantity = quantity
	builder.quantityFlag = true
	return builder
}

// 是否参与清算
//
//示例值：1
func (builder *PatchLeaveAccrualRecordReqBodyBuilder) SectionType(sectionType int) *PatchLeaveAccrualRecordReqBodyBuilder {
	builder.sectionType = sectionType
	builder.sectionTypeFlag = true
	return builder
}

func (builder *PatchLeaveAccrualRecordReqBodyBuilder) Build() *PatchLeaveAccrualRecordReqBody {
	req := &PatchLeaveAccrualRecordReqBody{}
	if builder.leaveGrantingRecordIdFlag {
		req.LeaveGrantingRecordId = &builder.leaveGrantingRecordId
	}
	if builder.employmentIdFlag {
		req.EmploymentId = &builder.employmentId
	}
	if builder.leaveTypeIdFlag {
		req.LeaveTypeId = &builder.leaveTypeId
	}
	if builder.reasonFlag {
		req.Reason = builder.reason
	}
	if builder.timeOffsetFlag {
		req.TimeOffset = &builder.timeOffset
	}
	if builder.expirationDateFlag {
		req.ExpirationDate = &builder.expirationDate
	}
	if builder.quantityFlag {
		req.Quantity = &builder.quantity
	}
	if builder.sectionTypeFlag {
		req.SectionType = &builder.sectionType
	}
	return req
}

type PatchLeaveAccrualRecordPathReqBodyBuilder struct {
	leaveGrantingRecordId     string
	leaveGrantingRecordIdFlag bool
	employmentId              string
	employmentIdFlag          bool
	leaveTypeId               string
	leaveTypeIdFlag           bool
	reason                    []*LangText
	reasonFlag                bool
	timeOffset                int
	timeOffsetFlag            bool
	expirationDate            string
	expirationDateFlag        bool
	quantity                  string
	quantityFlag              bool
	sectionType               int
	sectionTypeFlag           bool
}

func NewPatchLeaveAccrualRecordPathReqBodyBuilder() *PatchLeaveAccrualRecordPathReqBodyBuilder {
	builder := &PatchLeaveAccrualRecordPathReqBodyBuilder{}
	return builder
}

// 授予记录的唯一ID
//
// 示例值：1
func (builder *PatchLeaveAccrualRecordPathReqBodyBuilder) LeaveGrantingRecordId(leaveGrantingRecordId string) *PatchLeaveAccrualRecordPathReqBodyBuilder {
	builder.leaveGrantingRecordId = leaveGrantingRecordId
	builder.leaveGrantingRecordIdFlag = true
	return builder
}

// 员工ID
//
// 示例值：1
func (builder *PatchLeaveAccrualRecordPathReqBodyBuilder) EmploymentId(employmentId string) *PatchLeaveAccrualRecordPathReqBodyBuilder {
	builder.employmentId = employmentId
	builder.employmentIdFlag = true
	return builder
}

// 假期类型ID
//
// 示例值：1
func (builder *PatchLeaveAccrualRecordPathReqBodyBuilder) LeaveTypeId(leaveTypeId string) *PatchLeaveAccrualRecordPathReqBodyBuilder {
	builder.leaveTypeId = leaveTypeId
	builder.leaveTypeIdFlag = true
	return builder
}

// 修改授予记录原因
//
// 示例值：
func (builder *PatchLeaveAccrualRecordPathReqBodyBuilder) Reason(reason []*LangText) *PatchLeaveAccrualRecordPathReqBodyBuilder {
	builder.reason = reason
	builder.reasonFlag = true
	return builder
}

// 时间偏移，东八区：480	8*60
//
// 示例值：480
func (builder *PatchLeaveAccrualRecordPathReqBodyBuilder) TimeOffset(timeOffset int) *PatchLeaveAccrualRecordPathReqBodyBuilder {
	builder.timeOffset = timeOffset
	builder.timeOffsetFlag = true
	return builder
}

// 失效日期，格式"2020-01-01"
//
// 示例值：2020-01-01
func (builder *PatchLeaveAccrualRecordPathReqBodyBuilder) ExpirationDate(expirationDate string) *PatchLeaveAccrualRecordPathReqBodyBuilder {
	builder.expirationDate = expirationDate
	builder.expirationDateFlag = true
	return builder
}

// 修改source 余额
//
// 示例值：1
func (builder *PatchLeaveAccrualRecordPathReqBodyBuilder) Quantity(quantity string) *PatchLeaveAccrualRecordPathReqBodyBuilder {
	builder.quantity = quantity
	builder.quantityFlag = true
	return builder
}

// 是否参与清算
//
// 示例值：1
func (builder *PatchLeaveAccrualRecordPathReqBodyBuilder) SectionType(sectionType int) *PatchLeaveAccrualRecordPathReqBodyBuilder {
	builder.sectionType = sectionType
	builder.sectionTypeFlag = true
	return builder
}

func (builder *PatchLeaveAccrualRecordPathReqBodyBuilder) Build() (*PatchLeaveAccrualRecordReqBody, error) {
	req := &PatchLeaveAccrualRecordReqBody{}
	if builder.leaveGrantingRecordIdFlag {
		req.LeaveGrantingRecordId = &builder.leaveGrantingRecordId
	}
	if builder.employmentIdFlag {
		req.EmploymentId = &builder.employmentId
	}
	if builder.leaveTypeIdFlag {
		req.LeaveTypeId = &builder.leaveTypeId
	}
	if builder.reasonFlag {
		req.Reason = builder.reason
	}
	if builder.timeOffsetFlag {
		req.TimeOffset = &builder.timeOffset
	}
	if builder.expirationDateFlag {
		req.ExpirationDate = &builder.expirationDate
	}
	if builder.quantityFlag {
		req.Quantity = &builder.quantity
	}
	if builder.sectionTypeFlag {
		req.SectionType = &builder.sectionType
	}
	return req, nil
}

type PatchLeaveAccrualRecordReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *PatchLeaveAccrualRecordReqBody
}

func NewPatchLeaveAccrualRecordReqBuilder() *PatchLeaveAccrualRecordReqBuilder {
	builder := &PatchLeaveAccrualRecordReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 假期类型ID
//
// 示例值：1
func (builder *PatchLeaveAccrualRecordReqBuilder) LeaveId(leaveId string) *PatchLeaveAccrualRecordReqBuilder {
	builder.apiReq.PathParams.Set("leave_id", fmt.Sprint(leaveId))
	return builder
}

// 用户 ID 类型
//
// 示例值：open_id
func (builder *PatchLeaveAccrualRecordReqBuilder) UserIdType(userIdType string) *PatchLeaveAccrualRecordReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

//
func (builder *PatchLeaveAccrualRecordReqBuilder) Body(body *PatchLeaveAccrualRecordReqBody) *PatchLeaveAccrualRecordReqBuilder {
	builder.body = body
	return builder
}

func (builder *PatchLeaveAccrualRecordReqBuilder) Build() *PatchLeaveAccrualRecordReq {
	req := &PatchLeaveAccrualRecordReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type PatchLeaveAccrualRecordReqBody struct {
	LeaveGrantingRecordId *string `json:"leave_granting_record_id,omitempty"` // 授予记录的唯一ID

	EmploymentId *string `json:"employment_id,omitempty"` // 员工ID

	LeaveTypeId *string `json:"leave_type_id,omitempty"` // 假期类型ID

	Reason []*LangText `json:"reason,omitempty"` // 修改授予记录原因

	TimeOffset *int `json:"time_offset,omitempty"` // 时间偏移，东八区：480	8*60

	ExpirationDate *string `json:"expiration_date,omitempty"` // 失效日期，格式"2020-01-01"

	Quantity *string `json:"quantity,omitempty"` // 修改source 余额

	SectionType *int `json:"section_type,omitempty"` // 是否参与清算
}

type PatchLeaveAccrualRecordReq struct {
	apiReq *larkcore.ApiReq
	Body   *PatchLeaveAccrualRecordReqBody `body:""`
}

type PatchLeaveAccrualRecordRespData struct {
	Record *LeaveAccrualRecord `json:"record,omitempty"` // 员工过期日期的授予记录
}

type PatchLeaveAccrualRecordResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *PatchLeaveAccrualRecordRespData `json:"data"` // 业务数据
}

func (resp *PatchLeaveAccrualRecordResp) Success() bool {
	return resp.Code == 0
}

type GetLeaveEmployExpireRecordReqBodyBuilder struct {
	employmentId     string // 员工ID
	employmentIdFlag bool

	leaveTypeId     string // 假期类型ID
	leaveTypeIdFlag bool

	startExpirationDate     string // 失效最早日期  2023-04-10 格式
	startExpirationDateFlag bool

	endExpirationDate     string // 失效最晚日期 2023-05-10 格式
	endExpirationDateFlag bool

	timeOffset     int // 时间偏移，东八区：480	8*60， 如果没有这个参数，默认东八区
	timeOffsetFlag bool
}

func NewGetLeaveEmployExpireRecordReqBodyBuilder() *GetLeaveEmployExpireRecordReqBodyBuilder {
	builder := &GetLeaveEmployExpireRecordReqBodyBuilder{}
	return builder
}

// 员工ID
//
//示例值：1
func (builder *GetLeaveEmployExpireRecordReqBodyBuilder) EmploymentId(employmentId string) *GetLeaveEmployExpireRecordReqBodyBuilder {
	builder.employmentId = employmentId
	builder.employmentIdFlag = true
	return builder
}

// 假期类型ID
//
//示例值：1
func (builder *GetLeaveEmployExpireRecordReqBodyBuilder) LeaveTypeId(leaveTypeId string) *GetLeaveEmployExpireRecordReqBodyBuilder {
	builder.leaveTypeId = leaveTypeId
	builder.leaveTypeIdFlag = true
	return builder
}

// 失效最早日期  2023-04-10 格式
//
//示例值：2023-04-10
func (builder *GetLeaveEmployExpireRecordReqBodyBuilder) StartExpirationDate(startExpirationDate string) *GetLeaveEmployExpireRecordReqBodyBuilder {
	builder.startExpirationDate = startExpirationDate
	builder.startExpirationDateFlag = true
	return builder
}

// 失效最晚日期 2023-05-10 格式
//
//示例值：2023-05-10
func (builder *GetLeaveEmployExpireRecordReqBodyBuilder) EndExpirationDate(endExpirationDate string) *GetLeaveEmployExpireRecordReqBodyBuilder {
	builder.endExpirationDate = endExpirationDate
	builder.endExpirationDateFlag = true
	return builder
}

// 时间偏移，东八区：480	8*60， 如果没有这个参数，默认东八区
//
//示例值：480
func (builder *GetLeaveEmployExpireRecordReqBodyBuilder) TimeOffset(timeOffset int) *GetLeaveEmployExpireRecordReqBodyBuilder {
	builder.timeOffset = timeOffset
	builder.timeOffsetFlag = true
	return builder
}

func (builder *GetLeaveEmployExpireRecordReqBodyBuilder) Build() *GetLeaveEmployExpireRecordReqBody {
	req := &GetLeaveEmployExpireRecordReqBody{}
	if builder.employmentIdFlag {
		req.EmploymentId = &builder.employmentId
	}
	if builder.leaveTypeIdFlag {
		req.LeaveTypeId = &builder.leaveTypeId
	}
	if builder.startExpirationDateFlag {
		req.StartExpirationDate = &builder.startExpirationDate
	}
	if builder.endExpirationDateFlag {
		req.EndExpirationDate = &builder.endExpirationDate
	}
	if builder.timeOffsetFlag {
		req.TimeOffset = &builder.timeOffset
	}
	return req
}

type GetLeaveEmployExpireRecordPathReqBodyBuilder struct {
	employmentId            string
	employmentIdFlag        bool
	leaveTypeId             string
	leaveTypeIdFlag         bool
	startExpirationDate     string
	startExpirationDateFlag bool
	endExpirationDate       string
	endExpirationDateFlag   bool
	timeOffset              int
	timeOffsetFlag          bool
}

func NewGetLeaveEmployExpireRecordPathReqBodyBuilder() *GetLeaveEmployExpireRecordPathReqBodyBuilder {
	builder := &GetLeaveEmployExpireRecordPathReqBodyBuilder{}
	return builder
}

// 员工ID
//
// 示例值：1
func (builder *GetLeaveEmployExpireRecordPathReqBodyBuilder) EmploymentId(employmentId string) *GetLeaveEmployExpireRecordPathReqBodyBuilder {
	builder.employmentId = employmentId
	builder.employmentIdFlag = true
	return builder
}

// 假期类型ID
//
// 示例值：1
func (builder *GetLeaveEmployExpireRecordPathReqBodyBuilder) LeaveTypeId(leaveTypeId string) *GetLeaveEmployExpireRecordPathReqBodyBuilder {
	builder.leaveTypeId = leaveTypeId
	builder.leaveTypeIdFlag = true
	return builder
}

// 失效最早日期  2023-04-10 格式
//
// 示例值：2023-04-10
func (builder *GetLeaveEmployExpireRecordPathReqBodyBuilder) StartExpirationDate(startExpirationDate string) *GetLeaveEmployExpireRecordPathReqBodyBuilder {
	builder.startExpirationDate = startExpirationDate
	builder.startExpirationDateFlag = true
	return builder
}

// 失效最晚日期 2023-05-10 格式
//
// 示例值：2023-05-10
func (builder *GetLeaveEmployExpireRecordPathReqBodyBuilder) EndExpirationDate(endExpirationDate string) *GetLeaveEmployExpireRecordPathReqBodyBuilder {
	builder.endExpirationDate = endExpirationDate
	builder.endExpirationDateFlag = true
	return builder
}

// 时间偏移，东八区：480	8*60， 如果没有这个参数，默认东八区
//
// 示例值：480
func (builder *GetLeaveEmployExpireRecordPathReqBodyBuilder) TimeOffset(timeOffset int) *GetLeaveEmployExpireRecordPathReqBodyBuilder {
	builder.timeOffset = timeOffset
	builder.timeOffsetFlag = true
	return builder
}

func (builder *GetLeaveEmployExpireRecordPathReqBodyBuilder) Build() (*GetLeaveEmployExpireRecordReqBody, error) {
	req := &GetLeaveEmployExpireRecordReqBody{}
	if builder.employmentIdFlag {
		req.EmploymentId = &builder.employmentId
	}
	if builder.leaveTypeIdFlag {
		req.LeaveTypeId = &builder.leaveTypeId
	}
	if builder.startExpirationDateFlag {
		req.StartExpirationDate = &builder.startExpirationDate
	}
	if builder.endExpirationDateFlag {
		req.EndExpirationDate = &builder.endExpirationDate
	}
	if builder.timeOffsetFlag {
		req.TimeOffset = &builder.timeOffset
	}
	return req, nil
}

type GetLeaveEmployExpireRecordReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *GetLeaveEmployExpireRecordReqBody
}

func NewGetLeaveEmployExpireRecordReqBuilder() *GetLeaveEmployExpireRecordReqBuilder {
	builder := &GetLeaveEmployExpireRecordReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 假期类型ID
//
// 示例值：1
func (builder *GetLeaveEmployExpireRecordReqBuilder) LeaveId(leaveId string) *GetLeaveEmployExpireRecordReqBuilder {
	builder.apiReq.PathParams.Set("leave_id", fmt.Sprint(leaveId))
	return builder
}

// 用户 ID 类型
//
// 示例值：open_id
func (builder *GetLeaveEmployExpireRecordReqBuilder) UserIdType(userIdType string) *GetLeaveEmployExpireRecordReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

//
func (builder *GetLeaveEmployExpireRecordReqBuilder) Body(body *GetLeaveEmployExpireRecordReqBody) *GetLeaveEmployExpireRecordReqBuilder {
	builder.body = body
	return builder
}

func (builder *GetLeaveEmployExpireRecordReqBuilder) Build() *GetLeaveEmployExpireRecordReq {
	req := &GetLeaveEmployExpireRecordReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type GetLeaveEmployExpireRecordReqBody struct {
	EmploymentId *string `json:"employment_id,omitempty"` // 员工ID

	LeaveTypeId *string `json:"leave_type_id,omitempty"` // 假期类型ID

	StartExpirationDate *string `json:"start_expiration_date,omitempty"` // 失效最早日期  2023-04-10 格式

	EndExpirationDate *string `json:"end_expiration_date,omitempty"` // 失效最晚日期 2023-05-10 格式

	TimeOffset *int `json:"time_offset,omitempty"` // 时间偏移，东八区：480	8*60， 如果没有这个参数，默认东八区
}

type GetLeaveEmployExpireRecordReq struct {
	apiReq *larkcore.ApiReq
	Body   *GetLeaveEmployExpireRecordReqBody `body:""`
}

type GetLeaveEmployExpireRecordRespData struct {
	Records []*LeaveEmployExpireRecord `json:"records,omitempty"` // 员工过期日期的授予记录
}

type GetLeaveEmployExpireRecordResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *GetLeaveEmployExpireRecordRespData `json:"data"` // 业务数据
}

func (resp *GetLeaveEmployExpireRecordResp) Success() bool {
	return resp.Code == 0
}

type CreateShiftReqBuilder struct {
	apiReq *larkcore.ApiReq
	shift  *Shift
}

func NewCreateShiftReqBuilder() *CreateShiftReqBuilder {
	builder := &CreateShiftReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 用户 ID 的类型 不提供则用户相关字段无效
//
// 示例值：
func (builder *CreateShiftReqBuilder) EmployeeType(employeeType string) *CreateShiftReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 班次是描述一次考勤任务时间规则的统称，比如一天打多少次卡，每次卡的上下班时间，晚到多长时间算迟到，晚到多长时间算缺卡等。
func (builder *CreateShiftReqBuilder) Shift(shift *Shift) *CreateShiftReqBuilder {
	builder.shift = shift
	return builder
}

func (builder *CreateShiftReqBuilder) Build() *CreateShiftReq {
	req := &CreateShiftReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.shift
	return req
}

type CreateShiftReq struct {
	apiReq *larkcore.ApiReq
	Shift  *Shift `body:""`
}

type CreateShiftRespData struct {
	Shift *Shift `json:"shift,omitempty"` // 班次
}

type CreateShiftResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *CreateShiftRespData `json:"data"` // 业务数据
}

func (resp *CreateShiftResp) Success() bool {
	return resp.Code == 0
}

type DeleteShiftReqBuilder struct {
	apiReq *larkcore.ApiReq
}

func NewDeleteShiftReqBuilder() *DeleteShiftReqBuilder {
	builder := &DeleteShiftReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 班次 ID，获取方式：1）[按名称查询班次](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/shift/query) 2）[创建班次](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/shift/create)
//
// 示例值：6919358778597097404
func (builder *DeleteShiftReqBuilder) ShiftId(shiftId string) *DeleteShiftReqBuilder {
	builder.apiReq.PathParams.Set("shift_id", fmt.Sprint(shiftId))
	return builder
}

func (builder *DeleteShiftReqBuilder) Build() *DeleteShiftReq {
	req := &DeleteShiftReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	return req
}

type DeleteShiftReq struct {
	apiReq *larkcore.ApiReq
}

type DeleteShiftResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *DeleteShiftResp) Success() bool {
	return resp.Code == 0
}

type GetShiftReqBuilder struct {
	apiReq *larkcore.ApiReq
}

func NewGetShiftReqBuilder() *GetShiftReqBuilder {
	builder := &GetShiftReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 班次 ID，获取方式：1）[按名称查询班次](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/shift/query) 2）[创建班次](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/shift/create)
//
// 示例值：6919358778597097404
func (builder *GetShiftReqBuilder) ShiftId(shiftId string) *GetShiftReqBuilder {
	builder.apiReq.PathParams.Set("shift_id", fmt.Sprint(shiftId))
	return builder
}

func (builder *GetShiftReqBuilder) Build() *GetShiftReq {
	req := &GetShiftReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	return req
}

type GetShiftReq struct {
	apiReq *larkcore.ApiReq
}

type GetShiftRespData struct {
	ShiftId *string `json:"shift_id,omitempty"` // 班次Id

	ShiftName *string `json:"shift_name,omitempty"` // 班次名称

	PunchTimes *int `json:"punch_times,omitempty"` // 打卡次数

	SubShiftLeaderIds []string `json:"sub_shift_leader_ids,omitempty"` // 排班组子负责人id列表

	IsFlexible *bool `json:"is_flexible,omitempty"` // 是否弹性打卡

	FlexibleMinutes *int `json:"flexible_minutes,omitempty"` // 弹性打卡时间，设置【上班最多可晚到】与【下班最多可早走】时间，如果不设置flexible_rule则生效

	FlexibleRule []*FlexibleRule `json:"flexible_rule,omitempty"` // 弹性打卡时间设置

	NoNeedOff *bool `json:"no_need_off,omitempty"` // 不需要打下班卡

	PunchTimeRule []*PunchTimeRule `json:"punch_time_rule,omitempty"` // 打卡规则

	LateOffLateOnRule []*LateOffLateOnRule `json:"late_off_late_on_rule,omitempty"` // 晚走晚到规则

	RestTimeRule []*RestRule `json:"rest_time_rule,omitempty"` // 休息规则

	OvertimeRule []*OvertimeRule `json:"overtime_rule,omitempty"` // 打卡规则

	DayType *int `json:"day_type,omitempty"` // 日期类型，【是否弹性打卡 = ture】时，不可设置为“休息日”  可选值：1：工作日 2：休息日	 示例值：（默认值）1

	OvertimeRestTimeRule []*RestRule `json:"overtime_rest_time_rule,omitempty"` // 班外休息规则

	LateMinutesAsSeriousLate *int `json:"late_minutes_as_serious_late,omitempty"` // 晚到多久记为严重迟到（优先级比原有字段高）

	ShiftMiddleTimeRule *ShiftMiddleTimeRule `json:"shift_middle_time_rule,omitempty"` // 半天分割规则

	ShiftAttendanceTimeConfig *ShiftAttendanceTimeConfig `json:"shift_attendance_time_config,omitempty"` // 应出勤配置

	LateOffLateOnSetting *LateOffLateOnSetting `json:"late_off_late_on_setting,omitempty"` // 晚走次日晚到配置规则

	Id *string `json:"id,omitempty"` // 班次id(更新班次时需要传递)

	RestTimeFlexibleConfigs []*RestTimeFlexibleConfig `json:"rest_time_flexible_configs,omitempty"` // 休息弹性设置
}

type GetShiftResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *GetShiftRespData `json:"data"` // 业务数据
}

func (resp *GetShiftResp) Success() bool {
	return resp.Code == 0
}

type ListShiftReqBuilder struct {
	apiReq *larkcore.ApiReq
	limit  int // 最大返回多少记录，当使用迭代器访问时才有效
}

func NewListShiftReqBuilder() *ListShiftReqBuilder {
	builder := &ListShiftReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 最大返回多少记录，当使用迭代器访问时才有效
func (builder *ListShiftReqBuilder) Limit(limit int) *ListShiftReqBuilder {
	builder.limit = limit
	return builder
}

// 分页大小
//
// 示例值：10
func (builder *ListShiftReqBuilder) PageSize(pageSize int) *ListShiftReqBuilder {
	builder.apiReq.QueryParams.Set("page_size", fmt.Sprint(pageSize))
	return builder
}

// 分页标记，第一次请求不填，表示从头开始遍历；分页查询结果还有更多项时会同时返回新的 page_token，下次遍历可采用该 page_token 获取查询结果
//
// 示例值：YrkvQ1wGaPVta45tkxuGiQ==
func (builder *ListShiftReqBuilder) PageToken(pageToken string) *ListShiftReqBuilder {
	builder.apiReq.QueryParams.Set("page_token", fmt.Sprint(pageToken))
	return builder
}

func (builder *ListShiftReqBuilder) Build() *ListShiftReq {
	req := &ListShiftReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.Limit = builder.limit
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type ListShiftReq struct {
	apiReq *larkcore.ApiReq
	Limit  int // 最多返回多少记录，只有在使用迭代器访问时，才有效

}

type ListShiftRespData struct {
	ShiftList []*Shift `json:"shift_list,omitempty"` // 班次列表

	PageToken *string `json:"page_token,omitempty"` // 分页标记，当 has_more 为 true 时，会同时返回新的 page_token，否则不返回 page_token

	HasMore *bool `json:"has_more,omitempty"` // 是否还有更多项
}

type ListShiftResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *ListShiftRespData `json:"data"` // 业务数据
}

func (resp *ListShiftResp) Success() bool {
	return resp.Code == 0
}

type QueryShiftReqBuilder struct {
	apiReq *larkcore.ApiReq
}

func NewQueryShiftReqBuilder() *QueryShiftReqBuilder {
	builder := &QueryShiftReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 班次名称
//
// 示例值：早班
func (builder *QueryShiftReqBuilder) ShiftName(shiftName string) *QueryShiftReqBuilder {
	builder.apiReq.QueryParams.Set("shift_name", fmt.Sprint(shiftName))
	return builder
}

func (builder *QueryShiftReqBuilder) Build() *QueryShiftReq {
	req := &QueryShiftReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type QueryShiftReq struct {
	apiReq *larkcore.ApiReq
}

type QueryShiftRespData struct {
	ShiftId *string `json:"shift_id,omitempty"` // 班次Id

	ShiftName *string `json:"shift_name,omitempty"` // 班次名称

	PunchTimes *int `json:"punch_times,omitempty"` // 打卡次数

	SubShiftLeaderIds []string `json:"sub_shift_leader_ids,omitempty"` // 排班组子负责人id列表

	IsFlexible *bool `json:"is_flexible,omitempty"` // 是否弹性打卡

	FlexibleMinutes *int `json:"flexible_minutes,omitempty"` // 弹性打卡时间，设置【上班最多可晚到】与【下班最多可早走】时间，如果不设置flexible_rule则生效

	FlexibleRule []*FlexibleRule `json:"flexible_rule,omitempty"` // 弹性打卡时间设置

	NoNeedOff *bool `json:"no_need_off,omitempty"` // 不需要打下班卡

	PunchTimeRule []*PunchTimeRule `json:"punch_time_rule,omitempty"` // 打卡规则

	LateOffLateOnRule []*LateOffLateOnRule `json:"late_off_late_on_rule,omitempty"` // 晚走晚到规则

	RestTimeRule []*RestRule `json:"rest_time_rule,omitempty"` // 休息规则

	OvertimeRule []*OvertimeRule `json:"overtime_rule,omitempty"` // 打卡规则

	DayType *int `json:"day_type,omitempty"` // 日期类型，【是否弹性打卡 = ture】时，不可设置为“休息日”  可选值：1：工作日 2：休息日	 示例值：（默认值）1

	OvertimeRestTimeRule []*RestRule `json:"overtime_rest_time_rule,omitempty"` // 班外休息规则

	LateMinutesAsSeriousLate *int `json:"late_minutes_as_serious_late,omitempty"` // 晚到多久记为严重迟到（优先级比原有字段高）

	ShiftMiddleTimeRule *ShiftMiddleTimeRule `json:"shift_middle_time_rule,omitempty"` // 半天分割规则

	ShiftAttendanceTimeConfig *ShiftAttendanceTimeConfig `json:"shift_attendance_time_config,omitempty"` // 应出勤配置

	LateOffLateOnSetting *LateOffLateOnSetting `json:"late_off_late_on_setting,omitempty"` // 晚走次日晚到配置规则

	Id *string `json:"id,omitempty"` // 班次id(更新班次时需要传递)

	RestTimeFlexibleConfigs []*RestTimeFlexibleConfig `json:"rest_time_flexible_configs,omitempty"` // 休息弹性设置
}

type QueryShiftResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *QueryShiftRespData `json:"data"` // 业务数据
}

func (resp *QueryShiftResp) Success() bool {
	return resp.Code == 0
}

type CreateUserApprovalReqBodyBuilder struct {
	userApproval     *UserApproval // 审批信息
	userApprovalFlag bool
}

func NewCreateUserApprovalReqBodyBuilder() *CreateUserApprovalReqBodyBuilder {
	builder := &CreateUserApprovalReqBodyBuilder{}
	return builder
}

// 审批信息
//
//示例值：
func (builder *CreateUserApprovalReqBodyBuilder) UserApproval(userApproval *UserApproval) *CreateUserApprovalReqBodyBuilder {
	builder.userApproval = userApproval
	builder.userApprovalFlag = true
	return builder
}

func (builder *CreateUserApprovalReqBodyBuilder) Build() *CreateUserApprovalReqBody {
	req := &CreateUserApprovalReqBody{}
	if builder.userApprovalFlag {
		req.UserApproval = builder.userApproval
	}
	return req
}

type CreateUserApprovalPathReqBodyBuilder struct {
	userApproval     *UserApproval
	userApprovalFlag bool
}

func NewCreateUserApprovalPathReqBodyBuilder() *CreateUserApprovalPathReqBodyBuilder {
	builder := &CreateUserApprovalPathReqBodyBuilder{}
	return builder
}

// 审批信息
//
// 示例值：
func (builder *CreateUserApprovalPathReqBodyBuilder) UserApproval(userApproval *UserApproval) *CreateUserApprovalPathReqBodyBuilder {
	builder.userApproval = userApproval
	builder.userApprovalFlag = true
	return builder
}

func (builder *CreateUserApprovalPathReqBodyBuilder) Build() (*CreateUserApprovalReqBody, error) {
	req := &CreateUserApprovalReqBody{}
	if builder.userApprovalFlag {
		req.UserApproval = builder.userApproval
	}
	return req, nil
}

type CreateUserApprovalReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *CreateUserApprovalReqBody
}

func NewCreateUserApprovalReqBuilder() *CreateUserApprovalReqBuilder {
	builder := &CreateUserApprovalReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 请求体和响应体中的 user_id 的员工工号类型
//
// 示例值：employee_id
func (builder *CreateUserApprovalReqBuilder) EmployeeType(employeeType string) *CreateUserApprovalReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 由于部分企业使用的是自己的审批系统，而不是飞书审批系统，因此员工的请假、加班等数据无法流入到飞书考勤系统中，导致员工在请假时间段内依然收到打卡提醒，并且被记为缺卡。;;对于这些只使用飞书考勤系统，而未使用飞书审批系统的企业，可以通过考勤开放接口的形式，将三方审批结果数据回写到飞书考勤系统中。
func (builder *CreateUserApprovalReqBuilder) Body(body *CreateUserApprovalReqBody) *CreateUserApprovalReqBuilder {
	builder.body = body
	return builder
}

func (builder *CreateUserApprovalReqBuilder) Build() *CreateUserApprovalReq {
	req := &CreateUserApprovalReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type CreateUserApprovalReqBody struct {
	UserApproval *UserApproval `json:"user_approval,omitempty"` // 审批信息
}

type CreateUserApprovalReq struct {
	apiReq *larkcore.ApiReq
	Body   *CreateUserApprovalReqBody `body:""`
}

type CreateUserApprovalRespData struct {
	UserApproval *UserApproval `json:"user_approval,omitempty"` // 审批信息
}

type CreateUserApprovalResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *CreateUserApprovalRespData `json:"data"` // 业务数据
}

func (resp *CreateUserApprovalResp) Success() bool {
	return resp.Code == 0
}

type QueryUserApprovalReqBodyBuilder struct {
	userIds     []string // employee_no 或 employee_id 列表
	userIdsFlag bool

	checkDateFrom     int // 查询的起始工作日
	checkDateFromFlag bool

	checkDateTo     int // 查询的结束工作日，与 check_date_from 的时间间隔不超过 30 天
	checkDateToFlag bool

	checkDateType     string // 查询依据的时间类型（不填默认依据PeriodTime）
	checkDateTypeFlag bool

	status     int // 查询状态（不填默认查询已通过状态）
	statusFlag bool

	checkTimeFrom     string // 查询的起始时间，精确到秒的时间戳
	checkTimeFromFlag bool

	checkTimeTo     string // 查询的结束时间，精确到秒的时间戳
	checkTimeToFlag bool
}

func NewQueryUserApprovalReqBodyBuilder() *QueryUserApprovalReqBodyBuilder {
	builder := &QueryUserApprovalReqBodyBuilder{}
	return builder
}

// employee_no 或 employee_id 列表
//
//示例值：["abd754f7"]
func (builder *QueryUserApprovalReqBodyBuilder) UserIds(userIds []string) *QueryUserApprovalReqBodyBuilder {
	builder.userIds = userIds
	builder.userIdsFlag = true
	return builder
}

// 查询的起始工作日
//
//示例值：20190817
func (builder *QueryUserApprovalReqBodyBuilder) CheckDateFrom(checkDateFrom int) *QueryUserApprovalReqBodyBuilder {
	builder.checkDateFrom = checkDateFrom
	builder.checkDateFromFlag = true
	return builder
}

// 查询的结束工作日，与 check_date_from 的时间间隔不超过 30 天
//
//示例值：20190820
func (builder *QueryUserApprovalReqBodyBuilder) CheckDateTo(checkDateTo int) *QueryUserApprovalReqBodyBuilder {
	builder.checkDateTo = checkDateTo
	builder.checkDateToFlag = true
	return builder
}

// 查询依据的时间类型（不填默认依据PeriodTime）
//
//示例值：PeriodTime
func (builder *QueryUserApprovalReqBodyBuilder) CheckDateType(checkDateType string) *QueryUserApprovalReqBodyBuilder {
	builder.checkDateType = checkDateType
	builder.checkDateTypeFlag = true
	return builder
}

// 查询状态（不填默认查询已通过状态）
//
//示例值：2
func (builder *QueryUserApprovalReqBodyBuilder) Status(status int) *QueryUserApprovalReqBodyBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

// 查询的起始时间，精确到秒的时间戳
//
//示例值：1566641088
func (builder *QueryUserApprovalReqBodyBuilder) CheckTimeFrom(checkTimeFrom string) *QueryUserApprovalReqBodyBuilder {
	builder.checkTimeFrom = checkTimeFrom
	builder.checkTimeFromFlag = true
	return builder
}

// 查询的结束时间，精确到秒的时间戳
//
//示例值：1592561088
func (builder *QueryUserApprovalReqBodyBuilder) CheckTimeTo(checkTimeTo string) *QueryUserApprovalReqBodyBuilder {
	builder.checkTimeTo = checkTimeTo
	builder.checkTimeToFlag = true
	return builder
}

func (builder *QueryUserApprovalReqBodyBuilder) Build() *QueryUserApprovalReqBody {
	req := &QueryUserApprovalReqBody{}
	if builder.userIdsFlag {
		req.UserIds = builder.userIds
	}
	if builder.checkDateFromFlag {
		req.CheckDateFrom = &builder.checkDateFrom
	}
	if builder.checkDateToFlag {
		req.CheckDateTo = &builder.checkDateTo
	}
	if builder.checkDateTypeFlag {
		req.CheckDateType = &builder.checkDateType
	}
	if builder.statusFlag {
		req.Status = &builder.status
	}
	if builder.checkTimeFromFlag {
		req.CheckTimeFrom = &builder.checkTimeFrom
	}
	if builder.checkTimeToFlag {
		req.CheckTimeTo = &builder.checkTimeTo
	}
	return req
}

type QueryUserApprovalPathReqBodyBuilder struct {
	userIds           []string
	userIdsFlag       bool
	checkDateFrom     int
	checkDateFromFlag bool
	checkDateTo       int
	checkDateToFlag   bool
	checkDateType     string
	checkDateTypeFlag bool
	status            int
	statusFlag        bool
	checkTimeFrom     string
	checkTimeFromFlag bool
	checkTimeTo       string
	checkTimeToFlag   bool
}

func NewQueryUserApprovalPathReqBodyBuilder() *QueryUserApprovalPathReqBodyBuilder {
	builder := &QueryUserApprovalPathReqBodyBuilder{}
	return builder
}

// employee_no 或 employee_id 列表
//
// 示例值：["abd754f7"]
func (builder *QueryUserApprovalPathReqBodyBuilder) UserIds(userIds []string) *QueryUserApprovalPathReqBodyBuilder {
	builder.userIds = userIds
	builder.userIdsFlag = true
	return builder
}

// 查询的起始工作日
//
// 示例值：20190817
func (builder *QueryUserApprovalPathReqBodyBuilder) CheckDateFrom(checkDateFrom int) *QueryUserApprovalPathReqBodyBuilder {
	builder.checkDateFrom = checkDateFrom
	builder.checkDateFromFlag = true
	return builder
}

// 查询的结束工作日，与 check_date_from 的时间间隔不超过 30 天
//
// 示例值：20190820
func (builder *QueryUserApprovalPathReqBodyBuilder) CheckDateTo(checkDateTo int) *QueryUserApprovalPathReqBodyBuilder {
	builder.checkDateTo = checkDateTo
	builder.checkDateToFlag = true
	return builder
}

// 查询依据的时间类型（不填默认依据PeriodTime）
//
// 示例值：PeriodTime
func (builder *QueryUserApprovalPathReqBodyBuilder) CheckDateType(checkDateType string) *QueryUserApprovalPathReqBodyBuilder {
	builder.checkDateType = checkDateType
	builder.checkDateTypeFlag = true
	return builder
}

// 查询状态（不填默认查询已通过状态）
//
// 示例值：2
func (builder *QueryUserApprovalPathReqBodyBuilder) Status(status int) *QueryUserApprovalPathReqBodyBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

// 查询的起始时间，精确到秒的时间戳
//
// 示例值：1566641088
func (builder *QueryUserApprovalPathReqBodyBuilder) CheckTimeFrom(checkTimeFrom string) *QueryUserApprovalPathReqBodyBuilder {
	builder.checkTimeFrom = checkTimeFrom
	builder.checkTimeFromFlag = true
	return builder
}

// 查询的结束时间，精确到秒的时间戳
//
// 示例值：1592561088
func (builder *QueryUserApprovalPathReqBodyBuilder) CheckTimeTo(checkTimeTo string) *QueryUserApprovalPathReqBodyBuilder {
	builder.checkTimeTo = checkTimeTo
	builder.checkTimeToFlag = true
	return builder
}

func (builder *QueryUserApprovalPathReqBodyBuilder) Build() (*QueryUserApprovalReqBody, error) {
	req := &QueryUserApprovalReqBody{}
	if builder.userIdsFlag {
		req.UserIds = builder.userIds
	}
	if builder.checkDateFromFlag {
		req.CheckDateFrom = &builder.checkDateFrom
	}
	if builder.checkDateToFlag {
		req.CheckDateTo = &builder.checkDateTo
	}
	if builder.checkDateTypeFlag {
		req.CheckDateType = &builder.checkDateType
	}
	if builder.statusFlag {
		req.Status = &builder.status
	}
	if builder.checkTimeFromFlag {
		req.CheckTimeFrom = &builder.checkTimeFrom
	}
	if builder.checkTimeToFlag {
		req.CheckTimeTo = &builder.checkTimeTo
	}
	return req, nil
}

type QueryUserApprovalReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *QueryUserApprovalReqBody
}

func NewQueryUserApprovalReqBuilder() *QueryUserApprovalReqBuilder {
	builder := &QueryUserApprovalReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 请求体中的 user_ids 和响应体中的 user_id 的员工工号类型
//
// 示例值：employee_id
func (builder *QueryUserApprovalReqBuilder) EmployeeType(employeeType string) *QueryUserApprovalReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 获取员工在某段时间内的请假、加班、外出和出差四种审批的通过数据。
func (builder *QueryUserApprovalReqBuilder) Body(body *QueryUserApprovalReqBody) *QueryUserApprovalReqBuilder {
	builder.body = body
	return builder
}

func (builder *QueryUserApprovalReqBuilder) Build() *QueryUserApprovalReq {
	req := &QueryUserApprovalReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type QueryUserApprovalReqBody struct {
	UserIds []string `json:"user_ids,omitempty"` // employee_no 或 employee_id 列表

	CheckDateFrom *int `json:"check_date_from,omitempty"` // 查询的起始工作日

	CheckDateTo *int `json:"check_date_to,omitempty"` // 查询的结束工作日，与 check_date_from 的时间间隔不超过 30 天

	CheckDateType *string `json:"check_date_type,omitempty"` // 查询依据的时间类型（不填默认依据PeriodTime）

	Status *int `json:"status,omitempty"` // 查询状态（不填默认查询已通过状态）

	CheckTimeFrom *string `json:"check_time_from,omitempty"` // 查询的起始时间，精确到秒的时间戳

	CheckTimeTo *string `json:"check_time_to,omitempty"` // 查询的结束时间，精确到秒的时间戳
}

type QueryUserApprovalReq struct {
	apiReq *larkcore.ApiReq
	Body   *QueryUserApprovalReqBody `body:""`
}

type QueryUserApprovalRespData struct {
	UserApprovals []*UserApproval `json:"user_approvals,omitempty"` // 审批结果列表
}

type QueryUserApprovalResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *QueryUserApprovalRespData `json:"data"` // 业务数据
}

func (resp *QueryUserApprovalResp) Success() bool {
	return resp.Code == 0
}

type BatchCreateUserDailyShiftReqBodyBuilder struct {
	userDailyShifts     []*UserDailyShift // 班表信息列表（数量限制50以内）
	userDailyShiftsFlag bool

	operatorId     string // 操作人uid，如果您未操作[考勤管理后台“API 接入”流程](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/attendance-development-guidelines)，则此字段为必填字段
	operatorIdFlag bool
}

func NewBatchCreateUserDailyShiftReqBodyBuilder() *BatchCreateUserDailyShiftReqBodyBuilder {
	builder := &BatchCreateUserDailyShiftReqBodyBuilder{}
	return builder
}

// 班表信息列表（数量限制50以内）
//
//示例值：
func (builder *BatchCreateUserDailyShiftReqBodyBuilder) UserDailyShifts(userDailyShifts []*UserDailyShift) *BatchCreateUserDailyShiftReqBodyBuilder {
	builder.userDailyShifts = userDailyShifts
	builder.userDailyShiftsFlag = true
	return builder
}

// 操作人uid，如果您未操作[考勤管理后台“API 接入”流程](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/attendance-development-guidelines)，则此字段为必填字段
//
//示例值：dd31248a
func (builder *BatchCreateUserDailyShiftReqBodyBuilder) OperatorId(operatorId string) *BatchCreateUserDailyShiftReqBodyBuilder {
	builder.operatorId = operatorId
	builder.operatorIdFlag = true
	return builder
}

func (builder *BatchCreateUserDailyShiftReqBodyBuilder) Build() *BatchCreateUserDailyShiftReqBody {
	req := &BatchCreateUserDailyShiftReqBody{}
	if builder.userDailyShiftsFlag {
		req.UserDailyShifts = builder.userDailyShifts
	}
	if builder.operatorIdFlag {
		req.OperatorId = &builder.operatorId
	}
	return req
}

type BatchCreateUserDailyShiftPathReqBodyBuilder struct {
	userDailyShifts     []*UserDailyShift
	userDailyShiftsFlag bool
	operatorId          string
	operatorIdFlag      bool
}

func NewBatchCreateUserDailyShiftPathReqBodyBuilder() *BatchCreateUserDailyShiftPathReqBodyBuilder {
	builder := &BatchCreateUserDailyShiftPathReqBodyBuilder{}
	return builder
}

// 班表信息列表（数量限制50以内）
//
// 示例值：
func (builder *BatchCreateUserDailyShiftPathReqBodyBuilder) UserDailyShifts(userDailyShifts []*UserDailyShift) *BatchCreateUserDailyShiftPathReqBodyBuilder {
	builder.userDailyShifts = userDailyShifts
	builder.userDailyShiftsFlag = true
	return builder
}

// 操作人uid，如果您未操作[考勤管理后台“API 接入”流程](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/attendance-development-guidelines)，则此字段为必填字段
//
// 示例值：dd31248a
func (builder *BatchCreateUserDailyShiftPathReqBodyBuilder) OperatorId(operatorId string) *BatchCreateUserDailyShiftPathReqBodyBuilder {
	builder.operatorId = operatorId
	builder.operatorIdFlag = true
	return builder
}

func (builder *BatchCreateUserDailyShiftPathReqBodyBuilder) Build() (*BatchCreateUserDailyShiftReqBody, error) {
	req := &BatchCreateUserDailyShiftReqBody{}
	if builder.userDailyShiftsFlag {
		req.UserDailyShifts = builder.userDailyShifts
	}
	if builder.operatorIdFlag {
		req.OperatorId = &builder.operatorId
	}
	return req, nil
}

type BatchCreateUserDailyShiftReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *BatchCreateUserDailyShiftReqBody
}

func NewBatchCreateUserDailyShiftReqBuilder() *BatchCreateUserDailyShiftReqBuilder {
	builder := &BatchCreateUserDailyShiftReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 请求体和响应体中的 user_id 的员工工号类型
//
// 示例值：employee_id
func (builder *BatchCreateUserDailyShiftReqBuilder) EmployeeType(employeeType string) *BatchCreateUserDailyShiftReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 班表是用来描述考勤组内人员每天按哪个班次进行上班。目前班表支持按一个整月对一位或多位人员进行排班。
func (builder *BatchCreateUserDailyShiftReqBuilder) Body(body *BatchCreateUserDailyShiftReqBody) *BatchCreateUserDailyShiftReqBuilder {
	builder.body = body
	return builder
}

func (builder *BatchCreateUserDailyShiftReqBuilder) Build() *BatchCreateUserDailyShiftReq {
	req := &BatchCreateUserDailyShiftReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type BatchCreateUserDailyShiftReqBody struct {
	UserDailyShifts []*UserDailyShift `json:"user_daily_shifts,omitempty"` // 班表信息列表（数量限制50以内）

	OperatorId *string `json:"operator_id,omitempty"` // 操作人uid，如果您未操作[考勤管理后台“API 接入”流程](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/attendance-development-guidelines)，则此字段为必填字段
}

type BatchCreateUserDailyShiftReq struct {
	apiReq *larkcore.ApiReq
	Body   *BatchCreateUserDailyShiftReqBody `body:""`
}

type BatchCreateUserDailyShiftRespData struct {
	UserDailyShifts []*UserDailyShift `json:"user_daily_shifts,omitempty"` // 班表信息列表
}

type BatchCreateUserDailyShiftResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *BatchCreateUserDailyShiftRespData `json:"data"` // 业务数据
}

func (resp *BatchCreateUserDailyShiftResp) Success() bool {
	return resp.Code == 0
}

type BatchCreateTempUserDailyShiftReqBodyBuilder struct {
	userTmpDailyShifts     []*UserTmpDailyShift // 临时班表信息列表（数量限制50以内）
	userTmpDailyShiftsFlag bool

	operatorId     string // 操作人uid
	operatorIdFlag bool
}

func NewBatchCreateTempUserDailyShiftReqBodyBuilder() *BatchCreateTempUserDailyShiftReqBodyBuilder {
	builder := &BatchCreateTempUserDailyShiftReqBodyBuilder{}
	return builder
}

// 临时班表信息列表（数量限制50以内）
//
//示例值：
func (builder *BatchCreateTempUserDailyShiftReqBodyBuilder) UserTmpDailyShifts(userTmpDailyShifts []*UserTmpDailyShift) *BatchCreateTempUserDailyShiftReqBodyBuilder {
	builder.userTmpDailyShifts = userTmpDailyShifts
	builder.userTmpDailyShiftsFlag = true
	return builder
}

// 操作人uid
//
//示例值：dd31248a
func (builder *BatchCreateTempUserDailyShiftReqBodyBuilder) OperatorId(operatorId string) *BatchCreateTempUserDailyShiftReqBodyBuilder {
	builder.operatorId = operatorId
	builder.operatorIdFlag = true
	return builder
}

func (builder *BatchCreateTempUserDailyShiftReqBodyBuilder) Build() *BatchCreateTempUserDailyShiftReqBody {
	req := &BatchCreateTempUserDailyShiftReqBody{}
	if builder.userTmpDailyShiftsFlag {
		req.UserTmpDailyShifts = builder.userTmpDailyShifts
	}
	if builder.operatorIdFlag {
		req.OperatorId = &builder.operatorId
	}
	return req
}

type BatchCreateTempUserDailyShiftPathReqBodyBuilder struct {
	userTmpDailyShifts     []*UserTmpDailyShift
	userTmpDailyShiftsFlag bool
	operatorId             string
	operatorIdFlag         bool
}

func NewBatchCreateTempUserDailyShiftPathReqBodyBuilder() *BatchCreateTempUserDailyShiftPathReqBodyBuilder {
	builder := &BatchCreateTempUserDailyShiftPathReqBodyBuilder{}
	return builder
}

// 临时班表信息列表（数量限制50以内）
//
// 示例值：
func (builder *BatchCreateTempUserDailyShiftPathReqBodyBuilder) UserTmpDailyShifts(userTmpDailyShifts []*UserTmpDailyShift) *BatchCreateTempUserDailyShiftPathReqBodyBuilder {
	builder.userTmpDailyShifts = userTmpDailyShifts
	builder.userTmpDailyShiftsFlag = true
	return builder
}

// 操作人uid
//
// 示例值：dd31248a
func (builder *BatchCreateTempUserDailyShiftPathReqBodyBuilder) OperatorId(operatorId string) *BatchCreateTempUserDailyShiftPathReqBodyBuilder {
	builder.operatorId = operatorId
	builder.operatorIdFlag = true
	return builder
}

func (builder *BatchCreateTempUserDailyShiftPathReqBodyBuilder) Build() (*BatchCreateTempUserDailyShiftReqBody, error) {
	req := &BatchCreateTempUserDailyShiftReqBody{}
	if builder.userTmpDailyShiftsFlag {
		req.UserTmpDailyShifts = builder.userTmpDailyShifts
	}
	if builder.operatorIdFlag {
		req.OperatorId = &builder.operatorId
	}
	return req, nil
}

type BatchCreateTempUserDailyShiftReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *BatchCreateTempUserDailyShiftReqBody
}

func NewBatchCreateTempUserDailyShiftReqBuilder() *BatchCreateTempUserDailyShiftReqBuilder {
	builder := &BatchCreateTempUserDailyShiftReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 请求体和响应体中的 user_id 的员工工号类型
//
// 示例值：employee_id
func (builder *BatchCreateTempUserDailyShiftReqBuilder) EmployeeType(employeeType string) *BatchCreateTempUserDailyShiftReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

//
func (builder *BatchCreateTempUserDailyShiftReqBuilder) Body(body *BatchCreateTempUserDailyShiftReqBody) *BatchCreateTempUserDailyShiftReqBuilder {
	builder.body = body
	return builder
}

func (builder *BatchCreateTempUserDailyShiftReqBuilder) Build() *BatchCreateTempUserDailyShiftReq {
	req := &BatchCreateTempUserDailyShiftReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type BatchCreateTempUserDailyShiftReqBody struct {
	UserTmpDailyShifts []*UserTmpDailyShift `json:"user_tmp_daily_shifts,omitempty"` // 临时班表信息列表（数量限制50以内）

	OperatorId *string `json:"operator_id,omitempty"` // 操作人uid
}

type BatchCreateTempUserDailyShiftReq struct {
	apiReq *larkcore.ApiReq
	Body   *BatchCreateTempUserDailyShiftReqBody `body:""`
}

type BatchCreateTempUserDailyShiftRespData struct {
	UserTmpDailyShifts []*UserTmpDailyShift `json:"user_tmp_daily_shifts,omitempty"` // 临时班表信息列表
}

type BatchCreateTempUserDailyShiftResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *BatchCreateTempUserDailyShiftRespData `json:"data"` // 业务数据
}

func (resp *BatchCreateTempUserDailyShiftResp) Success() bool {
	return resp.Code == 0
}

type QueryUserDailyShiftReqBodyBuilder struct {
	userIds     []string // employee_no 或 employee_id 列表
	userIdsFlag bool

	checkDateFrom     int // 查询的起始工作日
	checkDateFromFlag bool

	checkDateTo     int // 查询的结束工作日
	checkDateToFlag bool
}

func NewQueryUserDailyShiftReqBodyBuilder() *QueryUserDailyShiftReqBodyBuilder {
	builder := &QueryUserDailyShiftReqBodyBuilder{}
	return builder
}

// employee_no 或 employee_id 列表
//
//示例值：["abd754f7"]
func (builder *QueryUserDailyShiftReqBodyBuilder) UserIds(userIds []string) *QueryUserDailyShiftReqBodyBuilder {
	builder.userIds = userIds
	builder.userIdsFlag = true
	return builder
}

// 查询的起始工作日
//
//示例值：20190817
func (builder *QueryUserDailyShiftReqBodyBuilder) CheckDateFrom(checkDateFrom int) *QueryUserDailyShiftReqBodyBuilder {
	builder.checkDateFrom = checkDateFrom
	builder.checkDateFromFlag = true
	return builder
}

// 查询的结束工作日
//
//示例值：20190820
func (builder *QueryUserDailyShiftReqBodyBuilder) CheckDateTo(checkDateTo int) *QueryUserDailyShiftReqBodyBuilder {
	builder.checkDateTo = checkDateTo
	builder.checkDateToFlag = true
	return builder
}

func (builder *QueryUserDailyShiftReqBodyBuilder) Build() *QueryUserDailyShiftReqBody {
	req := &QueryUserDailyShiftReqBody{}
	if builder.userIdsFlag {
		req.UserIds = builder.userIds
	}
	if builder.checkDateFromFlag {
		req.CheckDateFrom = &builder.checkDateFrom
	}
	if builder.checkDateToFlag {
		req.CheckDateTo = &builder.checkDateTo
	}
	return req
}

type QueryUserDailyShiftPathReqBodyBuilder struct {
	userIds           []string
	userIdsFlag       bool
	checkDateFrom     int
	checkDateFromFlag bool
	checkDateTo       int
	checkDateToFlag   bool
}

func NewQueryUserDailyShiftPathReqBodyBuilder() *QueryUserDailyShiftPathReqBodyBuilder {
	builder := &QueryUserDailyShiftPathReqBodyBuilder{}
	return builder
}

// employee_no 或 employee_id 列表
//
// 示例值：["abd754f7"]
func (builder *QueryUserDailyShiftPathReqBodyBuilder) UserIds(userIds []string) *QueryUserDailyShiftPathReqBodyBuilder {
	builder.userIds = userIds
	builder.userIdsFlag = true
	return builder
}

// 查询的起始工作日
//
// 示例值：20190817
func (builder *QueryUserDailyShiftPathReqBodyBuilder) CheckDateFrom(checkDateFrom int) *QueryUserDailyShiftPathReqBodyBuilder {
	builder.checkDateFrom = checkDateFrom
	builder.checkDateFromFlag = true
	return builder
}

// 查询的结束工作日
//
// 示例值：20190820
func (builder *QueryUserDailyShiftPathReqBodyBuilder) CheckDateTo(checkDateTo int) *QueryUserDailyShiftPathReqBodyBuilder {
	builder.checkDateTo = checkDateTo
	builder.checkDateToFlag = true
	return builder
}

func (builder *QueryUserDailyShiftPathReqBodyBuilder) Build() (*QueryUserDailyShiftReqBody, error) {
	req := &QueryUserDailyShiftReqBody{}
	if builder.userIdsFlag {
		req.UserIds = builder.userIds
	}
	if builder.checkDateFromFlag {
		req.CheckDateFrom = &builder.checkDateFrom
	}
	if builder.checkDateToFlag {
		req.CheckDateTo = &builder.checkDateTo
	}
	return req, nil
}

type QueryUserDailyShiftReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *QueryUserDailyShiftReqBody
}

func NewQueryUserDailyShiftReqBuilder() *QueryUserDailyShiftReqBuilder {
	builder := &QueryUserDailyShiftReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 请求体中的 user_ids 和响应体中的 user_id 的员工工号类型
//
// 示例值：employee_id
func (builder *QueryUserDailyShiftReqBuilder) EmployeeType(employeeType string) *QueryUserDailyShiftReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 支持查询多个用户的排班情况，查询的时间跨度不能超过 30 天。
func (builder *QueryUserDailyShiftReqBuilder) Body(body *QueryUserDailyShiftReqBody) *QueryUserDailyShiftReqBuilder {
	builder.body = body
	return builder
}

func (builder *QueryUserDailyShiftReqBuilder) Build() *QueryUserDailyShiftReq {
	req := &QueryUserDailyShiftReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type QueryUserDailyShiftReqBody struct {
	UserIds []string `json:"user_ids,omitempty"` // employee_no 或 employee_id 列表

	CheckDateFrom *int `json:"check_date_from,omitempty"` // 查询的起始工作日

	CheckDateTo *int `json:"check_date_to,omitempty"` // 查询的结束工作日
}

type QueryUserDailyShiftReq struct {
	apiReq *larkcore.ApiReq
	Body   *QueryUserDailyShiftReqBody `body:""`
}

type QueryUserDailyShiftRespData struct {
	UserDailyShifts []*UserDailyShift `json:"user_daily_shifts,omitempty"` // 班表信息列表
}

type QueryUserDailyShiftResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *QueryUserDailyShiftRespData `json:"data"` // 业务数据
}

func (resp *QueryUserDailyShiftResp) Success() bool {
	return resp.Code == 0
}

type BatchCreateUserFlowReqBodyBuilder struct {
	flowRecords     []*UserFlow // 打卡流水记录列表(数量限制50)
	flowRecordsFlag bool
}

func NewBatchCreateUserFlowReqBodyBuilder() *BatchCreateUserFlowReqBodyBuilder {
	builder := &BatchCreateUserFlowReqBodyBuilder{}
	return builder
}

// 打卡流水记录列表(数量限制50)
//
//示例值：
func (builder *BatchCreateUserFlowReqBodyBuilder) FlowRecords(flowRecords []*UserFlow) *BatchCreateUserFlowReqBodyBuilder {
	builder.flowRecords = flowRecords
	builder.flowRecordsFlag = true
	return builder
}

func (builder *BatchCreateUserFlowReqBodyBuilder) Build() *BatchCreateUserFlowReqBody {
	req := &BatchCreateUserFlowReqBody{}
	if builder.flowRecordsFlag {
		req.FlowRecords = builder.flowRecords
	}
	return req
}

type BatchCreateUserFlowPathReqBodyBuilder struct {
	flowRecords     []*UserFlow
	flowRecordsFlag bool
}

func NewBatchCreateUserFlowPathReqBodyBuilder() *BatchCreateUserFlowPathReqBodyBuilder {
	builder := &BatchCreateUserFlowPathReqBodyBuilder{}
	return builder
}

// 打卡流水记录列表(数量限制50)
//
// 示例值：
func (builder *BatchCreateUserFlowPathReqBodyBuilder) FlowRecords(flowRecords []*UserFlow) *BatchCreateUserFlowPathReqBodyBuilder {
	builder.flowRecords = flowRecords
	builder.flowRecordsFlag = true
	return builder
}

func (builder *BatchCreateUserFlowPathReqBodyBuilder) Build() (*BatchCreateUserFlowReqBody, error) {
	req := &BatchCreateUserFlowReqBody{}
	if builder.flowRecordsFlag {
		req.FlowRecords = builder.flowRecords
	}
	return req, nil
}

type BatchCreateUserFlowReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *BatchCreateUserFlowReqBody
}

func NewBatchCreateUserFlowReqBuilder() *BatchCreateUserFlowReqBuilder {
	builder := &BatchCreateUserFlowReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 请求体和响应体中的 user_id 和 creator_id 的员工工号类型
//
// 示例值：employee_id
func (builder *BatchCreateUserFlowReqBuilder) EmployeeType(employeeType string) *BatchCreateUserFlowReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 导入授权内员工的打卡流水记录。导入后，会根据员工所在的考勤组班次规则，计算最终的打卡状态与结果。
func (builder *BatchCreateUserFlowReqBuilder) Body(body *BatchCreateUserFlowReqBody) *BatchCreateUserFlowReqBuilder {
	builder.body = body
	return builder
}

func (builder *BatchCreateUserFlowReqBuilder) Build() *BatchCreateUserFlowReq {
	req := &BatchCreateUserFlowReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type BatchCreateUserFlowReqBody struct {
	FlowRecords []*UserFlow `json:"flow_records,omitempty"` // 打卡流水记录列表(数量限制50)
}

type BatchCreateUserFlowReq struct {
	apiReq *larkcore.ApiReq
	Body   *BatchCreateUserFlowReqBody `body:""`
}

type BatchCreateUserFlowRespData struct {
	FlowRecords []*UserFlow `json:"flow_records,omitempty"` // 打卡流水记录列表
}

type BatchCreateUserFlowResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *BatchCreateUserFlowRespData `json:"data"` // 业务数据
}

func (resp *BatchCreateUserFlowResp) Success() bool {
	return resp.Code == 0
}

type BatchDelUserFlowReqBodyBuilder struct {
	recordIds     []string // 流水记录ID
	recordIdsFlag bool
}

func NewBatchDelUserFlowReqBodyBuilder() *BatchDelUserFlowReqBodyBuilder {
	builder := &BatchDelUserFlowReqBodyBuilder{}
	return builder
}

// 流水记录ID
//
//示例值：
func (builder *BatchDelUserFlowReqBodyBuilder) RecordIds(recordIds []string) *BatchDelUserFlowReqBodyBuilder {
	builder.recordIds = recordIds
	builder.recordIdsFlag = true
	return builder
}

func (builder *BatchDelUserFlowReqBodyBuilder) Build() *BatchDelUserFlowReqBody {
	req := &BatchDelUserFlowReqBody{}
	if builder.recordIdsFlag {
		req.RecordIds = builder.recordIds
	}
	return req
}

type BatchDelUserFlowPathReqBodyBuilder struct {
	recordIds     []string
	recordIdsFlag bool
}

func NewBatchDelUserFlowPathReqBodyBuilder() *BatchDelUserFlowPathReqBodyBuilder {
	builder := &BatchDelUserFlowPathReqBodyBuilder{}
	return builder
}

// 流水记录ID
//
// 示例值：
func (builder *BatchDelUserFlowPathReqBodyBuilder) RecordIds(recordIds []string) *BatchDelUserFlowPathReqBodyBuilder {
	builder.recordIds = recordIds
	builder.recordIdsFlag = true
	return builder
}

func (builder *BatchDelUserFlowPathReqBodyBuilder) Build() (*BatchDelUserFlowReqBody, error) {
	req := &BatchDelUserFlowReqBody{}
	if builder.recordIdsFlag {
		req.RecordIds = builder.recordIds
	}
	return req, nil
}

type BatchDelUserFlowReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *BatchDelUserFlowReqBody
}

func NewBatchDelUserFlowReqBuilder() *BatchDelUserFlowReqBuilder {
	builder := &BatchDelUserFlowReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 批量删除流水
func (builder *BatchDelUserFlowReqBuilder) Body(body *BatchDelUserFlowReqBody) *BatchDelUserFlowReqBuilder {
	builder.body = body
	return builder
}

func (builder *BatchDelUserFlowReqBuilder) Build() *BatchDelUserFlowReq {
	req := &BatchDelUserFlowReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.Body = builder.body
	return req
}

type BatchDelUserFlowReqBody struct {
	RecordIds []string `json:"record_ids,omitempty"` // 流水记录ID
}

type BatchDelUserFlowReq struct {
	apiReq *larkcore.ApiReq
	Body   *BatchDelUserFlowReqBody `body:""`
}

type BatchDelUserFlowRespData struct {
	SuccessRecordIds []string `json:"success_record_ids,omitempty"` // 删除成功的流水记录ID列表

	FailRecordIds []string `json:"fail_record_ids,omitempty"` // 删除失败的流水记录ID列表
}

type BatchDelUserFlowResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *BatchDelUserFlowRespData `json:"data"` // 业务数据
}

func (resp *BatchDelUserFlowResp) Success() bool {
	return resp.Code == 0
}

type GetUserFlowReqBuilder struct {
	apiReq *larkcore.ApiReq
}

func NewGetUserFlowReqBuilder() *GetUserFlowReqBuilder {
	builder := &GetUserFlowReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 打卡流水记录 ID，获取方式：1）[批量查询打卡流水记录](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_flow/query) 2）[获取打卡结果](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_task/query) 3）[导入打卡流水记录](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_flow/batch_create)
//
// 示例值：6708236686834352397
func (builder *GetUserFlowReqBuilder) UserFlowId(userFlowId string) *GetUserFlowReqBuilder {
	builder.apiReq.PathParams.Set("user_flow_id", fmt.Sprint(userFlowId))
	return builder
}

// 响应体中的 user_id 和 creator_id 的员工工号类型
//
// 示例值：employee_id
func (builder *GetUserFlowReqBuilder) EmployeeType(employeeType string) *GetUserFlowReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

func (builder *GetUserFlowReqBuilder) Build() *GetUserFlowReq {
	req := &GetUserFlowReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type GetUserFlowReq struct {
	apiReq *larkcore.ApiReq
}

type GetUserFlowRespData struct {
	UserId *string `json:"user_id,omitempty"` // 用户工号

	CreatorId *string `json:"creator_id,omitempty"` // 记录创建者的工号

	LocationName *string `json:"location_name,omitempty"` // 打卡位置名称信息

	CheckTime *string `json:"check_time,omitempty"` // 打卡时间，精确到秒的时间戳

	Comment *string `json:"comment,omitempty"` // 打卡备注

	RecordId *string `json:"record_id,omitempty"` // 打卡记录ID

	Longitude *float64 `json:"longitude,omitempty"` // 打卡经度

	Latitude *float64 `json:"latitude,omitempty"` // 打卡纬度

	Ssid *string `json:"ssid,omitempty"` // 打卡wifi ssid

	Bssid *string `json:"bssid,omitempty"` // 打卡wifi MAC地址

	IsField *bool `json:"is_field,omitempty"` // 是否为外勤打卡

	IsWifi *bool `json:"is_wifi,omitempty"` // 是否为wifi打卡

	Type *int `json:"type,omitempty"` // 记录生成方式

	PhotoUrls []string `json:"photo_urls,omitempty"` // 打卡照片列表

	DeviceId *string `json:"device_id,omitempty"` // 打卡设备ID

	CheckResult *string `json:"check_result,omitempty"` // 打卡结果

	ExternalId *string `json:"external_id,omitempty"` // 用户导入的外部打卡记录ID

	IdempotentId *string `json:"idempotent_id,omitempty"` // 唯一幂等键

	CreateTime *string `json:"create_time,omitempty"` // 创建时间
}

type GetUserFlowResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *GetUserFlowRespData `json:"data"` // 业务数据
}

func (resp *GetUserFlowResp) Success() bool {
	return resp.Code == 0
}

type QueryUserFlowReqBodyBuilder struct {
	userIds     []string // employee_no 或 employee_id 列表，长度不超过 50
	userIdsFlag bool

	checkTimeFrom     string // 查询的起始时间，时间戳
	checkTimeFromFlag bool

	checkTimeTo     string // 查询的结束时间，时间戳
	checkTimeToFlag bool
}

func NewQueryUserFlowReqBodyBuilder() *QueryUserFlowReqBodyBuilder {
	builder := &QueryUserFlowReqBodyBuilder{}
	return builder
}

// employee_no 或 employee_id 列表，长度不超过 50
//
//示例值：[ "abd754f7"]
func (builder *QueryUserFlowReqBodyBuilder) UserIds(userIds []string) *QueryUserFlowReqBodyBuilder {
	builder.userIds = userIds
	builder.userIdsFlag = true
	return builder
}

// 查询的起始时间，时间戳
//
//示例值：1566641088
func (builder *QueryUserFlowReqBodyBuilder) CheckTimeFrom(checkTimeFrom string) *QueryUserFlowReqBodyBuilder {
	builder.checkTimeFrom = checkTimeFrom
	builder.checkTimeFromFlag = true
	return builder
}

// 查询的结束时间，时间戳
//
//示例值：1566641088
func (builder *QueryUserFlowReqBodyBuilder) CheckTimeTo(checkTimeTo string) *QueryUserFlowReqBodyBuilder {
	builder.checkTimeTo = checkTimeTo
	builder.checkTimeToFlag = true
	return builder
}

func (builder *QueryUserFlowReqBodyBuilder) Build() *QueryUserFlowReqBody {
	req := &QueryUserFlowReqBody{}
	if builder.userIdsFlag {
		req.UserIds = builder.userIds
	}
	if builder.checkTimeFromFlag {
		req.CheckTimeFrom = &builder.checkTimeFrom
	}
	if builder.checkTimeToFlag {
		req.CheckTimeTo = &builder.checkTimeTo
	}
	return req
}

type QueryUserFlowPathReqBodyBuilder struct {
	userIds           []string
	userIdsFlag       bool
	checkTimeFrom     string
	checkTimeFromFlag bool
	checkTimeTo       string
	checkTimeToFlag   bool
}

func NewQueryUserFlowPathReqBodyBuilder() *QueryUserFlowPathReqBodyBuilder {
	builder := &QueryUserFlowPathReqBodyBuilder{}
	return builder
}

// employee_no 或 employee_id 列表，长度不超过 50
//
// 示例值：[ "abd754f7"]
func (builder *QueryUserFlowPathReqBodyBuilder) UserIds(userIds []string) *QueryUserFlowPathReqBodyBuilder {
	builder.userIds = userIds
	builder.userIdsFlag = true
	return builder
}

// 查询的起始时间，时间戳
//
// 示例值：1566641088
func (builder *QueryUserFlowPathReqBodyBuilder) CheckTimeFrom(checkTimeFrom string) *QueryUserFlowPathReqBodyBuilder {
	builder.checkTimeFrom = checkTimeFrom
	builder.checkTimeFromFlag = true
	return builder
}

// 查询的结束时间，时间戳
//
// 示例值：1566641088
func (builder *QueryUserFlowPathReqBodyBuilder) CheckTimeTo(checkTimeTo string) *QueryUserFlowPathReqBodyBuilder {
	builder.checkTimeTo = checkTimeTo
	builder.checkTimeToFlag = true
	return builder
}

func (builder *QueryUserFlowPathReqBodyBuilder) Build() (*QueryUserFlowReqBody, error) {
	req := &QueryUserFlowReqBody{}
	if builder.userIdsFlag {
		req.UserIds = builder.userIds
	}
	if builder.checkTimeFromFlag {
		req.CheckTimeFrom = &builder.checkTimeFrom
	}
	if builder.checkTimeToFlag {
		req.CheckTimeTo = &builder.checkTimeTo
	}
	return req, nil
}

type QueryUserFlowReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *QueryUserFlowReqBody
}

func NewQueryUserFlowReqBuilder() *QueryUserFlowReqBuilder {
	builder := &QueryUserFlowReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 请求体中的 user_ids 和响应体中的 user_id 的员工工号类型
//
// 示例值：employee_id
func (builder *QueryUserFlowReqBuilder) EmployeeType(employeeType string) *QueryUserFlowReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 由于新入职用户可以复用已离职用户的employee_no/employee_id。如果true，返回employee_no/employee_id对应的所有在职+离职用户数据；如果false，只返回employee_no/employee_id对应的在职或最近一个离职用户数据
//
// 示例值：true
func (builder *QueryUserFlowReqBuilder) IncludeTerminatedUser(includeTerminatedUser bool) *QueryUserFlowReqBuilder {
	builder.apiReq.QueryParams.Set("include_terminated_user", fmt.Sprint(includeTerminatedUser))
	return builder
}

// 批量查询授权内员工的实际打卡流水记录。例如，企业给一个员工设定的班次是上午 9 点和下午 6 点各打一次上下班卡，但是该员工在这期间打了多次卡，该接口会把所有的打卡记录都返回。
func (builder *QueryUserFlowReqBuilder) Body(body *QueryUserFlowReqBody) *QueryUserFlowReqBuilder {
	builder.body = body
	return builder
}

func (builder *QueryUserFlowReqBuilder) Build() *QueryUserFlowReq {
	req := &QueryUserFlowReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type QueryUserFlowReqBody struct {
	UserIds []string `json:"user_ids,omitempty"` // employee_no 或 employee_id 列表，长度不超过 50

	CheckTimeFrom *string `json:"check_time_from,omitempty"` // 查询的起始时间，时间戳

	CheckTimeTo *string `json:"check_time_to,omitempty"` // 查询的结束时间，时间戳
}

type QueryUserFlowReq struct {
	apiReq *larkcore.ApiReq
	Body   *QueryUserFlowReqBody `body:""`
}

type QueryUserFlowRespData struct {
	UserFlowResults []*UserFlow `json:"user_flow_results,omitempty"` // 打卡记录列表
}

type QueryUserFlowResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *QueryUserFlowRespData `json:"data"` // 业务数据
}

func (resp *QueryUserFlowResp) Success() bool {
	return resp.Code == 0
}

type ModifyUserSettingReqBodyBuilder struct {
	userSetting     *UserSetting // 用户设置
	userSettingFlag bool
}

func NewModifyUserSettingReqBodyBuilder() *ModifyUserSettingReqBodyBuilder {
	builder := &ModifyUserSettingReqBodyBuilder{}
	return builder
}

// 用户设置
//
//示例值：
func (builder *ModifyUserSettingReqBodyBuilder) UserSetting(userSetting *UserSetting) *ModifyUserSettingReqBodyBuilder {
	builder.userSetting = userSetting
	builder.userSettingFlag = true
	return builder
}

func (builder *ModifyUserSettingReqBodyBuilder) Build() *ModifyUserSettingReqBody {
	req := &ModifyUserSettingReqBody{}
	if builder.userSettingFlag {
		req.UserSetting = builder.userSetting
	}
	return req
}

type ModifyUserSettingPathReqBodyBuilder struct {
	userSetting     *UserSetting
	userSettingFlag bool
}

func NewModifyUserSettingPathReqBodyBuilder() *ModifyUserSettingPathReqBodyBuilder {
	builder := &ModifyUserSettingPathReqBodyBuilder{}
	return builder
}

// 用户设置
//
// 示例值：
func (builder *ModifyUserSettingPathReqBodyBuilder) UserSetting(userSetting *UserSetting) *ModifyUserSettingPathReqBodyBuilder {
	builder.userSetting = userSetting
	builder.userSettingFlag = true
	return builder
}

func (builder *ModifyUserSettingPathReqBodyBuilder) Build() (*ModifyUserSettingReqBody, error) {
	req := &ModifyUserSettingReqBody{}
	if builder.userSettingFlag {
		req.UserSetting = builder.userSetting
	}
	return req, nil
}

type ModifyUserSettingReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *ModifyUserSettingReqBody
}

func NewModifyUserSettingReqBuilder() *ModifyUserSettingReqBuilder {
	builder := &ModifyUserSettingReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 请求体和响应体中的 user_id 的员工工号类型
//
// 示例值：employee_id
func (builder *ModifyUserSettingReqBuilder) EmployeeType(employeeType string) *ModifyUserSettingReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 修改授权内员工的用户设置信息，包括人脸照片文件 ID。
func (builder *ModifyUserSettingReqBuilder) Body(body *ModifyUserSettingReqBody) *ModifyUserSettingReqBuilder {
	builder.body = body
	return builder
}

func (builder *ModifyUserSettingReqBuilder) Build() *ModifyUserSettingReq {
	req := &ModifyUserSettingReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type ModifyUserSettingReqBody struct {
	UserSetting *UserSetting `json:"user_setting,omitempty"` // 用户设置
}

type ModifyUserSettingReq struct {
	apiReq *larkcore.ApiReq
	Body   *ModifyUserSettingReqBody `body:""`
}

type ModifyUserSettingRespData struct {
	UserSetting *UserSetting `json:"user_setting,omitempty"` // 用户设置
}

type ModifyUserSettingResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *ModifyUserSettingRespData `json:"data"` // 业务数据
}

func (resp *ModifyUserSettingResp) Success() bool {
	return resp.Code == 0
}

type QueryUserSettingReqBodyBuilder struct {
	userIds     []string // employee_no 或 employee_id 列表
	userIdsFlag bool
}

func NewQueryUserSettingReqBodyBuilder() *QueryUserSettingReqBodyBuilder {
	builder := &QueryUserSettingReqBodyBuilder{}
	return builder
}

// employee_no 或 employee_id 列表
//
//示例值：["abd754f7"]
func (builder *QueryUserSettingReqBodyBuilder) UserIds(userIds []string) *QueryUserSettingReqBodyBuilder {
	builder.userIds = userIds
	builder.userIdsFlag = true
	return builder
}

func (builder *QueryUserSettingReqBodyBuilder) Build() *QueryUserSettingReqBody {
	req := &QueryUserSettingReqBody{}
	if builder.userIdsFlag {
		req.UserIds = builder.userIds
	}
	return req
}

type QueryUserSettingPathReqBodyBuilder struct {
	userIds     []string
	userIdsFlag bool
}

func NewQueryUserSettingPathReqBodyBuilder() *QueryUserSettingPathReqBodyBuilder {
	builder := &QueryUserSettingPathReqBodyBuilder{}
	return builder
}

// employee_no 或 employee_id 列表
//
// 示例值：["abd754f7"]
func (builder *QueryUserSettingPathReqBodyBuilder) UserIds(userIds []string) *QueryUserSettingPathReqBodyBuilder {
	builder.userIds = userIds
	builder.userIdsFlag = true
	return builder
}

func (builder *QueryUserSettingPathReqBodyBuilder) Build() (*QueryUserSettingReqBody, error) {
	req := &QueryUserSettingReqBody{}
	if builder.userIdsFlag {
		req.UserIds = builder.userIds
	}
	return req, nil
}

type QueryUserSettingReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *QueryUserSettingReqBody
}

func NewQueryUserSettingReqBuilder() *QueryUserSettingReqBuilder {
	builder := &QueryUserSettingReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 请求体中的 user_ids 和响应体中的 user_id 的员工工号类型
//
// 示例值：employee_id
func (builder *QueryUserSettingReqBuilder) EmployeeType(employeeType string) *QueryUserSettingReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 批量查询授权内员工的用户设置信息，包括人脸照片文件 ID、人脸照片更新时间。
func (builder *QueryUserSettingReqBuilder) Body(body *QueryUserSettingReqBody) *QueryUserSettingReqBuilder {
	builder.body = body
	return builder
}

func (builder *QueryUserSettingReqBuilder) Build() *QueryUserSettingReq {
	req := &QueryUserSettingReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type QueryUserSettingReqBody struct {
	UserIds []string `json:"user_ids,omitempty"` // employee_no 或 employee_id 列表
}

type QueryUserSettingReq struct {
	apiReq *larkcore.ApiReq
	Body   *QueryUserSettingReqBody `body:""`
}

type QueryUserSettingRespData struct {
	UserSettings []*UserSetting `json:"user_settings,omitempty"` // 用户设置信息列表
}

type QueryUserSettingResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *QueryUserSettingRespData `json:"data"` // 业务数据
}

func (resp *QueryUserSettingResp) Success() bool {
	return resp.Code == 0
}

type QueryUserStatsDataReqBodyBuilder struct {
	locale     string // 语言类型
	localeFlag bool

	statsType     string // 统计类型
	statsTypeFlag bool

	startDate     int // 开始时间
	startDateFlag bool

	endDate     int // 结束时间;（时间间隔不超过 31 天）
	endDateFlag bool

	userIds     []string // 查询的用户 ID 列表;（用户数量不超过 200）
	userIdsFlag bool

	needHistory     bool // 是否需要历史数据
	needHistoryFlag bool

	currentGroupOnly     bool // 只展示当前考勤组
	currentGroupOnlyFlag bool

	userId     string // 查询用户id，同【更新统计设置】、【查询统计设置】user_id（新系统用户必填，否则会报错）
	userIdFlag bool
}

func NewQueryUserStatsDataReqBodyBuilder() *QueryUserStatsDataReqBodyBuilder {
	builder := &QueryUserStatsDataReqBodyBuilder{}
	return builder
}

// 语言类型
//
//示例值：zh
func (builder *QueryUserStatsDataReqBodyBuilder) Locale(locale string) *QueryUserStatsDataReqBodyBuilder {
	builder.locale = locale
	builder.localeFlag = true
	return builder
}

// 统计类型
//
//示例值：month
func (builder *QueryUserStatsDataReqBodyBuilder) StatsType(statsType string) *QueryUserStatsDataReqBodyBuilder {
	builder.statsType = statsType
	builder.statsTypeFlag = true
	return builder
}

// 开始时间
//
//示例值：20210316
func (builder *QueryUserStatsDataReqBodyBuilder) StartDate(startDate int) *QueryUserStatsDataReqBodyBuilder {
	builder.startDate = startDate
	builder.startDateFlag = true
	return builder
}

// 结束时间;（时间间隔不超过 31 天）
//
//示例值：20210323
func (builder *QueryUserStatsDataReqBodyBuilder) EndDate(endDate int) *QueryUserStatsDataReqBodyBuilder {
	builder.endDate = endDate
	builder.endDateFlag = true
	return builder
}

// 查询的用户 ID 列表;（用户数量不超过 200）
//
//示例值：[;		"ec8ddg56",;		"4dbb52f2",;		"4167842e";	]
func (builder *QueryUserStatsDataReqBodyBuilder) UserIds(userIds []string) *QueryUserStatsDataReqBodyBuilder {
	builder.userIds = userIds
	builder.userIdsFlag = true
	return builder
}

// 是否需要历史数据
//
//示例值：true
func (builder *QueryUserStatsDataReqBodyBuilder) NeedHistory(needHistory bool) *QueryUserStatsDataReqBodyBuilder {
	builder.needHistory = needHistory
	builder.needHistoryFlag = true
	return builder
}

// 只展示当前考勤组
//
//示例值：true
func (builder *QueryUserStatsDataReqBodyBuilder) CurrentGroupOnly(currentGroupOnly bool) *QueryUserStatsDataReqBodyBuilder {
	builder.currentGroupOnly = currentGroupOnly
	builder.currentGroupOnlyFlag = true
	return builder
}

// 查询用户id，同【更新统计设置】、【查询统计设置】user_id（新系统用户必填，否则会报错）
//
//示例值：ec8ddg56
func (builder *QueryUserStatsDataReqBodyBuilder) UserId(userId string) *QueryUserStatsDataReqBodyBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

func (builder *QueryUserStatsDataReqBodyBuilder) Build() *QueryUserStatsDataReqBody {
	req := &QueryUserStatsDataReqBody{}
	if builder.localeFlag {
		req.Locale = &builder.locale
	}
	if builder.statsTypeFlag {
		req.StatsType = &builder.statsType
	}
	if builder.startDateFlag {
		req.StartDate = &builder.startDate
	}
	if builder.endDateFlag {
		req.EndDate = &builder.endDate
	}
	if builder.userIdsFlag {
		req.UserIds = builder.userIds
	}
	if builder.needHistoryFlag {
		req.NeedHistory = &builder.needHistory
	}
	if builder.currentGroupOnlyFlag {
		req.CurrentGroupOnly = &builder.currentGroupOnly
	}
	if builder.userIdFlag {
		req.UserId = &builder.userId
	}
	return req
}

type QueryUserStatsDataPathReqBodyBuilder struct {
	locale               string
	localeFlag           bool
	statsType            string
	statsTypeFlag        bool
	startDate            int
	startDateFlag        bool
	endDate              int
	endDateFlag          bool
	userIds              []string
	userIdsFlag          bool
	needHistory          bool
	needHistoryFlag      bool
	currentGroupOnly     bool
	currentGroupOnlyFlag bool
	userId               string
	userIdFlag           bool
}

func NewQueryUserStatsDataPathReqBodyBuilder() *QueryUserStatsDataPathReqBodyBuilder {
	builder := &QueryUserStatsDataPathReqBodyBuilder{}
	return builder
}

// 语言类型
//
// 示例值：zh
func (builder *QueryUserStatsDataPathReqBodyBuilder) Locale(locale string) *QueryUserStatsDataPathReqBodyBuilder {
	builder.locale = locale
	builder.localeFlag = true
	return builder
}

// 统计类型
//
// 示例值：month
func (builder *QueryUserStatsDataPathReqBodyBuilder) StatsType(statsType string) *QueryUserStatsDataPathReqBodyBuilder {
	builder.statsType = statsType
	builder.statsTypeFlag = true
	return builder
}

// 开始时间
//
// 示例值：20210316
func (builder *QueryUserStatsDataPathReqBodyBuilder) StartDate(startDate int) *QueryUserStatsDataPathReqBodyBuilder {
	builder.startDate = startDate
	builder.startDateFlag = true
	return builder
}

// 结束时间;（时间间隔不超过 31 天）
//
// 示例值：20210323
func (builder *QueryUserStatsDataPathReqBodyBuilder) EndDate(endDate int) *QueryUserStatsDataPathReqBodyBuilder {
	builder.endDate = endDate
	builder.endDateFlag = true
	return builder
}

// 查询的用户 ID 列表;（用户数量不超过 200）
//
// 示例值：[;		"ec8ddg56",;		"4dbb52f2",;		"4167842e";	]
func (builder *QueryUserStatsDataPathReqBodyBuilder) UserIds(userIds []string) *QueryUserStatsDataPathReqBodyBuilder {
	builder.userIds = userIds
	builder.userIdsFlag = true
	return builder
}

// 是否需要历史数据
//
// 示例值：true
func (builder *QueryUserStatsDataPathReqBodyBuilder) NeedHistory(needHistory bool) *QueryUserStatsDataPathReqBodyBuilder {
	builder.needHistory = needHistory
	builder.needHistoryFlag = true
	return builder
}

// 只展示当前考勤组
//
// 示例值：true
func (builder *QueryUserStatsDataPathReqBodyBuilder) CurrentGroupOnly(currentGroupOnly bool) *QueryUserStatsDataPathReqBodyBuilder {
	builder.currentGroupOnly = currentGroupOnly
	builder.currentGroupOnlyFlag = true
	return builder
}

// 查询用户id，同【更新统计设置】、【查询统计设置】user_id（新系统用户必填，否则会报错）
//
// 示例值：ec8ddg56
func (builder *QueryUserStatsDataPathReqBodyBuilder) UserId(userId string) *QueryUserStatsDataPathReqBodyBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

func (builder *QueryUserStatsDataPathReqBodyBuilder) Build() (*QueryUserStatsDataReqBody, error) {
	req := &QueryUserStatsDataReqBody{}
	if builder.localeFlag {
		req.Locale = &builder.locale
	}
	if builder.statsTypeFlag {
		req.StatsType = &builder.statsType
	}
	if builder.startDateFlag {
		req.StartDate = &builder.startDate
	}
	if builder.endDateFlag {
		req.EndDate = &builder.endDate
	}
	if builder.userIdsFlag {
		req.UserIds = builder.userIds
	}
	if builder.needHistoryFlag {
		req.NeedHistory = &builder.needHistory
	}
	if builder.currentGroupOnlyFlag {
		req.CurrentGroupOnly = &builder.currentGroupOnly
	}
	if builder.userIdFlag {
		req.UserId = &builder.userId
	}
	return req, nil
}

type QueryUserStatsDataReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *QueryUserStatsDataReqBody
}

func NewQueryUserStatsDataReqBuilder() *QueryUserStatsDataReqBuilder {
	builder := &QueryUserStatsDataReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 请求体中的 user_ids 和响应体中的 user_id 的员工工号类型
//
// 示例值：employee_id
func (builder *QueryUserStatsDataReqBuilder) EmployeeType(employeeType string) *QueryUserStatsDataReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 查询日度统计或月度统计的统计数据。
func (builder *QueryUserStatsDataReqBuilder) Body(body *QueryUserStatsDataReqBody) *QueryUserStatsDataReqBuilder {
	builder.body = body
	return builder
}

func (builder *QueryUserStatsDataReqBuilder) Build() *QueryUserStatsDataReq {
	req := &QueryUserStatsDataReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type QueryUserStatsDataReqBody struct {
	Locale *string `json:"locale,omitempty"` // 语言类型

	StatsType *string `json:"stats_type,omitempty"` // 统计类型

	StartDate *int `json:"start_date,omitempty"` // 开始时间

	EndDate *int `json:"end_date,omitempty"` // 结束时间;（时间间隔不超过 31 天）

	UserIds []string `json:"user_ids,omitempty"` // 查询的用户 ID 列表;（用户数量不超过 200）

	NeedHistory *bool `json:"need_history,omitempty"` // 是否需要历史数据

	CurrentGroupOnly *bool `json:"current_group_only,omitempty"` // 只展示当前考勤组

	UserId *string `json:"user_id,omitempty"` // 查询用户id，同【更新统计设置】、【查询统计设置】user_id（新系统用户必填，否则会报错）
}

type QueryUserStatsDataReq struct {
	apiReq *larkcore.ApiReq
	Body   *QueryUserStatsDataReqBody `body:""`
}

type QueryUserStatsDataRespData struct {
	UserDatas []*UserStatsData `json:"user_datas,omitempty"` // 用户统计数据（限制1000条，超过1000条会截断）

	InvalidUserList []string `json:"invalid_user_list,omitempty"` // 无权限获取的用户列表
}

type QueryUserStatsDataResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *QueryUserStatsDataRespData `json:"data"` // 业务数据
}

func (resp *QueryUserStatsDataResp) Success() bool {
	return resp.Code == 0
}

type QueryUserStatsFieldReqBodyBuilder struct {
	locale     string // 语言类型
	localeFlag bool

	statsType     string // 统计类型
	statsTypeFlag bool

	startDate     int // 开始时间
	startDateFlag bool

	endDate     int // 结束时间（时间间隔不超过 40 天）
	endDateFlag bool
}

func NewQueryUserStatsFieldReqBodyBuilder() *QueryUserStatsFieldReqBodyBuilder {
	builder := &QueryUserStatsFieldReqBodyBuilder{}
	return builder
}

// 语言类型
//
//示例值：zh
func (builder *QueryUserStatsFieldReqBodyBuilder) Locale(locale string) *QueryUserStatsFieldReqBodyBuilder {
	builder.locale = locale
	builder.localeFlag = true
	return builder
}

// 统计类型
//
//示例值：daily
func (builder *QueryUserStatsFieldReqBodyBuilder) StatsType(statsType string) *QueryUserStatsFieldReqBodyBuilder {
	builder.statsType = statsType
	builder.statsTypeFlag = true
	return builder
}

// 开始时间
//
//示例值：20210316
func (builder *QueryUserStatsFieldReqBodyBuilder) StartDate(startDate int) *QueryUserStatsFieldReqBodyBuilder {
	builder.startDate = startDate
	builder.startDateFlag = true
	return builder
}

// 结束时间（时间间隔不超过 40 天）
//
//示例值：20210323
func (builder *QueryUserStatsFieldReqBodyBuilder) EndDate(endDate int) *QueryUserStatsFieldReqBodyBuilder {
	builder.endDate = endDate
	builder.endDateFlag = true
	return builder
}

func (builder *QueryUserStatsFieldReqBodyBuilder) Build() *QueryUserStatsFieldReqBody {
	req := &QueryUserStatsFieldReqBody{}
	if builder.localeFlag {
		req.Locale = &builder.locale
	}
	if builder.statsTypeFlag {
		req.StatsType = &builder.statsType
	}
	if builder.startDateFlag {
		req.StartDate = &builder.startDate
	}
	if builder.endDateFlag {
		req.EndDate = &builder.endDate
	}
	return req
}

type QueryUserStatsFieldPathReqBodyBuilder struct {
	locale        string
	localeFlag    bool
	statsType     string
	statsTypeFlag bool
	startDate     int
	startDateFlag bool
	endDate       int
	endDateFlag   bool
}

func NewQueryUserStatsFieldPathReqBodyBuilder() *QueryUserStatsFieldPathReqBodyBuilder {
	builder := &QueryUserStatsFieldPathReqBodyBuilder{}
	return builder
}

// 语言类型
//
// 示例值：zh
func (builder *QueryUserStatsFieldPathReqBodyBuilder) Locale(locale string) *QueryUserStatsFieldPathReqBodyBuilder {
	builder.locale = locale
	builder.localeFlag = true
	return builder
}

// 统计类型
//
// 示例值：daily
func (builder *QueryUserStatsFieldPathReqBodyBuilder) StatsType(statsType string) *QueryUserStatsFieldPathReqBodyBuilder {
	builder.statsType = statsType
	builder.statsTypeFlag = true
	return builder
}

// 开始时间
//
// 示例值：20210316
func (builder *QueryUserStatsFieldPathReqBodyBuilder) StartDate(startDate int) *QueryUserStatsFieldPathReqBodyBuilder {
	builder.startDate = startDate
	builder.startDateFlag = true
	return builder
}

// 结束时间（时间间隔不超过 40 天）
//
// 示例值：20210323
func (builder *QueryUserStatsFieldPathReqBodyBuilder) EndDate(endDate int) *QueryUserStatsFieldPathReqBodyBuilder {
	builder.endDate = endDate
	builder.endDateFlag = true
	return builder
}

func (builder *QueryUserStatsFieldPathReqBodyBuilder) Build() (*QueryUserStatsFieldReqBody, error) {
	req := &QueryUserStatsFieldReqBody{}
	if builder.localeFlag {
		req.Locale = &builder.locale
	}
	if builder.statsTypeFlag {
		req.StatsType = &builder.statsType
	}
	if builder.startDateFlag {
		req.StartDate = &builder.startDate
	}
	if builder.endDateFlag {
		req.EndDate = &builder.endDate
	}
	return req, nil
}

type QueryUserStatsFieldReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *QueryUserStatsFieldReqBody
}

func NewQueryUserStatsFieldReqBuilder() *QueryUserStatsFieldReqBuilder {
	builder := &QueryUserStatsFieldReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 响应体中的 user_id 的员工工号类型
//
// 示例值：employee_id
func (builder *QueryUserStatsFieldReqBuilder) EmployeeType(employeeType string) *QueryUserStatsFieldReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 查询考勤统计支持的日度统计或月度统计的统计表头。
func (builder *QueryUserStatsFieldReqBuilder) Body(body *QueryUserStatsFieldReqBody) *QueryUserStatsFieldReqBuilder {
	builder.body = body
	return builder
}

func (builder *QueryUserStatsFieldReqBuilder) Build() *QueryUserStatsFieldReq {
	req := &QueryUserStatsFieldReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type QueryUserStatsFieldReqBody struct {
	Locale *string `json:"locale,omitempty"` // 语言类型

	StatsType *string `json:"stats_type,omitempty"` // 统计类型

	StartDate *int `json:"start_date,omitempty"` // 开始时间

	EndDate *int `json:"end_date,omitempty"` // 结束时间（时间间隔不超过 40 天）
}

type QueryUserStatsFieldReq struct {
	apiReq *larkcore.ApiReq
	Body   *QueryUserStatsFieldReqBody `body:""`
}

type QueryUserStatsFieldRespData struct {
	UserStatsField *UserStatsField `json:"user_stats_field,omitempty"` // 统计数据表头
}

type QueryUserStatsFieldResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *QueryUserStatsFieldRespData `json:"data"` // 业务数据
}

func (resp *QueryUserStatsFieldResp) Success() bool {
	return resp.Code == 0
}

type QueryUserStatsViewReqBodyBuilder struct {
	locale     string // 语言类型
	localeFlag bool

	statsType     string // 统计类型
	statsTypeFlag bool

	userId     string // 查询用户id，同【查询统计数据】、【更新统计设置】user_id
	userIdFlag bool
}

func NewQueryUserStatsViewReqBodyBuilder() *QueryUserStatsViewReqBodyBuilder {
	builder := &QueryUserStatsViewReqBodyBuilder{}
	return builder
}

// 语言类型
//
//示例值：zh
func (builder *QueryUserStatsViewReqBodyBuilder) Locale(locale string) *QueryUserStatsViewReqBodyBuilder {
	builder.locale = locale
	builder.localeFlag = true
	return builder
}

// 统计类型
//
//示例值：daily
func (builder *QueryUserStatsViewReqBodyBuilder) StatsType(statsType string) *QueryUserStatsViewReqBodyBuilder {
	builder.statsType = statsType
	builder.statsTypeFlag = true
	return builder
}

// 查询用户id，同【查询统计数据】、【更新统计设置】user_id
//
//示例值：dd31248a
func (builder *QueryUserStatsViewReqBodyBuilder) UserId(userId string) *QueryUserStatsViewReqBodyBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

func (builder *QueryUserStatsViewReqBodyBuilder) Build() *QueryUserStatsViewReqBody {
	req := &QueryUserStatsViewReqBody{}
	if builder.localeFlag {
		req.Locale = &builder.locale
	}
	if builder.statsTypeFlag {
		req.StatsType = &builder.statsType
	}
	if builder.userIdFlag {
		req.UserId = &builder.userId
	}
	return req
}

type QueryUserStatsViewPathReqBodyBuilder struct {
	locale        string
	localeFlag    bool
	statsType     string
	statsTypeFlag bool
	userId        string
	userIdFlag    bool
}

func NewQueryUserStatsViewPathReqBodyBuilder() *QueryUserStatsViewPathReqBodyBuilder {
	builder := &QueryUserStatsViewPathReqBodyBuilder{}
	return builder
}

// 语言类型
//
// 示例值：zh
func (builder *QueryUserStatsViewPathReqBodyBuilder) Locale(locale string) *QueryUserStatsViewPathReqBodyBuilder {
	builder.locale = locale
	builder.localeFlag = true
	return builder
}

// 统计类型
//
// 示例值：daily
func (builder *QueryUserStatsViewPathReqBodyBuilder) StatsType(statsType string) *QueryUserStatsViewPathReqBodyBuilder {
	builder.statsType = statsType
	builder.statsTypeFlag = true
	return builder
}

// 查询用户id，同【查询统计数据】、【更新统计设置】user_id
//
// 示例值：dd31248a
func (builder *QueryUserStatsViewPathReqBodyBuilder) UserId(userId string) *QueryUserStatsViewPathReqBodyBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

func (builder *QueryUserStatsViewPathReqBodyBuilder) Build() (*QueryUserStatsViewReqBody, error) {
	req := &QueryUserStatsViewReqBody{}
	if builder.localeFlag {
		req.Locale = &builder.locale
	}
	if builder.statsTypeFlag {
		req.StatsType = &builder.statsType
	}
	if builder.userIdFlag {
		req.UserId = &builder.userId
	}
	return req, nil
}

type QueryUserStatsViewReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *QueryUserStatsViewReqBody
}

func NewQueryUserStatsViewReqBuilder() *QueryUserStatsViewReqBuilder {
	builder := &QueryUserStatsViewReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 响应体中的 user_id 的员工工号类型
//
// 示例值：employee_id
func (builder *QueryUserStatsViewReqBuilder) EmployeeType(employeeType string) *QueryUserStatsViewReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 查询开发者定制的日度统计或月度统计的统计报表表头设置信息。
func (builder *QueryUserStatsViewReqBuilder) Body(body *QueryUserStatsViewReqBody) *QueryUserStatsViewReqBuilder {
	builder.body = body
	return builder
}

func (builder *QueryUserStatsViewReqBuilder) Build() *QueryUserStatsViewReq {
	req := &QueryUserStatsViewReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type QueryUserStatsViewReqBody struct {
	Locale *string `json:"locale,omitempty"` // 语言类型

	StatsType *string `json:"stats_type,omitempty"` // 统计类型

	UserId *string `json:"user_id,omitempty"` // 查询用户id，同【查询统计数据】、【更新统计设置】user_id
}

type QueryUserStatsViewReq struct {
	apiReq *larkcore.ApiReq
	Body   *QueryUserStatsViewReqBody `body:""`
}

type QueryUserStatsViewRespData struct {
	View *UserStatsView `json:"view,omitempty"` // 统计视图
}

type QueryUserStatsViewResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *QueryUserStatsViewRespData `json:"data"` // 业务数据
}

func (resp *QueryUserStatsViewResp) Success() bool {
	return resp.Code == 0
}

type UpdateUserStatsViewReqBodyBuilder struct {
	view     *UserStatsView // 统计设置
	viewFlag bool
}

func NewUpdateUserStatsViewReqBodyBuilder() *UpdateUserStatsViewReqBodyBuilder {
	builder := &UpdateUserStatsViewReqBodyBuilder{}
	return builder
}

// 统计设置
//
//示例值：
func (builder *UpdateUserStatsViewReqBodyBuilder) View(view *UserStatsView) *UpdateUserStatsViewReqBodyBuilder {
	builder.view = view
	builder.viewFlag = true
	return builder
}

func (builder *UpdateUserStatsViewReqBodyBuilder) Build() *UpdateUserStatsViewReqBody {
	req := &UpdateUserStatsViewReqBody{}
	if builder.viewFlag {
		req.View = builder.view
	}
	return req
}

type UpdateUserStatsViewPathReqBodyBuilder struct {
	view     *UserStatsView
	viewFlag bool
}

func NewUpdateUserStatsViewPathReqBodyBuilder() *UpdateUserStatsViewPathReqBodyBuilder {
	builder := &UpdateUserStatsViewPathReqBodyBuilder{}
	return builder
}

// 统计设置
//
// 示例值：
func (builder *UpdateUserStatsViewPathReqBodyBuilder) View(view *UserStatsView) *UpdateUserStatsViewPathReqBodyBuilder {
	builder.view = view
	builder.viewFlag = true
	return builder
}

func (builder *UpdateUserStatsViewPathReqBodyBuilder) Build() (*UpdateUserStatsViewReqBody, error) {
	req := &UpdateUserStatsViewReqBody{}
	if builder.viewFlag {
		req.View = builder.view
	}
	return req, nil
}

type UpdateUserStatsViewReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *UpdateUserStatsViewReqBody
}

func NewUpdateUserStatsViewReqBuilder() *UpdateUserStatsViewReqBuilder {
	builder := &UpdateUserStatsViewReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 用户视图 ID，获取方式：1）[查询统计设置](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/user_stats_view/query)
//
// 示例值：TmpZNU5qTTJORFF6T1RnNU5UTTNOakV6TWl0dGIyNTBhQT09
func (builder *UpdateUserStatsViewReqBuilder) UserStatsViewId(userStatsViewId string) *UpdateUserStatsViewReqBuilder {
	builder.apiReq.PathParams.Set("user_stats_view_id", fmt.Sprint(userStatsViewId))
	return builder
}

// 员工工号类型
//
// 示例值：employee_id
func (builder *UpdateUserStatsViewReqBuilder) EmployeeType(employeeType string) *UpdateUserStatsViewReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 更新开发者定制的日度统计或月度统计的统计报表表头设置信息。
func (builder *UpdateUserStatsViewReqBuilder) Body(body *UpdateUserStatsViewReqBody) *UpdateUserStatsViewReqBuilder {
	builder.body = body
	return builder
}

func (builder *UpdateUserStatsViewReqBuilder) Build() *UpdateUserStatsViewReq {
	req := &UpdateUserStatsViewReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type UpdateUserStatsViewReqBody struct {
	View *UserStatsView `json:"view,omitempty"` // 统计设置
}

type UpdateUserStatsViewReq struct {
	apiReq *larkcore.ApiReq
	Body   *UpdateUserStatsViewReqBody `body:""`
}

type UpdateUserStatsViewRespData struct {
	View *UserStatsView `json:"view,omitempty"` // 视图
}

type UpdateUserStatsViewResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *UpdateUserStatsViewRespData `json:"data"` // 业务数据
}

func (resp *UpdateUserStatsViewResp) Success() bool {
	return resp.Code == 0
}

type QueryUserTaskReqBodyBuilder struct {
	userIds     []string // employee_no 或 employee_id 列表，长度不超过 50
	userIdsFlag bool

	checkDateFrom     int // 查询的起始工作日
	checkDateFromFlag bool

	checkDateTo     int // 查询的结束工作日
	checkDateToFlag bool

	needOvertimeResult     bool // 是否需要加班班段打卡结果
	needOvertimeResultFlag bool
}

func NewQueryUserTaskReqBodyBuilder() *QueryUserTaskReqBodyBuilder {
	builder := &QueryUserTaskReqBodyBuilder{}
	return builder
}

// employee_no 或 employee_id 列表，长度不超过 50
//
//示例值：abd754f7
func (builder *QueryUserTaskReqBodyBuilder) UserIds(userIds []string) *QueryUserTaskReqBodyBuilder {
	builder.userIds = userIds
	builder.userIdsFlag = true
	return builder
}

// 查询的起始工作日
//
//示例值：20190817
func (builder *QueryUserTaskReqBodyBuilder) CheckDateFrom(checkDateFrom int) *QueryUserTaskReqBodyBuilder {
	builder.checkDateFrom = checkDateFrom
	builder.checkDateFromFlag = true
	return builder
}

// 查询的结束工作日
//
//示例值：20190820
func (builder *QueryUserTaskReqBodyBuilder) CheckDateTo(checkDateTo int) *QueryUserTaskReqBodyBuilder {
	builder.checkDateTo = checkDateTo
	builder.checkDateToFlag = true
	return builder
}

// 是否需要加班班段打卡结果
//
//示例值：true
func (builder *QueryUserTaskReqBodyBuilder) NeedOvertimeResult(needOvertimeResult bool) *QueryUserTaskReqBodyBuilder {
	builder.needOvertimeResult = needOvertimeResult
	builder.needOvertimeResultFlag = true
	return builder
}

func (builder *QueryUserTaskReqBodyBuilder) Build() *QueryUserTaskReqBody {
	req := &QueryUserTaskReqBody{}
	if builder.userIdsFlag {
		req.UserIds = builder.userIds
	}
	if builder.checkDateFromFlag {
		req.CheckDateFrom = &builder.checkDateFrom
	}
	if builder.checkDateToFlag {
		req.CheckDateTo = &builder.checkDateTo
	}
	if builder.needOvertimeResultFlag {
		req.NeedOvertimeResult = &builder.needOvertimeResult
	}
	return req
}

type QueryUserTaskPathReqBodyBuilder struct {
	userIds                []string
	userIdsFlag            bool
	checkDateFrom          int
	checkDateFromFlag      bool
	checkDateTo            int
	checkDateToFlag        bool
	needOvertimeResult     bool
	needOvertimeResultFlag bool
}

func NewQueryUserTaskPathReqBodyBuilder() *QueryUserTaskPathReqBodyBuilder {
	builder := &QueryUserTaskPathReqBodyBuilder{}
	return builder
}

// employee_no 或 employee_id 列表，长度不超过 50
//
// 示例值：abd754f7
func (builder *QueryUserTaskPathReqBodyBuilder) UserIds(userIds []string) *QueryUserTaskPathReqBodyBuilder {
	builder.userIds = userIds
	builder.userIdsFlag = true
	return builder
}

// 查询的起始工作日
//
// 示例值：20190817
func (builder *QueryUserTaskPathReqBodyBuilder) CheckDateFrom(checkDateFrom int) *QueryUserTaskPathReqBodyBuilder {
	builder.checkDateFrom = checkDateFrom
	builder.checkDateFromFlag = true
	return builder
}

// 查询的结束工作日
//
// 示例值：20190820
func (builder *QueryUserTaskPathReqBodyBuilder) CheckDateTo(checkDateTo int) *QueryUserTaskPathReqBodyBuilder {
	builder.checkDateTo = checkDateTo
	builder.checkDateToFlag = true
	return builder
}

// 是否需要加班班段打卡结果
//
// 示例值：true
func (builder *QueryUserTaskPathReqBodyBuilder) NeedOvertimeResult(needOvertimeResult bool) *QueryUserTaskPathReqBodyBuilder {
	builder.needOvertimeResult = needOvertimeResult
	builder.needOvertimeResultFlag = true
	return builder
}

func (builder *QueryUserTaskPathReqBodyBuilder) Build() (*QueryUserTaskReqBody, error) {
	req := &QueryUserTaskReqBody{}
	if builder.userIdsFlag {
		req.UserIds = builder.userIds
	}
	if builder.checkDateFromFlag {
		req.CheckDateFrom = &builder.checkDateFrom
	}
	if builder.checkDateToFlag {
		req.CheckDateTo = &builder.checkDateTo
	}
	if builder.needOvertimeResultFlag {
		req.NeedOvertimeResult = &builder.needOvertimeResult
	}
	return req, nil
}

type QueryUserTaskReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *QueryUserTaskReqBody
}

func NewQueryUserTaskReqBuilder() *QueryUserTaskReqBuilder {
	builder := &QueryUserTaskReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 员工工号类型
//
// 示例值：employee_id
func (builder *QueryUserTaskReqBuilder) EmployeeType(employeeType string) *QueryUserTaskReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 是否忽略无效和没有权限的用户。如果 true，则返回有效用户的信息，并告知无效和没有权限的用户信息；如果 false，且 user_ids 中存在无效或没有权限的用户，则返回错误
//
// 示例值：true
func (builder *QueryUserTaskReqBuilder) IgnoreInvalidUsers(ignoreInvalidUsers bool) *QueryUserTaskReqBuilder {
	builder.apiReq.QueryParams.Set("ignore_invalid_users", fmt.Sprint(ignoreInvalidUsers))
	return builder
}

// 由于新入职员工可以复用已离职员工的 employee_no/employee_id，如果 true，则返回 employee_no/employee_id 对应的所有在职 + 离职员工的数据；如果 false，则只返回 employee_no/employee_id 对应的在职或最近一个离职员工的数据
//
// 示例值：true
func (builder *QueryUserTaskReqBuilder) IncludeTerminatedUser(includeTerminatedUser bool) *QueryUserTaskReqBuilder {
	builder.apiReq.QueryParams.Set("include_terminated_user", fmt.Sprint(includeTerminatedUser))
	return builder
}

// 获取企业内员工的实际打卡结果，包括上班打卡结果和下班打卡结果。
func (builder *QueryUserTaskReqBuilder) Body(body *QueryUserTaskReqBody) *QueryUserTaskReqBuilder {
	builder.body = body
	return builder
}

func (builder *QueryUserTaskReqBuilder) Build() *QueryUserTaskReq {
	req := &QueryUserTaskReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type QueryUserTaskReqBody struct {
	UserIds []string `json:"user_ids,omitempty"` // employee_no 或 employee_id 列表，长度不超过 50

	CheckDateFrom *int `json:"check_date_from,omitempty"` // 查询的起始工作日

	CheckDateTo *int `json:"check_date_to,omitempty"` // 查询的结束工作日

	NeedOvertimeResult *bool `json:"need_overtime_result,omitempty"` // 是否需要加班班段打卡结果
}

type QueryUserTaskReq struct {
	apiReq *larkcore.ApiReq
	Body   *QueryUserTaskReqBody `body:""`
}

type QueryUserTaskRespData struct {
	UserTaskResults []*UserTask `json:"user_task_results,omitempty"` // 打卡任务列表

	InvalidUserIds []string `json:"invalid_user_ids,omitempty"` // 无效用户 ID 列表

	UnauthorizedUserIds []string `json:"unauthorized_user_ids,omitempty"` // 没有权限用户 ID 列表
}

type QueryUserTaskResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *QueryUserTaskRespData `json:"data"` // 业务数据
}

func (resp *QueryUserTaskResp) Success() bool {
	return resp.Code == 0
}

type CreateUserTaskRemedyReqBuilder struct {
	apiReq         *larkcore.ApiReq
	userTaskRemedy *UserTaskRemedy
}

func NewCreateUserTaskRemedyReqBuilder() *CreateUserTaskRemedyReqBuilder {
	builder := &CreateUserTaskRemedyReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 请求体和响应体中的 user_id 的员工工号类型
//
// 示例值：employee_id
func (builder *CreateUserTaskRemedyReqBuilder) EmployeeType(employeeType string) *CreateUserTaskRemedyReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 对于只使用飞书考勤系统而未使用飞书审批系统的企业，可以通过该接口，将在三方审批系统中发起的补卡审批数据，写入到飞书考勤系统中，状态为审批中。写入后可以由[通知审批状态更新](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/attendance-v1/approval_info/process) 进行状态更新
func (builder *CreateUserTaskRemedyReqBuilder) UserTaskRemedy(userTaskRemedy *UserTaskRemedy) *CreateUserTaskRemedyReqBuilder {
	builder.userTaskRemedy = userTaskRemedy
	return builder
}

func (builder *CreateUserTaskRemedyReqBuilder) Build() *CreateUserTaskRemedyReq {
	req := &CreateUserTaskRemedyReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.userTaskRemedy
	return req
}

type CreateUserTaskRemedyReq struct {
	apiReq         *larkcore.ApiReq
	UserTaskRemedy *UserTaskRemedy `body:""`
}

type CreateUserTaskRemedyRespData struct {
	UserRemedy *UserTaskRemedy `json:"user_remedy,omitempty"` // 补卡审批信息
}

type CreateUserTaskRemedyResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *CreateUserTaskRemedyRespData `json:"data"` // 业务数据
}

func (resp *CreateUserTaskRemedyResp) Success() bool {
	return resp.Code == 0
}

type QueryUserTaskRemedyReqBodyBuilder struct {
	userIds     []string // employee_no 或 employee_id 列表
	userIdsFlag bool

	checkTimeFrom     string // 查询的起始时间，精确到秒的时间戳
	checkTimeFromFlag bool

	checkTimeTo     string // 查询的结束时间，精确到秒的时间戳
	checkTimeToFlag bool

	checkDateType     string // 查询依据的时间类型（默认依据PeriodTime，如果使用非默认的，非特定租户不支持）
	checkDateTypeFlag bool

	status     int // 查询状态（不填默认查询已通过状态）
	statusFlag bool
}

func NewQueryUserTaskRemedyReqBodyBuilder() *QueryUserTaskRemedyReqBodyBuilder {
	builder := &QueryUserTaskRemedyReqBodyBuilder{}
	return builder
}

// employee_no 或 employee_id 列表
//
//示例值：["abd754f7"]
func (builder *QueryUserTaskRemedyReqBodyBuilder) UserIds(userIds []string) *QueryUserTaskRemedyReqBodyBuilder {
	builder.userIds = userIds
	builder.userIdsFlag = true
	return builder
}

// 查询的起始时间，精确到秒的时间戳
//
//示例值：1566641088
func (builder *QueryUserTaskRemedyReqBodyBuilder) CheckTimeFrom(checkTimeFrom string) *QueryUserTaskRemedyReqBodyBuilder {
	builder.checkTimeFrom = checkTimeFrom
	builder.checkTimeFromFlag = true
	return builder
}

// 查询的结束时间，精确到秒的时间戳
//
//示例值：1592561088
func (builder *QueryUserTaskRemedyReqBodyBuilder) CheckTimeTo(checkTimeTo string) *QueryUserTaskRemedyReqBodyBuilder {
	builder.checkTimeTo = checkTimeTo
	builder.checkTimeToFlag = true
	return builder
}

// 查询依据的时间类型（默认依据PeriodTime，如果使用非默认的，非特定租户不支持）
//
//示例值：PeriodTime
func (builder *QueryUserTaskRemedyReqBodyBuilder) CheckDateType(checkDateType string) *QueryUserTaskRemedyReqBodyBuilder {
	builder.checkDateType = checkDateType
	builder.checkDateTypeFlag = true
	return builder
}

// 查询状态（不填默认查询已通过状态）
//
//示例值：2
func (builder *QueryUserTaskRemedyReqBodyBuilder) Status(status int) *QueryUserTaskRemedyReqBodyBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

func (builder *QueryUserTaskRemedyReqBodyBuilder) Build() *QueryUserTaskRemedyReqBody {
	req := &QueryUserTaskRemedyReqBody{}
	if builder.userIdsFlag {
		req.UserIds = builder.userIds
	}
	if builder.checkTimeFromFlag {
		req.CheckTimeFrom = &builder.checkTimeFrom
	}
	if builder.checkTimeToFlag {
		req.CheckTimeTo = &builder.checkTimeTo
	}
	if builder.checkDateTypeFlag {
		req.CheckDateType = &builder.checkDateType
	}
	if builder.statusFlag {
		req.Status = &builder.status
	}
	return req
}

type QueryUserTaskRemedyPathReqBodyBuilder struct {
	userIds           []string
	userIdsFlag       bool
	checkTimeFrom     string
	checkTimeFromFlag bool
	checkTimeTo       string
	checkTimeToFlag   bool
	checkDateType     string
	checkDateTypeFlag bool
	status            int
	statusFlag        bool
}

func NewQueryUserTaskRemedyPathReqBodyBuilder() *QueryUserTaskRemedyPathReqBodyBuilder {
	builder := &QueryUserTaskRemedyPathReqBodyBuilder{}
	return builder
}

// employee_no 或 employee_id 列表
//
// 示例值：["abd754f7"]
func (builder *QueryUserTaskRemedyPathReqBodyBuilder) UserIds(userIds []string) *QueryUserTaskRemedyPathReqBodyBuilder {
	builder.userIds = userIds
	builder.userIdsFlag = true
	return builder
}

// 查询的起始时间，精确到秒的时间戳
//
// 示例值：1566641088
func (builder *QueryUserTaskRemedyPathReqBodyBuilder) CheckTimeFrom(checkTimeFrom string) *QueryUserTaskRemedyPathReqBodyBuilder {
	builder.checkTimeFrom = checkTimeFrom
	builder.checkTimeFromFlag = true
	return builder
}

// 查询的结束时间，精确到秒的时间戳
//
// 示例值：1592561088
func (builder *QueryUserTaskRemedyPathReqBodyBuilder) CheckTimeTo(checkTimeTo string) *QueryUserTaskRemedyPathReqBodyBuilder {
	builder.checkTimeTo = checkTimeTo
	builder.checkTimeToFlag = true
	return builder
}

// 查询依据的时间类型（默认依据PeriodTime，如果使用非默认的，非特定租户不支持）
//
// 示例值：PeriodTime
func (builder *QueryUserTaskRemedyPathReqBodyBuilder) CheckDateType(checkDateType string) *QueryUserTaskRemedyPathReqBodyBuilder {
	builder.checkDateType = checkDateType
	builder.checkDateTypeFlag = true
	return builder
}

// 查询状态（不填默认查询已通过状态）
//
// 示例值：2
func (builder *QueryUserTaskRemedyPathReqBodyBuilder) Status(status int) *QueryUserTaskRemedyPathReqBodyBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

func (builder *QueryUserTaskRemedyPathReqBodyBuilder) Build() (*QueryUserTaskRemedyReqBody, error) {
	req := &QueryUserTaskRemedyReqBody{}
	if builder.userIdsFlag {
		req.UserIds = builder.userIds
	}
	if builder.checkTimeFromFlag {
		req.CheckTimeFrom = &builder.checkTimeFrom
	}
	if builder.checkTimeToFlag {
		req.CheckTimeTo = &builder.checkTimeTo
	}
	if builder.checkDateTypeFlag {
		req.CheckDateType = &builder.checkDateType
	}
	if builder.statusFlag {
		req.Status = &builder.status
	}
	return req, nil
}

type QueryUserTaskRemedyReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *QueryUserTaskRemedyReqBody
}

func NewQueryUserTaskRemedyReqBuilder() *QueryUserTaskRemedyReqBuilder {
	builder := &QueryUserTaskRemedyReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 请求体中的 user_ids 和响应体中的 user_id 的员工工号类型
//
// 示例值：employee_id
func (builder *QueryUserTaskRemedyReqBuilder) EmployeeType(employeeType string) *QueryUserTaskRemedyReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 获取授权内员工的补卡记录。
func (builder *QueryUserTaskRemedyReqBuilder) Body(body *QueryUserTaskRemedyReqBody) *QueryUserTaskRemedyReqBuilder {
	builder.body = body
	return builder
}

func (builder *QueryUserTaskRemedyReqBuilder) Build() *QueryUserTaskRemedyReq {
	req := &QueryUserTaskRemedyReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type QueryUserTaskRemedyReqBody struct {
	UserIds []string `json:"user_ids,omitempty"` // employee_no 或 employee_id 列表

	CheckTimeFrom *string `json:"check_time_from,omitempty"` // 查询的起始时间，精确到秒的时间戳

	CheckTimeTo *string `json:"check_time_to,omitempty"` // 查询的结束时间，精确到秒的时间戳

	CheckDateType *string `json:"check_date_type,omitempty"` // 查询依据的时间类型（默认依据PeriodTime，如果使用非默认的，非特定租户不支持）

	Status *int `json:"status,omitempty"` // 查询状态（不填默认查询已通过状态）
}

type QueryUserTaskRemedyReq struct {
	apiReq *larkcore.ApiReq
	Body   *QueryUserTaskRemedyReqBody `body:""`
}

type QueryUserTaskRemedyRespData struct {
	UserRemedys []*UserTaskRemedy `json:"user_remedys,omitempty"` // 补卡记录列表
}

type QueryUserTaskRemedyResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *QueryUserTaskRemedyRespData `json:"data"` // 业务数据
}

func (resp *QueryUserTaskRemedyResp) Success() bool {
	return resp.Code == 0
}

type QueryUserAllowedRemedysUserTaskRemedyReqBodyBuilder struct {
	userId     string // 用户 ID
	userIdFlag bool

	remedyDate     int // 补卡日期
	remedyDateFlag bool
}

func NewQueryUserAllowedRemedysUserTaskRemedyReqBodyBuilder() *QueryUserAllowedRemedysUserTaskRemedyReqBodyBuilder {
	builder := &QueryUserAllowedRemedysUserTaskRemedyReqBodyBuilder{}
	return builder
}

// 用户 ID
//
//示例值：abd754f7
func (builder *QueryUserAllowedRemedysUserTaskRemedyReqBodyBuilder) UserId(userId string) *QueryUserAllowedRemedysUserTaskRemedyReqBodyBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 补卡日期
//
//示例值：20210104
func (builder *QueryUserAllowedRemedysUserTaskRemedyReqBodyBuilder) RemedyDate(remedyDate int) *QueryUserAllowedRemedysUserTaskRemedyReqBodyBuilder {
	builder.remedyDate = remedyDate
	builder.remedyDateFlag = true
	return builder
}

func (builder *QueryUserAllowedRemedysUserTaskRemedyReqBodyBuilder) Build() *QueryUserAllowedRemedysUserTaskRemedyReqBody {
	req := &QueryUserAllowedRemedysUserTaskRemedyReqBody{}
	if builder.userIdFlag {
		req.UserId = &builder.userId
	}
	if builder.remedyDateFlag {
		req.RemedyDate = &builder.remedyDate
	}
	return req
}

type QueryUserAllowedRemedysUserTaskRemedyPathReqBodyBuilder struct {
	userId         string
	userIdFlag     bool
	remedyDate     int
	remedyDateFlag bool
}

func NewQueryUserAllowedRemedysUserTaskRemedyPathReqBodyBuilder() *QueryUserAllowedRemedysUserTaskRemedyPathReqBodyBuilder {
	builder := &QueryUserAllowedRemedysUserTaskRemedyPathReqBodyBuilder{}
	return builder
}

// 用户 ID
//
// 示例值：abd754f7
func (builder *QueryUserAllowedRemedysUserTaskRemedyPathReqBodyBuilder) UserId(userId string) *QueryUserAllowedRemedysUserTaskRemedyPathReqBodyBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 补卡日期
//
// 示例值：20210104
func (builder *QueryUserAllowedRemedysUserTaskRemedyPathReqBodyBuilder) RemedyDate(remedyDate int) *QueryUserAllowedRemedysUserTaskRemedyPathReqBodyBuilder {
	builder.remedyDate = remedyDate
	builder.remedyDateFlag = true
	return builder
}

func (builder *QueryUserAllowedRemedysUserTaskRemedyPathReqBodyBuilder) Build() (*QueryUserAllowedRemedysUserTaskRemedyReqBody, error) {
	req := &QueryUserAllowedRemedysUserTaskRemedyReqBody{}
	if builder.userIdFlag {
		req.UserId = &builder.userId
	}
	if builder.remedyDateFlag {
		req.RemedyDate = &builder.remedyDate
	}
	return req, nil
}

type QueryUserAllowedRemedysUserTaskRemedyReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *QueryUserAllowedRemedysUserTaskRemedyReqBody
}

func NewQueryUserAllowedRemedysUserTaskRemedyReqBuilder() *QueryUserAllowedRemedysUserTaskRemedyReqBuilder {
	builder := &QueryUserAllowedRemedysUserTaskRemedyReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 请求体和响应体中的 user_id 的员工工号类型
//
// 示例值：employee_id
func (builder *QueryUserAllowedRemedysUserTaskRemedyReqBuilder) EmployeeType(employeeType string) *QueryUserAllowedRemedysUserTaskRemedyReqBuilder {
	builder.apiReq.QueryParams.Set("employee_type", fmt.Sprint(employeeType))
	return builder
}

// 获取用户某天可以补的第几次上 / 下班卡的时间。
func (builder *QueryUserAllowedRemedysUserTaskRemedyReqBuilder) Body(body *QueryUserAllowedRemedysUserTaskRemedyReqBody) *QueryUserAllowedRemedysUserTaskRemedyReqBuilder {
	builder.body = body
	return builder
}

func (builder *QueryUserAllowedRemedysUserTaskRemedyReqBuilder) Build() *QueryUserAllowedRemedysUserTaskRemedyReq {
	req := &QueryUserAllowedRemedysUserTaskRemedyReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type QueryUserAllowedRemedysUserTaskRemedyReqBody struct {
	UserId *string `json:"user_id,omitempty"` // 用户 ID

	RemedyDate *int `json:"remedy_date,omitempty"` // 补卡日期
}

type QueryUserAllowedRemedysUserTaskRemedyReq struct {
	apiReq *larkcore.ApiReq
	Body   *QueryUserAllowedRemedysUserTaskRemedyReqBody `body:""`
}

type QueryUserAllowedRemedysUserTaskRemedyRespData struct {
	UserAllowedRemedys []*UserAllowedRemedy `json:"user_allowed_remedys,omitempty"` // 用户可补卡时间
}

type QueryUserAllowedRemedysUserTaskRemedyResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *QueryUserAllowedRemedysUserTaskRemedyRespData `json:"data"` // 业务数据
}

func (resp *QueryUserAllowedRemedysUserTaskRemedyResp) Success() bool {
	return resp.Code == 0
}

type ListArchiveRuleIterator struct {
	nextPageToken *string
	items         []*ArchiveReportMeta
	index         int
	limit         int
	ctx           context.Context
	req           *ListArchiveRuleReq
	listFunc      func(ctx context.Context, req *ListArchiveRuleReq, options ...larkcore.RequestOptionFunc) (*ListArchiveRuleResp, error)
	options       []larkcore.RequestOptionFunc
	curlNum       int
}

func (iterator *ListArchiveRuleIterator) Next() (bool, *ArchiveReportMeta, error) {
	// 达到最大量，则返回
	if iterator.limit > 0 && iterator.curlNum >= iterator.limit {
		return false, nil, nil
	}

	// 为0则拉取数据
	if iterator.index == 0 || iterator.index >= len(iterator.items) {
		if iterator.index != 0 && iterator.nextPageToken == nil {
			return false, nil, nil
		}
		if iterator.nextPageToken != nil {
			iterator.req.apiReq.QueryParams.Set("page_token", *iterator.nextPageToken)
		}
		resp, err := iterator.listFunc(iterator.ctx, iterator.req, iterator.options...)
		if err != nil {
			return false, nil, err
		}

		if resp.Code != 0 {
			return false, nil, errors.New(fmt.Sprintf("Code:%d,Msg:%s", resp.Code, resp.Msg))
		}

		if len(resp.Data.Items) == 0 {
			return false, nil, nil
		}

		iterator.nextPageToken = resp.Data.PageToken
		iterator.items = resp.Data.Items
		iterator.index = 0
	}

	block := iterator.items[iterator.index]
	iterator.index++
	iterator.curlNum++
	return true, block, nil
}

func (iterator *ListArchiveRuleIterator) NextPageToken() *string {
	return iterator.nextPageToken
}

type ListGroupIterator struct {
	nextPageToken *string
	items         []*GroupMeta
	index         int
	limit         int
	ctx           context.Context
	req           *ListGroupReq
	listFunc      func(ctx context.Context, req *ListGroupReq, options ...larkcore.RequestOptionFunc) (*ListGroupResp, error)
	options       []larkcore.RequestOptionFunc
	curlNum       int
}

func (iterator *ListGroupIterator) Next() (bool, *GroupMeta, error) {
	// 达到最大量，则返回
	if iterator.limit > 0 && iterator.curlNum >= iterator.limit {
		return false, nil, nil
	}

	// 为0则拉取数据
	if iterator.index == 0 || iterator.index >= len(iterator.items) {
		if iterator.index != 0 && iterator.nextPageToken == nil {
			return false, nil, nil
		}
		if iterator.nextPageToken != nil {
			iterator.req.apiReq.QueryParams.Set("page_token", *iterator.nextPageToken)
		}
		resp, err := iterator.listFunc(iterator.ctx, iterator.req, iterator.options...)
		if err != nil {
			return false, nil, err
		}

		if resp.Code != 0 {
			return false, nil, errors.New(fmt.Sprintf("Code:%d,Msg:%s", resp.Code, resp.Msg))
		}

		if len(resp.Data.GroupList) == 0 {
			return false, nil, nil
		}

		iterator.nextPageToken = resp.Data.PageToken
		iterator.items = resp.Data.GroupList
		iterator.index = 0
	}

	block := iterator.items[iterator.index]
	iterator.index++
	iterator.curlNum++
	return true, block, nil
}

func (iterator *ListGroupIterator) NextPageToken() *string {
	return iterator.nextPageToken
}

type ListShiftIterator struct {
	nextPageToken *string
	items         []*Shift
	index         int
	limit         int
	ctx           context.Context
	req           *ListShiftReq
	listFunc      func(ctx context.Context, req *ListShiftReq, options ...larkcore.RequestOptionFunc) (*ListShiftResp, error)
	options       []larkcore.RequestOptionFunc
	curlNum       int
}

func (iterator *ListShiftIterator) Next() (bool, *Shift, error) {
	// 达到最大量，则返回
	if iterator.limit > 0 && iterator.curlNum >= iterator.limit {
		return false, nil, nil
	}

	// 为0则拉取数据
	if iterator.index == 0 || iterator.index >= len(iterator.items) {
		if iterator.index != 0 && iterator.nextPageToken == nil {
			return false, nil, nil
		}
		if iterator.nextPageToken != nil {
			iterator.req.apiReq.QueryParams.Set("page_token", *iterator.nextPageToken)
		}
		resp, err := iterator.listFunc(iterator.ctx, iterator.req, iterator.options...)
		if err != nil {
			return false, nil, err
		}

		if resp.Code != 0 {
			return false, nil, errors.New(fmt.Sprintf("Code:%d,Msg:%s", resp.Code, resp.Msg))
		}

		if len(resp.Data.ShiftList) == 0 {
			return false, nil, nil
		}

		iterator.nextPageToken = resp.Data.PageToken
		iterator.items = resp.Data.ShiftList
		iterator.index = 0
	}

	block := iterator.items[iterator.index]
	iterator.index++
	iterator.curlNum++
	return true, block, nil
}

func (iterator *ListShiftIterator) NextPageToken() *string {
	return iterator.nextPageToken
}
