gitee.com/larksuite/oapi-sdk-go/v3@v3.0.3/service/approval/v4/model.go

// Package approval 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 larkapproval

import (
	"fmt"

	"context"
	"errors"

	"gitee.com/larksuite/oapi-sdk-go/v3/event"

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

const (
	DepartmentIdTypeDepartmentId     = "department_id"      // 以自定义department_id来标识部门
	DepartmentIdTypeOpenDepartmentId = "open_department_id" // 以open_department_id来标识部门
)

const (
	UserIdTypeUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeOpenId  = "open_id"  // 以open_id来识别用户
)

const (
	LocaleZhcn = "zh-CN" // 中文
	LocaleEnus = "en-US" // 英文
	LocaleJajp = "ja-JP" // 日文
)

const (
	DepartmentIdTypeCreateExternalApprovalDepartmentId     = "department_id"      // 以自定义department_id来标识部门
	DepartmentIdTypeCreateExternalApprovalOpenDepartmentId = "open_department_id" // 以open_department_id来标识部门
)

const (
	UserIdTypeCreateExternalApprovalUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeCreateExternalApprovalUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeCreateExternalApprovalOpenId  = "open_id"  // 以open_id来识别用户
)

const (
	StatusPending  = "PENDING"  // 审批中
	StatusApproved = "APPROVED" // 审批流程结束，结果为同意
	StatusRejected = "REJECTED" // 审批流程结束，结果为拒绝
	StatusCanceled = "CANCELED" // 审批发起人撤回
	StatusDeleted  = "DELETED"  // 审批被删除
	StatusHidden   = "HIDDEN"   // 状态隐藏(不显示状态)
)

const (
	DisplayMethodBrowser     = "BROWSER"     // 跳转系统默认浏览器打开
	DisplayMethodSIdebar     = "SIDEBAR"     // 飞书中侧边抽屉打开
	DisplayMethodNormal      = "NORMAL"      // 飞书内嵌页面打开
	DisplayMethodTrusteeship = "TRUSTEESHIP" // 以托管打开
)

const (
	UpdateModeReplace = "REPLACE" // 全量替换，默认值
	UpdateModeUpdate  = "UPDATE"  // 增量更新
)

const (
	ExternalTaskStatusPending     = "PENDING"     // 审批中
	ExternalTaskStatusApproved    = "APPROVED"    // 审批流程结束，结果为同意
	ExternalTaskStatusRejected    = "REJECTED"    // 审批流程结束，结果为拒绝
	ExternalTaskStatusTransferred = "TRANSFERRED" // 任务转交
	ExternalTaskStatusDone        = "DONE"        // 任务通过但审批人未操作；审批人看不到这个任务, 若想要看到, 可以通过抄送该人.
)

const (
	AddSignEnumAddSignPre      = 1 // 前加签
	AddSignEnumAddSignPost     = 2 // 后加签
	AddSignEnumAddSignParallel = 3 // 并加签

)

const (
	ApprovalMethodEnumOrSign  = 1 // 或签
	ApprovalMethodEnumAddSign = 2 // 会签

)

const (
	UserIdTypeCancelInstanceUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeCancelInstanceUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeCancelInstanceOpenId  = "open_id"  // 以open_id来识别用户
)

const (
	UserIdTypeCcInstanceUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeCcInstanceUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeCcInstanceOpenId  = "open_id"  // 以open_id来识别用户
)

const (
	LocaleGetInstanceZhcn = "zh-CN" // 中文
	LocaleGetInstanceEnus = "en-US" // 英文
	LocaleGetInstanceJajp = "ja-JP" // 日文
)

const (
	UserIdTypeGetInstanceUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeGetInstanceOpenId  = "open_id"  // 以open_id来识别用户
	UserIdTypeGetInstanceUnionId = "union_id" // 以union_id来识别用户
)

const (
	UserIdTypePreviewInstanceOpenId  = "open_id"  // 以open_id来识别用户
	UserIdTypePreviewInstanceUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypePreviewInstanceUnionId = "union_id" // 以union_id来识别用户
)

const (
	InstanceStatusPending   = "PENDING"  // 审批中
	InstanceStatusRecall    = "RECALL"   // 撤回
	InstanceStatusReject    = "REJECT"   // 拒绝
	InstanceStatusDeleted   = "DELETED"  // 已删除
	InstanceStatusApproverd = "APPROVED" // 通过
	InstanceStatusAll       = "ALL"      // 所有状态
)

const (
	LocaleQueryInstanceZhCn = "zh-CN" // 中文
	LocaleQueryInstanceEnUs = "en-US" // 英文
	LocaleQueryInstanceJaJp = "ja-JP" // 日文
)

const (
	UserIdTypeQueryInstanceUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeQueryInstanceUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeQueryInstanceOpenId  = "open_id"  // 以open_id来识别用户
)

const (
	ReadStatusREAD   = "READ"   // 已读
	ReadStatusUNREAD = "UNREAD" // 未读
	ReadStatusALL    = "ALL"    // 所有状态
)

const (
	LocaleSearchCcInstanceZhCn = "zh-CN" // 中文
	LocaleSearchCcInstanceEnUs = "en-US" // 英文
	LocaleSearchCcInstanceJaJp = "ja-JP" // 日文
)

const (
	UserIdTypeSearchCcInstanceUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeSearchCcInstanceUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeSearchCcInstanceOpenId  = "open_id"  // 以open_id来识别用户
)

const (
	UserIdTypeSpecifiedRollbackInstanceUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeSpecifiedRollbackInstanceUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeSpecifiedRollbackInstanceOpenId  = "open_id"  // 以open_id来识别用户
)

const (
	UserIdTypeCreateInstanceCommentOpenId  = "open_id"  // open_id(ou_开头)
	UserIdTypeCreateInstanceCommentUserId  = "user_id"  // user_id(字符串)
	UserIdTypeCreateInstanceCommentUnionId = "union_id" // union_id(on_开头)
)

const (
	UserIdTypeDeleteInstanceCommentOpenId  = "open_id"  // open_id(ou_开头)
	UserIdTypeDeleteInstanceCommentUserId  = "user_id"  // user_id（字符串）
	UserIdTypeDeleteInstanceCommentUnionId = "union_id" // union_id（on_开头）
)

const (
	UserIdTypeListInstanceCommentOpenId  = "open_id"  // open_id(ou_开头)
	UserIdTypeListInstanceCommentUserId  = "user_id"  // user_id(字符串)
	UserIdTypeListInstanceCommentUnionId = "union_id" // union_id(on_开头)
)

const (
	UserIdTypeRemoveInstanceCommentOpenId  = "open_id"  // open_id(ou_开头)
	UserIdTypeRemoveInstanceCommentUserId  = "user_id"  // user_id(字符串）
	UserIdTypeRemoveInstanceCommentUnionId = "union_id" // union_id(on_开头)
)

const (
	UserIdTypeApproveTaskUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeApproveTaskUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeApproveTaskOpenId  = "open_id"  // 以open_id来识别用户
)

const (
	TopicTodoApproval      = "1"  // 待办审批
	TopicDoneApproval      = "2"  // 已办审批
	TopicInitiatedApproval = "3"  // 已发起审批
	TopicUnreadNotice      = "17" // 未读知会
	TopicReadNotice        = "18" // 已读知会
)

const (
	UserIdTypeQueryTaskUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeQueryTaskUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeQueryTaskOpenId  = "open_id"  // 以open_id来识别用户
)

const (
	UserIdTypeRejectTaskUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeRejectTaskUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeRejectTaskOpenId  = "open_id"  // 以open_id来识别用户
)

const (
	UserIdTypeResubmitTaskUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeResubmitTaskUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeResubmitTaskOpenId  = "open_id"  // 以open_id来识别用户
)

const (
	TaskStatusPending     = "PENDING"     // 审批中
	TaskStatusReject      = "REJECTED"    // 拒绝
	TaskStatusApproverd   = "APPROVED"    // 通过
	TaskStatusTRANSFERRED = "TRANSFERRED" // 转交
	TaskStatusDONE        = "DONE"        // 已完成
	TaskStatusRMREPEAT    = "RM_REPEAT"   // 去重
	TaskStatusPROCESSED   = "PROCESSED"   // 已处理
	TaskStatusALL         = "ALL"         // 所有状态
)

const (
	LocaleSearchTaskZhCn = "zh-CN" // 中文
	LocaleSearchTaskEnUs = "en-US" // 英文
	LocaleSearchTaskJaJp = "ja-JP" // 日文
)

const (
	UserIdTypeSearchTaskUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeSearchTaskUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeSearchTaskOpenId  = "open_id"  // 以open_id来识别用户
)

const (
	UserIdTypeTransferTaskUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeTransferTaskUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeTransferTaskOpenId  = "open_id"  // 以open_id来识别用户
)

type ActionConfig struct {
	ActionType       *string `json:"action_type,omitempty"`        // 操作类型，每个任务都可以配置2个操作，会展示审批列表中，当用户操作时，回调请求会带上该字段，表示用户进行了同意操作还是拒绝操作
	ActionName       *string `json:"action_name,omitempty"`        // 操作名称，i18n key 用于前台展示，如果 action_type 不是 APPROVAL和REJECT，则必须提供该字段，用于展示特定的操作名称
	IsNeedReason     *bool   `json:"is_need_reason,omitempty"`     // 是否需要意见, 如果为true,则用户操作时，会跳转到 意见填写页面
	IsReasonRequired *bool   `json:"is_reason_required,omitempty"` // 审批意见是否必填
	IsNeedAttachment *bool   `json:"is_need_attachment,omitempty"` // 意见是否支持上传附件
}

type ActionConfigBuilder struct {
	actionType           string // 操作类型，每个任务都可以配置2个操作，会展示审批列表中，当用户操作时，回调请求会带上该字段，表示用户进行了同意操作还是拒绝操作
	actionTypeFlag       bool
	actionName           string // 操作名称，i18n key 用于前台展示，如果 action_type 不是 APPROVAL和REJECT，则必须提供该字段，用于展示特定的操作名称
	actionNameFlag       bool
	isNeedReason         bool // 是否需要意见, 如果为true,则用户操作时，会跳转到 意见填写页面
	isNeedReasonFlag     bool
	isReasonRequired     bool // 审批意见是否必填
	isReasonRequiredFlag bool
	isNeedAttachment     bool // 意见是否支持上传附件
	isNeedAttachmentFlag bool
}

func NewActionConfigBuilder() *ActionConfigBuilder {
	builder := &ActionConfigBuilder{}
	return builder
}

// 操作类型，每个任务都可以配置2个操作，会展示审批列表中，当用户操作时，回调请求会带上该字段，表示用户进行了同意操作还是拒绝操作
//
// 示例值：APPROVE
func (builder *ActionConfigBuilder) ActionType(actionType string) *ActionConfigBuilder {
	builder.actionType = actionType
	builder.actionTypeFlag = true
	return builder
}

// 操作名称，i18n key 用于前台展示，如果 action_type 不是 APPROVAL和REJECT，则必须提供该字段，用于展示特定的操作名称
//
// 示例值：@i18n@5
func (builder *ActionConfigBuilder) ActionName(actionName string) *ActionConfigBuilder {
	builder.actionName = actionName
	builder.actionNameFlag = true
	return builder
}

// 是否需要意见, 如果为true,则用户操作时，会跳转到 意见填写页面
//
// 示例值：false
func (builder *ActionConfigBuilder) IsNeedReason(isNeedReason bool) *ActionConfigBuilder {
	builder.isNeedReason = isNeedReason
	builder.isNeedReasonFlag = true
	return builder
}

// 审批意见是否必填
//
// 示例值：false
func (builder *ActionConfigBuilder) IsReasonRequired(isReasonRequired bool) *ActionConfigBuilder {
	builder.isReasonRequired = isReasonRequired
	builder.isReasonRequiredFlag = true
	return builder
}

// 意见是否支持上传附件
//
// 示例值：false
func (builder *ActionConfigBuilder) IsNeedAttachment(isNeedAttachment bool) *ActionConfigBuilder {
	builder.isNeedAttachment = isNeedAttachment
	builder.isNeedAttachmentFlag = true
	return builder
}

func (builder *ActionConfigBuilder) Build() *ActionConfig {
	req := &ActionConfig{}
	if builder.actionTypeFlag {
		req.ActionType = &builder.actionType

	}
	if builder.actionNameFlag {
		req.ActionName = &builder.actionName

	}
	if builder.isNeedReasonFlag {
		req.IsNeedReason = &builder.isNeedReason

	}
	if builder.isReasonRequiredFlag {
		req.IsReasonRequired = &builder.isReasonRequired

	}
	if builder.isNeedAttachmentFlag {
		req.IsNeedAttachment = &builder.isNeedAttachment

	}
	return req
}

type Approval struct {
	ApprovalCode *string `json:"approval_code,omitempty"` // 审批定义code
	ApprovalName *string `json:"approval_name,omitempty"` // 审批定义名称
}

type ApprovalBuilder struct {
	approvalCode     string // 审批定义code
	approvalCodeFlag bool
	approvalName     string // 审批定义名称
	approvalNameFlag bool
}

func NewApprovalBuilder() *ApprovalBuilder {
	builder := &ApprovalBuilder{}
	return builder
}

// 审批定义code
//
// 示例值：
func (builder *ApprovalBuilder) ApprovalCode(approvalCode string) *ApprovalBuilder {
	builder.approvalCode = approvalCode
	builder.approvalCodeFlag = true
	return builder
}

// 审批定义名称
//
// 示例值：
func (builder *ApprovalBuilder) ApprovalName(approvalName string) *ApprovalBuilder {
	builder.approvalName = approvalName
	builder.approvalNameFlag = true
	return builder
}

func (builder *ApprovalBuilder) Build() *Approval {
	req := &Approval{}
	if builder.approvalCodeFlag {
		req.ApprovalCode = &builder.approvalCode

	}
	if builder.approvalNameFlag {
		req.ApprovalName = &builder.approvalName

	}
	return req
}

type ApprovalApproverCcer struct {
	Type   *string `json:"type,omitempty"`    // 审批/抄送人类型， ; 1. 当 type 为 Supervisor、SupervisorTopDown、DepartmentManager 、DepartmentManagerTopDown 这 4 种时，需要在 level 中填写对应的级数，例如：由下往上三级主管审批，level = 3；;; 2. 当 type 为 Personal 时，需要填写对应的user_id ，用于指定用户；;; 3. 当 approver 为 Free 发起人自选时，不需要指定 user_id 和level；;; 4. ccer不支持 Free 发起人自选
	UserId *string `json:"user_id,omitempty"` // 用户id，根据user_id_type填写
	Level  *string `json:"level,omitempty"`   // 审批级数，当 type 为 Supervisor、SupervisorTopDown、DepartmentManager 、DepartmentManagerTopDown 这 4 种时，需要在 level 中填写对应的级数，例如：由下往上三级主管审批，level = 3
}

type ApprovalApproverCcerBuilder struct {
	type_      string // 审批/抄送人类型， ; 1. 当 type 为 Supervisor、SupervisorTopDown、DepartmentManager 、DepartmentManagerTopDown 这 4 种时，需要在 level 中填写对应的级数，例如：由下往上三级主管审批，level = 3；;; 2. 当 type 为 Personal 时，需要填写对应的user_id ，用于指定用户；;; 3. 当 approver 为 Free 发起人自选时，不需要指定 user_id 和level；;; 4. ccer不支持 Free 发起人自选
	typeFlag   bool
	userId     string // 用户id，根据user_id_type填写
	userIdFlag bool
	level      string // 审批级数，当 type 为 Supervisor、SupervisorTopDown、DepartmentManager 、DepartmentManagerTopDown 这 4 种时，需要在 level 中填写对应的级数，例如：由下往上三级主管审批，level = 3
	levelFlag  bool
}

func NewApprovalApproverCcerBuilder() *ApprovalApproverCcerBuilder {
	builder := &ApprovalApproverCcerBuilder{}
	return builder
}

// 审批/抄送人类型， ; 1. 当 type 为 Supervisor、SupervisorTopDown、DepartmentManager 、DepartmentManagerTopDown 这 4 种时，需要在 level 中填写对应的级数，例如：由下往上三级主管审批，level = 3；;; 2. 当 type 为 Personal 时，需要填写对应的user_id ，用于指定用户；;; 3. 当 approver 为 Free 发起人自选时，不需要指定 user_id 和level；;; 4. ccer不支持 Free 发起人自选
//
// 示例值：Supervisor
func (builder *ApprovalApproverCcerBuilder) Type(type_ string) *ApprovalApproverCcerBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

// 用户id，根据user_id_type填写
//
// 示例值：f7cb567e
func (builder *ApprovalApproverCcerBuilder) UserId(userId string) *ApprovalApproverCcerBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 审批级数，当 type 为 Supervisor、SupervisorTopDown、DepartmentManager 、DepartmentManagerTopDown 这 4 种时，需要在 level 中填写对应的级数，例如：由下往上三级主管审批，level = 3
//
// 示例值：3
func (builder *ApprovalApproverCcerBuilder) Level(level string) *ApprovalApproverCcerBuilder {
	builder.level = level
	builder.levelFlag = true
	return builder
}

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

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.levelFlag {
		req.Level = &builder.level

	}
	return req
}

type ApprovalConfig struct {
	CanUpdateViewer  *bool   `json:"can_update_viewer,omitempty"`  // 允许用户修改可见范围
	CanUpdateForm    *bool   `json:"can_update_form,omitempty"`    // 允许用户更新表单
	CanUpdateProcess *bool   `json:"can_update_process,omitempty"` // 允许用户更新流程定义
	CanUpdateRevert  *bool   `json:"can_update_revert,omitempty"`  // 允许用户更新撤回设置
	HelpUrl          *string `json:"help_url,omitempty"`           // 帮助文档链接
}

type ApprovalConfigBuilder struct {
	canUpdateViewer      bool // 允许用户修改可见范围
	canUpdateViewerFlag  bool
	canUpdateForm        bool // 允许用户更新表单
	canUpdateFormFlag    bool
	canUpdateProcess     bool // 允许用户更新流程定义
	canUpdateProcessFlag bool
	canUpdateRevert      bool // 允许用户更新撤回设置
	canUpdateRevertFlag  bool
	helpUrl              string // 帮助文档链接
	helpUrlFlag          bool
}

func NewApprovalConfigBuilder() *ApprovalConfigBuilder {
	builder := &ApprovalConfigBuilder{}
	return builder
}

// 允许用户修改可见范围
//
// 示例值：false
func (builder *ApprovalConfigBuilder) CanUpdateViewer(canUpdateViewer bool) *ApprovalConfigBuilder {
	builder.canUpdateViewer = canUpdateViewer
	builder.canUpdateViewerFlag = true
	return builder
}

// 允许用户更新表单
//
// 示例值：false
func (builder *ApprovalConfigBuilder) CanUpdateForm(canUpdateForm bool) *ApprovalConfigBuilder {
	builder.canUpdateForm = canUpdateForm
	builder.canUpdateFormFlag = true
	return builder
}

// 允许用户更新流程定义
//
// 示例值：false
func (builder *ApprovalConfigBuilder) CanUpdateProcess(canUpdateProcess bool) *ApprovalConfigBuilder {
	builder.canUpdateProcess = canUpdateProcess
	builder.canUpdateProcessFlag = true
	return builder
}

// 允许用户更新撤回设置
//
// 示例值：false
func (builder *ApprovalConfigBuilder) CanUpdateRevert(canUpdateRevert bool) *ApprovalConfigBuilder {
	builder.canUpdateRevert = canUpdateRevert
	builder.canUpdateRevertFlag = true
	return builder
}

// 帮助文档链接
//
// 示例值：https://www.baidu.com
func (builder *ApprovalConfigBuilder) HelpUrl(helpUrl string) *ApprovalConfigBuilder {
	builder.helpUrl = helpUrl
	builder.helpUrlFlag = true
	return builder
}

func (builder *ApprovalConfigBuilder) Build() *ApprovalConfig {
	req := &ApprovalConfig{}
	if builder.canUpdateViewerFlag {
		req.CanUpdateViewer = &builder.canUpdateViewer

	}
	if builder.canUpdateFormFlag {
		req.CanUpdateForm = &builder.canUpdateForm

	}
	if builder.canUpdateProcessFlag {
		req.CanUpdateProcess = &builder.canUpdateProcess

	}
	if builder.canUpdateRevertFlag {
		req.CanUpdateRevert = &builder.canUpdateRevert

	}
	if builder.helpUrlFlag {
		req.HelpUrl = &builder.helpUrl

	}
	return req
}

type ApprovalCreate struct {
	ApprovalName      *string                  `json:"approval_name,omitempty"`       // 审批名称的国际化文案 Key，以 @i18n@ 开头，长度不得少于 9 个字符
	ApprovalCode      *string                  `json:"approval_code,omitempty"`       // 传空表示新建
	Description       *string                  `json:"description,omitempty"`         // 审批描述的国际化文案 Key，以 @i18n@ 开头，长度不得少于 9 个字符
	Viewers           []*ApprovalCreateViewers `json:"viewers,omitempty"`             // viewers 字段指定了哪些人能从审批应用的前台发起该审批。;; 1. 当 view_type 为 USER，需要填写viewer_user_id；;; 2. 当 view_type 为DEPARTMENT，需要填写viewer_department_id；;; 3. 当 view_type 为TENANT或NONE时，viewer_user_id和viewer_department_id无需填写
	Form              *ApprovalForm            `json:"form,omitempty"`                // 审批定义表单
	NodeList          []*ApprovalNode          `json:"node_list,omitempty"`           // 审批定义节点，需要将开始节点作为 list 第一个元素，结束节点作为最后一个元素
	Settings          *ApprovalSetting         `json:"settings,omitempty"`            // 审批定义其他设置
	Config            *ApprovalConfig          `json:"config,omitempty"`              // 审批定义配置项，用于配置对应审批定义是否可以由用户在审批后台进行修改
	Icon              *int                     `json:"icon,omitempty"`                // 审批图标枚举，详见下方说明，默认为 0
	I18nResources     []*I18nResource          `json:"i18n_resources,omitempty"`      // 国际化文案
	ProcessManagerIds []string                 `json:"process_manager_ids,omitempty"` // 根据user_id_type填写流程管理员的用户id
}

type ApprovalCreateBuilder struct {
	approvalName          string // 审批名称的国际化文案 Key，以 @i18n@ 开头，长度不得少于 9 个字符
	approvalNameFlag      bool
	approvalCode          string // 传空表示新建
	approvalCodeFlag      bool
	description           string // 审批描述的国际化文案 Key，以 @i18n@ 开头，长度不得少于 9 个字符
	descriptionFlag       bool
	viewers               []*ApprovalCreateViewers // viewers 字段指定了哪些人能从审批应用的前台发起该审批。;; 1. 当 view_type 为 USER，需要填写viewer_user_id；;; 2. 当 view_type 为DEPARTMENT，需要填写viewer_department_id；;; 3. 当 view_type 为TENANT或NONE时，viewer_user_id和viewer_department_id无需填写
	viewersFlag           bool
	form                  *ApprovalForm // 审批定义表单
	formFlag              bool
	nodeList              []*ApprovalNode // 审批定义节点，需要将开始节点作为 list 第一个元素，结束节点作为最后一个元素
	nodeListFlag          bool
	settings              *ApprovalSetting // 审批定义其他设置
	settingsFlag          bool
	config                *ApprovalConfig // 审批定义配置项，用于配置对应审批定义是否可以由用户在审批后台进行修改
	configFlag            bool
	icon                  int // 审批图标枚举，详见下方说明，默认为 0
	iconFlag              bool
	i18nResources         []*I18nResource // 国际化文案
	i18nResourcesFlag     bool
	processManagerIds     []string // 根据user_id_type填写流程管理员的用户id
	processManagerIdsFlag bool
}

func NewApprovalCreateBuilder() *ApprovalCreateBuilder {
	builder := &ApprovalCreateBuilder{}
	return builder
}

// 审批名称的国际化文案 Key，以 @i18n@ 开头，长度不得少于 9 个字符
//
// 示例值：@i18n@approval_name
func (builder *ApprovalCreateBuilder) ApprovalName(approvalName string) *ApprovalCreateBuilder {
	builder.approvalName = approvalName
	builder.approvalNameFlag = true
	return builder
}

// 传空表示新建
//
// 示例值：7C468A54-8745-2245-9675-08B7C63E7A85
func (builder *ApprovalCreateBuilder) ApprovalCode(approvalCode string) *ApprovalCreateBuilder {
	builder.approvalCode = approvalCode
	builder.approvalCodeFlag = true
	return builder
}

// 审批描述的国际化文案 Key，以 @i18n@ 开头，长度不得少于 9 个字符
//
// 示例值：@i18n@description
func (builder *ApprovalCreateBuilder) Description(description string) *ApprovalCreateBuilder {
	builder.description = description
	builder.descriptionFlag = true
	return builder
}

// viewers 字段指定了哪些人能从审批应用的前台发起该审批。;; 1. 当 view_type 为 USER，需要填写viewer_user_id；;; 2. 当 view_type 为DEPARTMENT，需要填写viewer_department_id；;; 3. 当 view_type 为TENANT或NONE时，viewer_user_id和viewer_department_id无需填写
//
// 示例值：
func (builder *ApprovalCreateBuilder) Viewers(viewers []*ApprovalCreateViewers) *ApprovalCreateBuilder {
	builder.viewers = viewers
	builder.viewersFlag = true
	return builder
}

// 审批定义表单
//
// 示例值：
func (builder *ApprovalCreateBuilder) Form(form *ApprovalForm) *ApprovalCreateBuilder {
	builder.form = form
	builder.formFlag = true
	return builder
}

// 审批定义节点，需要将开始节点作为 list 第一个元素，结束节点作为最后一个元素
//
// 示例值：
func (builder *ApprovalCreateBuilder) NodeList(nodeList []*ApprovalNode) *ApprovalCreateBuilder {
	builder.nodeList = nodeList
	builder.nodeListFlag = true
	return builder
}

// 审批定义其他设置
//
// 示例值：
func (builder *ApprovalCreateBuilder) Settings(settings *ApprovalSetting) *ApprovalCreateBuilder {
	builder.settings = settings
	builder.settingsFlag = true
	return builder
}

// 审批定义配置项，用于配置对应审批定义是否可以由用户在审批后台进行修改
//
// 示例值：
func (builder *ApprovalCreateBuilder) Config(config *ApprovalConfig) *ApprovalCreateBuilder {
	builder.config = config
	builder.configFlag = true
	return builder
}

// 审批图标枚举，详见下方说明，默认为 0
//
// 示例值：0
func (builder *ApprovalCreateBuilder) Icon(icon int) *ApprovalCreateBuilder {
	builder.icon = icon
	builder.iconFlag = true
	return builder
}

// 国际化文案
//
// 示例值：
func (builder *ApprovalCreateBuilder) I18nResources(i18nResources []*I18nResource) *ApprovalCreateBuilder {
	builder.i18nResources = i18nResources
	builder.i18nResourcesFlag = true
	return builder
}

// 根据user_id_type填写流程管理员的用户id
//
// 示例值：["1c5ea995"]
func (builder *ApprovalCreateBuilder) ProcessManagerIds(processManagerIds []string) *ApprovalCreateBuilder {
	builder.processManagerIds = processManagerIds
	builder.processManagerIdsFlag = true
	return builder
}

func (builder *ApprovalCreateBuilder) Build() *ApprovalCreate {
	req := &ApprovalCreate{}
	if builder.approvalNameFlag {
		req.ApprovalName = &builder.approvalName

	}
	if builder.approvalCodeFlag {
		req.ApprovalCode = &builder.approvalCode

	}
	if builder.descriptionFlag {
		req.Description = &builder.description

	}
	if builder.viewersFlag {
		req.Viewers = builder.viewers
	}
	if builder.formFlag {
		req.Form = builder.form
	}
	if builder.nodeListFlag {
		req.NodeList = builder.nodeList
	}
	if builder.settingsFlag {
		req.Settings = builder.settings
	}
	if builder.configFlag {
		req.Config = builder.config
	}
	if builder.iconFlag {
		req.Icon = &builder.icon

	}
	if builder.i18nResourcesFlag {
		req.I18nResources = builder.i18nResources
	}
	if builder.processManagerIdsFlag {
		req.ProcessManagerIds = builder.processManagerIds
	}
	return req
}

type ApprovalCreateExternal struct {
	BizName                     *string `json:"biz_name,omitempty"`                      // 列表中用于提示审批来自哪里，i18n key， 注意不需要“来自”前缀，审批中心会拼上前缀
	BizType                     *string `json:"biz_type,omitempty"`                      // 审批定义业务类别
	CreateLinkMobile            *string `json:"create_link_mobile,omitempty"`            // 移动端发起链接，如果设置了该链接，则会在移动端审批发起页展示该审批，用户点击后会跳转到该链接进行发起； 如果不填，则在mobile端不显示该审批
	CreateLinkPc                *string `json:"create_link_pc,omitempty"`                // PC端发起链接，如果设置了该链接，则会在PC端审批发起页展示该审批，用户点击后会跳转到该链接进行发起； 如果不填，则在PC端不显示该审批；
	SupportPc                   *bool   `json:"support_pc,omitempty"`                    // 审批实例、审批任务、审批抄送是否要在PC端展示，如果为 true，则PC端列表会展示该定义下的实例信息，否则，不展示
	SupportMobile               *bool   `json:"support_mobile,omitempty"`                // 审批实例、审批任务、审批抄送是否要在移动端展示，如果为 true，则移动端列表会展示该定义下的实例信息，否则，不展示； support_pc和support_mobile不可都为false，否则不展示
	SupportBatchRead            *bool   `json:"support_batch_read,omitempty"`            // 是否支持批量已读
	EnableMarkReaded            *bool   `json:"enable_mark_readed,omitempty"`            // 是否支持标注可读（该字段无效）
	EnableQuickOperate          *bool   `json:"enable_quick_operate,omitempty"`          // 是否支持快速操作
	ActionCallbackUrl           *string `json:"action_callback_url,omitempty"`           // 三方系统的操作回调 url，【待审批】列表的任务审批人点同意或拒绝操作后，审批中心调用该地址通知三方系统，回调地址相关信息可参见：[三方审批快捷审批回调](/ssl:ttdoc/ukTMukTMukTM/ukjNyYjL5YjM24SO2IjN/quick-approval-callback)
	ActionCallbackToken         *string `json:"action_callback_token,omitempty"`         // 回调时带的 token， 用于业务系统验证请求来自审批,具体参考 [开放平台文档](/ssl:ttdoc/ukTMukTMukTM/uUTNz4SN1MjL1UzM)
	ActionCallbackKey           *string `json:"action_callback_key,omitempty"`           // 请求参数加密密钥，如果配置了该参数，则会对请求参数进行加密，业务需要对请求进行解密，加解密算法参考 [关联外部选项说明](/ssl:ttdoc/ukTMukTMukTM/uADM4QjLwADO04CMwgDN)
	AllowBatchOperate           *bool   `json:"allow_batch_operate,omitempty"`           // 是否支持批量审批
	ExcludeEfficiencyStatistics *bool   `json:"exclude_efficiency_statistics,omitempty"` // 审批流程数据是否不纳入效率统计
}

type ApprovalCreateExternalBuilder struct {
	bizName                         string // 列表中用于提示审批来自哪里，i18n key， 注意不需要“来自”前缀，审批中心会拼上前缀
	bizNameFlag                     bool
	bizType                         string // 审批定义业务类别
	bizTypeFlag                     bool
	createLinkMobile                string // 移动端发起链接，如果设置了该链接，则会在移动端审批发起页展示该审批，用户点击后会跳转到该链接进行发起； 如果不填，则在mobile端不显示该审批
	createLinkMobileFlag            bool
	createLinkPc                    string // PC端发起链接，如果设置了该链接，则会在PC端审批发起页展示该审批，用户点击后会跳转到该链接进行发起； 如果不填，则在PC端不显示该审批；
	createLinkPcFlag                bool
	supportPc                       bool // 审批实例、审批任务、审批抄送是否要在PC端展示，如果为 true，则PC端列表会展示该定义下的实例信息，否则，不展示
	supportPcFlag                   bool
	supportMobile                   bool // 审批实例、审批任务、审批抄送是否要在移动端展示，如果为 true，则移动端列表会展示该定义下的实例信息，否则，不展示； support_pc和support_mobile不可都为false，否则不展示
	supportMobileFlag               bool
	supportBatchRead                bool // 是否支持批量已读
	supportBatchReadFlag            bool
	enableMarkReaded                bool // 是否支持标注可读（该字段无效）
	enableMarkReadedFlag            bool
	enableQuickOperate              bool // 是否支持快速操作
	enableQuickOperateFlag          bool
	actionCallbackUrl               string // 三方系统的操作回调 url，【待审批】列表的任务审批人点同意或拒绝操作后，审批中心调用该地址通知三方系统，回调地址相关信息可参见：[三方审批快捷审批回调](/ssl:ttdoc/ukTMukTMukTM/ukjNyYjL5YjM24SO2IjN/quick-approval-callback)
	actionCallbackUrlFlag           bool
	actionCallbackToken             string // 回调时带的 token， 用于业务系统验证请求来自审批,具体参考 [开放平台文档](/ssl:ttdoc/ukTMukTMukTM/uUTNz4SN1MjL1UzM)
	actionCallbackTokenFlag         bool
	actionCallbackKey               string // 请求参数加密密钥，如果配置了该参数，则会对请求参数进行加密，业务需要对请求进行解密，加解密算法参考 [关联外部选项说明](/ssl:ttdoc/ukTMukTMukTM/uADM4QjLwADO04CMwgDN)
	actionCallbackKeyFlag           bool
	allowBatchOperate               bool // 是否支持批量审批
	allowBatchOperateFlag           bool
	excludeEfficiencyStatistics     bool // 审批流程数据是否不纳入效率统计
	excludeEfficiencyStatisticsFlag bool
}

func NewApprovalCreateExternalBuilder() *ApprovalCreateExternalBuilder {
	builder := &ApprovalCreateExternalBuilder{}
	return builder
}

// 列表中用于提示审批来自哪里，i18n key， 注意不需要“来自”前缀，审批中心会拼上前缀
//
// 示例值：@i18n@3
func (builder *ApprovalCreateExternalBuilder) BizName(bizName string) *ApprovalCreateExternalBuilder {
	builder.bizName = bizName
	builder.bizNameFlag = true
	return builder
}

// 审批定义业务类别
//
// 示例值：permission
func (builder *ApprovalCreateExternalBuilder) BizType(bizType string) *ApprovalCreateExternalBuilder {
	builder.bizType = bizType
	builder.bizTypeFlag = true
	return builder
}

// 移动端发起链接，如果设置了该链接，则会在移动端审批发起页展示该审批，用户点击后会跳转到该链接进行发起； 如果不填，则在mobile端不显示该审批
//
// 示例值：https://applink.feishu.cn/client/mini_program/open?appId=cli_9c90fc38e07a9101&path=pages/approval-form/index?id=9999
func (builder *ApprovalCreateExternalBuilder) CreateLinkMobile(createLinkMobile string) *ApprovalCreateExternalBuilder {
	builder.createLinkMobile = createLinkMobile
	builder.createLinkMobileFlag = true
	return builder
}

// PC端发起链接，如果设置了该链接，则会在PC端审批发起页展示该审批，用户点击后会跳转到该链接进行发起； 如果不填，则在PC端不显示该审批；
//
// 示例值：https://applink.feishu.cn/client/mini_program/open?mode=appCenter&appId=cli_9c90fc38e07a9101&path=pc/pages/create-form/index?id=9999
func (builder *ApprovalCreateExternalBuilder) CreateLinkPc(createLinkPc string) *ApprovalCreateExternalBuilder {
	builder.createLinkPc = createLinkPc
	builder.createLinkPcFlag = true
	return builder
}

// 审批实例、审批任务、审批抄送是否要在PC端展示，如果为 true，则PC端列表会展示该定义下的实例信息，否则，不展示
//
// 示例值：true
func (builder *ApprovalCreateExternalBuilder) SupportPc(supportPc bool) *ApprovalCreateExternalBuilder {
	builder.supportPc = supportPc
	builder.supportPcFlag = true
	return builder
}

// 审批实例、审批任务、审批抄送是否要在移动端展示，如果为 true，则移动端列表会展示该定义下的实例信息，否则，不展示； support_pc和support_mobile不可都为false，否则不展示
//
// 示例值：true
func (builder *ApprovalCreateExternalBuilder) SupportMobile(supportMobile bool) *ApprovalCreateExternalBuilder {
	builder.supportMobile = supportMobile
	builder.supportMobileFlag = true
	return builder
}

// 是否支持批量已读
//
// 示例值：true
func (builder *ApprovalCreateExternalBuilder) SupportBatchRead(supportBatchRead bool) *ApprovalCreateExternalBuilder {
	builder.supportBatchRead = supportBatchRead
	builder.supportBatchReadFlag = true
	return builder
}

// 是否支持标注可读（该字段无效）
//
// 示例值：true
func (builder *ApprovalCreateExternalBuilder) EnableMarkReaded(enableMarkReaded bool) *ApprovalCreateExternalBuilder {
	builder.enableMarkReaded = enableMarkReaded
	builder.enableMarkReadedFlag = true
	return builder
}

// 是否支持快速操作
//
// 示例值：true
func (builder *ApprovalCreateExternalBuilder) EnableQuickOperate(enableQuickOperate bool) *ApprovalCreateExternalBuilder {
	builder.enableQuickOperate = enableQuickOperate
	builder.enableQuickOperateFlag = true
	return builder
}

// 三方系统的操作回调 url，【待审批】列表的任务审批人点同意或拒绝操作后，审批中心调用该地址通知三方系统，回调地址相关信息可参见：[三方审批快捷审批回调](/ssl:ttdoc/ukTMukTMukTM/ukjNyYjL5YjM24SO2IjN/quick-approval-callback)
//
// 示例值：http://www.feishu.cn/approval/openapi/instanceOperate
func (builder *ApprovalCreateExternalBuilder) ActionCallbackUrl(actionCallbackUrl string) *ApprovalCreateExternalBuilder {
	builder.actionCallbackUrl = actionCallbackUrl
	builder.actionCallbackUrlFlag = true
	return builder
}

// 回调时带的 token， 用于业务系统验证请求来自审批,具体参考 [开放平台文档](/ssl:ttdoc/ukTMukTMukTM/uUTNz4SN1MjL1UzM)
//
// 示例值：sdjkljkx9lsadf110
func (builder *ApprovalCreateExternalBuilder) ActionCallbackToken(actionCallbackToken string) *ApprovalCreateExternalBuilder {
	builder.actionCallbackToken = actionCallbackToken
	builder.actionCallbackTokenFlag = true
	return builder
}

// 请求参数加密密钥，如果配置了该参数，则会对请求参数进行加密，业务需要对请求进行解密，加解密算法参考 [关联外部选项说明](/ssl:ttdoc/ukTMukTMukTM/uADM4QjLwADO04CMwgDN)
//
// 示例值：gfdqedvsadfgfsd
func (builder *ApprovalCreateExternalBuilder) ActionCallbackKey(actionCallbackKey string) *ApprovalCreateExternalBuilder {
	builder.actionCallbackKey = actionCallbackKey
	builder.actionCallbackKeyFlag = true
	return builder
}

// 是否支持批量审批
//
// 示例值：true
func (builder *ApprovalCreateExternalBuilder) AllowBatchOperate(allowBatchOperate bool) *ApprovalCreateExternalBuilder {
	builder.allowBatchOperate = allowBatchOperate
	builder.allowBatchOperateFlag = true
	return builder
}

// 审批流程数据是否不纳入效率统计
//
// 示例值：true
func (builder *ApprovalCreateExternalBuilder) ExcludeEfficiencyStatistics(excludeEfficiencyStatistics bool) *ApprovalCreateExternalBuilder {
	builder.excludeEfficiencyStatistics = excludeEfficiencyStatistics
	builder.excludeEfficiencyStatisticsFlag = true
	return builder
}

func (builder *ApprovalCreateExternalBuilder) Build() *ApprovalCreateExternal {
	req := &ApprovalCreateExternal{}
	if builder.bizNameFlag {
		req.BizName = &builder.bizName

	}
	if builder.bizTypeFlag {
		req.BizType = &builder.bizType

	}
	if builder.createLinkMobileFlag {
		req.CreateLinkMobile = &builder.createLinkMobile

	}
	if builder.createLinkPcFlag {
		req.CreateLinkPc = &builder.createLinkPc

	}
	if builder.supportPcFlag {
		req.SupportPc = &builder.supportPc

	}
	if builder.supportMobileFlag {
		req.SupportMobile = &builder.supportMobile

	}
	if builder.supportBatchReadFlag {
		req.SupportBatchRead = &builder.supportBatchRead

	}
	if builder.enableMarkReadedFlag {
		req.EnableMarkReaded = &builder.enableMarkReaded

	}
	if builder.enableQuickOperateFlag {
		req.EnableQuickOperate = &builder.enableQuickOperate

	}
	if builder.actionCallbackUrlFlag {
		req.ActionCallbackUrl = &builder.actionCallbackUrl

	}
	if builder.actionCallbackTokenFlag {
		req.ActionCallbackToken = &builder.actionCallbackToken

	}
	if builder.actionCallbackKeyFlag {
		req.ActionCallbackKey = &builder.actionCallbackKey

	}
	if builder.allowBatchOperateFlag {
		req.AllowBatchOperate = &builder.allowBatchOperate

	}
	if builder.excludeEfficiencyStatisticsFlag {
		req.ExcludeEfficiencyStatistics = &builder.excludeEfficiencyStatistics

	}
	return req
}

type ApprovalCreateViewers struct {
	ViewerType         *string `json:"viewer_type,omitempty"`          // 可见人类型
	ViewerUserId       *string `json:"viewer_user_id,omitempty"`       // 当 view_type 是 USER，根据user_id_type填写用户id
	ViewerDepartmentId *string `json:"viewer_department_id,omitempty"` // 当 view_type 为DEPARTMENT，根据department_id_type填写部门id
}

type ApprovalCreateViewersBuilder struct {
	viewerType             string // 可见人类型
	viewerTypeFlag         bool
	viewerUserId           string // 当 view_type 是 USER，根据user_id_type填写用户id
	viewerUserIdFlag       bool
	viewerDepartmentId     string // 当 view_type 为DEPARTMENT，根据department_id_type填写部门id
	viewerDepartmentIdFlag bool
}

func NewApprovalCreateViewersBuilder() *ApprovalCreateViewersBuilder {
	builder := &ApprovalCreateViewersBuilder{}
	return builder
}

// 可见人类型
//
// 示例值：USER
func (builder *ApprovalCreateViewersBuilder) ViewerType(viewerType string) *ApprovalCreateViewersBuilder {
	builder.viewerType = viewerType
	builder.viewerTypeFlag = true
	return builder
}

// 当 view_type 是 USER，根据user_id_type填写用户id
//
// 示例值：19a294c2
func (builder *ApprovalCreateViewersBuilder) ViewerUserId(viewerUserId string) *ApprovalCreateViewersBuilder {
	builder.viewerUserId = viewerUserId
	builder.viewerUserIdFlag = true
	return builder
}

// 当 view_type 为DEPARTMENT，根据department_id_type填写部门id
//
// 示例值：od-ac9d697abfa990b715dcc33d58a62a9d
func (builder *ApprovalCreateViewersBuilder) ViewerDepartmentId(viewerDepartmentId string) *ApprovalCreateViewersBuilder {
	builder.viewerDepartmentId = viewerDepartmentId
	builder.viewerDepartmentIdFlag = true
	return builder
}

func (builder *ApprovalCreateViewersBuilder) Build() *ApprovalCreateViewers {
	req := &ApprovalCreateViewers{}
	if builder.viewerTypeFlag {
		req.ViewerType = &builder.viewerType

	}
	if builder.viewerUserIdFlag {
		req.ViewerUserId = &builder.viewerUserId

	}
	if builder.viewerDepartmentIdFlag {
		req.ViewerDepartmentId = &builder.viewerDepartmentId

	}
	return req
}

type ApprovalEvent struct {
	ApprovalId       *string `json:"approval_id,omitempty"`        //
	ApprovalCode     *string `json:"approval_code,omitempty"`      //
	VersionId        *string `json:"version_id,omitempty"`         //
	WidgetGroupType  *int    `json:"widget_group_type,omitempty"`  //
	FormDefinitionId *string `json:"form_definition_id,omitempty"` //
	ProcessObj       *string `json:"process_obj,omitempty"`        //
	Timestamp        *string `json:"timestamp,omitempty"`          //
	Extra            *string `json:"extra,omitempty"`              //
}

type ApprovalEventBuilder struct {
	approvalId           string //
	approvalIdFlag       bool
	approvalCode         string //
	approvalCodeFlag     bool
	versionId            string //
	versionIdFlag        bool
	widgetGroupType      int //
	widgetGroupTypeFlag  bool
	formDefinitionId     string //
	formDefinitionIdFlag bool
	processObj           string //
	processObjFlag       bool
	timestamp            string //
	timestampFlag        bool
	extra                string //
	extraFlag            bool
}

func NewApprovalEventBuilder() *ApprovalEventBuilder {
	builder := &ApprovalEventBuilder{}
	return builder
}

//
//
// 示例值：
func (builder *ApprovalEventBuilder) ApprovalId(approvalId string) *ApprovalEventBuilder {
	builder.approvalId = approvalId
	builder.approvalIdFlag = true
	return builder
}

//
//
// 示例值：
func (builder *ApprovalEventBuilder) ApprovalCode(approvalCode string) *ApprovalEventBuilder {
	builder.approvalCode = approvalCode
	builder.approvalCodeFlag = true
	return builder
}

//
//
// 示例值：
func (builder *ApprovalEventBuilder) VersionId(versionId string) *ApprovalEventBuilder {
	builder.versionId = versionId
	builder.versionIdFlag = true
	return builder
}

//
//
// 示例值：
func (builder *ApprovalEventBuilder) WidgetGroupType(widgetGroupType int) *ApprovalEventBuilder {
	builder.widgetGroupType = widgetGroupType
	builder.widgetGroupTypeFlag = true
	return builder
}

//
//
// 示例值：
func (builder *ApprovalEventBuilder) FormDefinitionId(formDefinitionId string) *ApprovalEventBuilder {
	builder.formDefinitionId = formDefinitionId
	builder.formDefinitionIdFlag = true
	return builder
}

//
//
// 示例值：
func (builder *ApprovalEventBuilder) ProcessObj(processObj string) *ApprovalEventBuilder {
	builder.processObj = processObj
	builder.processObjFlag = true
	return builder
}

//
//
// 示例值：
func (builder *ApprovalEventBuilder) Timestamp(timestamp string) *ApprovalEventBuilder {
	builder.timestamp = timestamp
	builder.timestampFlag = true
	return builder
}

//
//
// 示例值：
func (builder *ApprovalEventBuilder) Extra(extra string) *ApprovalEventBuilder {
	builder.extra = extra
	builder.extraFlag = true
	return builder
}

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

	}
	if builder.approvalCodeFlag {
		req.ApprovalCode = &builder.approvalCode

	}
	if builder.versionIdFlag {
		req.VersionId = &builder.versionId

	}
	if builder.widgetGroupTypeFlag {
		req.WidgetGroupType = &builder.widgetGroupType

	}
	if builder.formDefinitionIdFlag {
		req.FormDefinitionId = &builder.formDefinitionId

	}
	if builder.processObjFlag {
		req.ProcessObj = &builder.processObj

	}
	if builder.timestampFlag {
		req.Timestamp = &builder.timestamp

	}
	if builder.extraFlag {
		req.Extra = &builder.extra

	}
	return req
}

type ApprovalForm struct {
	FormContent *string `json:"form_content,omitempty"` // 审批定义表单，json 数组，见下方form_content字段说明
}

type ApprovalFormBuilder struct {
	formContent     string // 审批定义表单，json 数组，见下方form_content字段说明
	formContentFlag bool
}

func NewApprovalFormBuilder() *ApprovalFormBuilder {
	builder := &ApprovalFormBuilder{}
	return builder
}

// 审批定义表单，json 数组，见下方form_content字段说明
//
// 示例值：[{\"id\":\"user_name\", \"type\": \"input\", \"required\":true, \"name\":\"@i18n@widget1\"}]
func (builder *ApprovalFormBuilder) FormContent(formContent string) *ApprovalFormBuilder {
	builder.formContent = formContent
	builder.formContentFlag = true
	return builder
}

func (builder *ApprovalFormBuilder) Build() *ApprovalForm {
	req := &ApprovalForm{}
	if builder.formContentFlag {
		req.FormContent = &builder.formContent

	}
	return req
}

type ApprovalNode struct {
	Id             *string                 `json:"id,omitempty"`              // 节点 ID，开始节点的 ID 为 START，结束节点的 ID 为 END，开始和结束节点不需要指定 name、node_type 以及 approver
	Name           *string                 `json:"name,omitempty"`            // 节点名称的国际化文案 Key，以 @i18n@ 开头，长度不得少于 9 个字符
	NodeType       *string                 `json:"node_type,omitempty"`       // 审批类型枚举,当 node_type 为依次审批时，审批人必须为『发起人自选』
	Approver       []*ApprovalApproverCcer `json:"approver,omitempty"`        // 审批人列表
	Ccer           []*ApprovalApproverCcer `json:"ccer,omitempty"`            // 抄送人列表
	PrivilegeField *FieldGroup             `json:"privilege_field,omitempty"` // 表单项的控件权限
}

type ApprovalNodeBuilder struct {
	id                 string // 节点 ID，开始节点的 ID 为 START，结束节点的 ID 为 END，开始和结束节点不需要指定 name、node_type 以及 approver
	idFlag             bool
	name               string // 节点名称的国际化文案 Key，以 @i18n@ 开头，长度不得少于 9 个字符
	nameFlag           bool
	nodeType           string // 审批类型枚举,当 node_type 为依次审批时，审批人必须为『发起人自选』
	nodeTypeFlag       bool
	approver           []*ApprovalApproverCcer // 审批人列表
	approverFlag       bool
	ccer               []*ApprovalApproverCcer // 抄送人列表
	ccerFlag           bool
	privilegeField     *FieldGroup // 表单项的控件权限
	privilegeFieldFlag bool
}

func NewApprovalNodeBuilder() *ApprovalNodeBuilder {
	builder := &ApprovalNodeBuilder{}
	return builder
}

// 节点 ID，开始节点的 ID 为 START，结束节点的 ID 为 END，开始和结束节点不需要指定 name、node_type 以及 approver
//
// 示例值：START
func (builder *ApprovalNodeBuilder) Id(id string) *ApprovalNodeBuilder {
	builder.id = id
	builder.idFlag = true
	return builder
}

// 节点名称的国际化文案 Key，以 @i18n@ 开头，长度不得少于 9 个字符
//
// 示例值：@i18n@node_name
func (builder *ApprovalNodeBuilder) Name(name string) *ApprovalNodeBuilder {
	builder.name = name
	builder.nameFlag = true
	return builder
}

// 审批类型枚举,当 node_type 为依次审批时，审批人必须为『发起人自选』
//
// 示例值：AND
func (builder *ApprovalNodeBuilder) NodeType(nodeType string) *ApprovalNodeBuilder {
	builder.nodeType = nodeType
	builder.nodeTypeFlag = true
	return builder
}

// 审批人列表
//
// 示例值：
func (builder *ApprovalNodeBuilder) Approver(approver []*ApprovalApproverCcer) *ApprovalNodeBuilder {
	builder.approver = approver
	builder.approverFlag = true
	return builder
}

// 抄送人列表
//
// 示例值：
func (builder *ApprovalNodeBuilder) Ccer(ccer []*ApprovalApproverCcer) *ApprovalNodeBuilder {
	builder.ccer = ccer
	builder.ccerFlag = true
	return builder
}

// 表单项的控件权限
//
// 示例值：
func (builder *ApprovalNodeBuilder) PrivilegeField(privilegeField *FieldGroup) *ApprovalNodeBuilder {
	builder.privilegeField = privilegeField
	builder.privilegeFieldFlag = true
	return builder
}

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

	}
	if builder.nameFlag {
		req.Name = &builder.name

	}
	if builder.nodeTypeFlag {
		req.NodeType = &builder.nodeType

	}
	if builder.approverFlag {
		req.Approver = builder.approver
	}
	if builder.ccerFlag {
		req.Ccer = builder.ccer
	}
	if builder.privilegeFieldFlag {
		req.PrivilegeField = builder.privilegeField
	}
	return req
}

type ApprovalNodeInfo struct {
	Name                *string                `json:"name,omitempty"`                  // 节点名称
	NeedApprover        *bool                  `json:"need_approver,omitempty"`         // 是否发起人自选节点 true - 发起审批时需要提交审批人
	NodeId              *string                `json:"node_id,omitempty"`               // 节点 ID
	CustomNodeId        *string                `json:"custom_node_id,omitempty"`        // 节点自定义 ID，如果没有设置则不返回
	NodeType            *string                `json:"node_type,omitempty"`             // 审批方式
	ApproverChosenMulti *bool                  `json:"approver_chosen_multi,omitempty"` // 是否支持多选：true-支持，发起、结束节点该值无意义
	ApproverChosenRange []*ApproverChosenRange `json:"approver_chosen_range,omitempty"` // 自选范围
}

type ApprovalNodeInfoBuilder struct {
	name                    string // 节点名称
	nameFlag                bool
	needApprover            bool // 是否发起人自选节点 true - 发起审批时需要提交审批人
	needApproverFlag        bool
	nodeId                  string // 节点 ID
	nodeIdFlag              bool
	customNodeId            string // 节点自定义 ID，如果没有设置则不返回
	customNodeIdFlag        bool
	nodeType                string // 审批方式
	nodeTypeFlag            bool
	approverChosenMulti     bool // 是否支持多选：true-支持，发起、结束节点该值无意义
	approverChosenMultiFlag bool
	approverChosenRange     []*ApproverChosenRange // 自选范围
	approverChosenRangeFlag bool
}

func NewApprovalNodeInfoBuilder() *ApprovalNodeInfoBuilder {
	builder := &ApprovalNodeInfoBuilder{}
	return builder
}

// 节点名称
//
// 示例值：Approval
func (builder *ApprovalNodeInfoBuilder) Name(name string) *ApprovalNodeInfoBuilder {
	builder.name = name
	builder.nameFlag = true
	return builder
}

// 是否发起人自选节点 true - 发起审批时需要提交审批人
//
// 示例值：true
func (builder *ApprovalNodeInfoBuilder) NeedApprover(needApprover bool) *ApprovalNodeInfoBuilder {
	builder.needApprover = needApprover
	builder.needApproverFlag = true
	return builder
}

// 节点 ID
//
// 示例值：46e6d96cfa756980907209209ec03b64
func (builder *ApprovalNodeInfoBuilder) NodeId(nodeId string) *ApprovalNodeInfoBuilder {
	builder.nodeId = nodeId
	builder.nodeIdFlag = true
	return builder
}

// 节点自定义 ID，如果没有设置则不返回
//
// 示例值：46e6d96cfa756980907209209ec03b64
func (builder *ApprovalNodeInfoBuilder) CustomNodeId(customNodeId string) *ApprovalNodeInfoBuilder {
	builder.customNodeId = customNodeId
	builder.customNodeIdFlag = true
	return builder
}

// 审批方式
//
// 示例值：AND
func (builder *ApprovalNodeInfoBuilder) NodeType(nodeType string) *ApprovalNodeInfoBuilder {
	builder.nodeType = nodeType
	builder.nodeTypeFlag = true
	return builder
}

// 是否支持多选：true-支持，发起、结束节点该值无意义
//
// 示例值：true
func (builder *ApprovalNodeInfoBuilder) ApproverChosenMulti(approverChosenMulti bool) *ApprovalNodeInfoBuilder {
	builder.approverChosenMulti = approverChosenMulti
	builder.approverChosenMultiFlag = true
	return builder
}

// 自选范围
//
// 示例值：
func (builder *ApprovalNodeInfoBuilder) ApproverChosenRange(approverChosenRange []*ApproverChosenRange) *ApprovalNodeInfoBuilder {
	builder.approverChosenRange = approverChosenRange
	builder.approverChosenRangeFlag = true
	return builder
}

func (builder *ApprovalNodeInfoBuilder) Build() *ApprovalNodeInfo {
	req := &ApprovalNodeInfo{}
	if builder.nameFlag {
		req.Name = &builder.name

	}
	if builder.needApproverFlag {
		req.NeedApprover = &builder.needApprover

	}
	if builder.nodeIdFlag {
		req.NodeId = &builder.nodeId

	}
	if builder.customNodeIdFlag {
		req.CustomNodeId = &builder.customNodeId

	}
	if builder.nodeTypeFlag {
		req.NodeType = &builder.nodeType

	}
	if builder.approverChosenMultiFlag {
		req.ApproverChosenMulti = &builder.approverChosenMulti

	}
	if builder.approverChosenRangeFlag {
		req.ApproverChosenRange = builder.approverChosenRange
	}
	return req
}

type ApprovalSetting struct {
	RevertInterval *int `json:"revert_interval,omitempty"` // 审批实例通过后允许撤回的时间，以秒为单位，默认 31 天，0 为不可撤回
	RevertOption   *int `json:"revert_option,omitempty"`   // 是否支持审批通过第一个节点后撤回，默认为1，0为不支持
}

type ApprovalSettingBuilder struct {
	revertInterval     int // 审批实例通过后允许撤回的时间，以秒为单位，默认 31 天，0 为不可撤回
	revertIntervalFlag bool
	revertOption       int // 是否支持审批通过第一个节点后撤回，默认为1，0为不支持
	revertOptionFlag   bool
}

func NewApprovalSettingBuilder() *ApprovalSettingBuilder {
	builder := &ApprovalSettingBuilder{}
	return builder
}

// 审批实例通过后允许撤回的时间，以秒为单位，默认 31 天，0 为不可撤回
//
// 示例值：0
func (builder *ApprovalSettingBuilder) RevertInterval(revertInterval int) *ApprovalSettingBuilder {
	builder.revertInterval = revertInterval
	builder.revertIntervalFlag = true
	return builder
}

// 是否支持审批通过第一个节点后撤回，默认为1，0为不支持
//
// 示例值：0
func (builder *ApprovalSettingBuilder) RevertOption(revertOption int) *ApprovalSettingBuilder {
	builder.revertOption = revertOption
	builder.revertOptionFlag = true
	return builder
}

func (builder *ApprovalSettingBuilder) Build() *ApprovalSetting {
	req := &ApprovalSetting{}
	if builder.revertIntervalFlag {
		req.RevertInterval = &builder.revertInterval

	}
	if builder.revertOptionFlag {
		req.RevertOption = &builder.revertOption

	}
	return req
}

type ApprovalViewer struct {
	Type    *string `json:"type,omitempty"`     // 可见人类型，人员、部门或全体
	OpenId  *string `json:"open_id,omitempty"`  // 同一个应用中对用户进行标识的id
	UserId  *string `json:"user_id,omitempty"`  // 用户id
	UnionId *string `json:"union_id,omitempty"` // 同一个应用开发主体下对用户进行标识的id
}

type ApprovalViewerBuilder struct {
	type_       string // 可见人类型，人员、部门或全体
	typeFlag    bool
	openId      string // 同一个应用中对用户进行标识的id
	openIdFlag  bool
	userId      string // 用户id
	userIdFlag  bool
	unionId     string // 同一个应用开发主体下对用户进行标识的id
	unionIdFlag bool
}

func NewApprovalViewerBuilder() *ApprovalViewerBuilder {
	builder := &ApprovalViewerBuilder{}
	return builder
}

// 可见人类型，人员、部门或全体
//
// 示例值：TENANT
func (builder *ApprovalViewerBuilder) Type(type_ string) *ApprovalViewerBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

// 同一个应用中对用户进行标识的id
//
// 示例值：ou_e03053f0541cecc3269d7a9dc34a0b21
func (builder *ApprovalViewerBuilder) OpenId(openId string) *ApprovalViewerBuilder {
	builder.openId = openId
	builder.openIdFlag = true
	return builder
}

// 用户id
//
// 示例值：f7cb567e
func (builder *ApprovalViewerBuilder) UserId(userId string) *ApprovalViewerBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 同一个应用开发主体下对用户进行标识的id
//
// 示例值：f7cb567e
func (builder *ApprovalViewerBuilder) UnionId(unionId string) *ApprovalViewerBuilder {
	builder.unionId = unionId
	builder.unionIdFlag = true
	return builder
}

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

	}
	if builder.openIdFlag {
		req.OpenId = &builder.openId

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.unionIdFlag {
		req.UnionId = &builder.unionId

	}
	return req
}

type ApprovalViewerInfo struct {
	Type   *string `json:"type,omitempty"`    // 可见人类型
	Id     *string `json:"id,omitempty"`      // 在可见人类型为DEPARTMENT时，id为部门的id ；在可见人类型为USER时，id为用户的id ；在可见人类型为ROLE时，id为角色的id ；在可见人类型为USER_GROUP时，id为用户组的id
	UserId *string `json:"user_id,omitempty"` // 在可见人类型为USER时，表示可见人用户id
}

type ApprovalViewerInfoBuilder struct {
	type_      string // 可见人类型
	typeFlag   bool
	id         string // 在可见人类型为DEPARTMENT时，id为部门的id ；在可见人类型为USER时，id为用户的id ；在可见人类型为ROLE时，id为角色的id ；在可见人类型为USER_GROUP时，id为用户组的id
	idFlag     bool
	userId     string // 在可见人类型为USER时，表示可见人用户id
	userIdFlag bool
}

func NewApprovalViewerInfoBuilder() *ApprovalViewerInfoBuilder {
	builder := &ApprovalViewerInfoBuilder{}
	return builder
}

// 可见人类型
//
// 示例值：TENANT
func (builder *ApprovalViewerInfoBuilder) Type(type_ string) *ApprovalViewerInfoBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

// 在可见人类型为DEPARTMENT时，id为部门的id ；在可见人类型为USER时，id为用户的id ；在可见人类型为ROLE时，id为角色的id ；在可见人类型为USER_GROUP时，id为用户组的id
//
// 示例值：ou_e03053f0541cecc3269d7a9dc34a0b21
func (builder *ApprovalViewerInfoBuilder) Id(id string) *ApprovalViewerInfoBuilder {
	builder.id = id
	builder.idFlag = true
	return builder
}

// 在可见人类型为USER时，表示可见人用户id
//
// 示例值：f7cb567e
func (builder *ApprovalViewerInfoBuilder) UserId(userId string) *ApprovalViewerInfoBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

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

	}
	if builder.idFlag {
		req.Id = &builder.id

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	return req
}

type ApproverChosenRange struct {
	ApproverRangeType *int     `json:"approver_range_type,omitempty"` // 指定范围：0-all，1-指定角色，2-指定人员
	ApproverRangeIds  []string `json:"approver_range_ids,omitempty"`  // 根据上面的type，分别存放角色id与userid，type为0时本字段为空列表
}

type ApproverChosenRangeBuilder struct {
	approverRangeType     int // 指定范围：0-all，1-指定角色，2-指定人员
	approverRangeTypeFlag bool
	approverRangeIds      []string // 根据上面的type，分别存放角色id与userid，type为0时本字段为空列表
	approverRangeIdsFlag  bool
}

func NewApproverChosenRangeBuilder() *ApproverChosenRangeBuilder {
	builder := &ApproverChosenRangeBuilder{}
	return builder
}

// 指定范围：0-all，1-指定角色，2-指定人员
//
// 示例值：2
func (builder *ApproverChosenRangeBuilder) ApproverRangeType(approverRangeType int) *ApproverChosenRangeBuilder {
	builder.approverRangeType = approverRangeType
	builder.approverRangeTypeFlag = true
	return builder
}

// 根据上面的type，分别存放角色id与userid，type为0时本字段为空列表
//
// 示例值：
func (builder *ApproverChosenRangeBuilder) ApproverRangeIds(approverRangeIds []string) *ApproverChosenRangeBuilder {
	builder.approverRangeIds = approverRangeIds
	builder.approverRangeIdsFlag = true
	return builder
}

func (builder *ApproverChosenRangeBuilder) Build() *ApproverChosenRange {
	req := &ApproverChosenRange{}
	if builder.approverRangeTypeFlag {
		req.ApproverRangeType = &builder.approverRangeType

	}
	if builder.approverRangeIdsFlag {
		req.ApproverRangeIds = builder.approverRangeIds
	}
	return req
}

type CcNode struct {
	CcId          *string               `json:"cc_id,omitempty"`          // 审批实例内唯一标识
	UserId        *string               `json:"user_id,omitempty"`        // 抄送人 employee id
	OpenId        *string               `json:"open_id,omitempty"`        // 抄送人 open id，和user id 二选一
	Links         *ExternalInstanceLink `json:"links,omitempty"`          // 跳转链接，用于【抄送我的】列表中的跳转pc_link 和 mobile_link 必须填一个，填写的是哪一端的链接，即会跳转到该链接，不受平台影响
	ReadStatus    *string               `json:"read_status,omitempty"`    // 阅读状态，空值表示不支持已读未读：
	Extra         *string               `json:"extra,omitempty"`          // 扩展 json
	Title         *string               `json:"title,omitempty"`          // 抄送任务名称
	CreateTime    *string               `json:"create_time,omitempty"`    // 抄送发起时间，Unix 毫秒时间戳
	UpdateTime    *string               `json:"update_time,omitempty"`    // 抄送最近更新时间，用于推送数据版本控制更新策略同 instance 的update_time
	DisplayMethod *string               `json:"display_method,omitempty"` // 列表页打开审批任务的方式
}

type CcNodeBuilder struct {
	ccId              string // 审批实例内唯一标识
	ccIdFlag          bool
	userId            string // 抄送人 employee id
	userIdFlag        bool
	openId            string // 抄送人 open id，和user id 二选一
	openIdFlag        bool
	links             *ExternalInstanceLink // 跳转链接，用于【抄送我的】列表中的跳转pc_link 和 mobile_link 必须填一个，填写的是哪一端的链接，即会跳转到该链接，不受平台影响
	linksFlag         bool
	readStatus        string // 阅读状态，空值表示不支持已读未读：
	readStatusFlag    bool
	extra             string // 扩展 json
	extraFlag         bool
	title             string // 抄送任务名称
	titleFlag         bool
	createTime        string // 抄送发起时间，Unix 毫秒时间戳
	createTimeFlag    bool
	updateTime        string // 抄送最近更新时间，用于推送数据版本控制更新策略同 instance 的update_time
	updateTimeFlag    bool
	displayMethod     string // 列表页打开审批任务的方式
	displayMethodFlag bool
}

func NewCcNodeBuilder() *CcNodeBuilder {
	builder := &CcNodeBuilder{}
	return builder
}

// 审批实例内唯一标识
//
// 示例值：123456
func (builder *CcNodeBuilder) CcId(ccId string) *CcNodeBuilder {
	builder.ccId = ccId
	builder.ccIdFlag = true
	return builder
}

// 抄送人 employee id
//
// 示例值：12345
func (builder *CcNodeBuilder) UserId(userId string) *CcNodeBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 抄送人 open id，和user id 二选一
//
// 示例值：ou_be73cbc0ee35eb6ca54e9e7cc14998c1
func (builder *CcNodeBuilder) OpenId(openId string) *CcNodeBuilder {
	builder.openId = openId
	builder.openIdFlag = true
	return builder
}

// 跳转链接，用于【抄送我的】列表中的跳转pc_link 和 mobile_link 必须填一个，填写的是哪一端的链接，即会跳转到该链接，不受平台影响
//
// 示例值：
func (builder *CcNodeBuilder) Links(links *ExternalInstanceLink) *CcNodeBuilder {
	builder.links = links
	builder.linksFlag = true
	return builder
}

// 阅读状态，空值表示不支持已读未读：
//
// 示例值：READ
func (builder *CcNodeBuilder) ReadStatus(readStatus string) *CcNodeBuilder {
	builder.readStatus = readStatus
	builder.readStatusFlag = true
	return builder
}

// 扩展 json
//
// 示例值：{\"xxx\":\"xxx\"}
func (builder *CcNodeBuilder) Extra(extra string) *CcNodeBuilder {
	builder.extra = extra
	builder.extraFlag = true
	return builder
}

// 抄送任务名称
//
// 示例值：xxx
func (builder *CcNodeBuilder) Title(title string) *CcNodeBuilder {
	builder.title = title
	builder.titleFlag = true
	return builder
}

// 抄送发起时间，Unix 毫秒时间戳
//
// 示例值：1556468012678
func (builder *CcNodeBuilder) CreateTime(createTime string) *CcNodeBuilder {
	builder.createTime = createTime
	builder.createTimeFlag = true
	return builder
}

// 抄送最近更新时间，用于推送数据版本控制更新策略同 instance 的update_time
//
// 示例值：1556468012678
func (builder *CcNodeBuilder) UpdateTime(updateTime string) *CcNodeBuilder {
	builder.updateTime = updateTime
	builder.updateTimeFlag = true
	return builder
}

// 列表页打开审批任务的方式
//
// 示例值：BROWSER
func (builder *CcNodeBuilder) DisplayMethod(displayMethod string) *CcNodeBuilder {
	builder.displayMethod = displayMethod
	builder.displayMethodFlag = true
	return builder
}

func (builder *CcNodeBuilder) Build() *CcNode {
	req := &CcNode{}
	if builder.ccIdFlag {
		req.CcId = &builder.ccId

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.openIdFlag {
		req.OpenId = &builder.openId

	}
	if builder.linksFlag {
		req.Links = builder.links
	}
	if builder.readStatusFlag {
		req.ReadStatus = &builder.readStatus

	}
	if builder.extraFlag {
		req.Extra = &builder.extra

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

	}
	if builder.createTimeFlag {
		req.CreateTime = &builder.createTime

	}
	if builder.updateTimeFlag {
		req.UpdateTime = &builder.updateTime

	}
	if builder.displayMethodFlag {
		req.DisplayMethod = &builder.displayMethod

	}
	return req
}

type CcSearch struct {
	UserId             *string `json:"user_id,omitempty"`              // 根据x_user_type填写用户 id
	ApprovalCode       *string `json:"approval_code,omitempty"`        // 审批定义 code
	InstanceCode       *string `json:"instance_code,omitempty"`        // 审批实例 code
	InstanceExternalId *string `json:"instance_external_id,omitempty"` // 审批实例第三方 id 注：和 approval_code 取并集
	GroupExternalId    *string `json:"group_external_id,omitempty"`    // 审批定义分组第三方 id 注：和 instance_code 取并集
	CcTitle            *string `json:"cc_title,omitempty"`             // 审批抄送标题（只有第三方审批有）
	ReadStatus         *string `json:"read_status,omitempty"`          // 审批抄送状态，注：若不设置，查询全部状态 若不在集合中，报错
	CcCreateTimeFrom   *string `json:"cc_create_time_from,omitempty"`  // 抄送查询开始时间（unix毫秒时间戳）
	CcCreateTimeTo     *string `json:"cc_create_time_to,omitempty"`    // 抄送查询结束时间 (unix毫秒时间戳)
	Locale             *string `json:"locale,omitempty"`               // 地区
}

type CcSearchBuilder struct {
	userId                 string // 根据x_user_type填写用户 id
	userIdFlag             bool
	approvalCode           string // 审批定义 code
	approvalCodeFlag       bool
	instanceCode           string // 审批实例 code
	instanceCodeFlag       bool
	instanceExternalId     string // 审批实例第三方 id 注：和 approval_code 取并集
	instanceExternalIdFlag bool
	groupExternalId        string // 审批定义分组第三方 id 注：和 instance_code 取并集
	groupExternalIdFlag    bool
	ccTitle                string // 审批抄送标题（只有第三方审批有）
	ccTitleFlag            bool
	readStatus             string // 审批抄送状态，注：若不设置，查询全部状态 若不在集合中，报错
	readStatusFlag         bool
	ccCreateTimeFrom       string // 抄送查询开始时间（unix毫秒时间戳）
	ccCreateTimeFromFlag   bool
	ccCreateTimeTo         string // 抄送查询结束时间 (unix毫秒时间戳)
	ccCreateTimeToFlag     bool
	locale                 string // 地区
	localeFlag             bool
}

func NewCcSearchBuilder() *CcSearchBuilder {
	builder := &CcSearchBuilder{}
	return builder
}

// 根据x_user_type填写用户 id
//
// 示例值：lwiu098wj
func (builder *CcSearchBuilder) UserId(userId string) *CcSearchBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 审批定义 code
//
// 示例值：EB828003-9FFE-4B3F-AA50-2E199E2ED942
func (builder *CcSearchBuilder) ApprovalCode(approvalCode string) *CcSearchBuilder {
	builder.approvalCode = approvalCode
	builder.approvalCodeFlag = true
	return builder
}

// 审批实例 code
//
// 示例值：EB828003-9FFE-4B3F-AA50-2E199E2ED943
func (builder *CcSearchBuilder) InstanceCode(instanceCode string) *CcSearchBuilder {
	builder.instanceCode = instanceCode
	builder.instanceCodeFlag = true
	return builder
}

// 审批实例第三方 id 注：和 approval_code 取并集
//
// 示例值：EB828003-9FFE-4B3F-AA50-2E199E2ED976
func (builder *CcSearchBuilder) InstanceExternalId(instanceExternalId string) *CcSearchBuilder {
	builder.instanceExternalId = instanceExternalId
	builder.instanceExternalIdFlag = true
	return builder
}

// 审批定义分组第三方 id 注：和 instance_code 取并集
//
// 示例值：1234567
func (builder *CcSearchBuilder) GroupExternalId(groupExternalId string) *CcSearchBuilder {
	builder.groupExternalId = groupExternalId
	builder.groupExternalIdFlag = true
	return builder
}

// 审批抄送标题（只有第三方审批有）
//
// 示例值：test
func (builder *CcSearchBuilder) CcTitle(ccTitle string) *CcSearchBuilder {
	builder.ccTitle = ccTitle
	builder.ccTitleFlag = true
	return builder
}

// 审批抄送状态，注：若不设置，查询全部状态 若不在集合中，报错
//
// 示例值：read
func (builder *CcSearchBuilder) ReadStatus(readStatus string) *CcSearchBuilder {
	builder.readStatus = readStatus
	builder.readStatusFlag = true
	return builder
}

// 抄送查询开始时间（unix毫秒时间戳）
//
// 示例值：1547654251506
func (builder *CcSearchBuilder) CcCreateTimeFrom(ccCreateTimeFrom string) *CcSearchBuilder {
	builder.ccCreateTimeFrom = ccCreateTimeFrom
	builder.ccCreateTimeFromFlag = true
	return builder
}

// 抄送查询结束时间 (unix毫秒时间戳)
//
// 示例值：1547654251506
func (builder *CcSearchBuilder) CcCreateTimeTo(ccCreateTimeTo string) *CcSearchBuilder {
	builder.ccCreateTimeTo = ccCreateTimeTo
	builder.ccCreateTimeToFlag = true
	return builder
}

// 地区
//
// 示例值：zh-CN
func (builder *CcSearchBuilder) Locale(locale string) *CcSearchBuilder {
	builder.locale = locale
	builder.localeFlag = true
	return builder
}

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

	}
	if builder.approvalCodeFlag {
		req.ApprovalCode = &builder.approvalCode

	}
	if builder.instanceCodeFlag {
		req.InstanceCode = &builder.instanceCode

	}
	if builder.instanceExternalIdFlag {
		req.InstanceExternalId = &builder.instanceExternalId

	}
	if builder.groupExternalIdFlag {
		req.GroupExternalId = &builder.groupExternalId

	}
	if builder.ccTitleFlag {
		req.CcTitle = &builder.ccTitle

	}
	if builder.readStatusFlag {
		req.ReadStatus = &builder.readStatus

	}
	if builder.ccCreateTimeFromFlag {
		req.CcCreateTimeFrom = &builder.ccCreateTimeFrom

	}
	if builder.ccCreateTimeToFlag {
		req.CcCreateTimeTo = &builder.ccCreateTimeTo

	}
	if builder.localeFlag {
		req.Locale = &builder.locale

	}
	return req
}

type CcSearchItem struct {
	Approval *InstanceSearchApproval `json:"approval,omitempty"` // 审批定义
	Group    *InstanceSearchGroup    `json:"group,omitempty"`    // 审批定义分组
	Instance *InstanceSearchNode     `json:"instance,omitempty"` // 审批实例信息
	Cc       *CcSearchNode           `json:"cc,omitempty"`       // 审批抄送
}

type CcSearchItemBuilder struct {
	approval     *InstanceSearchApproval // 审批定义
	approvalFlag bool
	group        *InstanceSearchGroup // 审批定义分组
	groupFlag    bool
	instance     *InstanceSearchNode // 审批实例信息
	instanceFlag bool
	cc           *CcSearchNode // 审批抄送
	ccFlag       bool
}

func NewCcSearchItemBuilder() *CcSearchItemBuilder {
	builder := &CcSearchItemBuilder{}
	return builder
}

// 审批定义
//
// 示例值：
func (builder *CcSearchItemBuilder) Approval(approval *InstanceSearchApproval) *CcSearchItemBuilder {
	builder.approval = approval
	builder.approvalFlag = true
	return builder
}

// 审批定义分组
//
// 示例值：
func (builder *CcSearchItemBuilder) Group(group *InstanceSearchGroup) *CcSearchItemBuilder {
	builder.group = group
	builder.groupFlag = true
	return builder
}

// 审批实例信息
//
// 示例值：
func (builder *CcSearchItemBuilder) Instance(instance *InstanceSearchNode) *CcSearchItemBuilder {
	builder.instance = instance
	builder.instanceFlag = true
	return builder
}

// 审批抄送
//
// 示例值：
func (builder *CcSearchItemBuilder) Cc(cc *CcSearchNode) *CcSearchItemBuilder {
	builder.cc = cc
	builder.ccFlag = true
	return builder
}

func (builder *CcSearchItemBuilder) Build() *CcSearchItem {
	req := &CcSearchItem{}
	if builder.approvalFlag {
		req.Approval = builder.approval
	}
	if builder.groupFlag {
		req.Group = builder.group
	}
	if builder.instanceFlag {
		req.Instance = builder.instance
	}
	if builder.ccFlag {
		req.Cc = builder.cc
	}
	return req
}

type CcSearchNode struct {
	UserId     *string             `json:"user_id,omitempty"`     // 审批抄送发起人 id
	CreateTime *string             `json:"create_time,omitempty"` // 审批抄送开始时间
	ReadStatus *string             `json:"read_status,omitempty"` // 审批抄送状态
	Title      *string             `json:"title,omitempty"`       // 审批抄送名称（只有第三方审批有）
	Extra      *string             `json:"extra,omitempty"`       // 审批抄送扩展字段，string型json
	Link       *InstanceSearchLink `json:"link,omitempty"`        // 审批抄送链接（只有第三方审批有）
}

type CcSearchNodeBuilder struct {
	userId         string // 审批抄送发起人 id
	userIdFlag     bool
	createTime     string // 审批抄送开始时间
	createTimeFlag bool
	readStatus     string // 审批抄送状态
	readStatusFlag bool
	title          string // 审批抄送名称（只有第三方审批有）
	titleFlag      bool
	extra          string // 审批抄送扩展字段，string型json
	extraFlag      bool
	link           *InstanceSearchLink // 审批抄送链接（只有第三方审批有）
	linkFlag       bool
}

func NewCcSearchNodeBuilder() *CcSearchNodeBuilder {
	builder := &CcSearchNodeBuilder{}
	return builder
}

// 审批抄送发起人 id
//
// 示例值：lwiu098wj
func (builder *CcSearchNodeBuilder) UserId(userId string) *CcSearchNodeBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 审批抄送开始时间
//
// 示例值：1547654251506
func (builder *CcSearchNodeBuilder) CreateTime(createTime string) *CcSearchNodeBuilder {
	builder.createTime = createTime
	builder.createTimeFlag = true
	return builder
}

// 审批抄送状态
//
// 示例值：read
func (builder *CcSearchNodeBuilder) ReadStatus(readStatus string) *CcSearchNodeBuilder {
	builder.readStatus = readStatus
	builder.readStatusFlag = true
	return builder
}

// 审批抄送名称（只有第三方审批有）
//
// 示例值：test
func (builder *CcSearchNodeBuilder) Title(title string) *CcSearchNodeBuilder {
	builder.title = title
	builder.titleFlag = true
	return builder
}

// 审批抄送扩展字段，string型json
//
// 示例值：{}
func (builder *CcSearchNodeBuilder) Extra(extra string) *CcSearchNodeBuilder {
	builder.extra = extra
	builder.extraFlag = true
	return builder
}

// 审批抄送链接（只有第三方审批有）
//
// 示例值：
func (builder *CcSearchNodeBuilder) Link(link *InstanceSearchLink) *CcSearchNodeBuilder {
	builder.link = link
	builder.linkFlag = true
	return builder
}

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

	}
	if builder.createTimeFlag {
		req.CreateTime = &builder.createTime

	}
	if builder.readStatusFlag {
		req.ReadStatus = &builder.readStatus

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

	}
	if builder.extraFlag {
		req.Extra = &builder.extra

	}
	if builder.linkFlag {
		req.Link = builder.link
	}
	return req
}

type Comment struct {
	Id          *string          `json:"id,omitempty"`           // 评论ID
	Content     *string          `json:"content,omitempty"`      // 评论内容
	CreateTime  *string          `json:"create_time,omitempty"`  // 评论创建时间
	UpdateTime  *string          `json:"update_time,omitempty"`  // 评论更新时间
	IsDelete    *int             `json:"is_delete,omitempty"`    // 是否删除，0:未删除，1:已删除
	Replies     []*CommentReply  `json:"replies,omitempty"`      // 评论的回复
	AtInfoList  []*CommentAtInfo `json:"at_info_list,omitempty"` // 评论中艾特人信息
	Commentator *string          `json:"commentator,omitempty"`  // 评论创建人
	Extra       *string          `json:"extra,omitempty"`        // 附加字段
}

type CommentBuilder struct {
	id              string // 评论ID
	idFlag          bool
	content         string // 评论内容
	contentFlag     bool
	createTime      string // 评论创建时间
	createTimeFlag  bool
	updateTime      string // 评论更新时间
	updateTimeFlag  bool
	isDelete        int // 是否删除，0:未删除，1:已删除
	isDeleteFlag    bool
	replies         []*CommentReply // 评论的回复
	repliesFlag     bool
	atInfoList      []*CommentAtInfo // 评论中艾特人信息
	atInfoListFlag  bool
	commentator     string // 评论创建人
	commentatorFlag bool
	extra           string // 附加字段
	extraFlag       bool
}

func NewCommentBuilder() *CommentBuilder {
	builder := &CommentBuilder{}
	return builder
}

// 评论ID
//
// 示例值：7081516627711524883
func (builder *CommentBuilder) Id(id string) *CommentBuilder {
	builder.id = id
	builder.idFlag = true
	return builder
}

// 评论内容
//
// 示例值：{\"text\":\"x@王某自小程序的评论111我带了附件，而且我艾特了人 \",\"files\":[{\"url\":\"https://xx-xxx-xxx.bytedance.net/lark-approval-attachment/image/20220401/1/d43216ca-93b5-43a8-8a34-23c66820463a.png~tplv-k7bg0smxju-image.image?x-orig-authkey=boeorigin\&x-orig-expires=1650963890\&x-orig-sign=668QhQbRSt6638x2Ws8wFI%2FxqVg%3D#.png\",\"fileSize\":155149,\"title\":\"9a9fedc5cfb01a4a20c715098.png\",\"type\":\"image\"}]}
func (builder *CommentBuilder) Content(content string) *CommentBuilder {
	builder.content = content
	builder.contentFlag = true
	return builder
}

// 评论创建时间
//
// 示例值：1648801211000
func (builder *CommentBuilder) CreateTime(createTime string) *CommentBuilder {
	builder.createTime = createTime
	builder.createTimeFlag = true
	return builder
}

// 评论更新时间
//
// 示例值：1648801211000
func (builder *CommentBuilder) UpdateTime(updateTime string) *CommentBuilder {
	builder.updateTime = updateTime
	builder.updateTimeFlag = true
	return builder
}

// 是否删除，0:未删除，1:已删除
//
// 示例值：1
func (builder *CommentBuilder) IsDelete(isDelete int) *CommentBuilder {
	builder.isDelete = isDelete
	builder.isDeleteFlag = true
	return builder
}

// 评论的回复
//
// 示例值：
func (builder *CommentBuilder) Replies(replies []*CommentReply) *CommentBuilder {
	builder.replies = replies
	builder.repliesFlag = true
	return builder
}

// 评论中艾特人信息
//
// 示例值：
func (builder *CommentBuilder) AtInfoList(atInfoList []*CommentAtInfo) *CommentBuilder {
	builder.atInfoList = atInfoList
	builder.atInfoListFlag = true
	return builder
}

// 评论创建人
//
// 示例值：893g4c45
func (builder *CommentBuilder) Commentator(commentator string) *CommentBuilder {
	builder.commentator = commentator
	builder.commentatorFlag = true
	return builder
}

// 附加字段
//
// 示例值：{\"a\":\"a\"}
func (builder *CommentBuilder) Extra(extra string) *CommentBuilder {
	builder.extra = extra
	builder.extraFlag = true
	return builder
}

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

	}
	if builder.contentFlag {
		req.Content = &builder.content

	}
	if builder.createTimeFlag {
		req.CreateTime = &builder.createTime

	}
	if builder.updateTimeFlag {
		req.UpdateTime = &builder.updateTime

	}
	if builder.isDeleteFlag {
		req.IsDelete = &builder.isDelete

	}
	if builder.repliesFlag {
		req.Replies = builder.replies
	}
	if builder.atInfoListFlag {
		req.AtInfoList = builder.atInfoList
	}
	if builder.commentatorFlag {
		req.Commentator = &builder.commentator

	}
	if builder.extraFlag {
		req.Extra = &builder.extra

	}
	return req
}

type CommentAtInfo struct {
	UserId *string `json:"user_id,omitempty"` // 被艾特人的ID
	Name   *string `json:"name,omitempty"`    // 被艾特人的姓名
	Offset *string `json:"offset,omitempty"`  // 被艾特人在评论中的位置，从0开始
}

type CommentAtInfoBuilder struct {
	userId     string // 被艾特人的ID
	userIdFlag bool
	name       string // 被艾特人的姓名
	nameFlag   bool
	offset     string // 被艾特人在评论中的位置，从0开始
	offsetFlag bool
}

func NewCommentAtInfoBuilder() *CommentAtInfoBuilder {
	builder := &CommentAtInfoBuilder{}
	return builder
}

// 被艾特人的ID
//
// 示例值：579fd9c4
func (builder *CommentAtInfoBuilder) UserId(userId string) *CommentAtInfoBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 被艾特人的姓名
//
// 示例值：张某
func (builder *CommentAtInfoBuilder) Name(name string) *CommentAtInfoBuilder {
	builder.name = name
	builder.nameFlag = true
	return builder
}

// 被艾特人在评论中的位置，从0开始
//
// 示例值：1
func (builder *CommentAtInfoBuilder) Offset(offset string) *CommentAtInfoBuilder {
	builder.offset = offset
	builder.offsetFlag = true
	return builder
}

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

	}
	if builder.nameFlag {
		req.Name = &builder.name

	}
	if builder.offsetFlag {
		req.Offset = &builder.offset

	}
	return req
}

type CommentReply struct {
	Id          *string          `json:"id,omitempty"`           // 评论ID
	Content     *string          `json:"content,omitempty"`      // 评论内容
	CreateTime  *string          `json:"create_time,omitempty"`  // 评论创建时间
	UpdateTime  *string          `json:"update_time,omitempty"`  // 评论更新时间
	IsDelete    *int             `json:"is_delete,omitempty"`    // 是否删除，0:未删除，1:已删除
	AtInfoList  []*CommentAtInfo `json:"at_info_list,omitempty"` // 评论中艾特人信息
	Commentator *string          `json:"commentator,omitempty"`  // 评论创建人
	Extra       *string          `json:"extra,omitempty"`        // 附加字段
}

type CommentReplyBuilder struct {
	id              string // 评论ID
	idFlag          bool
	content         string // 评论内容
	contentFlag     bool
	createTime      string // 评论创建时间
	createTimeFlag  bool
	updateTime      string // 评论更新时间
	updateTimeFlag  bool
	isDelete        int // 是否删除，0:未删除，1:已删除
	isDeleteFlag    bool
	atInfoList      []*CommentAtInfo // 评论中艾特人信息
	atInfoListFlag  bool
	commentator     string // 评论创建人
	commentatorFlag bool
	extra           string // 附加字段
	extraFlag       bool
}

func NewCommentReplyBuilder() *CommentReplyBuilder {
	builder := &CommentReplyBuilder{}
	return builder
}

// 评论ID
//
// 示例值：7081516611634741268
func (builder *CommentReplyBuilder) Id(id string) *CommentReplyBuilder {
	builder.id = id
	builder.idFlag = true
	return builder
}

// 评论内容
//
// 示例值：{\"text\":\"x@张某来自小程序的评论111,这是一条回复\",\"files\":[{\"url\":\"https://xx-xxx-xxx.bytedance.net/lark-approval-attachment/image/20220401/1/d43216ca-93b5-43a8-8a34-23c66820463a.png~tplv-k7bg0smxju-image.image?x-orig-authkey=boeorigin\&x-orig-expires=1650963890\&x-orig-sign=668QhQbRSt6638x2Ws8wFI%2FxqVg%3D#.png\",\"fileSize\":155149,\"title\":\"9a9fedc5cfb01a4a20c715098.png\",\"type\":\"image\"}]}
func (builder *CommentReplyBuilder) Content(content string) *CommentReplyBuilder {
	builder.content = content
	builder.contentFlag = true
	return builder
}

// 评论创建时间
//
// 示例值：1648803677000
func (builder *CommentReplyBuilder) CreateTime(createTime string) *CommentReplyBuilder {
	builder.createTime = createTime
	builder.createTimeFlag = true
	return builder
}

// 评论更新时间
//
// 示例值：1648803677000
func (builder *CommentReplyBuilder) UpdateTime(updateTime string) *CommentReplyBuilder {
	builder.updateTime = updateTime
	builder.updateTimeFlag = true
	return builder
}

// 是否删除，0:未删除，1:已删除
//
// 示例值：0
func (builder *CommentReplyBuilder) IsDelete(isDelete int) *CommentReplyBuilder {
	builder.isDelete = isDelete
	builder.isDeleteFlag = true
	return builder
}

// 评论中艾特人信息
//
// 示例值：
func (builder *CommentReplyBuilder) AtInfoList(atInfoList []*CommentAtInfo) *CommentReplyBuilder {
	builder.atInfoList = atInfoList
	builder.atInfoListFlag = true
	return builder
}

// 评论创建人
//
// 示例值：893g4c45
func (builder *CommentReplyBuilder) Commentator(commentator string) *CommentReplyBuilder {
	builder.commentator = commentator
	builder.commentatorFlag = true
	return builder
}

// 附加字段
//
// 示例值：{\"a\":\"a\"}
func (builder *CommentReplyBuilder) Extra(extra string) *CommentReplyBuilder {
	builder.extra = extra
	builder.extraFlag = true
	return builder
}

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

	}
	if builder.contentFlag {
		req.Content = &builder.content

	}
	if builder.createTimeFlag {
		req.CreateTime = &builder.createTime

	}
	if builder.updateTimeFlag {
		req.UpdateTime = &builder.updateTime

	}
	if builder.isDeleteFlag {
		req.IsDelete = &builder.isDelete

	}
	if builder.atInfoListFlag {
		req.AtInfoList = builder.atInfoList
	}
	if builder.commentatorFlag {
		req.Commentator = &builder.commentator

	}
	if builder.extraFlag {
		req.Extra = &builder.extra

	}
	return req
}

type CommentRequest struct {
	Content         *string          `json:"content,omitempty"`           // 评论内容，包含艾特人、附件等
	AtInfoList      []*CommentAtInfo `json:"at_info_list,omitempty"`      // 评论中艾特人信息
	ParentCommentId *string          `json:"parent_comment_id,omitempty"` // 父评论ID，如果是回复评论，需要传
	CommentId       *string          `json:"comment_id,omitempty"`        // 评论ID，如果是编辑、删除一条评论，需要传
	DisableBot      *bool            `json:"disable_bot,omitempty"`       // disable_bot=true只同步数据，不触发bot
	Extra           *string          `json:"extra,omitempty"`             // 附加字段
}

type CommentRequestBuilder struct {
	content             string // 评论内容，包含艾特人、附件等
	contentFlag         bool
	atInfoList          []*CommentAtInfo // 评论中艾特人信息
	atInfoListFlag      bool
	parentCommentId     string // 父评论ID，如果是回复评论，需要传
	parentCommentIdFlag bool
	commentId           string // 评论ID，如果是编辑、删除一条评论，需要传
	commentIdFlag       bool
	disableBot          bool // disable_bot=true只同步数据，不触发bot
	disableBotFlag      bool
	extra               string // 附加字段
	extraFlag           bool
}

func NewCommentRequestBuilder() *CommentRequestBuilder {
	builder := &CommentRequestBuilder{}
	return builder
}

// 评论内容，包含艾特人、附件等
//
// 示例值：{\"text\":\"来自小程序的评论111我带附件中有extra \",\"files\":[{\"url\":\"xxx\",\"fileSize\":155149,\"title\":\"9a9fedc5cfb01a4a20c715098.png\",\"type\":\"image\",\"extra\":\"\"}]}
func (builder *CommentRequestBuilder) Content(content string) *CommentRequestBuilder {
	builder.content = content
	builder.contentFlag = true
	return builder
}

// 评论中艾特人信息
//
// 示例值：
func (builder *CommentRequestBuilder) AtInfoList(atInfoList []*CommentAtInfo) *CommentRequestBuilder {
	builder.atInfoList = atInfoList
	builder.atInfoListFlag = true
	return builder
}

// 父评论ID，如果是回复评论，需要传
//
// 示例值：7081516627711524883
func (builder *CommentRequestBuilder) ParentCommentId(parentCommentId string) *CommentRequestBuilder {
	builder.parentCommentId = parentCommentId
	builder.parentCommentIdFlag = true
	return builder
}

// 评论ID，如果是编辑、删除一条评论，需要传
//
// 示例值：7081516627711524883
func (builder *CommentRequestBuilder) CommentId(commentId string) *CommentRequestBuilder {
	builder.commentId = commentId
	builder.commentIdFlag = true
	return builder
}

// disable_bot=true只同步数据，不触发bot
//
// 示例值：false
func (builder *CommentRequestBuilder) DisableBot(disableBot bool) *CommentRequestBuilder {
	builder.disableBot = disableBot
	builder.disableBotFlag = true
	return builder
}

// 附加字段
//
// 示例值：{\"a\":\"a\"}
func (builder *CommentRequestBuilder) Extra(extra string) *CommentRequestBuilder {
	builder.extra = extra
	builder.extraFlag = true
	return builder
}

func (builder *CommentRequestBuilder) Build() *CommentRequest {
	req := &CommentRequest{}
	if builder.contentFlag {
		req.Content = &builder.content

	}
	if builder.atInfoListFlag {
		req.AtInfoList = builder.atInfoList
	}
	if builder.parentCommentIdFlag {
		req.ParentCommentId = &builder.parentCommentId

	}
	if builder.commentIdFlag {
		req.CommentId = &builder.commentId

	}
	if builder.disableBotFlag {
		req.DisableBot = &builder.disableBot

	}
	if builder.extraFlag {
		req.Extra = &builder.extra

	}
	return req
}

type Count struct {
	Total   *int  `json:"total,omitempty"`    // 总数，大于等于 1000 个项目时将返回 999
	HasMore *bool `json:"has_more,omitempty"` // 还有更多，当大于等于 1000 时将返回 true
}

type CountBuilder struct {
	total       int // 总数，大于等于 1000 个项目时将返回 999
	totalFlag   bool
	hasMore     bool // 还有更多，当大于等于 1000 时将返回 true
	hasMoreFlag bool
}

func NewCountBuilder() *CountBuilder {
	builder := &CountBuilder{}
	return builder
}

// 总数，大于等于 1000 个项目时将返回 999
//
// 示例值：123
func (builder *CountBuilder) Total(total int) *CountBuilder {
	builder.total = total
	builder.totalFlag = true
	return builder
}

// 还有更多，当大于等于 1000 时将返回 true
//
// 示例值：false
func (builder *CountBuilder) HasMore(hasMore bool) *CountBuilder {
	builder.hasMore = hasMore
	builder.hasMoreFlag = true
	return builder
}

func (builder *CountBuilder) Build() *Count {
	req := &Count{}
	if builder.totalFlag {
		req.Total = &builder.total

	}
	if builder.hasMoreFlag {
		req.HasMore = &builder.hasMore

	}
	return req
}

type ExteranlInstanceCheck struct {
	InstanceId *string                 `json:"instance_id,omitempty"` // 审批实例 id
	UpdateTime *string                 `json:"update_time,omitempty"` // 审批实例最近更新时间
	Tasks      []*ExternalInstanceTask `json:"tasks,omitempty"`       // 任务信息
}

type ExteranlInstanceCheckBuilder struct {
	instanceId     string // 审批实例 id
	instanceIdFlag bool
	updateTime     string // 审批实例最近更新时间
	updateTimeFlag bool
	tasks          []*ExternalInstanceTask // 任务信息
	tasksFlag      bool
}

func NewExteranlInstanceCheckBuilder() *ExteranlInstanceCheckBuilder {
	builder := &ExteranlInstanceCheckBuilder{}
	return builder
}

// 审批实例 id
//
// 示例值：1234234234242423
func (builder *ExteranlInstanceCheckBuilder) InstanceId(instanceId string) *ExteranlInstanceCheckBuilder {
	builder.instanceId = instanceId
	builder.instanceIdFlag = true
	return builder
}

// 审批实例最近更新时间
//
// 示例值：1591603040000
func (builder *ExteranlInstanceCheckBuilder) UpdateTime(updateTime string) *ExteranlInstanceCheckBuilder {
	builder.updateTime = updateTime
	builder.updateTimeFlag = true
	return builder
}

// 任务信息
//
// 示例值：
func (builder *ExteranlInstanceCheckBuilder) Tasks(tasks []*ExternalInstanceTask) *ExteranlInstanceCheckBuilder {
	builder.tasks = tasks
	builder.tasksFlag = true
	return builder
}

func (builder *ExteranlInstanceCheckBuilder) Build() *ExteranlInstanceCheck {
	req := &ExteranlInstanceCheck{}
	if builder.instanceIdFlag {
		req.InstanceId = &builder.instanceId

	}
	if builder.updateTimeFlag {
		req.UpdateTime = &builder.updateTime

	}
	if builder.tasksFlag {
		req.Tasks = builder.tasks
	}
	return req
}

type ExteranlInstanceCheckResponse struct {
	InstanceId *string                 `json:"instance_id,omitempty"` // 审批实例 id
	UpdateTime *string                 `json:"update_time,omitempty"` // 任务最近更新时间
	Tasks      []*ExternalInstanceTask `json:"tasks,omitempty"`       // 任务信息
}

type ExteranlInstanceCheckResponseBuilder struct {
	instanceId     string // 审批实例 id
	instanceIdFlag bool
	updateTime     string // 任务最近更新时间
	updateTimeFlag bool
	tasks          []*ExternalInstanceTask // 任务信息
	tasksFlag      bool
}

func NewExteranlInstanceCheckResponseBuilder() *ExteranlInstanceCheckResponseBuilder {
	builder := &ExteranlInstanceCheckResponseBuilder{}
	return builder
}

// 审批实例 id
//
// 示例值：1234234234242423
func (builder *ExteranlInstanceCheckResponseBuilder) InstanceId(instanceId string) *ExteranlInstanceCheckResponseBuilder {
	builder.instanceId = instanceId
	builder.instanceIdFlag = true
	return builder
}

// 任务最近更新时间
//
// 示例值：1591603040000
func (builder *ExteranlInstanceCheckResponseBuilder) UpdateTime(updateTime string) *ExteranlInstanceCheckResponseBuilder {
	builder.updateTime = updateTime
	builder.updateTimeFlag = true
	return builder
}

// 任务信息
//
// 示例值：
func (builder *ExteranlInstanceCheckResponseBuilder) Tasks(tasks []*ExternalInstanceTask) *ExteranlInstanceCheckResponseBuilder {
	builder.tasks = tasks
	builder.tasksFlag = true
	return builder
}

func (builder *ExteranlInstanceCheckResponseBuilder) Build() *ExteranlInstanceCheckResponse {
	req := &ExteranlInstanceCheckResponse{}
	if builder.instanceIdFlag {
		req.InstanceId = &builder.instanceId

	}
	if builder.updateTimeFlag {
		req.UpdateTime = &builder.updateTime

	}
	if builder.tasksFlag {
		req.Tasks = builder.tasks
	}
	return req
}

type ExternalApproval struct {
	ApprovalName  *string                  `json:"approval_name,omitempty"`  // 审批定义名称，创建审批定义返回的值，表示该实例属于哪个流程；该字段会影响到列表中该实例的标题，标题取自对应定义的 name 字段。
	ApprovalCode  *string                  `json:"approval_code,omitempty"`  // 审批定义 code，用户自定义，定义的唯一标识，如果不存在该 code，则创建，否则更新
	GroupCode     *string                  `json:"group_code,omitempty"`     // 审批定义所属审批分组，用户自定义； 如果group_code当前不存在，则会新建审批分组； 如果group_code已经存在，则会使用group_name更新审批分组名称
	GroupName     *string                  `json:"group_name,omitempty"`     // 分组名称，值的格式是 i18n key，文案放在 i18n_resource； 如果是 group_code 当前不存在，则该 group_name 必填，否则，如果填写了则会更新分组名称，不填则不更新分组名称； 审批发起页 审批定义的分组名称来自该字段
	Description   *string                  `json:"description,omitempty"`    // 审批定义的说明，值的格式是 i18n key，文案放在 i18n_resource； 审批发起页 审批定义的说明内容来自该字段
	External      *ApprovalCreateExternal  `json:"external,omitempty"`       // 三方审批相关
	Viewers       []*ApprovalCreateViewers `json:"viewers,omitempty"`        // 可见人列表，可通知配置多个可见人，只有在配置的范围内用户可以在审批发起也看到该审批，默认不传，则是任何人不可见
	I18nResources []*I18nResource          `json:"i18n_resources,omitempty"` // 国际化文案
	Managers      []string                 `json:"managers,omitempty"`       // 根据user_id_type填写流程管理员id
}

type ExternalApprovalBuilder struct {
	approvalName      string // 审批定义名称，创建审批定义返回的值，表示该实例属于哪个流程；该字段会影响到列表中该实例的标题，标题取自对应定义的 name 字段。
	approvalNameFlag  bool
	approvalCode      string // 审批定义 code，用户自定义，定义的唯一标识，如果不存在该 code，则创建，否则更新
	approvalCodeFlag  bool
	groupCode         string // 审批定义所属审批分组，用户自定义； 如果group_code当前不存在，则会新建审批分组； 如果group_code已经存在，则会使用group_name更新审批分组名称
	groupCodeFlag     bool
	groupName         string // 分组名称，值的格式是 i18n key，文案放在 i18n_resource； 如果是 group_code 当前不存在，则该 group_name 必填，否则，如果填写了则会更新分组名称，不填则不更新分组名称； 审批发起页 审批定义的分组名称来自该字段
	groupNameFlag     bool
	description       string // 审批定义的说明，值的格式是 i18n key，文案放在 i18n_resource； 审批发起页 审批定义的说明内容来自该字段
	descriptionFlag   bool
	external          *ApprovalCreateExternal // 三方审批相关
	externalFlag      bool
	viewers           []*ApprovalCreateViewers // 可见人列表，可通知配置多个可见人，只有在配置的范围内用户可以在审批发起也看到该审批，默认不传，则是任何人不可见
	viewersFlag       bool
	i18nResources     []*I18nResource // 国际化文案
	i18nResourcesFlag bool
	managers          []string // 根据user_id_type填写流程管理员id
	managersFlag      bool
}

func NewExternalApprovalBuilder() *ExternalApprovalBuilder {
	builder := &ExternalApprovalBuilder{}
	return builder
}

// 审批定义名称，创建审批定义返回的值，表示该实例属于哪个流程；该字段会影响到列表中该实例的标题，标题取自对应定义的 name 字段。
//
// 示例值：@i18n@1
func (builder *ExternalApprovalBuilder) ApprovalName(approvalName string) *ExternalApprovalBuilder {
	builder.approvalName = approvalName
	builder.approvalNameFlag = true
	return builder
}

// 审批定义 code，用户自定义，定义的唯一标识，如果不存在该 code，则创建，否则更新
//
// 示例值：permission_test
func (builder *ExternalApprovalBuilder) ApprovalCode(approvalCode string) *ExternalApprovalBuilder {
	builder.approvalCode = approvalCode
	builder.approvalCodeFlag = true
	return builder
}

// 审批定义所属审批分组，用户自定义； 如果group_code当前不存在，则会新建审批分组； 如果group_code已经存在，则会使用group_name更新审批分组名称
//
// 示例值：work_group
func (builder *ExternalApprovalBuilder) GroupCode(groupCode string) *ExternalApprovalBuilder {
	builder.groupCode = groupCode
	builder.groupCodeFlag = true
	return builder
}

// 分组名称，值的格式是 i18n key，文案放在 i18n_resource； 如果是 group_code 当前不存在，则该 group_name 必填，否则，如果填写了则会更新分组名称，不填则不更新分组名称； 审批发起页 审批定义的分组名称来自该字段
//
// 示例值：@i18n@2
func (builder *ExternalApprovalBuilder) GroupName(groupName string) *ExternalApprovalBuilder {
	builder.groupName = groupName
	builder.groupNameFlag = true
	return builder
}

// 审批定义的说明，值的格式是 i18n key，文案放在 i18n_resource； 审批发起页 审批定义的说明内容来自该字段
//
// 示例值：@i18n@2
func (builder *ExternalApprovalBuilder) Description(description string) *ExternalApprovalBuilder {
	builder.description = description
	builder.descriptionFlag = true
	return builder
}

// 三方审批相关
//
// 示例值：
func (builder *ExternalApprovalBuilder) External(external *ApprovalCreateExternal) *ExternalApprovalBuilder {
	builder.external = external
	builder.externalFlag = true
	return builder
}

// 可见人列表，可通知配置多个可见人，只有在配置的范围内用户可以在审批发起也看到该审批，默认不传，则是任何人不可见
//
// 示例值：
func (builder *ExternalApprovalBuilder) Viewers(viewers []*ApprovalCreateViewers) *ExternalApprovalBuilder {
	builder.viewers = viewers
	builder.viewersFlag = true
	return builder
}

// 国际化文案
//
// 示例值：
func (builder *ExternalApprovalBuilder) I18nResources(i18nResources []*I18nResource) *ExternalApprovalBuilder {
	builder.i18nResources = i18nResources
	builder.i18nResourcesFlag = true
	return builder
}

// 根据user_id_type填写流程管理员id
//
// 示例值：19a294c2
func (builder *ExternalApprovalBuilder) Managers(managers []string) *ExternalApprovalBuilder {
	builder.managers = managers
	builder.managersFlag = true
	return builder
}

func (builder *ExternalApprovalBuilder) Build() *ExternalApproval {
	req := &ExternalApproval{}
	if builder.approvalNameFlag {
		req.ApprovalName = &builder.approvalName

	}
	if builder.approvalCodeFlag {
		req.ApprovalCode = &builder.approvalCode

	}
	if builder.groupCodeFlag {
		req.GroupCode = &builder.groupCode

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

	}
	if builder.descriptionFlag {
		req.Description = &builder.description

	}
	if builder.externalFlag {
		req.External = builder.external
	}
	if builder.viewersFlag {
		req.Viewers = builder.viewers
	}
	if builder.i18nResourcesFlag {
		req.I18nResources = builder.i18nResources
	}
	if builder.managersFlag {
		req.Managers = builder.managers
	}
	return req
}

type ExternalInstance struct {
	ApprovalCode          *string                     `json:"approval_code,omitempty"`            // 审批定义 code， 创建审批定义返回的值，表示该实例属于哪个流程；该字段会影响到列表中该实例的标题，标题取自对应定义的 name 字段
	Status                *string                     `json:"status,omitempty"`                   // 审批实例状态
	Extra                 *string                     `json:"extra,omitempty"`                    // 审批实例扩展 JSON
	InstanceId            *string                     `json:"instance_id,omitempty"`              // 审批实例唯一标识，用户自定义，需确保证租户、应用下唯一
	Links                 *ExternalInstanceLink       `json:"links,omitempty"`                    // 审批实例链接集合 ，用于【已发起】列表的跳转，跳转回三方系统； pc_link 和 mobile_link 必须填一个，填写的是哪一端的链接，即会跳转到该链接，不受平台影响
	Title                 *string                     `json:"title,omitempty"`                    // 审批展示名称，如果填写了该字段，则审批列表中的审批名称使用该字段，如果不填该字段，则审批名称使用审批定义的名称
	Form                  []*ExternalInstanceForm     `json:"form,omitempty"`                     // 用户提交审批时填写的表单数据，用于所有审批列表中展示。可传多个值，但审批中心pc展示前2个,移动端展示前3个,长度不超过2048字符
	UserId                *string                     `json:"user_id,omitempty"`                  // 审批发起人 user_id，发起人可在【已发起】列表中看到所有已发起的审批; 在【待审批】，【已审批】【抄送我】列表中，该字段展示审批是谁发起的。审批发起人 open id，和 user id 二选一。
	UserName              *string                     `json:"user_name,omitempty"`                // 审批发起人 用户名，如果发起人不是真实的用户（例如是某个部门），没有 user_id，则可以使用该字段传名称
	OpenId                *string                     `json:"open_id,omitempty"`                  // 审批发起人 open id，和 user id 二选一
	DepartmentId          *string                     `json:"department_id,omitempty"`            // 发起人部门，用于列表中展示发起人所属部门。不传则不展示。如果用户没加入任何部门，传 ""，将展示租户名称传 department_name 展示部门名称
	DepartmentName        *string                     `json:"department_name,omitempty"`          // 审批发起人 部门，如果发起人不是真实的用户（例如是某个部门），没有 department_id，则可以使用该字段传名称
	StartTime             *string                     `json:"start_time,omitempty"`               // 审批发起时间，Unix毫秒时间戳
	EndTime               *string                     `json:"end_time,omitempty"`                 // 审批实例结束时间：未结束的审批为 0，Unix毫秒时间戳
	UpdateTime            *string                     `json:"update_time,omitempty"`              // 审批实例最近更新时间；用于推送数据版本控制如果 update_mode 值为 UPDATE，则只有传过来的 update_time 有变化时（变大），才会更新审批中心中的审批实例信息。使用该字段主要用来避免并发时老的数据更新了新的数据
	DisplayMethod         *string                     `json:"display_method,omitempty"`           // 列表页打开审批实例的方式
	UpdateMode            *string                     `json:"update_mode,omitempty"`              // 更新方式， 当 update_mode=REPLACE时，每次都以当前推送的数据为最终数据，会删掉审批中心中多余的任务、抄送数据（不在这次推送的数据中）; 当 update_mode=UPDATE时，则不会删除审批中心的数据，而只是进行新增和更新实例、任务数据
	TaskList              []*ExternalInstanceTaskNode `json:"task_list,omitempty"`                // 任务列表
	CcList                []*CcNode                   `json:"cc_list,omitempty"`                  // 抄送列表
	I18nResources         []*I18nResource             `json:"i18n_resources,omitempty"`           // 国际化文案
	TrusteeshipUrlToken   *string                     `json:"trusteeship_url_token,omitempty"`    // 单据托管认证token，托管回调会附带此token，帮助业务方认证
	TrusteeshipUserIdType *string                     `json:"trusteeship_user_id_type,omitempty"` // 用户的类型，会影响请求参数用户标识域的选择，包括加签操作回传的目标用户， 目前仅支持 "user_id"
	TrusteeshipUrls       *TrusteeshipUrls            `json:"trusteeship_urls,omitempty"`         // 单据托管回调接入方的接口的URL地址
}

type ExternalInstanceBuilder struct {
	approvalCode              string // 审批定义 code， 创建审批定义返回的值，表示该实例属于哪个流程；该字段会影响到列表中该实例的标题，标题取自对应定义的 name 字段
	approvalCodeFlag          bool
	status                    string // 审批实例状态
	statusFlag                bool
	extra                     string // 审批实例扩展 JSON
	extraFlag                 bool
	instanceId                string // 审批实例唯一标识，用户自定义，需确保证租户、应用下唯一
	instanceIdFlag            bool
	links                     *ExternalInstanceLink // 审批实例链接集合 ，用于【已发起】列表的跳转，跳转回三方系统； pc_link 和 mobile_link 必须填一个，填写的是哪一端的链接，即会跳转到该链接，不受平台影响
	linksFlag                 bool
	title                     string // 审批展示名称，如果填写了该字段，则审批列表中的审批名称使用该字段，如果不填该字段，则审批名称使用审批定义的名称
	titleFlag                 bool
	form                      []*ExternalInstanceForm // 用户提交审批时填写的表单数据，用于所有审批列表中展示。可传多个值，但审批中心pc展示前2个,移动端展示前3个,长度不超过2048字符
	formFlag                  bool
	userId                    string // 审批发起人 user_id，发起人可在【已发起】列表中看到所有已发起的审批; 在【待审批】，【已审批】【抄送我】列表中，该字段展示审批是谁发起的。审批发起人 open id，和 user id 二选一。
	userIdFlag                bool
	userName                  string // 审批发起人 用户名，如果发起人不是真实的用户（例如是某个部门），没有 user_id，则可以使用该字段传名称
	userNameFlag              bool
	openId                    string // 审批发起人 open id，和 user id 二选一
	openIdFlag                bool
	departmentId              string // 发起人部门，用于列表中展示发起人所属部门。不传则不展示。如果用户没加入任何部门，传 ""，将展示租户名称传 department_name 展示部门名称
	departmentIdFlag          bool
	departmentName            string // 审批发起人 部门，如果发起人不是真实的用户（例如是某个部门），没有 department_id，则可以使用该字段传名称
	departmentNameFlag        bool
	startTime                 string // 审批发起时间，Unix毫秒时间戳
	startTimeFlag             bool
	endTime                   string // 审批实例结束时间：未结束的审批为 0，Unix毫秒时间戳
	endTimeFlag               bool
	updateTime                string // 审批实例最近更新时间；用于推送数据版本控制如果 update_mode 值为 UPDATE，则只有传过来的 update_time 有变化时（变大），才会更新审批中心中的审批实例信息。使用该字段主要用来避免并发时老的数据更新了新的数据
	updateTimeFlag            bool
	displayMethod             string // 列表页打开审批实例的方式
	displayMethodFlag         bool
	updateMode                string // 更新方式， 当 update_mode=REPLACE时，每次都以当前推送的数据为最终数据，会删掉审批中心中多余的任务、抄送数据（不在这次推送的数据中）; 当 update_mode=UPDATE时，则不会删除审批中心的数据，而只是进行新增和更新实例、任务数据
	updateModeFlag            bool
	taskList                  []*ExternalInstanceTaskNode // 任务列表
	taskListFlag              bool
	ccList                    []*CcNode // 抄送列表
	ccListFlag                bool
	i18nResources             []*I18nResource // 国际化文案
	i18nResourcesFlag         bool
	trusteeshipUrlToken       string // 单据托管认证token，托管回调会附带此token，帮助业务方认证
	trusteeshipUrlTokenFlag   bool
	trusteeshipUserIdType     string // 用户的类型，会影响请求参数用户标识域的选择，包括加签操作回传的目标用户， 目前仅支持 "user_id"
	trusteeshipUserIdTypeFlag bool
	trusteeshipUrls           *TrusteeshipUrls // 单据托管回调接入方的接口的URL地址
	trusteeshipUrlsFlag       bool
}

func NewExternalInstanceBuilder() *ExternalInstanceBuilder {
	builder := &ExternalInstanceBuilder{}
	return builder
}

// 审批定义 code， 创建审批定义返回的值，表示该实例属于哪个流程；该字段会影响到列表中该实例的标题，标题取自对应定义的 name 字段
//
// 示例值：81D31358-93AF-92D6-7425-01A5D67C4E71
func (builder *ExternalInstanceBuilder) ApprovalCode(approvalCode string) *ExternalInstanceBuilder {
	builder.approvalCode = approvalCode
	builder.approvalCodeFlag = true
	return builder
}

// 审批实例状态
//
// 示例值：PENDING
func (builder *ExternalInstanceBuilder) Status(status string) *ExternalInstanceBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

// 审批实例扩展 JSON
//
// 示例值：{\"xxx\":\"xxx\"}
func (builder *ExternalInstanceBuilder) Extra(extra string) *ExternalInstanceBuilder {
	builder.extra = extra
	builder.extraFlag = true
	return builder
}

// 审批实例唯一标识，用户自定义，需确保证租户、应用下唯一
//
// 示例值：24492654
func (builder *ExternalInstanceBuilder) InstanceId(instanceId string) *ExternalInstanceBuilder {
	builder.instanceId = instanceId
	builder.instanceIdFlag = true
	return builder
}

// 审批实例链接集合 ，用于【已发起】列表的跳转，跳转回三方系统； pc_link 和 mobile_link 必须填一个，填写的是哪一端的链接，即会跳转到该链接，不受平台影响
//
// 示例值：
func (builder *ExternalInstanceBuilder) Links(links *ExternalInstanceLink) *ExternalInstanceBuilder {
	builder.links = links
	builder.linksFlag = true
	return builder
}

// 审批展示名称，如果填写了该字段，则审批列表中的审批名称使用该字段，如果不填该字段，则审批名称使用审批定义的名称
//
// 示例值：@i18n@1
func (builder *ExternalInstanceBuilder) Title(title string) *ExternalInstanceBuilder {
	builder.title = title
	builder.titleFlag = true
	return builder
}

// 用户提交审批时填写的表单数据，用于所有审批列表中展示。可传多个值，但审批中心pc展示前2个,移动端展示前3个,长度不超过2048字符
//
// 示例值：[{ "name": "@i18n@2", "value": "@i18n@3" }]
func (builder *ExternalInstanceBuilder) Form(form []*ExternalInstanceForm) *ExternalInstanceBuilder {
	builder.form = form
	builder.formFlag = true
	return builder
}

// 审批发起人 user_id，发起人可在【已发起】列表中看到所有已发起的审批; 在【待审批】，【已审批】【抄送我】列表中，该字段展示审批是谁发起的。审批发起人 open id，和 user id 二选一。
//
// 示例值：a987sf9s
func (builder *ExternalInstanceBuilder) UserId(userId string) *ExternalInstanceBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 审批发起人 用户名，如果发起人不是真实的用户（例如是某个部门），没有 user_id，则可以使用该字段传名称
//
// 示例值：@i18n@9
func (builder *ExternalInstanceBuilder) UserName(userName string) *ExternalInstanceBuilder {
	builder.userName = userName
	builder.userNameFlag = true
	return builder
}

// 审批发起人 open id，和 user id 二选一
//
// 示例值：ou_be73cbc0ee35eb6ca54e9e7cc14998c1
func (builder *ExternalInstanceBuilder) OpenId(openId string) *ExternalInstanceBuilder {
	builder.openId = openId
	builder.openIdFlag = true
	return builder
}

// 发起人部门，用于列表中展示发起人所属部门。不传则不展示。如果用户没加入任何部门，传 ""，将展示租户名称传 department_name 展示部门名称
//
// 示例值：od-8ec33278bc2
func (builder *ExternalInstanceBuilder) DepartmentId(departmentId string) *ExternalInstanceBuilder {
	builder.departmentId = departmentId
	builder.departmentIdFlag = true
	return builder
}

// 审批发起人 部门，如果发起人不是真实的用户（例如是某个部门），没有 department_id，则可以使用该字段传名称
//
// 示例值：@i18n@10
func (builder *ExternalInstanceBuilder) DepartmentName(departmentName string) *ExternalInstanceBuilder {
	builder.departmentName = departmentName
	builder.departmentNameFlag = true
	return builder
}

// 审批发起时间，Unix毫秒时间戳
//
// 示例值：1556468012678
func (builder *ExternalInstanceBuilder) StartTime(startTime string) *ExternalInstanceBuilder {
	builder.startTime = startTime
	builder.startTimeFlag = true
	return builder
}

// 审批实例结束时间：未结束的审批为 0，Unix毫秒时间戳
//
// 示例值：1556468012678
func (builder *ExternalInstanceBuilder) EndTime(endTime string) *ExternalInstanceBuilder {
	builder.endTime = endTime
	builder.endTimeFlag = true
	return builder
}

// 审批实例最近更新时间；用于推送数据版本控制如果 update_mode 值为 UPDATE，则只有传过来的 update_time 有变化时（变大），才会更新审批中心中的审批实例信息。使用该字段主要用来避免并发时老的数据更新了新的数据
//
// 示例值：1556468012678
func (builder *ExternalInstanceBuilder) UpdateTime(updateTime string) *ExternalInstanceBuilder {
	builder.updateTime = updateTime
	builder.updateTimeFlag = true
	return builder
}

// 列表页打开审批实例的方式
//
// 示例值：BROWSER
func (builder *ExternalInstanceBuilder) DisplayMethod(displayMethod string) *ExternalInstanceBuilder {
	builder.displayMethod = displayMethod
	builder.displayMethodFlag = true
	return builder
}

// 更新方式， 当 update_mode=REPLACE时，每次都以当前推送的数据为最终数据，会删掉审批中心中多余的任务、抄送数据（不在这次推送的数据中）; 当 update_mode=UPDATE时，则不会删除审批中心的数据，而只是进行新增和更新实例、任务数据
//
// 示例值：UPDATE
func (builder *ExternalInstanceBuilder) UpdateMode(updateMode string) *ExternalInstanceBuilder {
	builder.updateMode = updateMode
	builder.updateModeFlag = true
	return builder
}

// 任务列表
//
// 示例值：
func (builder *ExternalInstanceBuilder) TaskList(taskList []*ExternalInstanceTaskNode) *ExternalInstanceBuilder {
	builder.taskList = taskList
	builder.taskListFlag = true
	return builder
}

// 抄送列表
//
// 示例值：
func (builder *ExternalInstanceBuilder) CcList(ccList []*CcNode) *ExternalInstanceBuilder {
	builder.ccList = ccList
	builder.ccListFlag = true
	return builder
}

// 国际化文案
//
// 示例值：
func (builder *ExternalInstanceBuilder) I18nResources(i18nResources []*I18nResource) *ExternalInstanceBuilder {
	builder.i18nResources = i18nResources
	builder.i18nResourcesFlag = true
	return builder
}

// 单据托管认证token，托管回调会附带此token，帮助业务方认证
//
// 示例值：788981c886b1c28ac29d1e68efd60683d6d90dfce80938ee9453e2a5f3e9e306
func (builder *ExternalInstanceBuilder) TrusteeshipUrlToken(trusteeshipUrlToken string) *ExternalInstanceBuilder {
	builder.trusteeshipUrlToken = trusteeshipUrlToken
	builder.trusteeshipUrlTokenFlag = true
	return builder
}

// 用户的类型，会影响请求参数用户标识域的选择，包括加签操作回传的目标用户， 目前仅支持 "user_id"
//
// 示例值：user_id
func (builder *ExternalInstanceBuilder) TrusteeshipUserIdType(trusteeshipUserIdType string) *ExternalInstanceBuilder {
	builder.trusteeshipUserIdType = trusteeshipUserIdType
	builder.trusteeshipUserIdTypeFlag = true
	return builder
}

// 单据托管回调接入方的接口的URL地址
//
// 示例值：
func (builder *ExternalInstanceBuilder) TrusteeshipUrls(trusteeshipUrls *TrusteeshipUrls) *ExternalInstanceBuilder {
	builder.trusteeshipUrls = trusteeshipUrls
	builder.trusteeshipUrlsFlag = true
	return builder
}

func (builder *ExternalInstanceBuilder) Build() *ExternalInstance {
	req := &ExternalInstance{}
	if builder.approvalCodeFlag {
		req.ApprovalCode = &builder.approvalCode

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

	}
	if builder.extraFlag {
		req.Extra = &builder.extra

	}
	if builder.instanceIdFlag {
		req.InstanceId = &builder.instanceId

	}
	if builder.linksFlag {
		req.Links = builder.links
	}
	if builder.titleFlag {
		req.Title = &builder.title

	}
	if builder.formFlag {
		req.Form = builder.form
	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.userNameFlag {
		req.UserName = &builder.userName

	}
	if builder.openIdFlag {
		req.OpenId = &builder.openId

	}
	if builder.departmentIdFlag {
		req.DepartmentId = &builder.departmentId

	}
	if builder.departmentNameFlag {
		req.DepartmentName = &builder.departmentName

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

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

	}
	if builder.updateTimeFlag {
		req.UpdateTime = &builder.updateTime

	}
	if builder.displayMethodFlag {
		req.DisplayMethod = &builder.displayMethod

	}
	if builder.updateModeFlag {
		req.UpdateMode = &builder.updateMode

	}
	if builder.taskListFlag {
		req.TaskList = builder.taskList
	}
	if builder.ccListFlag {
		req.CcList = builder.ccList
	}
	if builder.i18nResourcesFlag {
		req.I18nResources = builder.i18nResources
	}
	if builder.trusteeshipUrlTokenFlag {
		req.TrusteeshipUrlToken = &builder.trusteeshipUrlToken

	}
	if builder.trusteeshipUserIdTypeFlag {
		req.TrusteeshipUserIdType = &builder.trusteeshipUserIdType

	}
	if builder.trusteeshipUrlsFlag {
		req.TrusteeshipUrls = builder.trusteeshipUrls
	}
	return req
}

type ExternalInstanceForm struct {
	Name  *string `json:"name,omitempty"`  // 表单字段名称
	Value *string `json:"value,omitempty"` // 表单值
}

type ExternalInstanceFormBuilder struct {
	name      string // 表单字段名称
	nameFlag  bool
	value     string // 表单值
	valueFlag bool
}

func NewExternalInstanceFormBuilder() *ExternalInstanceFormBuilder {
	builder := &ExternalInstanceFormBuilder{}
	return builder
}

// 表单字段名称
//
// 示例值：@i18n@2
func (builder *ExternalInstanceFormBuilder) Name(name string) *ExternalInstanceFormBuilder {
	builder.name = name
	builder.nameFlag = true
	return builder
}

// 表单值
//
// 示例值：@i18n@3
func (builder *ExternalInstanceFormBuilder) Value(value string) *ExternalInstanceFormBuilder {
	builder.value = value
	builder.valueFlag = true
	return builder
}

func (builder *ExternalInstanceFormBuilder) Build() *ExternalInstanceForm {
	req := &ExternalInstanceForm{}
	if builder.nameFlag {
		req.Name = &builder.name

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

	}
	return req
}

type ExternalInstanceLink struct {
	PcLink     *string `json:"pc_link,omitempty"`     // pc 端的跳转链接，当用户使用飞书 pc 端时，使用该字段进行跳转
	MobileLink *string `json:"mobile_link,omitempty"` // 移动端 跳转链接，当用户使用飞书 移动端时，使用该字段进行跳转
}

type ExternalInstanceLinkBuilder struct {
	pcLink         string // pc 端的跳转链接，当用户使用飞书 pc 端时，使用该字段进行跳转
	pcLinkFlag     bool
	mobileLink     string // 移动端 跳转链接，当用户使用飞书 移动端时，使用该字段进行跳转
	mobileLinkFlag bool
}

func NewExternalInstanceLinkBuilder() *ExternalInstanceLinkBuilder {
	builder := &ExternalInstanceLinkBuilder{}
	return builder
}

// pc 端的跳转链接，当用户使用飞书 pc 端时，使用该字段进行跳转
//
// 示例值：https://applink.feishu.cn/client/mini_program/open?mode=appCenter&appId=cli_9c90fc38e07a9101&path=pc/pages/detail?id=1234
func (builder *ExternalInstanceLinkBuilder) PcLink(pcLink string) *ExternalInstanceLinkBuilder {
	builder.pcLink = pcLink
	builder.pcLinkFlag = true
	return builder
}

// 移动端 跳转链接，当用户使用飞书 移动端时，使用该字段进行跳转
//
// 示例值：https://applink.feishu.cn/client/mini_program/open?appId=cli_9c90fc38e07a9101&path=pages/detail?id=1234
func (builder *ExternalInstanceLinkBuilder) MobileLink(mobileLink string) *ExternalInstanceLinkBuilder {
	builder.mobileLink = mobileLink
	builder.mobileLinkFlag = true
	return builder
}

func (builder *ExternalInstanceLinkBuilder) Build() *ExternalInstanceLink {
	req := &ExternalInstanceLink{}
	if builder.pcLinkFlag {
		req.PcLink = &builder.pcLink

	}
	if builder.mobileLinkFlag {
		req.MobileLink = &builder.mobileLink

	}
	return req
}

type ExternalInstanceTask struct {
	TaskId     *string `json:"task_id,omitempty"`     // 任务 id
	UpdateTime *string `json:"update_time,omitempty"` // 任务最近更新时间
}

type ExternalInstanceTaskBuilder struct {
	taskId         string // 任务 id
	taskIdFlag     bool
	updateTime     string // 任务最近更新时间
	updateTimeFlag bool
}

func NewExternalInstanceTaskBuilder() *ExternalInstanceTaskBuilder {
	builder := &ExternalInstanceTaskBuilder{}
	return builder
}

// 任务 id
//
// 示例值：112253
func (builder *ExternalInstanceTaskBuilder) TaskId(taskId string) *ExternalInstanceTaskBuilder {
	builder.taskId = taskId
	builder.taskIdFlag = true
	return builder
}

// 任务最近更新时间
//
// 示例值：1591603040000
func (builder *ExternalInstanceTaskBuilder) UpdateTime(updateTime string) *ExternalInstanceTaskBuilder {
	builder.updateTime = updateTime
	builder.updateTimeFlag = true
	return builder
}

func (builder *ExternalInstanceTaskBuilder) Build() *ExternalInstanceTask {
	req := &ExternalInstanceTask{}
	if builder.taskIdFlag {
		req.TaskId = &builder.taskId

	}
	if builder.updateTimeFlag {
		req.UpdateTime = &builder.updateTime

	}
	return req
}

type ExternalInstanceTaskNode struct {
	TaskId            *string               `json:"task_id,omitempty"`            // 审批实例内的唯一标识，用于更新审批任务时定位数据
	UserId            *string               `json:"user_id,omitempty"`            // 审批人 user_id，该任务会出现在审批人的【待审批】或【已审批】列表中
	OpenId            *string               `json:"open_id,omitempty"`            // 审批人 open id，和 user id 二选一
	Title             *string               `json:"title,omitempty"`              // 审批任务名称
	Links             *ExternalInstanceLink `json:"links,omitempty"`              // 【待审批】或【已审批】中使用的跳转链接，用于跳转回三方系统pc_link 和 mobile_link 必须填一个，填写的是哪一端的链接，即会跳转到该链接，不受平台影响
	Status            *string               `json:"status,omitempty"`             // 任务状态
	Extra             *string               `json:"extra,omitempty"`              // 扩展 json
	CreateTime        *string               `json:"create_time,omitempty"`        // 任务创建时间，Unix 毫秒时间戳
	EndTime           *string               `json:"end_time,omitempty"`           // 任务完成时间：未结束的审批为 0，Unix 毫秒时间戳
	UpdateTime        *string               `json:"update_time,omitempty"`        // task最近更新时间，用于推送数据版本控制； 更新策略同 instance 中的 update_time
	ActionContext     *string               `json:"action_context,omitempty"`     // 操作上下文，当用户操作时，回调请求中带上该参数，用于传递该任务的上下文数据
	ActionConfigs     []*ActionConfig       `json:"action_configs,omitempty"`     // 任务级别操作配置,快捷审批目前支持移动端操作
	DisplayMethod     *string               `json:"display_method,omitempty"`     // 列表页打开审批任务的方式
	ExcludeStatistics *bool                 `json:"exclude_statistics,omitempty"` // 三方任务支持不纳入效率统计
}

type ExternalInstanceTaskNodeBuilder struct {
	taskId                string // 审批实例内的唯一标识，用于更新审批任务时定位数据
	taskIdFlag            bool
	userId                string // 审批人 user_id，该任务会出现在审批人的【待审批】或【已审批】列表中
	userIdFlag            bool
	openId                string // 审批人 open id，和 user id 二选一
	openIdFlag            bool
	title                 string // 审批任务名称
	titleFlag             bool
	links                 *ExternalInstanceLink // 【待审批】或【已审批】中使用的跳转链接，用于跳转回三方系统pc_link 和 mobile_link 必须填一个，填写的是哪一端的链接，即会跳转到该链接，不受平台影响
	linksFlag             bool
	status                string // 任务状态
	statusFlag            bool
	extra                 string // 扩展 json
	extraFlag             bool
	createTime            string // 任务创建时间，Unix 毫秒时间戳
	createTimeFlag        bool
	endTime               string // 任务完成时间：未结束的审批为 0，Unix 毫秒时间戳
	endTimeFlag           bool
	updateTime            string // task最近更新时间，用于推送数据版本控制； 更新策略同 instance 中的 update_time
	updateTimeFlag        bool
	actionContext         string // 操作上下文，当用户操作时，回调请求中带上该参数，用于传递该任务的上下文数据
	actionContextFlag     bool
	actionConfigs         []*ActionConfig // 任务级别操作配置,快捷审批目前支持移动端操作
	actionConfigsFlag     bool
	displayMethod         string // 列表页打开审批任务的方式
	displayMethodFlag     bool
	excludeStatistics     bool // 三方任务支持不纳入效率统计
	excludeStatisticsFlag bool
}

func NewExternalInstanceTaskNodeBuilder() *ExternalInstanceTaskNodeBuilder {
	builder := &ExternalInstanceTaskNodeBuilder{}
	return builder
}

// 审批实例内的唯一标识，用于更新审批任务时定位数据
//
// 示例值：112534
func (builder *ExternalInstanceTaskNodeBuilder) TaskId(taskId string) *ExternalInstanceTaskNodeBuilder {
	builder.taskId = taskId
	builder.taskIdFlag = true
	return builder
}

// 审批人 user_id，该任务会出现在审批人的【待审批】或【已审批】列表中
//
// 示例值：a987sf9s
func (builder *ExternalInstanceTaskNodeBuilder) UserId(userId string) *ExternalInstanceTaskNodeBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 审批人 open id，和 user id 二选一
//
// 示例值：ou_be73cbc0ee35eb6ca54e9e7cc14998c1
func (builder *ExternalInstanceTaskNodeBuilder) OpenId(openId string) *ExternalInstanceTaskNodeBuilder {
	builder.openId = openId
	builder.openIdFlag = true
	return builder
}

// 审批任务名称
//
// 示例值：i18n1
func (builder *ExternalInstanceTaskNodeBuilder) Title(title string) *ExternalInstanceTaskNodeBuilder {
	builder.title = title
	builder.titleFlag = true
	return builder
}

// 【待审批】或【已审批】中使用的跳转链接，用于跳转回三方系统pc_link 和 mobile_link 必须填一个，填写的是哪一端的链接，即会跳转到该链接，不受平台影响
//
// 示例值：
func (builder *ExternalInstanceTaskNodeBuilder) Links(links *ExternalInstanceLink) *ExternalInstanceTaskNodeBuilder {
	builder.links = links
	builder.linksFlag = true
	return builder
}

// 任务状态
//
// 示例值：PENDING
func (builder *ExternalInstanceTaskNodeBuilder) Status(status string) *ExternalInstanceTaskNodeBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

// 扩展 json
//
// 示例值：{\"xxx\":\"xxx\"}
func (builder *ExternalInstanceTaskNodeBuilder) Extra(extra string) *ExternalInstanceTaskNodeBuilder {
	builder.extra = extra
	builder.extraFlag = true
	return builder
}

// 任务创建时间，Unix 毫秒时间戳
//
// 示例值：1556468012678
func (builder *ExternalInstanceTaskNodeBuilder) CreateTime(createTime string) *ExternalInstanceTaskNodeBuilder {
	builder.createTime = createTime
	builder.createTimeFlag = true
	return builder
}

// 任务完成时间：未结束的审批为 0，Unix 毫秒时间戳
//
// 示例值：1556468012678
func (builder *ExternalInstanceTaskNodeBuilder) EndTime(endTime string) *ExternalInstanceTaskNodeBuilder {
	builder.endTime = endTime
	builder.endTimeFlag = true
	return builder
}

// task最近更新时间，用于推送数据版本控制； 更新策略同 instance 中的 update_time
//
// 示例值：1556468012678
func (builder *ExternalInstanceTaskNodeBuilder) UpdateTime(updateTime string) *ExternalInstanceTaskNodeBuilder {
	builder.updateTime = updateTime
	builder.updateTimeFlag = true
	return builder
}

// 操作上下文，当用户操作时，回调请求中带上该参数，用于传递该任务的上下文数据
//
// 示例值：123456
func (builder *ExternalInstanceTaskNodeBuilder) ActionContext(actionContext string) *ExternalInstanceTaskNodeBuilder {
	builder.actionContext = actionContext
	builder.actionContextFlag = true
	return builder
}

// 任务级别操作配置,快捷审批目前支持移动端操作
//
// 示例值：
func (builder *ExternalInstanceTaskNodeBuilder) ActionConfigs(actionConfigs []*ActionConfig) *ExternalInstanceTaskNodeBuilder {
	builder.actionConfigs = actionConfigs
	builder.actionConfigsFlag = true
	return builder
}

// 列表页打开审批任务的方式
//
// 示例值：BROWSER
func (builder *ExternalInstanceTaskNodeBuilder) DisplayMethod(displayMethod string) *ExternalInstanceTaskNodeBuilder {
	builder.displayMethod = displayMethod
	builder.displayMethodFlag = true
	return builder
}

// 三方任务支持不纳入效率统计
//
// 示例值：true
func (builder *ExternalInstanceTaskNodeBuilder) ExcludeStatistics(excludeStatistics bool) *ExternalInstanceTaskNodeBuilder {
	builder.excludeStatistics = excludeStatistics
	builder.excludeStatisticsFlag = true
	return builder
}

func (builder *ExternalInstanceTaskNodeBuilder) Build() *ExternalInstanceTaskNode {
	req := &ExternalInstanceTaskNode{}
	if builder.taskIdFlag {
		req.TaskId = &builder.taskId

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.openIdFlag {
		req.OpenId = &builder.openId

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

	}
	if builder.linksFlag {
		req.Links = builder.links
	}
	if builder.statusFlag {
		req.Status = &builder.status

	}
	if builder.extraFlag {
		req.Extra = &builder.extra

	}
	if builder.createTimeFlag {
		req.CreateTime = &builder.createTime

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

	}
	if builder.updateTimeFlag {
		req.UpdateTime = &builder.updateTime

	}
	if builder.actionContextFlag {
		req.ActionContext = &builder.actionContext

	}
	if builder.actionConfigsFlag {
		req.ActionConfigs = builder.actionConfigs
	}
	if builder.displayMethodFlag {
		req.DisplayMethod = &builder.displayMethod

	}
	if builder.excludeStatisticsFlag {
		req.ExcludeStatistics = &builder.excludeStatistics

	}
	return req
}

type ExternalTaskItem struct {
	Id         *string `json:"id,omitempty"`          // 审批任务 ID
	Status     *string `json:"status,omitempty"`      // 审批任务状态
	UpdateTime *string `json:"update_time,omitempty"` // 审批任务最后更新时间，单位 毫秒
}

type ExternalTaskItemBuilder struct {
	id             string // 审批任务 ID
	idFlag         bool
	status         string // 审批任务状态
	statusFlag     bool
	updateTime     string // 审批任务最后更新时间，单位 毫秒
	updateTimeFlag bool
}

func NewExternalTaskItemBuilder() *ExternalTaskItemBuilder {
	builder := &ExternalTaskItemBuilder{}
	return builder
}

// 审批任务 ID
//
// 示例值：310
func (builder *ExternalTaskItemBuilder) Id(id string) *ExternalTaskItemBuilder {
	builder.id = id
	builder.idFlag = true
	return builder
}

// 审批任务状态
//
// 示例值：PENDING
func (builder *ExternalTaskItemBuilder) Status(status string) *ExternalTaskItemBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

// 审批任务最后更新时间，单位 毫秒
//
// 示例值：1621863215000
func (builder *ExternalTaskItemBuilder) UpdateTime(updateTime string) *ExternalTaskItemBuilder {
	builder.updateTime = updateTime
	builder.updateTimeFlag = true
	return builder
}

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

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

	}
	if builder.updateTimeFlag {
		req.UpdateTime = &builder.updateTime

	}
	return req
}

type ExternalTaskList struct {
	InstanceId   *string             `json:"instance_id,omitempty"`   // 审批实例 ID
	ApprovalId   *string             `json:"approval_id,omitempty"`   // 审批的id
	ApprovalCode *string             `json:"approval_code,omitempty"` // 审批对应的 approval_code
	Status       *string             `json:"status,omitempty"`        // 审批实例当前的状态
	UpdateTime   *string             `json:"update_time,omitempty"`   // 审批实例最后更新时间，单位 毫秒
	Tasks        []*ExternalTaskItem `json:"tasks,omitempty"`         // 审批实例下的审批任务
}

type ExternalTaskListBuilder struct {
	instanceId       string // 审批实例 ID
	instanceIdFlag   bool
	approvalId       string // 审批的id
	approvalIdFlag   bool
	approvalCode     string // 审批对应的 approval_code
	approvalCodeFlag bool
	status           string // 审批实例当前的状态
	statusFlag       bool
	updateTime       string // 审批实例最后更新时间，单位 毫秒
	updateTimeFlag   bool
	tasks            []*ExternalTaskItem // 审批实例下的审批任务
	tasksFlag        bool
}

func NewExternalTaskListBuilder() *ExternalTaskListBuilder {
	builder := &ExternalTaskListBuilder{}
	return builder
}

// 审批实例 ID
//
// 示例值：29075
func (builder *ExternalTaskListBuilder) InstanceId(instanceId string) *ExternalTaskListBuilder {
	builder.instanceId = instanceId
	builder.instanceIdFlag = true
	return builder
}

// 审批的id
//
// 示例值：fwwweffff33111133xxx
func (builder *ExternalTaskListBuilder) ApprovalId(approvalId string) *ExternalTaskListBuilder {
	builder.approvalId = approvalId
	builder.approvalIdFlag = true
	return builder
}

// 审批对应的 approval_code
//
// 示例值：B7B65FFE-C2GC-452F-9F0F-9AA8352363D6
func (builder *ExternalTaskListBuilder) ApprovalCode(approvalCode string) *ExternalTaskListBuilder {
	builder.approvalCode = approvalCode
	builder.approvalCodeFlag = true
	return builder
}

// 审批实例当前的状态
//
// 示例值：PENDING
func (builder *ExternalTaskListBuilder) Status(status string) *ExternalTaskListBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

// 审批实例最后更新时间，单位 毫秒
//
// 示例值：1621863215000
func (builder *ExternalTaskListBuilder) UpdateTime(updateTime string) *ExternalTaskListBuilder {
	builder.updateTime = updateTime
	builder.updateTimeFlag = true
	return builder
}

// 审批实例下的审批任务
//
// 示例值：
func (builder *ExternalTaskListBuilder) Tasks(tasks []*ExternalTaskItem) *ExternalTaskListBuilder {
	builder.tasks = tasks
	builder.tasksFlag = true
	return builder
}

func (builder *ExternalTaskListBuilder) Build() *ExternalTaskList {
	req := &ExternalTaskList{}
	if builder.instanceIdFlag {
		req.InstanceId = &builder.instanceId

	}
	if builder.approvalIdFlag {
		req.ApprovalId = &builder.approvalId

	}
	if builder.approvalCodeFlag {
		req.ApprovalCode = &builder.approvalCode

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

	}
	if builder.updateTimeFlag {
		req.UpdateTime = &builder.updateTime

	}
	if builder.tasksFlag {
		req.Tasks = builder.tasks
	}
	return req
}

type FieldGroup struct {
	Writable []string `json:"writable,omitempty"` // 可写权限的表单项的 id列表
	Readable []string `json:"readable,omitempty"` // 可读权限的表单项的 id列表
}

type FieldGroupBuilder struct {
	writable     []string // 可写权限的表单项的 id列表
	writableFlag bool
	readable     []string // 可读权限的表单项的 id列表
	readableFlag bool
}

func NewFieldGroupBuilder() *FieldGroupBuilder {
	builder := &FieldGroupBuilder{}
	return builder
}

// 可写权限的表单项的 id列表
//
// 示例值：9293493
func (builder *FieldGroupBuilder) Writable(writable []string) *FieldGroupBuilder {
	builder.writable = writable
	builder.writableFlag = true
	return builder
}

// 可读权限的表单项的 id列表
//
// 示例值：9293493
func (builder *FieldGroupBuilder) Readable(readable []string) *FieldGroupBuilder {
	builder.readable = readable
	builder.readableFlag = true
	return builder
}

func (builder *FieldGroupBuilder) Build() *FieldGroup {
	req := &FieldGroup{}
	if builder.writableFlag {
		req.Writable = builder.writable
	}
	if builder.readableFlag {
		req.Readable = builder.readable
	}
	return req
}

type File struct {
	Url      *string `json:"url,omitempty"`       // 附件路径
	FileSize *int    `json:"file_size,omitempty"` // 附件大小
	Title    *string `json:"title,omitempty"`     // 附件标题
	Type     *string `json:"type,omitempty"`      // 附件类别
}

type FileBuilder struct {
	url          string // 附件路径
	urlFlag      bool
	fileSize     int // 附件大小
	fileSizeFlag bool
	title        string // 附件标题
	titleFlag    bool
	type_        string // 附件类别
	typeFlag     bool
}

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

// 附件路径
//
// 示例值：https://p3-approval-sign.byteimg.com/lark-approval-attachment/image/20220714/1/332f3596-0845-4746-a4bc-818d54ad435b.png~tplv-ottatrvjsm-image.image?x-expires=1659033558&x-signature=6edF3k%2BaHeAuvfcBRGOkbckoUl4%3D#.png
func (builder *FileBuilder) Url(url string) *FileBuilder {
	builder.url = url
	builder.urlFlag = true
	return builder
}

// 附件大小
//
// 示例值：186823
func (builder *FileBuilder) FileSize(fileSize int) *FileBuilder {
	builder.fileSize = fileSize
	builder.fileSizeFlag = true
	return builder
}

// 附件标题
//
// 示例值：e018906140ed9388234bd03b0.png
func (builder *FileBuilder) Title(title string) *FileBuilder {
	builder.title = title
	builder.titleFlag = true
	return builder
}

// 附件类别
//
// 示例值：image
func (builder *FileBuilder) Type(type_ string) *FileBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

func (builder *FileBuilder) Build() *File {
	req := &File{}
	if builder.urlFlag {
		req.Url = &builder.url

	}
	if builder.fileSizeFlag {
		req.FileSize = &builder.fileSize

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

	}
	if builder.typeFlag {
		req.Type = &builder.type_

	}
	return req
}

type I18nResource struct {
	Locale    *string             `json:"locale,omitempty"`     // 语言可选值有： zh-CN：中文 en-US：英文 ja-JP：日文
	Texts     []*I18nResourceText `json:"texts,omitempty"`      // 文案 key, value, i18n key 以 @i18n@ 开头； 该字段主要用于做国际化，语序用户同时传多个语言的文案，审批中心会根据用户当前的语音环境使用对应的文案，如果没有传用户当前的语音环境文案，则会使用默认的语言文案。
	IsDefault *bool               `json:"is_default,omitempty"` // 是否默认语言，默认语言需要包含所有key，非默认语言如果key不存在会使用默认语言代替
}

type I18nResourceBuilder struct {
	locale        string // 语言可选值有： zh-CN：中文 en-US：英文 ja-JP：日文
	localeFlag    bool
	texts         []*I18nResourceText // 文案 key, value, i18n key 以 @i18n@ 开头； 该字段主要用于做国际化，语序用户同时传多个语言的文案，审批中心会根据用户当前的语音环境使用对应的文案，如果没有传用户当前的语音环境文案，则会使用默认的语言文案。
	textsFlag     bool
	isDefault     bool // 是否默认语言，默认语言需要包含所有key，非默认语言如果key不存在会使用默认语言代替
	isDefaultFlag bool
}

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

// 语言可选值有： zh-CN：中文 en-US：英文 ja-JP：日文
//
// 示例值：zh-CN
func (builder *I18nResourceBuilder) Locale(locale string) *I18nResourceBuilder {
	builder.locale = locale
	builder.localeFlag = true
	return builder
}

// 文案 key, value, i18n key 以 @i18n@ 开头； 该字段主要用于做国际化，语序用户同时传多个语言的文案，审批中心会根据用户当前的语音环境使用对应的文案，如果没有传用户当前的语音环境文案，则会使用默认的语言文案。
//
// 示例值：{ "@i18n@1": "权限申请", "@i18n@2": "OA审批", "@i18n@3": "Permission" }
func (builder *I18nResourceBuilder) Texts(texts []*I18nResourceText) *I18nResourceBuilder {
	builder.texts = texts
	builder.textsFlag = true
	return builder
}

// 是否默认语言，默认语言需要包含所有key，非默认语言如果key不存在会使用默认语言代替
//
// 示例值：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.localeFlag {
		req.Locale = &builder.locale

	}
	if builder.textsFlag {
		req.Texts = builder.texts
	}
	if builder.isDefaultFlag {
		req.IsDefault = &builder.isDefault

	}
	return req
}

type I18nResourceText struct {
	Key   *string `json:"key,omitempty"`   // 文案key
	Value *string `json:"value,omitempty"` // 文案
}

type I18nResourceTextBuilder struct {
	key       string // 文案key
	keyFlag   bool
	value     string // 文案
	valueFlag bool
}

func NewI18nResourceTextBuilder() *I18nResourceTextBuilder {
	builder := &I18nResourceTextBuilder{}
	return builder
}

// 文案key
//
// 示例值：@i18n@1
func (builder *I18nResourceTextBuilder) Key(key string) *I18nResourceTextBuilder {
	builder.key = key
	builder.keyFlag = true
	return builder
}

// 文案
//
// 示例值：people
func (builder *I18nResourceTextBuilder) Value(value string) *I18nResourceTextBuilder {
	builder.value = value
	builder.valueFlag = true
	return builder
}

func (builder *I18nResourceTextBuilder) Build() *I18nResourceText {
	req := &I18nResourceText{}
	if builder.keyFlag {
		req.Key = &builder.key

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

	}
	return req
}

type Instance struct {
	InstanceCode *string `json:"instance_code,omitempty"` // 审批实例code
	ApprovalName *string `json:"approval_name,omitempty"` // 审批名称
	StartTime    *string `json:"start_time,omitempty"`    // 审批实例发起时间戳
	EndTime      *string `json:"end_time,omitempty"`      // 审批实例结束时间戳
	UserId       *string `json:"user_id,omitempty"`       // 发起人
	SerialId     *string `json:"serial_id,omitempty"`     // 申请编号
}

type InstanceBuilder struct {
	instanceCode     string // 审批实例code
	instanceCodeFlag bool
	approvalName     string // 审批名称
	approvalNameFlag bool
	startTime        string // 审批实例发起时间戳
	startTimeFlag    bool
	endTime          string // 审批实例结束时间戳
	endTimeFlag      bool
	userId           string // 发起人
	userIdFlag       bool
	serialId         string // 申请编号
	serialIdFlag     bool
}

func NewInstanceBuilder() *InstanceBuilder {
	builder := &InstanceBuilder{}
	return builder
}

// 审批实例code
//
// 示例值：
func (builder *InstanceBuilder) InstanceCode(instanceCode string) *InstanceBuilder {
	builder.instanceCode = instanceCode
	builder.instanceCodeFlag = true
	return builder
}

// 审批名称
//
// 示例值：
func (builder *InstanceBuilder) ApprovalName(approvalName string) *InstanceBuilder {
	builder.approvalName = approvalName
	builder.approvalNameFlag = true
	return builder
}

// 审批实例发起时间戳
//
// 示例值：
func (builder *InstanceBuilder) StartTime(startTime string) *InstanceBuilder {
	builder.startTime = startTime
	builder.startTimeFlag = true
	return builder
}

// 审批实例结束时间戳
//
// 示例值：
func (builder *InstanceBuilder) EndTime(endTime string) *InstanceBuilder {
	builder.endTime = endTime
	builder.endTimeFlag = true
	return builder
}

// 发起人
//
// 示例值：
func (builder *InstanceBuilder) UserId(userId string) *InstanceBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 申请编号
//
// 示例值：
func (builder *InstanceBuilder) SerialId(serialId string) *InstanceBuilder {
	builder.serialId = serialId
	builder.serialIdFlag = true
	return builder
}

func (builder *InstanceBuilder) Build() *Instance {
	req := &Instance{}
	if builder.instanceCodeFlag {
		req.InstanceCode = &builder.instanceCode

	}
	if builder.approvalNameFlag {
		req.ApprovalName = &builder.approvalName

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

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

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.serialIdFlag {
		req.SerialId = &builder.serialId

	}
	return req
}

type InstanceCancel struct {
	ApprovalCode *string `json:"approval_code,omitempty"` // 审批定义Code
	InstanceCode *string `json:"instance_code,omitempty"` // 审批实例Code
	UserId       *string `json:"user_id,omitempty"`       // 操作用户, 根据user_id_type填写
}

type InstanceCancelBuilder struct {
	approvalCode     string // 审批定义Code
	approvalCodeFlag bool
	instanceCode     string // 审批实例Code
	instanceCodeFlag bool
	userId           string // 操作用户, 根据user_id_type填写
	userIdFlag       bool
}

func NewInstanceCancelBuilder() *InstanceCancelBuilder {
	builder := &InstanceCancelBuilder{}
	return builder
}

// 审批定义Code
//
// 示例值：7C468A54-8745-2245-9675-08B7C63E7A85
func (builder *InstanceCancelBuilder) ApprovalCode(approvalCode string) *InstanceCancelBuilder {
	builder.approvalCode = approvalCode
	builder.approvalCodeFlag = true
	return builder
}

// 审批实例Code
//
// 示例值：81D31358-93AF-92D6-7425-01A5D67C4E71
func (builder *InstanceCancelBuilder) InstanceCode(instanceCode string) *InstanceCancelBuilder {
	builder.instanceCode = instanceCode
	builder.instanceCodeFlag = true
	return builder
}

// 操作用户, 根据user_id_type填写
//
// 示例值：f7cb567e
func (builder *InstanceCancelBuilder) UserId(userId string) *InstanceCancelBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

func (builder *InstanceCancelBuilder) Build() *InstanceCancel {
	req := &InstanceCancel{}
	if builder.approvalCodeFlag {
		req.ApprovalCode = &builder.approvalCode

	}
	if builder.instanceCodeFlag {
		req.InstanceCode = &builder.instanceCode

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	return req
}

type InstanceCc struct {
	ApprovalCode *string  `json:"approval_code,omitempty"` // 审批定义 code
	InstanceCode *string  `json:"instance_code,omitempty"` // 审批实例 code
	UserId       *string  `json:"user_id,omitempty"`       // 根据user_id_type填写发起抄送的人的用户id
	CcUserIds    []string `json:"cc_user_ids,omitempty"`   // 根据user_id_type填写被抄送人的 用户id 列表
	Comment      *string  `json:"comment,omitempty"`       // 抄送留言
}

type InstanceCcBuilder struct {
	approvalCode     string // 审批定义 code
	approvalCodeFlag bool
	instanceCode     string // 审批实例 code
	instanceCodeFlag bool
	userId           string // 根据user_id_type填写发起抄送的人的用户id
	userIdFlag       bool
	ccUserIds        []string // 根据user_id_type填写被抄送人的 用户id 列表
	ccUserIdsFlag    bool
	comment          string // 抄送留言
	commentFlag      bool
}

func NewInstanceCcBuilder() *InstanceCcBuilder {
	builder := &InstanceCcBuilder{}
	return builder
}

// 审批定义 code
//
// 示例值：7C468A54-8745-2245-9675-08B7C63E7A85
func (builder *InstanceCcBuilder) ApprovalCode(approvalCode string) *InstanceCcBuilder {
	builder.approvalCode = approvalCode
	builder.approvalCodeFlag = true
	return builder
}

// 审批实例 code
//
// 示例值：7C468A54-8745-2245-9675-08B7C63E7A85
func (builder *InstanceCcBuilder) InstanceCode(instanceCode string) *InstanceCcBuilder {
	builder.instanceCode = instanceCode
	builder.instanceCodeFlag = true
	return builder
}

// 根据user_id_type填写发起抄送的人的用户id
//
// 示例值：f7cb567e
func (builder *InstanceCcBuilder) UserId(userId string) *InstanceCcBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 根据user_id_type填写被抄送人的 用户id 列表
//
// 示例值：f7cb567e
func (builder *InstanceCcBuilder) CcUserIds(ccUserIds []string) *InstanceCcBuilder {
	builder.ccUserIds = ccUserIds
	builder.ccUserIdsFlag = true
	return builder
}

// 抄送留言
//
// 示例值：ok
func (builder *InstanceCcBuilder) Comment(comment string) *InstanceCcBuilder {
	builder.comment = comment
	builder.commentFlag = true
	return builder
}

func (builder *InstanceCcBuilder) Build() *InstanceCc {
	req := &InstanceCc{}
	if builder.approvalCodeFlag {
		req.ApprovalCode = &builder.approvalCode

	}
	if builder.instanceCodeFlag {
		req.InstanceCode = &builder.instanceCode

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.ccUserIdsFlag {
		req.CcUserIds = builder.ccUserIds
	}
	if builder.commentFlag {
		req.Comment = &builder.comment

	}
	return req
}

type InstanceCcUser struct {
	UserId *string `json:"user_id,omitempty"` // 抄送人 user id
	CcId   *string `json:"cc_id,omitempty"`   // 审批实例内抄送唯一标识
	OpenId *string `json:"open_id,omitempty"` // 抄送人 open id
}

type InstanceCcUserBuilder struct {
	userId     string // 抄送人 user id
	userIdFlag bool
	ccId       string // 审批实例内抄送唯一标识
	ccIdFlag   bool
	openId     string // 抄送人 open id
	openIdFlag bool
}

func NewInstanceCcUserBuilder() *InstanceCcUserBuilder {
	builder := &InstanceCcUserBuilder{}
	return builder
}

// 抄送人 user id
//
// 示例值：eea5gefe
func (builder *InstanceCcUserBuilder) UserId(userId string) *InstanceCcUserBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 审批实例内抄送唯一标识
//
// 示例值：123445
func (builder *InstanceCcUserBuilder) CcId(ccId string) *InstanceCcUserBuilder {
	builder.ccId = ccId
	builder.ccIdFlag = true
	return builder
}

// 抄送人 open id
//
// 示例值：ou_12345
func (builder *InstanceCcUserBuilder) OpenId(openId string) *InstanceCcUserBuilder {
	builder.openId = openId
	builder.openIdFlag = true
	return builder
}

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

	}
	if builder.ccIdFlag {
		req.CcId = &builder.ccId

	}
	if builder.openIdFlag {
		req.OpenId = &builder.openId

	}
	return req
}

type InstanceComment struct {
	Id         *string `json:"id,omitempty"`          // 评论 id
	UserId     *string `json:"user_id,omitempty"`     // 发表评论用户
	OpenId     *string `json:"open_id,omitempty"`     // 发表评论用户 open id
	Comment    *string `json:"comment,omitempty"`     // 评论内容
	CreateTime *string `json:"create_time,omitempty"` // 1564590532967
	Files      []*File `json:"files,omitempty"`       // 评论附件
}

type InstanceCommentBuilder struct {
	id             string // 评论 id
	idFlag         bool
	userId         string // 发表评论用户
	userIdFlag     bool
	openId         string // 发表评论用户 open id
	openIdFlag     bool
	comment        string // 评论内容
	commentFlag    bool
	createTime     string // 1564590532967
	createTimeFlag bool
	files          []*File // 评论附件
	filesFlag      bool
}

func NewInstanceCommentBuilder() *InstanceCommentBuilder {
	builder := &InstanceCommentBuilder{}
	return builder
}

// 评论 id
//
// 示例值：1234
func (builder *InstanceCommentBuilder) Id(id string) *InstanceCommentBuilder {
	builder.id = id
	builder.idFlag = true
	return builder
}

// 发表评论用户
//
// 示例值：f7cb567e
func (builder *InstanceCommentBuilder) UserId(userId string) *InstanceCommentBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 发表评论用户 open id
//
// 示例值：ou_123456
func (builder *InstanceCommentBuilder) OpenId(openId string) *InstanceCommentBuilder {
	builder.openId = openId
	builder.openIdFlag = true
	return builder
}

// 评论内容
//
// 示例值：ok
func (builder *InstanceCommentBuilder) Comment(comment string) *InstanceCommentBuilder {
	builder.comment = comment
	builder.commentFlag = true
	return builder
}

// 1564590532967
//
// 示例值：评论时间
func (builder *InstanceCommentBuilder) CreateTime(createTime string) *InstanceCommentBuilder {
	builder.createTime = createTime
	builder.createTimeFlag = true
	return builder
}

// 评论附件
//
// 示例值：
func (builder *InstanceCommentBuilder) Files(files []*File) *InstanceCommentBuilder {
	builder.files = files
	builder.filesFlag = true
	return builder
}

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

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.openIdFlag {
		req.OpenId = &builder.openId

	}
	if builder.commentFlag {
		req.Comment = &builder.comment

	}
	if builder.createTimeFlag {
		req.CreateTime = &builder.createTime

	}
	if builder.filesFlag {
		req.Files = builder.files
	}
	return req
}

type InstanceCreate struct {
	ApprovalCode           *string         `json:"approval_code,omitempty"`              // 审批定义 code
	UserId                 *string         `json:"user_id,omitempty"`                    // 发起审批用户
	OpenId                 *string         `json:"open_id,omitempty"`                    // 发起审批用户 open id, 如果传了 user_id 则优先使用 user_id
	DepartmentId           *string         `json:"department_id,omitempty"`              // 发起审批用户部门id，如果用户只属于一个部门，可以不填。如果属于多个部门，默认会选择部门列表第一个部门
	Form                   *string         `json:"form,omitempty"`                       // json 数组，控件值
	NodeApproverUserIdList []*NodeApprover `json:"node_approver_user_id_list,omitempty"` // 如果有发起人自选节点，则需要填写对应节点的审批人
	NodeApproverOpenIdList []*NodeApprover `json:"node_approver_open_id_list,omitempty"` // 审批人发起人自选 open id，与上述node_approver_user_id_list字段取并集
	NodeCcUserIdList       []*NodeCc       `json:"node_cc_user_id_list,omitempty"`       // 如果有发起人自选节点，则可填写对应节点的抄送人，单个节点最多选择20位抄送人
	NodeCcOpenIdList       []*NodeCc       `json:"node_cc_open_id_list,omitempty"`       // 抄送人发起人自选 open id 单个节点最多选择20位抄送人
	Uuid                   *string         `json:"uuid,omitempty"`                       // 审批实例 uuid，用于幂等操作, 每个租户下面的唯一key，同一个 uuid 只能用于创建一个审批实例，如果冲突，返回错误码 60012 ，格式建议为 XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX，不区分大小写
	AllowResubmit          *bool           `json:"allow_resubmit,omitempty"`             // 可配置是否可以再次提交
	AllowSubmitAgain       *bool           `json:"allow_submit_again,omitempty"`         // 可配置是否可以重新提交
}

type InstanceCreateBuilder struct {
	approvalCode               string // 审批定义 code
	approvalCodeFlag           bool
	userId                     string // 发起审批用户
	userIdFlag                 bool
	openId                     string // 发起审批用户 open id, 如果传了 user_id 则优先使用 user_id
	openIdFlag                 bool
	departmentId               string // 发起审批用户部门id，如果用户只属于一个部门，可以不填。如果属于多个部门，默认会选择部门列表第一个部门
	departmentIdFlag           bool
	form                       string // json 数组，控件值
	formFlag                   bool
	nodeApproverUserIdList     []*NodeApprover // 如果有发起人自选节点，则需要填写对应节点的审批人
	nodeApproverUserIdListFlag bool
	nodeApproverOpenIdList     []*NodeApprover // 审批人发起人自选 open id，与上述node_approver_user_id_list字段取并集
	nodeApproverOpenIdListFlag bool
	nodeCcUserIdList           []*NodeCc // 如果有发起人自选节点，则可填写对应节点的抄送人，单个节点最多选择20位抄送人
	nodeCcUserIdListFlag       bool
	nodeCcOpenIdList           []*NodeCc // 抄送人发起人自选 open id 单个节点最多选择20位抄送人
	nodeCcOpenIdListFlag       bool
	uuid                       string // 审批实例 uuid，用于幂等操作, 每个租户下面的唯一key，同一个 uuid 只能用于创建一个审批实例，如果冲突，返回错误码 60012 ，格式建议为 XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX，不区分大小写
	uuidFlag                   bool
	allowResubmit              bool // 可配置是否可以再次提交
	allowResubmitFlag          bool
	allowSubmitAgain           bool // 可配置是否可以重新提交
	allowSubmitAgainFlag       bool
}

func NewInstanceCreateBuilder() *InstanceCreateBuilder {
	builder := &InstanceCreateBuilder{}
	return builder
}

// 审批定义 code
//
// 示例值：7C468A54-8745-2245-9675-08B7C63E7A85
func (builder *InstanceCreateBuilder) ApprovalCode(approvalCode string) *InstanceCreateBuilder {
	builder.approvalCode = approvalCode
	builder.approvalCodeFlag = true
	return builder
}

// 发起审批用户
//
// 示例值：f7cb567e
func (builder *InstanceCreateBuilder) UserId(userId string) *InstanceCreateBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 发起审批用户 open id, 如果传了 user_id 则优先使用 user_id
//
// 示例值：ou_3cda9c969f737aaa05e6915dce306cb9
func (builder *InstanceCreateBuilder) OpenId(openId string) *InstanceCreateBuilder {
	builder.openId = openId
	builder.openIdFlag = true
	return builder
}

// 发起审批用户部门id，如果用户只属于一个部门，可以不填。如果属于多个部门，默认会选择部门列表第一个部门
//
// 示例值：9293493ccacbdb9a
func (builder *InstanceCreateBuilder) DepartmentId(departmentId string) *InstanceCreateBuilder {
	builder.departmentId = departmentId
	builder.departmentIdFlag = true
	return builder
}

// json 数组，控件值
//
// 示例值：[{\"id\":\"111\", \"type\": \"input\", \"value\":\"test\"}]
func (builder *InstanceCreateBuilder) Form(form string) *InstanceCreateBuilder {
	builder.form = form
	builder.formFlag = true
	return builder
}

// 如果有发起人自选节点，则需要填写对应节点的审批人
//
// 示例值：
func (builder *InstanceCreateBuilder) NodeApproverUserIdList(nodeApproverUserIdList []*NodeApprover) *InstanceCreateBuilder {
	builder.nodeApproverUserIdList = nodeApproverUserIdList
	builder.nodeApproverUserIdListFlag = true
	return builder
}

// 审批人发起人自选 open id，与上述node_approver_user_id_list字段取并集
//
// 示例值：
func (builder *InstanceCreateBuilder) NodeApproverOpenIdList(nodeApproverOpenIdList []*NodeApprover) *InstanceCreateBuilder {
	builder.nodeApproverOpenIdList = nodeApproverOpenIdList
	builder.nodeApproverOpenIdListFlag = true
	return builder
}

// 如果有发起人自选节点，则可填写对应节点的抄送人，单个节点最多选择20位抄送人
//
// 示例值：
func (builder *InstanceCreateBuilder) NodeCcUserIdList(nodeCcUserIdList []*NodeCc) *InstanceCreateBuilder {
	builder.nodeCcUserIdList = nodeCcUserIdList
	builder.nodeCcUserIdListFlag = true
	return builder
}

// 抄送人发起人自选 open id 单个节点最多选择20位抄送人
//
// 示例值：
func (builder *InstanceCreateBuilder) NodeCcOpenIdList(nodeCcOpenIdList []*NodeCc) *InstanceCreateBuilder {
	builder.nodeCcOpenIdList = nodeCcOpenIdList
	builder.nodeCcOpenIdListFlag = true
	return builder
}

// 审批实例 uuid，用于幂等操作, 每个租户下面的唯一key，同一个 uuid 只能用于创建一个审批实例，如果冲突，返回错误码 60012 ，格式建议为 XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX，不区分大小写
//
// 示例值：7C468A54-8745-2245-9675-08B7C63E7A87
func (builder *InstanceCreateBuilder) Uuid(uuid string) *InstanceCreateBuilder {
	builder.uuid = uuid
	builder.uuidFlag = true
	return builder
}

// 可配置是否可以再次提交
//
// 示例值：true
func (builder *InstanceCreateBuilder) AllowResubmit(allowResubmit bool) *InstanceCreateBuilder {
	builder.allowResubmit = allowResubmit
	builder.allowResubmitFlag = true
	return builder
}

// 可配置是否可以重新提交
//
// 示例值：true
func (builder *InstanceCreateBuilder) AllowSubmitAgain(allowSubmitAgain bool) *InstanceCreateBuilder {
	builder.allowSubmitAgain = allowSubmitAgain
	builder.allowSubmitAgainFlag = true
	return builder
}

func (builder *InstanceCreateBuilder) Build() *InstanceCreate {
	req := &InstanceCreate{}
	if builder.approvalCodeFlag {
		req.ApprovalCode = &builder.approvalCode

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.openIdFlag {
		req.OpenId = &builder.openId

	}
	if builder.departmentIdFlag {
		req.DepartmentId = &builder.departmentId

	}
	if builder.formFlag {
		req.Form = &builder.form

	}
	if builder.nodeApproverUserIdListFlag {
		req.NodeApproverUserIdList = builder.nodeApproverUserIdList
	}
	if builder.nodeApproverOpenIdListFlag {
		req.NodeApproverOpenIdList = builder.nodeApproverOpenIdList
	}
	if builder.nodeCcUserIdListFlag {
		req.NodeCcUserIdList = builder.nodeCcUserIdList
	}
	if builder.nodeCcOpenIdListFlag {
		req.NodeCcOpenIdList = builder.nodeCcOpenIdList
	}
	if builder.uuidFlag {
		req.Uuid = &builder.uuid

	}
	if builder.allowResubmitFlag {
		req.AllowResubmit = &builder.allowResubmit

	}
	if builder.allowSubmitAgainFlag {
		req.AllowSubmitAgain = &builder.allowSubmitAgain

	}
	return req
}

type InstanceSearch struct {
	UserId                *string `json:"user_id,omitempty"`                  // 根据x_user_type填写用户 id
	ApprovalCode          *string `json:"approval_code,omitempty"`            // 审批定义 code
	InstanceCode          *string `json:"instance_code,omitempty"`            // 审批实例 code
	InstanceExternalId    *string `json:"instance_external_id,omitempty"`     // 审批实例第三方 id 注：和 approval_code 取并集
	GroupExternalId       *string `json:"group_external_id,omitempty"`        // 审批定义分组第三方 id 注：和 instance_code 取并集
	InstanceTitle         *string `json:"instance_title,omitempty"`           // 审批实例标题（只有第三方审批有）
	InstanceStatus        *string `json:"instance_status,omitempty"`          // 审批实例状态，注：若不设置，查询全部状态 若不在集合中，报错
	InstanceStartTimeFrom *string `json:"instance_start_time_from,omitempty"` // 实例查询开始时间（unix毫秒时间戳）
	InstanceStartTimeTo   *string `json:"instance_start_time_to,omitempty"`   // 实例查询结束时间 (unix毫秒时间戳)
	Locale                *string `json:"locale,omitempty"`                   // 地区
}

type InstanceSearchBuilder struct {
	userId                    string // 根据x_user_type填写用户 id
	userIdFlag                bool
	approvalCode              string // 审批定义 code
	approvalCodeFlag          bool
	instanceCode              string // 审批实例 code
	instanceCodeFlag          bool
	instanceExternalId        string // 审批实例第三方 id 注：和 approval_code 取并集
	instanceExternalIdFlag    bool
	groupExternalId           string // 审批定义分组第三方 id 注：和 instance_code 取并集
	groupExternalIdFlag       bool
	instanceTitle             string // 审批实例标题（只有第三方审批有）
	instanceTitleFlag         bool
	instanceStatus            string // 审批实例状态，注：若不设置，查询全部状态 若不在集合中，报错
	instanceStatusFlag        bool
	instanceStartTimeFrom     string // 实例查询开始时间（unix毫秒时间戳）
	instanceStartTimeFromFlag bool
	instanceStartTimeTo       string // 实例查询结束时间 (unix毫秒时间戳)
	instanceStartTimeToFlag   bool
	locale                    string // 地区
	localeFlag                bool
}

func NewInstanceSearchBuilder() *InstanceSearchBuilder {
	builder := &InstanceSearchBuilder{}
	return builder
}

// 根据x_user_type填写用户 id
//
// 示例值：lwiu098wj
func (builder *InstanceSearchBuilder) UserId(userId string) *InstanceSearchBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 审批定义 code
//
// 示例值：EB828003-9FFE-4B3F-AA50-2E199E2ED942
func (builder *InstanceSearchBuilder) ApprovalCode(approvalCode string) *InstanceSearchBuilder {
	builder.approvalCode = approvalCode
	builder.approvalCodeFlag = true
	return builder
}

// 审批实例 code
//
// 示例值：EB828003-9FFE-4B3F-AA50-2E199E2ED943
func (builder *InstanceSearchBuilder) InstanceCode(instanceCode string) *InstanceSearchBuilder {
	builder.instanceCode = instanceCode
	builder.instanceCodeFlag = true
	return builder
}

// 审批实例第三方 id 注：和 approval_code 取并集
//
// 示例值：EB828003-9FFE-4B3F-AA50-2E199E2ED976
func (builder *InstanceSearchBuilder) InstanceExternalId(instanceExternalId string) *InstanceSearchBuilder {
	builder.instanceExternalId = instanceExternalId
	builder.instanceExternalIdFlag = true
	return builder
}

// 审批定义分组第三方 id 注：和 instance_code 取并集
//
// 示例值：1234567
func (builder *InstanceSearchBuilder) GroupExternalId(groupExternalId string) *InstanceSearchBuilder {
	builder.groupExternalId = groupExternalId
	builder.groupExternalIdFlag = true
	return builder
}

// 审批实例标题（只有第三方审批有）
//
// 示例值：test
func (builder *InstanceSearchBuilder) InstanceTitle(instanceTitle string) *InstanceSearchBuilder {
	builder.instanceTitle = instanceTitle
	builder.instanceTitleFlag = true
	return builder
}

// 审批实例状态，注：若不设置，查询全部状态 若不在集合中，报错
//
// 示例值：PENDING
func (builder *InstanceSearchBuilder) InstanceStatus(instanceStatus string) *InstanceSearchBuilder {
	builder.instanceStatus = instanceStatus
	builder.instanceStatusFlag = true
	return builder
}

// 实例查询开始时间（unix毫秒时间戳）
//
// 示例值：1547654251506
func (builder *InstanceSearchBuilder) InstanceStartTimeFrom(instanceStartTimeFrom string) *InstanceSearchBuilder {
	builder.instanceStartTimeFrom = instanceStartTimeFrom
	builder.instanceStartTimeFromFlag = true
	return builder
}

// 实例查询结束时间 (unix毫秒时间戳)
//
// 示例值：1547654251506
func (builder *InstanceSearchBuilder) InstanceStartTimeTo(instanceStartTimeTo string) *InstanceSearchBuilder {
	builder.instanceStartTimeTo = instanceStartTimeTo
	builder.instanceStartTimeToFlag = true
	return builder
}

// 地区
//
// 示例值：zh-CN
func (builder *InstanceSearchBuilder) Locale(locale string) *InstanceSearchBuilder {
	builder.locale = locale
	builder.localeFlag = true
	return builder
}

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

	}
	if builder.approvalCodeFlag {
		req.ApprovalCode = &builder.approvalCode

	}
	if builder.instanceCodeFlag {
		req.InstanceCode = &builder.instanceCode

	}
	if builder.instanceExternalIdFlag {
		req.InstanceExternalId = &builder.instanceExternalId

	}
	if builder.groupExternalIdFlag {
		req.GroupExternalId = &builder.groupExternalId

	}
	if builder.instanceTitleFlag {
		req.InstanceTitle = &builder.instanceTitle

	}
	if builder.instanceStatusFlag {
		req.InstanceStatus = &builder.instanceStatus

	}
	if builder.instanceStartTimeFromFlag {
		req.InstanceStartTimeFrom = &builder.instanceStartTimeFrom

	}
	if builder.instanceStartTimeToFlag {
		req.InstanceStartTimeTo = &builder.instanceStartTimeTo

	}
	if builder.localeFlag {
		req.Locale = &builder.locale

	}
	return req
}

type InstanceSearchApproval struct {
	Code       *string                         `json:"code,omitempty"`        // 审批定义 code
	Name       *string                         `json:"name,omitempty"`        // 审批定义名称
	IsExternal *bool                           `json:"is_external,omitempty"` // 是否为第三方审批
	External   *InstanceSearchApprovalExternal `json:"external,omitempty"`    // 第三方审批信息
}

type InstanceSearchApprovalBuilder struct {
	code           string // 审批定义 code
	codeFlag       bool
	name           string // 审批定义名称
	nameFlag       bool
	isExternal     bool // 是否为第三方审批
	isExternalFlag bool
	external       *InstanceSearchApprovalExternal // 第三方审批信息
	externalFlag   bool
}

func NewInstanceSearchApprovalBuilder() *InstanceSearchApprovalBuilder {
	builder := &InstanceSearchApprovalBuilder{}
	return builder
}

// 审批定义 code
//
// 示例值：EB828003-9FFE-4B3F-AA50-2E199E2ED943
func (builder *InstanceSearchApprovalBuilder) Code(code string) *InstanceSearchApprovalBuilder {
	builder.code = code
	builder.codeFlag = true
	return builder
}

// 审批定义名称
//
// 示例值：approval
func (builder *InstanceSearchApprovalBuilder) Name(name string) *InstanceSearchApprovalBuilder {
	builder.name = name
	builder.nameFlag = true
	return builder
}

// 是否为第三方审批
//
// 示例值：true
func (builder *InstanceSearchApprovalBuilder) IsExternal(isExternal bool) *InstanceSearchApprovalBuilder {
	builder.isExternal = isExternal
	builder.isExternalFlag = true
	return builder
}

// 第三方审批信息
//
// 示例值：
func (builder *InstanceSearchApprovalBuilder) External(external *InstanceSearchApprovalExternal) *InstanceSearchApprovalBuilder {
	builder.external = external
	builder.externalFlag = true
	return builder
}

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

	}
	if builder.nameFlag {
		req.Name = &builder.name

	}
	if builder.isExternalFlag {
		req.IsExternal = &builder.isExternal

	}
	if builder.externalFlag {
		req.External = builder.external
	}
	return req
}

type InstanceSearchApprovalExternal struct {
	BatchCcRead *bool `json:"batch_cc_read,omitempty"` // 是否支持批量读
}

type InstanceSearchApprovalExternalBuilder struct {
	batchCcRead     bool // 是否支持批量读
	batchCcReadFlag bool
}

func NewInstanceSearchApprovalExternalBuilder() *InstanceSearchApprovalExternalBuilder {
	builder := &InstanceSearchApprovalExternalBuilder{}
	return builder
}

// 是否支持批量读
//
// 示例值：false
func (builder *InstanceSearchApprovalExternalBuilder) BatchCcRead(batchCcRead bool) *InstanceSearchApprovalExternalBuilder {
	builder.batchCcRead = batchCcRead
	builder.batchCcReadFlag = true
	return builder
}

func (builder *InstanceSearchApprovalExternalBuilder) Build() *InstanceSearchApprovalExternal {
	req := &InstanceSearchApprovalExternal{}
	if builder.batchCcReadFlag {
		req.BatchCcRead = &builder.batchCcRead

	}
	return req
}

type InstanceSearchGroup struct {
	ExternalId *string `json:"external_id,omitempty"` // 审批定义分组外部 id
	Name       *string `json:"name,omitempty"`        // 审批定义分组名称
}

type InstanceSearchGroupBuilder struct {
	externalId     string // 审批定义分组外部 id
	externalIdFlag bool
	name           string // 审批定义分组名称
	nameFlag       bool
}

func NewInstanceSearchGroupBuilder() *InstanceSearchGroupBuilder {
	builder := &InstanceSearchGroupBuilder{}
	return builder
}

// 审批定义分组外部 id
//
// 示例值：0004
func (builder *InstanceSearchGroupBuilder) ExternalId(externalId string) *InstanceSearchGroupBuilder {
	builder.externalId = externalId
	builder.externalIdFlag = true
	return builder
}

// 审批定义分组名称
//
// 示例值：groupA
func (builder *InstanceSearchGroupBuilder) Name(name string) *InstanceSearchGroupBuilder {
	builder.name = name
	builder.nameFlag = true
	return builder
}

func (builder *InstanceSearchGroupBuilder) Build() *InstanceSearchGroup {
	req := &InstanceSearchGroup{}
	if builder.externalIdFlag {
		req.ExternalId = &builder.externalId

	}
	if builder.nameFlag {
		req.Name = &builder.name

	}
	return req
}

type InstanceSearchItem struct {
	Approval *InstanceSearchApproval `json:"approval,omitempty"` // 审批定义
	Group    *InstanceSearchGroup    `json:"group,omitempty"`    // 审批定义分组
	Instance *InstanceSearchNode     `json:"instance,omitempty"` // 审批实例信息
}

type InstanceSearchItemBuilder struct {
	approval     *InstanceSearchApproval // 审批定义
	approvalFlag bool
	group        *InstanceSearchGroup // 审批定义分组
	groupFlag    bool
	instance     *InstanceSearchNode // 审批实例信息
	instanceFlag bool
}

func NewInstanceSearchItemBuilder() *InstanceSearchItemBuilder {
	builder := &InstanceSearchItemBuilder{}
	return builder
}

// 审批定义
//
// 示例值：
func (builder *InstanceSearchItemBuilder) Approval(approval *InstanceSearchApproval) *InstanceSearchItemBuilder {
	builder.approval = approval
	builder.approvalFlag = true
	return builder
}

// 审批定义分组
//
// 示例值：
func (builder *InstanceSearchItemBuilder) Group(group *InstanceSearchGroup) *InstanceSearchItemBuilder {
	builder.group = group
	builder.groupFlag = true
	return builder
}

// 审批实例信息
//
// 示例值：
func (builder *InstanceSearchItemBuilder) Instance(instance *InstanceSearchNode) *InstanceSearchItemBuilder {
	builder.instance = instance
	builder.instanceFlag = true
	return builder
}

func (builder *InstanceSearchItemBuilder) Build() *InstanceSearchItem {
	req := &InstanceSearchItem{}
	if builder.approvalFlag {
		req.Approval = builder.approval
	}
	if builder.groupFlag {
		req.Group = builder.group
	}
	if builder.instanceFlag {
		req.Instance = builder.instance
	}
	return req
}

type InstanceSearchLink struct {
	PcLink     *string `json:"pc_link,omitempty"`     // 审批实例 pc 端链接
	MobileLink *string `json:"mobile_link,omitempty"` // 审批实例移动端链接
}

type InstanceSearchLinkBuilder struct {
	pcLink         string // 审批实例 pc 端链接
	pcLinkFlag     bool
	mobileLink     string // 审批实例移动端链接
	mobileLinkFlag bool
}

func NewInstanceSearchLinkBuilder() *InstanceSearchLinkBuilder {
	builder := &InstanceSearchLinkBuilder{}
	return builder
}

// 审批实例 pc 端链接
//
// 示例值：https://www.baidu.com/
func (builder *InstanceSearchLinkBuilder) PcLink(pcLink string) *InstanceSearchLinkBuilder {
	builder.pcLink = pcLink
	builder.pcLinkFlag = true
	return builder
}

// 审批实例移动端链接
//
// 示例值：https://www.baidu.com/
func (builder *InstanceSearchLinkBuilder) MobileLink(mobileLink string) *InstanceSearchLinkBuilder {
	builder.mobileLink = mobileLink
	builder.mobileLinkFlag = true
	return builder
}

func (builder *InstanceSearchLinkBuilder) Build() *InstanceSearchLink {
	req := &InstanceSearchLink{}
	if builder.pcLinkFlag {
		req.PcLink = &builder.pcLink

	}
	if builder.mobileLinkFlag {
		req.MobileLink = &builder.mobileLink

	}
	return req
}

type InstanceSearchNode struct {
	Code       *string             `json:"code,omitempty"`        // 审批实例 code
	ExternalId *string             `json:"external_id,omitempty"` // 审批实例外部 id
	UserId     *string             `json:"user_id,omitempty"`     // 审批实例发起人 id
	StartTime  *string             `json:"start_time,omitempty"`  // 审批实例开始时间
	EndTime    *string             `json:"end_time,omitempty"`    // 审批实例结束时间
	Status     *string             `json:"status,omitempty"`      // 审批实例状态
	Title      *string             `json:"title,omitempty"`       // 审批实例名称（只有第三方审批有）
	Extra      *string             `json:"extra,omitempty"`       // 审批实例扩展字段，string型json
	SerialId   *string             `json:"serial_id,omitempty"`   // 审批流水号
	Link       *InstanceSearchLink `json:"link,omitempty"`        // 审批实例链接（只有第三方审批有）
}

type InstanceSearchNodeBuilder struct {
	code           string // 审批实例 code
	codeFlag       bool
	externalId     string // 审批实例外部 id
	externalIdFlag bool
	userId         string // 审批实例发起人 id
	userIdFlag     bool
	startTime      string // 审批实例开始时间
	startTimeFlag  bool
	endTime        string // 审批实例结束时间
	endTimeFlag    bool
	status         string // 审批实例状态
	statusFlag     bool
	title          string // 审批实例名称（只有第三方审批有）
	titleFlag      bool
	extra          string // 审批实例扩展字段，string型json
	extraFlag      bool
	serialId       string // 审批流水号
	serialIdFlag   bool
	link           *InstanceSearchLink // 审批实例链接（只有第三方审批有）
	linkFlag       bool
}

func NewInstanceSearchNodeBuilder() *InstanceSearchNodeBuilder {
	builder := &InstanceSearchNodeBuilder{}
	return builder
}

// 审批实例 code
//
// 示例值：EB828003-9FFE-4B3F-AA50-2E199E2ED943
func (builder *InstanceSearchNodeBuilder) Code(code string) *InstanceSearchNodeBuilder {
	builder.code = code
	builder.codeFlag = true
	return builder
}

// 审批实例外部 id
//
// 示例值：0004_3ED52DC1-AA6C
func (builder *InstanceSearchNodeBuilder) ExternalId(externalId string) *InstanceSearchNodeBuilder {
	builder.externalId = externalId
	builder.externalIdFlag = true
	return builder
}

// 审批实例发起人 id
//
// 示例值：lwiu098wj
func (builder *InstanceSearchNodeBuilder) UserId(userId string) *InstanceSearchNodeBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 审批实例开始时间
//
// 示例值：1547654251506
func (builder *InstanceSearchNodeBuilder) StartTime(startTime string) *InstanceSearchNodeBuilder {
	builder.startTime = startTime
	builder.startTimeFlag = true
	return builder
}

// 审批实例结束时间
//
// 示例值：1547654251506
func (builder *InstanceSearchNodeBuilder) EndTime(endTime string) *InstanceSearchNodeBuilder {
	builder.endTime = endTime
	builder.endTimeFlag = true
	return builder
}

// 审批实例状态
//
// 示例值：pending
func (builder *InstanceSearchNodeBuilder) Status(status string) *InstanceSearchNodeBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

// 审批实例名称（只有第三方审批有）
//
// 示例值：test
func (builder *InstanceSearchNodeBuilder) Title(title string) *InstanceSearchNodeBuilder {
	builder.title = title
	builder.titleFlag = true
	return builder
}

// 审批实例扩展字段，string型json
//
// 示例值：{}
func (builder *InstanceSearchNodeBuilder) Extra(extra string) *InstanceSearchNodeBuilder {
	builder.extra = extra
	builder.extraFlag = true
	return builder
}

// 审批流水号
//
// 示例值：201902020001
func (builder *InstanceSearchNodeBuilder) SerialId(serialId string) *InstanceSearchNodeBuilder {
	builder.serialId = serialId
	builder.serialIdFlag = true
	return builder
}

// 审批实例链接（只有第三方审批有）
//
// 示例值：
func (builder *InstanceSearchNodeBuilder) Link(link *InstanceSearchLink) *InstanceSearchNodeBuilder {
	builder.link = link
	builder.linkFlag = true
	return builder
}

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

	}
	if builder.externalIdFlag {
		req.ExternalId = &builder.externalId

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

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

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

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

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

	}
	if builder.extraFlag {
		req.Extra = &builder.extra

	}
	if builder.serialIdFlag {
		req.SerialId = &builder.serialId

	}
	if builder.linkFlag {
		req.Link = builder.link
	}
	return req
}

type InstanceTask struct {
	Id           *string `json:"id,omitempty"`             // task id
	UserId       *string `json:"user_id,omitempty"`        // 审批人的用户id，自动通过、自动拒绝 时为空
	OpenId       *string `json:"open_id,omitempty"`        // 审批人 open id
	Status       *string `json:"status,omitempty"`         // 任务状态
	NodeId       *string `json:"node_id,omitempty"`        // task 所属节点 id
	NodeName     *string `json:"node_name,omitempty"`      // task 所属节点名称
	CustomNodeId *string `json:"custom_node_id,omitempty"` // task 所属节点自定义 id, 如果没设置自定义 id, 则不返回该字段
	Type         *string `json:"type,omitempty"`           // 审批方式
	StartTime    *string `json:"start_time,omitempty"`     // task 开始时间
	EndTime      *string `json:"end_time,omitempty"`       // task 完成时间, 未完成为 0
}

type InstanceTaskBuilder struct {
	id               string // task id
	idFlag           bool
	userId           string // 审批人的用户id，自动通过、自动拒绝 时为空
	userIdFlag       bool
	openId           string // 审批人 open id
	openIdFlag       bool
	status           string // 任务状态
	statusFlag       bool
	nodeId           string // task 所属节点 id
	nodeIdFlag       bool
	nodeName         string // task 所属节点名称
	nodeNameFlag     bool
	customNodeId     string // task 所属节点自定义 id, 如果没设置自定义 id, 则不返回该字段
	customNodeIdFlag bool
	type_            string // 审批方式
	typeFlag         bool
	startTime        string // task 开始时间
	startTimeFlag    bool
	endTime          string // task 完成时间, 未完成为 0
	endTimeFlag      bool
}

func NewInstanceTaskBuilder() *InstanceTaskBuilder {
	builder := &InstanceTaskBuilder{}
	return builder
}

// task id
//
// 示例值：1234
func (builder *InstanceTaskBuilder) Id(id string) *InstanceTaskBuilder {
	builder.id = id
	builder.idFlag = true
	return builder
}

// 审批人的用户id，自动通过、自动拒绝 时为空
//
// 示例值：f7cb567e
func (builder *InstanceTaskBuilder) UserId(userId string) *InstanceTaskBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 审批人 open id
//
// 示例值：ou_123457
func (builder *InstanceTaskBuilder) OpenId(openId string) *InstanceTaskBuilder {
	builder.openId = openId
	builder.openIdFlag = true
	return builder
}

// 任务状态
//
// 示例值：PENDING
func (builder *InstanceTaskBuilder) Status(status string) *InstanceTaskBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

// task 所属节点 id
//
// 示例值：46e6d96cfa756980907209209ec03b64
func (builder *InstanceTaskBuilder) NodeId(nodeId string) *InstanceTaskBuilder {
	builder.nodeId = nodeId
	builder.nodeIdFlag = true
	return builder
}

// task 所属节点名称
//
// 示例值：开始
func (builder *InstanceTaskBuilder) NodeName(nodeName string) *InstanceTaskBuilder {
	builder.nodeName = nodeName
	builder.nodeNameFlag = true
	return builder
}

// task 所属节点自定义 id, 如果没设置自定义 id, 则不返回该字段
//
// 示例值：manager
func (builder *InstanceTaskBuilder) CustomNodeId(customNodeId string) *InstanceTaskBuilder {
	builder.customNodeId = customNodeId
	builder.customNodeIdFlag = true
	return builder
}

// 审批方式
//
// 示例值：AND
func (builder *InstanceTaskBuilder) Type(type_ string) *InstanceTaskBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

// task 开始时间
//
// 示例值：1564590532967
func (builder *InstanceTaskBuilder) StartTime(startTime string) *InstanceTaskBuilder {
	builder.startTime = startTime
	builder.startTimeFlag = true
	return builder
}

// task 完成时间, 未完成为 0
//
// 示例值：0
func (builder *InstanceTaskBuilder) EndTime(endTime string) *InstanceTaskBuilder {
	builder.endTime = endTime
	builder.endTimeFlag = true
	return builder
}

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

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.openIdFlag {
		req.OpenId = &builder.openId

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

	}
	if builder.nodeIdFlag {
		req.NodeId = &builder.nodeId

	}
	if builder.nodeNameFlag {
		req.NodeName = &builder.nodeName

	}
	if builder.customNodeIdFlag {
		req.CustomNodeId = &builder.customNodeId

	}
	if builder.typeFlag {
		req.Type = &builder.type_

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

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

	}
	return req
}

type InstanceTimeline struct {
	Type       *string           `json:"type,omitempty"`         // 动态类型，不同类型 ext 内的 user_id_list 含义不一样
	CreateTime *string           `json:"create_time,omitempty"`  // 发生时间
	UserId     *string           `json:"user_id,omitempty"`      // 动态产生用户
	OpenId     *string           `json:"open_id,omitempty"`      // 动态产生用户 open id
	UserIdList []string          `json:"user_id_list,omitempty"` // 被抄送人列表
	OpenIdList []string          `json:"open_id_list,omitempty"` // 被抄送人列表
	TaskId     *string           `json:"task_id,omitempty"`      // 产生动态关联的task_id
	Comment    *string           `json:"comment,omitempty"`      // 理由
	CcUserList []*InstanceCcUser `json:"cc_user_list,omitempty"` // 抄送人列表
	Ext        *string           `json:"ext,omitempty"`          // 动态其他信息，json格式，目前包括 user_id_list, user_id，open_id_list，open_id
	NodeKey    *string           `json:"node_key,omitempty"`     // 产生task的节点key
	Files      []*File           `json:"files,omitempty"`        // 审批附件
}

type InstanceTimelineBuilder struct {
	type_          string // 动态类型，不同类型 ext 内的 user_id_list 含义不一样
	typeFlag       bool
	createTime     string // 发生时间
	createTimeFlag bool
	userId         string // 动态产生用户
	userIdFlag     bool
	openId         string // 动态产生用户 open id
	openIdFlag     bool
	userIdList     []string // 被抄送人列表
	userIdListFlag bool
	openIdList     []string // 被抄送人列表
	openIdListFlag bool
	taskId         string // 产生动态关联的task_id
	taskIdFlag     bool
	comment        string // 理由
	commentFlag    bool
	ccUserList     []*InstanceCcUser // 抄送人列表
	ccUserListFlag bool
	ext            string // 动态其他信息，json格式，目前包括 user_id_list, user_id，open_id_list，open_id
	extFlag        bool
	nodeKey        string // 产生task的节点key
	nodeKeyFlag    bool
	files          []*File // 审批附件
	filesFlag      bool
}

func NewInstanceTimelineBuilder() *InstanceTimelineBuilder {
	builder := &InstanceTimelineBuilder{}
	return builder
}

// 动态类型，不同类型 ext 内的 user_id_list 含义不一样
//
// 示例值：PASS
func (builder *InstanceTimelineBuilder) Type(type_ string) *InstanceTimelineBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

// 发生时间
//
// 示例值：1564590532967
func (builder *InstanceTimelineBuilder) CreateTime(createTime string) *InstanceTimelineBuilder {
	builder.createTime = createTime
	builder.createTimeFlag = true
	return builder
}

// 动态产生用户
//
// 示例值：f7cb567e
func (builder *InstanceTimelineBuilder) UserId(userId string) *InstanceTimelineBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 动态产生用户 open id
//
// 示例值：ou_123456
func (builder *InstanceTimelineBuilder) OpenId(openId string) *InstanceTimelineBuilder {
	builder.openId = openId
	builder.openIdFlag = true
	return builder
}

// 被抄送人列表
//
// 示例值：f7cb567e
func (builder *InstanceTimelineBuilder) UserIdList(userIdList []string) *InstanceTimelineBuilder {
	builder.userIdList = userIdList
	builder.userIdListFlag = true
	return builder
}

// 被抄送人列表
//
// 示例值：ou_123456
func (builder *InstanceTimelineBuilder) OpenIdList(openIdList []string) *InstanceTimelineBuilder {
	builder.openIdList = openIdList
	builder.openIdListFlag = true
	return builder
}

// 产生动态关联的task_id
//
// 示例值：1234
func (builder *InstanceTimelineBuilder) TaskId(taskId string) *InstanceTimelineBuilder {
	builder.taskId = taskId
	builder.taskIdFlag = true
	return builder
}

// 理由
//
// 示例值：ok
func (builder *InstanceTimelineBuilder) Comment(comment string) *InstanceTimelineBuilder {
	builder.comment = comment
	builder.commentFlag = true
	return builder
}

// 抄送人列表
//
// 示例值：
func (builder *InstanceTimelineBuilder) CcUserList(ccUserList []*InstanceCcUser) *InstanceTimelineBuilder {
	builder.ccUserList = ccUserList
	builder.ccUserListFlag = true
	return builder
}

// 动态其他信息，json格式，目前包括 user_id_list, user_id，open_id_list，open_id
//
// 示例值：{\"user_id\":\"62d4a44c\",\"open_id\":\"ou_123456\"}
func (builder *InstanceTimelineBuilder) Ext(ext string) *InstanceTimelineBuilder {
	builder.ext = ext
	builder.extFlag = true
	return builder
}

// 产生task的节点key
//
// 示例值：APPROVAL_240330_4058663
func (builder *InstanceTimelineBuilder) NodeKey(nodeKey string) *InstanceTimelineBuilder {
	builder.nodeKey = nodeKey
	builder.nodeKeyFlag = true
	return builder
}

// 审批附件
//
// 示例值：
func (builder *InstanceTimelineBuilder) Files(files []*File) *InstanceTimelineBuilder {
	builder.files = files
	builder.filesFlag = true
	return builder
}

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

	}
	if builder.createTimeFlag {
		req.CreateTime = &builder.createTime

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.openIdFlag {
		req.OpenId = &builder.openId

	}
	if builder.userIdListFlag {
		req.UserIdList = builder.userIdList
	}
	if builder.openIdListFlag {
		req.OpenIdList = builder.openIdList
	}
	if builder.taskIdFlag {
		req.TaskId = &builder.taskId

	}
	if builder.commentFlag {
		req.Comment = &builder.comment

	}
	if builder.ccUserListFlag {
		req.CcUserList = builder.ccUserList
	}
	if builder.extFlag {
		req.Ext = &builder.ext

	}
	if builder.nodeKeyFlag {
		req.NodeKey = &builder.nodeKey

	}
	if builder.filesFlag {
		req.Files = builder.files
	}
	return req
}

type Message struct {
	Id        *string `json:"id,omitempty"`         // 消息id标识
	ReceiveId *string `json:"receive_id,omitempty"` // 接受消息的各类id
	Content   *string `json:"content,omitempty"`    // 消息体, json格式
	MsgType   *string `json:"msg_type,omitempty"`   // 消息类型
	Config    *string `json:"config,omitempty"`     // 发送配置
	Extra     *string `json:"extra,omitempty"`      // 特殊配制
	Uuid      *string `json:"uuid,omitempty"`       // 幂等key
}

type MessageBuilder struct {
	id            string // 消息id标识
	idFlag        bool
	receiveId     string // 接受消息的各类id
	receiveIdFlag bool
	content       string // 消息体, json格式
	contentFlag   bool
	msgType       string // 消息类型
	msgTypeFlag   bool
	config        string // 发送配置
	configFlag    bool
	extra         string // 特殊配制
	extraFlag     bool
	uuid          string // 幂等key
	uuidFlag      bool
}

func NewMessageBuilder() *MessageBuilder {
	builder := &MessageBuilder{}
	return builder
}

// 消息id标识
//
// 示例值：1705036822442409986
func (builder *MessageBuilder) Id(id string) *MessageBuilder {
	builder.id = id
	builder.idFlag = true
	return builder
}

// 接受消息的各类id
//
// 示例值：ou_xxx
func (builder *MessageBuilder) ReceiveId(receiveId string) *MessageBuilder {
	builder.receiveId = receiveId
	builder.receiveIdFlag = true
	return builder
}

// 消息体, json格式
//
// 示例值：{}
func (builder *MessageBuilder) Content(content string) *MessageBuilder {
	builder.content = content
	builder.contentFlag = true
	return builder
}

// 消息类型
//
// 示例值：interactive
func (builder *MessageBuilder) MsgType(msgType string) *MessageBuilder {
	builder.msgType = msgType
	builder.msgTypeFlag = true
	return builder
}

// 发送配置
//
// 示例值：{}
func (builder *MessageBuilder) Config(config string) *MessageBuilder {
	builder.config = config
	builder.configFlag = true
	return builder
}

// 特殊配制
//
// 示例值：v2
func (builder *MessageBuilder) Extra(extra string) *MessageBuilder {
	builder.extra = extra
	builder.extraFlag = true
	return builder
}

// 幂等key
//
// 示例值：a60cfe61268e10f054a3211ab72185c
func (builder *MessageBuilder) Uuid(uuid string) *MessageBuilder {
	builder.uuid = uuid
	builder.uuidFlag = true
	return builder
}

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

	}
	if builder.receiveIdFlag {
		req.ReceiveId = &builder.receiveId

	}
	if builder.contentFlag {
		req.Content = &builder.content

	}
	if builder.msgTypeFlag {
		req.MsgType = &builder.msgType

	}
	if builder.configFlag {
		req.Config = &builder.config

	}
	if builder.extraFlag {
		req.Extra = &builder.extra

	}
	if builder.uuidFlag {
		req.Uuid = &builder.uuid

	}
	return req
}

type NodeApprover struct {
	Key   *string  `json:"key,omitempty"`   // node id 或 custom node id，通过 [查看审批定义](/ssl:ttdoc/uAjLw4CM/ukTMukTMukTM/reference/approval-v4/approval/get) 获取
	Value []string `json:"value,omitempty"` // value: 审批人列表
}

type NodeApproverBuilder struct {
	key       string // node id 或 custom node id，通过 [查看审批定义](/ssl:ttdoc/uAjLw4CM/ukTMukTMukTM/reference/approval-v4/approval/get) 获取
	keyFlag   bool
	value     []string // value: 审批人列表
	valueFlag bool
}

func NewNodeApproverBuilder() *NodeApproverBuilder {
	builder := &NodeApproverBuilder{}
	return builder
}

// node id 或 custom node id，通过 [查看审批定义](/ssl:ttdoc/uAjLw4CM/ukTMukTMukTM/reference/approval-v4/approval/get) 获取
//
// 示例值：46e6d96cfa756980907209209ec03b64
func (builder *NodeApproverBuilder) Key(key string) *NodeApproverBuilder {
	builder.key = key
	builder.keyFlag = true
	return builder
}

// value: 审批人列表
//
// 示例值：["f7cb567e"]
func (builder *NodeApproverBuilder) Value(value []string) *NodeApproverBuilder {
	builder.value = value
	builder.valueFlag = true
	return builder
}

func (builder *NodeApproverBuilder) Build() *NodeApprover {
	req := &NodeApprover{}
	if builder.keyFlag {
		req.Key = &builder.key

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

type NodeCc struct {
	Key   *string  `json:"key,omitempty"`   // node id ，通过 [查看审批定义](/ssl:ttdoc/uAjLw4CM/ukTMukTMukTM/reference/approval-v4/approval/get) 获取
	Value []string `json:"value,omitempty"` // value: 审批人列表
}

type NodeCcBuilder struct {
	key       string // node id ，通过 [查看审批定义](/ssl:ttdoc/uAjLw4CM/ukTMukTMukTM/reference/approval-v4/approval/get) 获取
	keyFlag   bool
	value     []string // value: 审批人列表
	valueFlag bool
}

func NewNodeCcBuilder() *NodeCcBuilder {
	builder := &NodeCcBuilder{}
	return builder
}

// node id ，通过 [查看审批定义](/ssl:ttdoc/uAjLw4CM/ukTMukTMukTM/reference/approval-v4/approval/get) 获取
//
// 示例值：46e6d96cfa756980907209209ec03b75
func (builder *NodeCcBuilder) Key(key string) *NodeCcBuilder {
	builder.key = key
	builder.keyFlag = true
	return builder
}

// value: 审批人列表
//
// 示例值：["f7cb567e"]
func (builder *NodeCcBuilder) Value(value []string) *NodeCcBuilder {
	builder.value = value
	builder.valueFlag = true
	return builder
}

func (builder *NodeCcBuilder) Build() *NodeCc {
	req := &NodeCc{}
	if builder.keyFlag {
		req.Key = &builder.key

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

type PreviewNode struct {
	NodeId             *string  `json:"node_id,omitempty"`               // 节点id
	NodeName           *string  `json:"node_name,omitempty"`             // 节点名称
	NodeType           *string  `json:"node_type,omitempty"`             // 节点类型 “AND":会签  “OR”:或签
	Comments           []string `json:"comments,omitempty"`              // 节点描述
	CustomNodeId       *string  `json:"custom_node_id,omitempty"`        // 租户节点id
	UserIdList         []string `json:"user_id_list,omitempty"`          // 审批人id列表
	EndCcIdList        []string `json:"end_cc_id_list,omitempty"`        // 节点结束抄送人id列表
	IsEmptyLogic       *bool    `json:"is_empty_logic,omitempty"`        // 审批人是否为空
	IsApproverTypeFree *bool    `json:"is_approver_type_free,omitempty"` // 是否是发起人自选类型
	HasCcTypeFree      *bool    `json:"has_cc_type_free,omitempty"`      // 是否包含抄送人自选类型
}

type PreviewNodeBuilder struct {
	nodeId                 string // 节点id
	nodeIdFlag             bool
	nodeName               string // 节点名称
	nodeNameFlag           bool
	nodeType               string // 节点类型 “AND":会签  “OR”:或签
	nodeTypeFlag           bool
	comments               []string // 节点描述
	commentsFlag           bool
	customNodeId           string // 租户节点id
	customNodeIdFlag       bool
	userIdList             []string // 审批人id列表
	userIdListFlag         bool
	endCcIdList            []string // 节点结束抄送人id列表
	endCcIdListFlag        bool
	isEmptyLogic           bool // 审批人是否为空
	isEmptyLogicFlag       bool
	isApproverTypeFree     bool // 是否是发起人自选类型
	isApproverTypeFreeFlag bool
	hasCcTypeFree          bool // 是否包含抄送人自选类型
	hasCcTypeFreeFlag      bool
}

func NewPreviewNodeBuilder() *PreviewNodeBuilder {
	builder := &PreviewNodeBuilder{}
	return builder
}

// 节点id
//
// 示例值：
func (builder *PreviewNodeBuilder) NodeId(nodeId string) *PreviewNodeBuilder {
	builder.nodeId = nodeId
	builder.nodeIdFlag = true
	return builder
}

// 节点名称
//
// 示例值：
func (builder *PreviewNodeBuilder) NodeName(nodeName string) *PreviewNodeBuilder {
	builder.nodeName = nodeName
	builder.nodeNameFlag = true
	return builder
}

// 节点类型 “AND":会签  “OR”:或签
//
// 示例值：
func (builder *PreviewNodeBuilder) NodeType(nodeType string) *PreviewNodeBuilder {
	builder.nodeType = nodeType
	builder.nodeTypeFlag = true
	return builder
}

// 节点描述
//
// 示例值：
func (builder *PreviewNodeBuilder) Comments(comments []string) *PreviewNodeBuilder {
	builder.comments = comments
	builder.commentsFlag = true
	return builder
}

// 租户节点id
//
// 示例值：
func (builder *PreviewNodeBuilder) CustomNodeId(customNodeId string) *PreviewNodeBuilder {
	builder.customNodeId = customNodeId
	builder.customNodeIdFlag = true
	return builder
}

// 审批人id列表
//
// 示例值：
func (builder *PreviewNodeBuilder) UserIdList(userIdList []string) *PreviewNodeBuilder {
	builder.userIdList = userIdList
	builder.userIdListFlag = true
	return builder
}

// 节点结束抄送人id列表
//
// 示例值：
func (builder *PreviewNodeBuilder) EndCcIdList(endCcIdList []string) *PreviewNodeBuilder {
	builder.endCcIdList = endCcIdList
	builder.endCcIdListFlag = true
	return builder
}

// 审批人是否为空
//
// 示例值：
func (builder *PreviewNodeBuilder) IsEmptyLogic(isEmptyLogic bool) *PreviewNodeBuilder {
	builder.isEmptyLogic = isEmptyLogic
	builder.isEmptyLogicFlag = true
	return builder
}

// 是否是发起人自选类型
//
// 示例值：
func (builder *PreviewNodeBuilder) IsApproverTypeFree(isApproverTypeFree bool) *PreviewNodeBuilder {
	builder.isApproverTypeFree = isApproverTypeFree
	builder.isApproverTypeFreeFlag = true
	return builder
}

// 是否包含抄送人自选类型
//
// 示例值：
func (builder *PreviewNodeBuilder) HasCcTypeFree(hasCcTypeFree bool) *PreviewNodeBuilder {
	builder.hasCcTypeFree = hasCcTypeFree
	builder.hasCcTypeFreeFlag = true
	return builder
}

func (builder *PreviewNodeBuilder) Build() *PreviewNode {
	req := &PreviewNode{}
	if builder.nodeIdFlag {
		req.NodeId = &builder.nodeId

	}
	if builder.nodeNameFlag {
		req.NodeName = &builder.nodeName

	}
	if builder.nodeTypeFlag {
		req.NodeType = &builder.nodeType

	}
	if builder.commentsFlag {
		req.Comments = builder.comments
	}
	if builder.customNodeIdFlag {
		req.CustomNodeId = &builder.customNodeId

	}
	if builder.userIdListFlag {
		req.UserIdList = builder.userIdList
	}
	if builder.endCcIdListFlag {
		req.EndCcIdList = builder.endCcIdList
	}
	if builder.isEmptyLogicFlag {
		req.IsEmptyLogic = &builder.isEmptyLogic

	}
	if builder.isApproverTypeFreeFlag {
		req.IsApproverTypeFree = &builder.isApproverTypeFree

	}
	if builder.hasCcTypeFreeFlag {
		req.HasCcTypeFree = &builder.hasCcTypeFree

	}
	return req
}

type Reason struct {
	Text  *string `json:"text,omitempty"`  // 原因说明
	Files []*File `json:"files,omitempty"` // 附件集合
}

type ReasonBuilder struct {
	text      string // 原因说明
	textFlag  bool
	files     []*File // 附件集合
	filesFlag bool
}

func NewReasonBuilder() *ReasonBuilder {
	builder := &ReasonBuilder{}
	return builder
}

// 原因说明
//
// 示例值：
func (builder *ReasonBuilder) Text(text string) *ReasonBuilder {
	builder.text = text
	builder.textFlag = true
	return builder
}

// 附件集合
//
// 示例值：
func (builder *ReasonBuilder) Files(files []*File) *ReasonBuilder {
	builder.files = files
	builder.filesFlag = true
	return builder
}

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

	}
	if builder.filesFlag {
		req.Files = builder.files
	}
	return req
}

type RemedyGroup struct {
	Type         *string `json:"type,omitempty"`          //
	InstanceCode *string `json:"instance_code,omitempty"` //
	EmployeeId   *string `json:"employee_id,omitempty"`   //
	StartTime    *int    `json:"start_time,omitempty"`    //
	EndTime      *int    `json:"end_time,omitempty"`      //
	RemedyTime   *int    `json:"remedy_time,omitempty"`   //
	RemedyReason *string `json:"remedy_reason,omitempty"` //
	Status       *string `json:"status,omitempty"`        //
}

type RemedyGroupBuilder struct {
	type_            string //
	typeFlag         bool
	instanceCode     string //
	instanceCodeFlag bool
	employeeId       string //
	employeeIdFlag   bool
	startTime        int //
	startTimeFlag    bool
	endTime          int //
	endTimeFlag      bool
	remedyTime       int //
	remedyTimeFlag   bool
	remedyReason     string //
	remedyReasonFlag bool
	status           string //
	statusFlag       bool
}

func NewRemedyGroupBuilder() *RemedyGroupBuilder {
	builder := &RemedyGroupBuilder{}
	return builder
}

//
//
// 示例值：
func (builder *RemedyGroupBuilder) Type(type_ string) *RemedyGroupBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

//
//
// 示例值：
func (builder *RemedyGroupBuilder) InstanceCode(instanceCode string) *RemedyGroupBuilder {
	builder.instanceCode = instanceCode
	builder.instanceCodeFlag = true
	return builder
}

//
//
// 示例值：
func (builder *RemedyGroupBuilder) EmployeeId(employeeId string) *RemedyGroupBuilder {
	builder.employeeId = employeeId
	builder.employeeIdFlag = true
	return builder
}

//
//
// 示例值：
func (builder *RemedyGroupBuilder) StartTime(startTime int) *RemedyGroupBuilder {
	builder.startTime = startTime
	builder.startTimeFlag = true
	return builder
}

//
//
// 示例值：
func (builder *RemedyGroupBuilder) EndTime(endTime int) *RemedyGroupBuilder {
	builder.endTime = endTime
	builder.endTimeFlag = true
	return builder
}

//
//
// 示例值：
func (builder *RemedyGroupBuilder) RemedyTime(remedyTime int) *RemedyGroupBuilder {
	builder.remedyTime = remedyTime
	builder.remedyTimeFlag = true
	return builder
}

//
//
// 示例值：
func (builder *RemedyGroupBuilder) RemedyReason(remedyReason string) *RemedyGroupBuilder {
	builder.remedyReason = remedyReason
	builder.remedyReasonFlag = true
	return builder
}

//
//
// 示例值：
func (builder *RemedyGroupBuilder) Status(status string) *RemedyGroupBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

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

	}
	if builder.instanceCodeFlag {
		req.InstanceCode = &builder.instanceCode

	}
	if builder.employeeIdFlag {
		req.EmployeeId = &builder.employeeId

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

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

	}
	if builder.remedyTimeFlag {
		req.RemedyTime = &builder.remedyTime

	}
	if builder.remedyReasonFlag {
		req.RemedyReason = &builder.remedyReason

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

	}
	return req
}

type SignGroup struct {
	InstanceCode          *string `json:"instance_code,omitempty"`           //
	UserId                *UserId `json:"user_id,omitempty"`                 //
	AccountCode           *string `json:"account_code,omitempty"`            //
	BoilerplateUniqueCode *string `json:"boilerplate_unique_code,omitempty"` //
	StartTime             *int    `json:"start_time,omitempty"`              //
	EndTime               *int    `json:"end_time,omitempty"`                //
	Type                  *string `json:"type,omitempty"`                    //
}

type SignGroupBuilder struct {
	instanceCode              string //
	instanceCodeFlag          bool
	userId                    *UserId //
	userIdFlag                bool
	accountCode               string //
	accountCodeFlag           bool
	boilerplateUniqueCode     string //
	boilerplateUniqueCodeFlag bool
	startTime                 int //
	startTimeFlag             bool
	endTime                   int //
	endTimeFlag               bool
	type_                     string //
	typeFlag                  bool
}

func NewSignGroupBuilder() *SignGroupBuilder {
	builder := &SignGroupBuilder{}
	return builder
}

//
//
// 示例值：
func (builder *SignGroupBuilder) InstanceCode(instanceCode string) *SignGroupBuilder {
	builder.instanceCode = instanceCode
	builder.instanceCodeFlag = true
	return builder
}

//
//
// 示例值：
func (builder *SignGroupBuilder) UserId(userId *UserId) *SignGroupBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

//
//
// 示例值：
func (builder *SignGroupBuilder) AccountCode(accountCode string) *SignGroupBuilder {
	builder.accountCode = accountCode
	builder.accountCodeFlag = true
	return builder
}

//
//
// 示例值：
func (builder *SignGroupBuilder) BoilerplateUniqueCode(boilerplateUniqueCode string) *SignGroupBuilder {
	builder.boilerplateUniqueCode = boilerplateUniqueCode
	builder.boilerplateUniqueCodeFlag = true
	return builder
}

//
//
// 示例值：
func (builder *SignGroupBuilder) StartTime(startTime int) *SignGroupBuilder {
	builder.startTime = startTime
	builder.startTimeFlag = true
	return builder
}

//
//
// 示例值：
func (builder *SignGroupBuilder) EndTime(endTime int) *SignGroupBuilder {
	builder.endTime = endTime
	builder.endTimeFlag = true
	return builder
}

//
//
// 示例值：
func (builder *SignGroupBuilder) Type(type_ string) *SignGroupBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

func (builder *SignGroupBuilder) Build() *SignGroup {
	req := &SignGroup{}
	if builder.instanceCodeFlag {
		req.InstanceCode = &builder.instanceCode

	}
	if builder.userIdFlag {
		req.UserId = builder.userId
	}
	if builder.accountCodeFlag {
		req.AccountCode = &builder.accountCode

	}
	if builder.boilerplateUniqueCodeFlag {
		req.BoilerplateUniqueCode = &builder.boilerplateUniqueCode

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

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

	}
	if builder.typeFlag {
		req.Type = &builder.type_

	}
	return req
}

type SpecifiedRollback struct {
	UserId         *string  `json:"user_id,omitempty"`           // 用户ID
	TaskId         *string  `json:"task_id,omitempty"`           // 回退的任务ID
	Reason         *string  `json:"reason,omitempty"`            // 退回原因
	Extra          *string  `json:"extra,omitempty"`             // 扩展字段
	TaskDefKeyList []string `json:"task_def_key_list,omitempty"` // 退回到节点列表
}

type SpecifiedRollbackBuilder struct {
	userId             string // 用户ID
	userIdFlag         bool
	taskId             string // 回退的任务ID
	taskIdFlag         bool
	reason             string // 退回原因
	reasonFlag         bool
	extra              string // 扩展字段
	extraFlag          bool
	taskDefKeyList     []string // 退回到节点列表
	taskDefKeyListFlag bool
}

func NewSpecifiedRollbackBuilder() *SpecifiedRollbackBuilder {
	builder := &SpecifiedRollbackBuilder{}
	return builder
}

// 用户ID
//
// 示例值：893g4c45
func (builder *SpecifiedRollbackBuilder) UserId(userId string) *SpecifiedRollbackBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 回退的任务ID
//
// 示例值：7026591166355210260
func (builder *SpecifiedRollbackBuilder) TaskId(taskId string) *SpecifiedRollbackBuilder {
	builder.taskId = taskId
	builder.taskIdFlag = true
	return builder
}

// 退回原因
//
// 示例值：申请事项填写不具体，请重新填写
func (builder *SpecifiedRollbackBuilder) Reason(reason string) *SpecifiedRollbackBuilder {
	builder.reason = reason
	builder.reasonFlag = true
	return builder
}

// 扩展字段
//
// 示例值：暂不填写
func (builder *SpecifiedRollbackBuilder) Extra(extra string) *SpecifiedRollbackBuilder {
	builder.extra = extra
	builder.extraFlag = true
	return builder
}

// 退回到节点列表
//
// 示例值：["START","APPROVAL_27997_285502","APPROVAL_462205_2734554"]
func (builder *SpecifiedRollbackBuilder) TaskDefKeyList(taskDefKeyList []string) *SpecifiedRollbackBuilder {
	builder.taskDefKeyList = taskDefKeyList
	builder.taskDefKeyListFlag = true
	return builder
}

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

	}
	if builder.taskIdFlag {
		req.TaskId = &builder.taskId

	}
	if builder.reasonFlag {
		req.Reason = &builder.reason

	}
	if builder.extraFlag {
		req.Extra = &builder.extra

	}
	if builder.taskDefKeyListFlag {
		req.TaskDefKeyList = builder.taskDefKeyList
	}
	return req
}

type Task struct {
	Topic               *string   `json:"topic,omitempty"`                 // 任务所属的任务分组，如「待办」、「已办」等
	UserId              *string   `json:"user_id,omitempty"`               // 任务所属的用户 ID
	Title               *string   `json:"title,omitempty"`                 // 任务题目
	Urls                *TaskUrls `json:"urls,omitempty"`                  // 任务相关 URL
	ProcessExternalId   *string   `json:"process_external_id,omitempty"`   // 流程三方 ID，仅第三方流程，需要在当前租户、当前 APP 内唯一
	TaskExternalId      *string   `json:"task_external_id,omitempty"`      // 任务三方 ID，仅第三方流程，需要在当前流程实例内唯一
	Status              *string   `json:"status,omitempty"`                // 任务状态
	ProcessStatus       *string   `json:"process_status,omitempty"`        // 流程实例状态
	DefinitionCode      *string   `json:"definition_code,omitempty"`       // 流程定义 Code
	Initiators          []string  `json:"initiators,omitempty"`            // 发起人 ID 列表
	InitiatorNames      []string  `json:"initiator_names,omitempty"`       // 发起人姓名列表
	TaskId              *string   `json:"task_id,omitempty"`               // 任务 ID，全局唯一
	ProcessId           *string   `json:"process_id,omitempty"`            // 流程 ID，全局唯一
	ProcessCode         *string   `json:"process_code,omitempty"`          // 流程 Code
	DefinitionGroupId   *string   `json:"definition_group_id,omitempty"`   // 流程定义分组 ID
	DefinitionGroupName *string   `json:"definition_group_name,omitempty"` // 流程定义分组名称
	DefinitionId        *string   `json:"definition_id,omitempty"`         // 流程定义 ID
	DefinitionName      *string   `json:"definition_name,omitempty"`       // 流程定义名称
}

type TaskBuilder struct {
	topic                   string // 任务所属的任务分组，如「待办」、「已办」等
	topicFlag               bool
	userId                  string // 任务所属的用户 ID
	userIdFlag              bool
	title                   string // 任务题目
	titleFlag               bool
	urls                    *TaskUrls // 任务相关 URL
	urlsFlag                bool
	processExternalId       string // 流程三方 ID，仅第三方流程，需要在当前租户、当前 APP 内唯一
	processExternalIdFlag   bool
	taskExternalId          string // 任务三方 ID，仅第三方流程，需要在当前流程实例内唯一
	taskExternalIdFlag      bool
	status                  string // 任务状态
	statusFlag              bool
	processStatus           string // 流程实例状态
	processStatusFlag       bool
	definitionCode          string // 流程定义 Code
	definitionCodeFlag      bool
	initiators              []string // 发起人 ID 列表
	initiatorsFlag          bool
	initiatorNames          []string // 发起人姓名列表
	initiatorNamesFlag      bool
	taskId                  string // 任务 ID，全局唯一
	taskIdFlag              bool
	processId               string // 流程 ID，全局唯一
	processIdFlag           bool
	processCode             string // 流程 Code
	processCodeFlag         bool
	definitionGroupId       string // 流程定义分组 ID
	definitionGroupIdFlag   bool
	definitionGroupName     string // 流程定义分组名称
	definitionGroupNameFlag bool
	definitionId            string // 流程定义 ID
	definitionIdFlag        bool
	definitionName          string // 流程定义名称
	definitionNameFlag      bool
}

func NewTaskBuilder() *TaskBuilder {
	builder := &TaskBuilder{}
	return builder
}

// 任务所属的任务分组，如「待办」、「已办」等
//
// 示例值：1
func (builder *TaskBuilder) Topic(topic string) *TaskBuilder {
	builder.topic = topic
	builder.topicFlag = true
	return builder
}

// 任务所属的用户 ID
//
// 示例值：example_user_id
func (builder *TaskBuilder) UserId(userId string) *TaskBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 任务题目
//
// 示例值：任务题目示例
func (builder *TaskBuilder) Title(title string) *TaskBuilder {
	builder.title = title
	builder.titleFlag = true
	return builder
}

// 任务相关 URL
//
// 示例值：
func (builder *TaskBuilder) Urls(urls *TaskUrls) *TaskBuilder {
	builder.urls = urls
	builder.urlsFlag = true
	return builder
}

// 流程三方 ID，仅第三方流程，需要在当前租户、当前 APP 内唯一
//
// 示例值：example_instance_id
func (builder *TaskBuilder) ProcessExternalId(processExternalId string) *TaskBuilder {
	builder.processExternalId = processExternalId
	builder.processExternalIdFlag = true
	return builder
}

// 任务三方 ID，仅第三方流程，需要在当前流程实例内唯一
//
// 示例值：example_task_id
func (builder *TaskBuilder) TaskExternalId(taskExternalId string) *TaskBuilder {
	builder.taskExternalId = taskExternalId
	builder.taskExternalIdFlag = true
	return builder
}

// 任务状态
//
// 示例值：Todo
func (builder *TaskBuilder) Status(status string) *TaskBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

// 流程实例状态
//
// 示例值：Running
func (builder *TaskBuilder) ProcessStatus(processStatus string) *TaskBuilder {
	builder.processStatus = processStatus
	builder.processStatusFlag = true
	return builder
}

// 流程定义 Code
//
// 示例值：000000-00000000000000-0example
func (builder *TaskBuilder) DefinitionCode(definitionCode string) *TaskBuilder {
	builder.definitionCode = definitionCode
	builder.definitionCodeFlag = true
	return builder
}

// 发起人 ID 列表
//
// 示例值：
func (builder *TaskBuilder) Initiators(initiators []string) *TaskBuilder {
	builder.initiators = initiators
	builder.initiatorsFlag = true
	return builder
}

// 发起人姓名列表
//
// 示例值：
func (builder *TaskBuilder) InitiatorNames(initiatorNames []string) *TaskBuilder {
	builder.initiatorNames = initiatorNames
	builder.initiatorNamesFlag = true
	return builder
}

// 任务 ID，全局唯一
//
// 示例值：1212564555454
func (builder *TaskBuilder) TaskId(taskId string) *TaskBuilder {
	builder.taskId = taskId
	builder.taskIdFlag = true
	return builder
}

// 流程 ID，全局唯一
//
// 示例值：1214564545474
func (builder *TaskBuilder) ProcessId(processId string) *TaskBuilder {
	builder.processId = processId
	builder.processIdFlag = true
	return builder
}

// 流程 Code
//
// 示例值：123e4567-e89b-12d3-a456-426655440000
func (builder *TaskBuilder) ProcessCode(processCode string) *TaskBuilder {
	builder.processCode = processCode
	builder.processCodeFlag = true
	return builder
}

// 流程定义分组 ID
//
// 示例值：1212564555454
func (builder *TaskBuilder) DefinitionGroupId(definitionGroupId string) *TaskBuilder {
	builder.definitionGroupId = definitionGroupId
	builder.definitionGroupIdFlag = true
	return builder
}

// 流程定义分组名称
//
// 示例值：流程定义名称
func (builder *TaskBuilder) DefinitionGroupName(definitionGroupName string) *TaskBuilder {
	builder.definitionGroupName = definitionGroupName
	builder.definitionGroupNameFlag = true
	return builder
}

// 流程定义 ID
//
// 示例值：1212564555454
func (builder *TaskBuilder) DefinitionId(definitionId string) *TaskBuilder {
	builder.definitionId = definitionId
	builder.definitionIdFlag = true
	return builder
}

// 流程定义名称
//
// 示例值：流程定义组名称
func (builder *TaskBuilder) DefinitionName(definitionName string) *TaskBuilder {
	builder.definitionName = definitionName
	builder.definitionNameFlag = true
	return builder
}

func (builder *TaskBuilder) Build() *Task {
	req := &Task{}
	if builder.topicFlag {
		req.Topic = &builder.topic

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

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

	}
	if builder.urlsFlag {
		req.Urls = builder.urls
	}
	if builder.processExternalIdFlag {
		req.ProcessExternalId = &builder.processExternalId

	}
	if builder.taskExternalIdFlag {
		req.TaskExternalId = &builder.taskExternalId

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

	}
	if builder.processStatusFlag {
		req.ProcessStatus = &builder.processStatus

	}
	if builder.definitionCodeFlag {
		req.DefinitionCode = &builder.definitionCode

	}
	if builder.initiatorsFlag {
		req.Initiators = builder.initiators
	}
	if builder.initiatorNamesFlag {
		req.InitiatorNames = builder.initiatorNames
	}
	if builder.taskIdFlag {
		req.TaskId = &builder.taskId

	}
	if builder.processIdFlag {
		req.ProcessId = &builder.processId

	}
	if builder.processCodeFlag {
		req.ProcessCode = &builder.processCode

	}
	if builder.definitionGroupIdFlag {
		req.DefinitionGroupId = &builder.definitionGroupId

	}
	if builder.definitionGroupNameFlag {
		req.DefinitionGroupName = &builder.definitionGroupName

	}
	if builder.definitionIdFlag {
		req.DefinitionId = &builder.definitionId

	}
	if builder.definitionNameFlag {
		req.DefinitionName = &builder.definitionName

	}
	return req
}

type TaskApprove struct {
	ApprovalCode *string `json:"approval_code,omitempty"` // 审批定义 Code
	InstanceCode *string `json:"instance_code,omitempty"` // 审批实例 Code
	UserId       *string `json:"user_id,omitempty"`       // 根据user_id_type填写操作用户id
	Comment      *string `json:"comment,omitempty"`       // 意见
	TaskId       *string `json:"task_id,omitempty"`       // 任务 ID， 审批实例详情task_list中id
	Form         *string `json:"form,omitempty"`          // json 数组，控件值
}

type TaskApproveBuilder struct {
	approvalCode     string // 审批定义 Code
	approvalCodeFlag bool
	instanceCode     string // 审批实例 Code
	instanceCodeFlag bool
	userId           string // 根据user_id_type填写操作用户id
	userIdFlag       bool
	comment          string // 意见
	commentFlag      bool
	taskId           string // 任务 ID， 审批实例详情task_list中id
	taskIdFlag       bool
	form             string // json 数组，控件值
	formFlag         bool
}

func NewTaskApproveBuilder() *TaskApproveBuilder {
	builder := &TaskApproveBuilder{}
	return builder
}

// 审批定义 Code
//
// 示例值：7C468A54-8745-2245-9675-08B7C63E7A85
func (builder *TaskApproveBuilder) ApprovalCode(approvalCode string) *TaskApproveBuilder {
	builder.approvalCode = approvalCode
	builder.approvalCodeFlag = true
	return builder
}

// 审批实例 Code
//
// 示例值：81D31358-93AF-92D6-7425-01A5D67C4E71
func (builder *TaskApproveBuilder) InstanceCode(instanceCode string) *TaskApproveBuilder {
	builder.instanceCode = instanceCode
	builder.instanceCodeFlag = true
	return builder
}

// 根据user_id_type填写操作用户id
//
// 示例值：f7cb567e
func (builder *TaskApproveBuilder) UserId(userId string) *TaskApproveBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 意见
//
// 示例值：OK
func (builder *TaskApproveBuilder) Comment(comment string) *TaskApproveBuilder {
	builder.comment = comment
	builder.commentFlag = true
	return builder
}

// 任务 ID， 审批实例详情task_list中id
//
// 示例值：12345
func (builder *TaskApproveBuilder) TaskId(taskId string) *TaskApproveBuilder {
	builder.taskId = taskId
	builder.taskIdFlag = true
	return builder
}

// json 数组，控件值
//
// 示例值：[{\"id\":\"111\", \"type\": \"input\", \"value\":\"test\"}]
func (builder *TaskApproveBuilder) Form(form string) *TaskApproveBuilder {
	builder.form = form
	builder.formFlag = true
	return builder
}

func (builder *TaskApproveBuilder) Build() *TaskApprove {
	req := &TaskApprove{}
	if builder.approvalCodeFlag {
		req.ApprovalCode = &builder.approvalCode

	}
	if builder.instanceCodeFlag {
		req.InstanceCode = &builder.instanceCode

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.commentFlag {
		req.Comment = &builder.comment

	}
	if builder.taskIdFlag {
		req.TaskId = &builder.taskId

	}
	if builder.formFlag {
		req.Form = &builder.form

	}
	return req
}

type TaskResubmit struct {
	ApprovalCode *string `json:"approval_code,omitempty"` // 审批定义 Code
	InstanceCode *string `json:"instance_code,omitempty"` // 审批实例 Code
	UserId       *string `json:"user_id,omitempty"`       // 根据user_id_type填写操作用户id
	Comment      *string `json:"comment,omitempty"`       // 意见
	TaskId       *string `json:"task_id,omitempty"`       // 任务 ID， 审批实例详情task_list中id
	Form         *string `json:"form,omitempty"`          // json 数组，控件值，同创建审批实例接口中form字段
}

type TaskResubmitBuilder struct {
	approvalCode     string // 审批定义 Code
	approvalCodeFlag bool
	instanceCode     string // 审批实例 Code
	instanceCodeFlag bool
	userId           string // 根据user_id_type填写操作用户id
	userIdFlag       bool
	comment          string // 意见
	commentFlag      bool
	taskId           string // 任务 ID， 审批实例详情task_list中id
	taskIdFlag       bool
	form             string // json 数组，控件值，同创建审批实例接口中form字段
	formFlag         bool
}

func NewTaskResubmitBuilder() *TaskResubmitBuilder {
	builder := &TaskResubmitBuilder{}
	return builder
}

// 审批定义 Code
//
// 示例值：7C468A54-8745-2245-9675-08B7C63E7A85
func (builder *TaskResubmitBuilder) ApprovalCode(approvalCode string) *TaskResubmitBuilder {
	builder.approvalCode = approvalCode
	builder.approvalCodeFlag = true
	return builder
}

// 审批实例 Code
//
// 示例值：81D31358-93AF-92D6-7425-01A5D67C4E71
func (builder *TaskResubmitBuilder) InstanceCode(instanceCode string) *TaskResubmitBuilder {
	builder.instanceCode = instanceCode
	builder.instanceCodeFlag = true
	return builder
}

// 根据user_id_type填写操作用户id
//
// 示例值：f7cb567e
func (builder *TaskResubmitBuilder) UserId(userId string) *TaskResubmitBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 意见
//
// 示例值：{\"text\":\"评论\",\"file_codes\":[\"ABCD1232s\",\"ABC12334d22\"]}
func (builder *TaskResubmitBuilder) Comment(comment string) *TaskResubmitBuilder {
	builder.comment = comment
	builder.commentFlag = true
	return builder
}

// 任务 ID， 审批实例详情task_list中id
//
// 示例值：12345
func (builder *TaskResubmitBuilder) TaskId(taskId string) *TaskResubmitBuilder {
	builder.taskId = taskId
	builder.taskIdFlag = true
	return builder
}

// json 数组，控件值，同创建审批实例接口中form字段
//
// 示例值：[{\"id\":\"user_name\", \"type\": \"input\", \"value\":\"test\"}]
func (builder *TaskResubmitBuilder) Form(form string) *TaskResubmitBuilder {
	builder.form = form
	builder.formFlag = true
	return builder
}

func (builder *TaskResubmitBuilder) Build() *TaskResubmit {
	req := &TaskResubmit{}
	if builder.approvalCodeFlag {
		req.ApprovalCode = &builder.approvalCode

	}
	if builder.instanceCodeFlag {
		req.InstanceCode = &builder.instanceCode

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.commentFlag {
		req.Comment = &builder.comment

	}
	if builder.taskIdFlag {
		req.TaskId = &builder.taskId

	}
	if builder.formFlag {
		req.Form = &builder.form

	}
	return req
}

type TaskSearch struct {
	UserId             *string `json:"user_id,omitempty"`              // 根据x_user_type填写用户 id
	ApprovalCode       *string `json:"approval_code,omitempty"`        // 审批定义 code
	InstanceCode       *string `json:"instance_code,omitempty"`        // 审批实例 code
	InstanceExternalId *string `json:"instance_external_id,omitempty"` // 审批实例第三方 id 注：和 approval_code 取并集
	GroupExternalId    *string `json:"group_external_id,omitempty"`    // 审批定义分组第三方 id 注：和 instance_code 取并集
	TaskTitle          *string `json:"task_title,omitempty"`           // 审批任务标题（只有第三方审批有）
	TaskStatus         *string `json:"task_status,omitempty"`          // 审批任务状态，注：若不设置，查询全部状态 若不在集合中，报错
	TaskStartTimeFrom  *string `json:"task_start_time_from,omitempty"` // 任务查询开始时间（unix毫秒时间戳）
	TaskStartTimeTo    *string `json:"task_start_time_to,omitempty"`   // 任务查询结束时间 (unix毫秒时间戳)
	Locale             *string `json:"locale,omitempty"`               // 地区
}

type TaskSearchBuilder struct {
	userId                 string // 根据x_user_type填写用户 id
	userIdFlag             bool
	approvalCode           string // 审批定义 code
	approvalCodeFlag       bool
	instanceCode           string // 审批实例 code
	instanceCodeFlag       bool
	instanceExternalId     string // 审批实例第三方 id 注：和 approval_code 取并集
	instanceExternalIdFlag bool
	groupExternalId        string // 审批定义分组第三方 id 注：和 instance_code 取并集
	groupExternalIdFlag    bool
	taskTitle              string // 审批任务标题（只有第三方审批有）
	taskTitleFlag          bool
	taskStatus             string // 审批任务状态，注：若不设置，查询全部状态 若不在集合中，报错
	taskStatusFlag         bool
	taskStartTimeFrom      string // 任务查询开始时间（unix毫秒时间戳）
	taskStartTimeFromFlag  bool
	taskStartTimeTo        string // 任务查询结束时间 (unix毫秒时间戳)
	taskStartTimeToFlag    bool
	locale                 string // 地区
	localeFlag             bool
}

func NewTaskSearchBuilder() *TaskSearchBuilder {
	builder := &TaskSearchBuilder{}
	return builder
}

// 根据x_user_type填写用户 id
//
// 示例值：lwiu098wj
func (builder *TaskSearchBuilder) UserId(userId string) *TaskSearchBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 审批定义 code
//
// 示例值：EB828003-9FFE-4B3F-AA50-2E199E2ED942
func (builder *TaskSearchBuilder) ApprovalCode(approvalCode string) *TaskSearchBuilder {
	builder.approvalCode = approvalCode
	builder.approvalCodeFlag = true
	return builder
}

// 审批实例 code
//
// 示例值：EB828003-9FFE-4B3F-AA50-2E199E2ED943
func (builder *TaskSearchBuilder) InstanceCode(instanceCode string) *TaskSearchBuilder {
	builder.instanceCode = instanceCode
	builder.instanceCodeFlag = true
	return builder
}

// 审批实例第三方 id 注：和 approval_code 取并集
//
// 示例值：EB828003-9FFE-4B3F-AA50-2E199E2ED976
func (builder *TaskSearchBuilder) InstanceExternalId(instanceExternalId string) *TaskSearchBuilder {
	builder.instanceExternalId = instanceExternalId
	builder.instanceExternalIdFlag = true
	return builder
}

// 审批定义分组第三方 id 注：和 instance_code 取并集
//
// 示例值：1234567
func (builder *TaskSearchBuilder) GroupExternalId(groupExternalId string) *TaskSearchBuilder {
	builder.groupExternalId = groupExternalId
	builder.groupExternalIdFlag = true
	return builder
}

// 审批任务标题（只有第三方审批有）
//
// 示例值：test
func (builder *TaskSearchBuilder) TaskTitle(taskTitle string) *TaskSearchBuilder {
	builder.taskTitle = taskTitle
	builder.taskTitleFlag = true
	return builder
}

// 审批任务状态，注：若不设置，查询全部状态 若不在集合中，报错
//
// 示例值：PENDING
func (builder *TaskSearchBuilder) TaskStatus(taskStatus string) *TaskSearchBuilder {
	builder.taskStatus = taskStatus
	builder.taskStatusFlag = true
	return builder
}

// 任务查询开始时间（unix毫秒时间戳）
//
// 示例值：1547654251506
func (builder *TaskSearchBuilder) TaskStartTimeFrom(taskStartTimeFrom string) *TaskSearchBuilder {
	builder.taskStartTimeFrom = taskStartTimeFrom
	builder.taskStartTimeFromFlag = true
	return builder
}

// 任务查询结束时间 (unix毫秒时间戳)
//
// 示例值：1547654251506
func (builder *TaskSearchBuilder) TaskStartTimeTo(taskStartTimeTo string) *TaskSearchBuilder {
	builder.taskStartTimeTo = taskStartTimeTo
	builder.taskStartTimeToFlag = true
	return builder
}

// 地区
//
// 示例值：zh-CN
func (builder *TaskSearchBuilder) Locale(locale string) *TaskSearchBuilder {
	builder.locale = locale
	builder.localeFlag = true
	return builder
}

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

	}
	if builder.approvalCodeFlag {
		req.ApprovalCode = &builder.approvalCode

	}
	if builder.instanceCodeFlag {
		req.InstanceCode = &builder.instanceCode

	}
	if builder.instanceExternalIdFlag {
		req.InstanceExternalId = &builder.instanceExternalId

	}
	if builder.groupExternalIdFlag {
		req.GroupExternalId = &builder.groupExternalId

	}
	if builder.taskTitleFlag {
		req.TaskTitle = &builder.taskTitle

	}
	if builder.taskStatusFlag {
		req.TaskStatus = &builder.taskStatus

	}
	if builder.taskStartTimeFromFlag {
		req.TaskStartTimeFrom = &builder.taskStartTimeFrom

	}
	if builder.taskStartTimeToFlag {
		req.TaskStartTimeTo = &builder.taskStartTimeTo

	}
	if builder.localeFlag {
		req.Locale = &builder.locale

	}
	return req
}

type TaskSearchItem struct {
	Approval *InstanceSearchApproval `json:"approval,omitempty"` // 审批定义
	Group    *InstanceSearchGroup    `json:"group,omitempty"`    // 审批定义分组
	Instance *InstanceSearchNode     `json:"instance,omitempty"` // 审批实例信息
	Task     *TaskSearchNode         `json:"task,omitempty"`     // 审批任务
}

type TaskSearchItemBuilder struct {
	approval     *InstanceSearchApproval // 审批定义
	approvalFlag bool
	group        *InstanceSearchGroup // 审批定义分组
	groupFlag    bool
	instance     *InstanceSearchNode // 审批实例信息
	instanceFlag bool
	task         *TaskSearchNode // 审批任务
	taskFlag     bool
}

func NewTaskSearchItemBuilder() *TaskSearchItemBuilder {
	builder := &TaskSearchItemBuilder{}
	return builder
}

// 审批定义
//
// 示例值：
func (builder *TaskSearchItemBuilder) Approval(approval *InstanceSearchApproval) *TaskSearchItemBuilder {
	builder.approval = approval
	builder.approvalFlag = true
	return builder
}

// 审批定义分组
//
// 示例值：
func (builder *TaskSearchItemBuilder) Group(group *InstanceSearchGroup) *TaskSearchItemBuilder {
	builder.group = group
	builder.groupFlag = true
	return builder
}

// 审批实例信息
//
// 示例值：
func (builder *TaskSearchItemBuilder) Instance(instance *InstanceSearchNode) *TaskSearchItemBuilder {
	builder.instance = instance
	builder.instanceFlag = true
	return builder
}

// 审批任务
//
// 示例值：
func (builder *TaskSearchItemBuilder) Task(task *TaskSearchNode) *TaskSearchItemBuilder {
	builder.task = task
	builder.taskFlag = true
	return builder
}

func (builder *TaskSearchItemBuilder) Build() *TaskSearchItem {
	req := &TaskSearchItem{}
	if builder.approvalFlag {
		req.Approval = builder.approval
	}
	if builder.groupFlag {
		req.Group = builder.group
	}
	if builder.instanceFlag {
		req.Instance = builder.instance
	}
	if builder.taskFlag {
		req.Task = builder.task
	}
	return req
}

type TaskSearchNode struct {
	UserId    *string             `json:"user_id,omitempty"`    // 审批任务发起人 id
	StartTime *string             `json:"start_time,omitempty"` // 审批任务开始时间
	EndTime   *string             `json:"end_time,omitempty"`   // 审批任务结束时间
	Status    *string             `json:"status,omitempty"`     // 审批任务状态
	Title     *string             `json:"title,omitempty"`      // 审批任务名称（只有第三方审批有）
	Extra     *string             `json:"extra,omitempty"`      // 审批任务扩展字段，string型json
	Link      *InstanceSearchLink `json:"link,omitempty"`       // 审批任务链接（只有第三方审批有）
	TaskId    *string             `json:"task_id,omitempty"`    // 任务id
}

type TaskSearchNodeBuilder struct {
	userId        string // 审批任务发起人 id
	userIdFlag    bool
	startTime     string // 审批任务开始时间
	startTimeFlag bool
	endTime       string // 审批任务结束时间
	endTimeFlag   bool
	status        string // 审批任务状态
	statusFlag    bool
	title         string // 审批任务名称（只有第三方审批有）
	titleFlag     bool
	extra         string // 审批任务扩展字段，string型json
	extraFlag     bool
	link          *InstanceSearchLink // 审批任务链接（只有第三方审批有）
	linkFlag      bool
	taskId        string // 任务id
	taskIdFlag    bool
}

func NewTaskSearchNodeBuilder() *TaskSearchNodeBuilder {
	builder := &TaskSearchNodeBuilder{}
	return builder
}

// 审批任务发起人 id
//
// 示例值：lwiu098wj
func (builder *TaskSearchNodeBuilder) UserId(userId string) *TaskSearchNodeBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 审批任务开始时间
//
// 示例值：1547654251506
func (builder *TaskSearchNodeBuilder) StartTime(startTime string) *TaskSearchNodeBuilder {
	builder.startTime = startTime
	builder.startTimeFlag = true
	return builder
}

// 审批任务结束时间
//
// 示例值：1547654251506
func (builder *TaskSearchNodeBuilder) EndTime(endTime string) *TaskSearchNodeBuilder {
	builder.endTime = endTime
	builder.endTimeFlag = true
	return builder
}

// 审批任务状态
//
// 示例值：pending
func (builder *TaskSearchNodeBuilder) Status(status string) *TaskSearchNodeBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

// 审批任务名称（只有第三方审批有）
//
// 示例值：test
func (builder *TaskSearchNodeBuilder) Title(title string) *TaskSearchNodeBuilder {
	builder.title = title
	builder.titleFlag = true
	return builder
}

// 审批任务扩展字段，string型json
//
// 示例值：{}
func (builder *TaskSearchNodeBuilder) Extra(extra string) *TaskSearchNodeBuilder {
	builder.extra = extra
	builder.extraFlag = true
	return builder
}

// 审批任务链接（只有第三方审批有）
//
// 示例值：
func (builder *TaskSearchNodeBuilder) Link(link *InstanceSearchLink) *TaskSearchNodeBuilder {
	builder.link = link
	builder.linkFlag = true
	return builder
}

// 任务id
//
// 示例值：7110153401253494803
func (builder *TaskSearchNodeBuilder) TaskId(taskId string) *TaskSearchNodeBuilder {
	builder.taskId = taskId
	builder.taskIdFlag = true
	return builder
}

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

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

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

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

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

	}
	if builder.extraFlag {
		req.Extra = &builder.extra

	}
	if builder.linkFlag {
		req.Link = builder.link
	}
	if builder.taskIdFlag {
		req.TaskId = &builder.taskId

	}
	return req
}

type TaskTransfer struct {
	ApprovalCode   *string `json:"approval_code,omitempty"`    // 审批定义 Code
	InstanceCode   *string `json:"instance_code,omitempty"`    // 审批实例 Code
	UserId         *string `json:"user_id,omitempty"`          // 根据user_id_type填写操作用户id
	Comment        *string `json:"comment,omitempty"`          // 意见
	TransferUserId *string `json:"transfer_user_id,omitempty"` // 根据user_id_type填写被转交人唯一 ID
	TaskId         *string `json:"task_id,omitempty"`          // 任务 ID， 审批实例详情task_list中id
}

type TaskTransferBuilder struct {
	approvalCode       string // 审批定义 Code
	approvalCodeFlag   bool
	instanceCode       string // 审批实例 Code
	instanceCodeFlag   bool
	userId             string // 根据user_id_type填写操作用户id
	userIdFlag         bool
	comment            string // 意见
	commentFlag        bool
	transferUserId     string // 根据user_id_type填写被转交人唯一 ID
	transferUserIdFlag bool
	taskId             string // 任务 ID， 审批实例详情task_list中id
	taskIdFlag         bool
}

func NewTaskTransferBuilder() *TaskTransferBuilder {
	builder := &TaskTransferBuilder{}
	return builder
}

// 审批定义 Code
//
// 示例值：7C468A54-8745-2245-9675-08B7C63E7A85
func (builder *TaskTransferBuilder) ApprovalCode(approvalCode string) *TaskTransferBuilder {
	builder.approvalCode = approvalCode
	builder.approvalCodeFlag = true
	return builder
}

// 审批实例 Code
//
// 示例值：81D31358-93AF-92D6-7425-01A5D67C4E71
func (builder *TaskTransferBuilder) InstanceCode(instanceCode string) *TaskTransferBuilder {
	builder.instanceCode = instanceCode
	builder.instanceCodeFlag = true
	return builder
}

// 根据user_id_type填写操作用户id
//
// 示例值：f7cb567e
func (builder *TaskTransferBuilder) UserId(userId string) *TaskTransferBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 意见
//
// 示例值：OK
func (builder *TaskTransferBuilder) Comment(comment string) *TaskTransferBuilder {
	builder.comment = comment
	builder.commentFlag = true
	return builder
}

// 根据user_id_type填写被转交人唯一 ID
//
// 示例值：f4ip317q
func (builder *TaskTransferBuilder) TransferUserId(transferUserId string) *TaskTransferBuilder {
	builder.transferUserId = transferUserId
	builder.transferUserIdFlag = true
	return builder
}

// 任务 ID， 审批实例详情task_list中id
//
// 示例值：12345
func (builder *TaskTransferBuilder) TaskId(taskId string) *TaskTransferBuilder {
	builder.taskId = taskId
	builder.taskIdFlag = true
	return builder
}

func (builder *TaskTransferBuilder) Build() *TaskTransfer {
	req := &TaskTransfer{}
	if builder.approvalCodeFlag {
		req.ApprovalCode = &builder.approvalCode

	}
	if builder.instanceCodeFlag {
		req.InstanceCode = &builder.instanceCode

	}
	if builder.userIdFlag {
		req.UserId = &builder.userId

	}
	if builder.commentFlag {
		req.Comment = &builder.comment

	}
	if builder.transferUserIdFlag {
		req.TransferUserId = &builder.transferUserId

	}
	if builder.taskIdFlag {
		req.TaskId = &builder.taskId

	}
	return req
}

type TaskUrls struct {
	Helpdesk *string `json:"helpdesk,omitempty"` // 帮助服务台 URL
	Mobile   *string `json:"mobile,omitempty"`   // 移动端 URL
	Pc       *string `json:"pc,omitempty"`       // PC 端 URL
}

type TaskUrlsBuilder struct {
	helpdesk     string // 帮助服务台 URL
	helpdeskFlag bool
	mobile       string // 移动端 URL
	mobileFlag   bool
	pc           string // PC 端 URL
	pcFlag       bool
}

func NewTaskUrlsBuilder() *TaskUrlsBuilder {
	builder := &TaskUrlsBuilder{}
	return builder
}

// 帮助服务台 URL
//
// 示例值：https://blabla
func (builder *TaskUrlsBuilder) Helpdesk(helpdesk string) *TaskUrlsBuilder {
	builder.helpdesk = helpdesk
	builder.helpdeskFlag = true
	return builder
}

// 移动端 URL
//
// 示例值：https://blabla
func (builder *TaskUrlsBuilder) Mobile(mobile string) *TaskUrlsBuilder {
	builder.mobile = mobile
	builder.mobileFlag = true
	return builder
}

// PC 端 URL
//
// 示例值：https://blabla
func (builder *TaskUrlsBuilder) Pc(pc string) *TaskUrlsBuilder {
	builder.pc = pc
	builder.pcFlag = true
	return builder
}

func (builder *TaskUrlsBuilder) Build() *TaskUrls {
	req := &TaskUrls{}
	if builder.helpdeskFlag {
		req.Helpdesk = &builder.helpdesk

	}
	if builder.mobileFlag {
		req.Mobile = &builder.mobile

	}
	if builder.pcFlag {
		req.Pc = &builder.pc

	}
	return req
}

type TripGroup struct {
	Type         *string              `json:"type,omitempty"`          // 出差类型
	InstanceCode *string              `json:"instance_code,omitempty"` // 实例code
	StartUser    *User                `json:"start_user,omitempty"`    // 发起人
	StartTime    *string              `json:"start_time,omitempty"`    // 开始时间
	EndTime      *string              `json:"end_time,omitempty"`      // 结束时间
	TripInterval *string              `json:"trip_interval,omitempty"` // 出差时间
	TripReason   *string              `json:"trip_reason,omitempty"`   // 出差理由
	Schedules    []*TripGroupSchedule `json:"schedules,omitempty"`     // 出差计划
	TripPeers    []*User              `json:"trip_peers,omitempty"`    // 同行人
}

type TripGroupBuilder struct {
	type_            string // 出差类型
	typeFlag         bool
	instanceCode     string // 实例code
	instanceCodeFlag bool
	startUser        *User // 发起人
	startUserFlag    bool
	startTime        string // 开始时间
	startTimeFlag    bool
	endTime          string // 结束时间
	endTimeFlag      bool
	tripInterval     string // 出差时间
	tripIntervalFlag bool
	tripReason       string // 出差理由
	tripReasonFlag   bool
	schedules        []*TripGroupSchedule // 出差计划
	schedulesFlag    bool
	tripPeers        []*User // 同行人
	tripPeersFlag    bool
}

func NewTripGroupBuilder() *TripGroupBuilder {
	builder := &TripGroupBuilder{}
	return builder
}

// 出差类型
//
// 示例值：
func (builder *TripGroupBuilder) Type(type_ string) *TripGroupBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

// 实例code
//
// 示例值：
func (builder *TripGroupBuilder) InstanceCode(instanceCode string) *TripGroupBuilder {
	builder.instanceCode = instanceCode
	builder.instanceCodeFlag = true
	return builder
}

// 发起人
//
// 示例值：
func (builder *TripGroupBuilder) StartUser(startUser *User) *TripGroupBuilder {
	builder.startUser = startUser
	builder.startUserFlag = true
	return builder
}

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

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

// 出差时间
//
// 示例值：
func (builder *TripGroupBuilder) TripInterval(tripInterval string) *TripGroupBuilder {
	builder.tripInterval = tripInterval
	builder.tripIntervalFlag = true
	return builder
}

// 出差理由
//
// 示例值：
func (builder *TripGroupBuilder) TripReason(tripReason string) *TripGroupBuilder {
	builder.tripReason = tripReason
	builder.tripReasonFlag = true
	return builder
}

// 出差计划
//
// 示例值：
func (builder *TripGroupBuilder) Schedules(schedules []*TripGroupSchedule) *TripGroupBuilder {
	builder.schedules = schedules
	builder.schedulesFlag = true
	return builder
}

// 同行人
//
// 示例值：
func (builder *TripGroupBuilder) TripPeers(tripPeers []*User) *TripGroupBuilder {
	builder.tripPeers = tripPeers
	builder.tripPeersFlag = true
	return builder
}

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

	}
	if builder.instanceCodeFlag {
		req.InstanceCode = &builder.instanceCode

	}
	if builder.startUserFlag {
		req.StartUser = builder.startUser
	}
	if builder.startTimeFlag {
		req.StartTime = &builder.startTime

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

	}
	if builder.tripIntervalFlag {
		req.TripInterval = &builder.tripInterval

	}
	if builder.tripReasonFlag {
		req.TripReason = &builder.tripReason

	}
	if builder.schedulesFlag {
		req.Schedules = builder.schedules
	}
	if builder.tripPeersFlag {
		req.TripPeers = builder.tripPeers
	}
	return req
}

type TripGroupSchedule struct {
	TripStartTime  *string `json:"trip_start_time,omitempty"` // 开始时间
	TripEndTime    *string `json:"trip_end_time,omitempty"`   // 结束时间
	TripInterval   *string `json:"trip_interval,omitempty"`   // 周期
	Departure      *string `json:"departure,omitempty"`       // 出发地
	Destination    *string `json:"destination,omitempty"`     // 目的地
	Transportation *string `json:"transportation,omitempty"`  // 交通工具
	TripType       *string `json:"trip_type,omitempty"`       // 出差类型
	Remark         *string `json:"remark,omitempty"`          // 备注
}

type TripGroupScheduleBuilder struct {
	tripStartTime      string // 开始时间
	tripStartTimeFlag  bool
	tripEndTime        string // 结束时间
	tripEndTimeFlag    bool
	tripInterval       string // 周期
	tripIntervalFlag   bool
	departure          string // 出发地
	departureFlag      bool
	destination        string // 目的地
	destinationFlag    bool
	transportation     string // 交通工具
	transportationFlag bool
	tripType           string // 出差类型
	tripTypeFlag       bool
	remark             string // 备注
	remarkFlag         bool
}

func NewTripGroupScheduleBuilder() *TripGroupScheduleBuilder {
	builder := &TripGroupScheduleBuilder{}
	return builder
}

// 开始时间
//
// 示例值：
func (builder *TripGroupScheduleBuilder) TripStartTime(tripStartTime string) *TripGroupScheduleBuilder {
	builder.tripStartTime = tripStartTime
	builder.tripStartTimeFlag = true
	return builder
}

// 结束时间
//
// 示例值：
func (builder *TripGroupScheduleBuilder) TripEndTime(tripEndTime string) *TripGroupScheduleBuilder {
	builder.tripEndTime = tripEndTime
	builder.tripEndTimeFlag = true
	return builder
}

// 周期
//
// 示例值：
func (builder *TripGroupScheduleBuilder) TripInterval(tripInterval string) *TripGroupScheduleBuilder {
	builder.tripInterval = tripInterval
	builder.tripIntervalFlag = true
	return builder
}

// 出发地
//
// 示例值：
func (builder *TripGroupScheduleBuilder) Departure(departure string) *TripGroupScheduleBuilder {
	builder.departure = departure
	builder.departureFlag = true
	return builder
}

// 目的地
//
// 示例值：
func (builder *TripGroupScheduleBuilder) Destination(destination string) *TripGroupScheduleBuilder {
	builder.destination = destination
	builder.destinationFlag = true
	return builder
}

// 交通工具
//
// 示例值：
func (builder *TripGroupScheduleBuilder) Transportation(transportation string) *TripGroupScheduleBuilder {
	builder.transportation = transportation
	builder.transportationFlag = true
	return builder
}

// 出差类型
//
// 示例值：
func (builder *TripGroupScheduleBuilder) TripType(tripType string) *TripGroupScheduleBuilder {
	builder.tripType = tripType
	builder.tripTypeFlag = true
	return builder
}

// 备注
//
// 示例值：
func (builder *TripGroupScheduleBuilder) Remark(remark string) *TripGroupScheduleBuilder {
	builder.remark = remark
	builder.remarkFlag = true
	return builder
}

func (builder *TripGroupScheduleBuilder) Build() *TripGroupSchedule {
	req := &TripGroupSchedule{}
	if builder.tripStartTimeFlag {
		req.TripStartTime = &builder.tripStartTime

	}
	if builder.tripEndTimeFlag {
		req.TripEndTime = &builder.tripEndTime

	}
	if builder.tripIntervalFlag {
		req.TripInterval = &builder.tripInterval

	}
	if builder.departureFlag {
		req.Departure = &builder.departure

	}
	if builder.destinationFlag {
		req.Destination = &builder.destination

	}
	if builder.transportationFlag {
		req.Transportation = &builder.transportation

	}
	if builder.tripTypeFlag {
		req.TripType = &builder.tripType

	}
	if builder.remarkFlag {
		req.Remark = &builder.remark

	}
	return req
}

type TrusteeshipUrls struct {
	FormDetailUrl       *string `json:"form_detail_url,omitempty"`       // 获取表单schema相关数据的url地址
	ActionDefinitionUrl *string `json:"action_definition_url,omitempty"` // 表示获取审批操作区数据的url地址
	ApprovalNodeUrl     *string `json:"approval_node_url,omitempty"`     // 获取审批记录相关数据的url地址
	ActionCallbackUrl   *string `json:"action_callback_url,omitempty"`   // 进行审批操作时回调的url地址
}

type TrusteeshipUrlsBuilder struct {
	formDetailUrl           string // 获取表单schema相关数据的url地址
	formDetailUrlFlag       bool
	actionDefinitionUrl     string // 表示获取审批操作区数据的url地址
	actionDefinitionUrlFlag bool
	approvalNodeUrl         string // 获取审批记录相关数据的url地址
	approvalNodeUrlFlag     bool
	actionCallbackUrl       string // 进行审批操作时回调的url地址
	actionCallbackUrlFlag   bool
}

func NewTrusteeshipUrlsBuilder() *TrusteeshipUrlsBuilder {
	builder := &TrusteeshipUrlsBuilder{}
	return builder
}

// 获取表单schema相关数据的url地址
//
// 示例值：https://#{your_domain}/api/form_detail
func (builder *TrusteeshipUrlsBuilder) FormDetailUrl(formDetailUrl string) *TrusteeshipUrlsBuilder {
	builder.formDetailUrl = formDetailUrl
	builder.formDetailUrlFlag = true
	return builder
}

// 表示获取审批操作区数据的url地址
//
// 示例值：https://#{your_domain}/api/action_definition
func (builder *TrusteeshipUrlsBuilder) ActionDefinitionUrl(actionDefinitionUrl string) *TrusteeshipUrlsBuilder {
	builder.actionDefinitionUrl = actionDefinitionUrl
	builder.actionDefinitionUrlFlag = true
	return builder
}

// 获取审批记录相关数据的url地址
//
// 示例值：https://#{your_domain}/api/approval_node
func (builder *TrusteeshipUrlsBuilder) ApprovalNodeUrl(approvalNodeUrl string) *TrusteeshipUrlsBuilder {
	builder.approvalNodeUrl = approvalNodeUrl
	builder.approvalNodeUrlFlag = true
	return builder
}

// 进行审批操作时回调的url地址
//
// 示例值：https://#{your_domain}/api/approval_node
func (builder *TrusteeshipUrlsBuilder) ActionCallbackUrl(actionCallbackUrl string) *TrusteeshipUrlsBuilder {
	builder.actionCallbackUrl = actionCallbackUrl
	builder.actionCallbackUrlFlag = true
	return builder
}

func (builder *TrusteeshipUrlsBuilder) Build() *TrusteeshipUrls {
	req := &TrusteeshipUrls{}
	if builder.formDetailUrlFlag {
		req.FormDetailUrl = &builder.formDetailUrl

	}
	if builder.actionDefinitionUrlFlag {
		req.ActionDefinitionUrl = &builder.actionDefinitionUrl

	}
	if builder.approvalNodeUrlFlag {
		req.ApprovalNodeUrl = &builder.approvalNodeUrl

	}
	if builder.actionCallbackUrlFlag {
		req.ActionCallbackUrl = &builder.actionCallbackUrl

	}
	return req
}

type User struct {
	Id   *UserId `json:"id,omitempty"`   // 用户id
	Name *string `json:"name,omitempty"` // 用户名
}

type UserBuilder struct {
	id       *UserId // 用户id
	idFlag   bool
	name     string // 用户名
	nameFlag bool
}

func NewUserBuilder() *UserBuilder {
	builder := &UserBuilder{}
	return builder
}

// 用户id
//
// 示例值：
func (builder *UserBuilder) Id(id *UserId) *UserBuilder {
	builder.id = id
	builder.idFlag = true
	return builder
}

// 用户名
//
// 示例值：
func (builder *UserBuilder) Name(name string) *UserBuilder {
	builder.name = name
	builder.nameFlag = true
	return builder
}

func (builder *UserBuilder) Build() *User {
	req := &User{}
	if builder.idFlag {
		req.Id = builder.id
	}
	if builder.nameFlag {
		req.Name = &builder.name

	}
	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 CreateApprovalReqBuilder struct {
	apiReq         *larkcore.ApiReq
	approvalCreate *ApprovalCreate
}

func NewCreateApprovalReqBuilder() *CreateApprovalReqBuilder {
	builder := &CreateApprovalReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 此次调用中使用的部门ID的类型
//
// 示例值：open_department_id
func (builder *CreateApprovalReqBuilder) DepartmentIdType(departmentIdType string) *CreateApprovalReqBuilder {
	builder.apiReq.QueryParams.Set("department_id_type", fmt.Sprint(departmentIdType))
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *CreateApprovalReqBuilder) UserIdType(userIdType string) *CreateApprovalReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 用于通过接口创建简单的审批定义，可以灵活指定定义的基础信息、表单和流程等。创建成功后，不支持从审批管理后台删除该定义。不推荐企业自建应用使用，如有需要尽量联系管理员在审批管理后台创建定义。
func (builder *CreateApprovalReqBuilder) ApprovalCreate(approvalCreate *ApprovalCreate) *CreateApprovalReqBuilder {
	builder.approvalCreate = approvalCreate
	return builder
}

func (builder *CreateApprovalReqBuilder) Build() *CreateApprovalReq {
	req := &CreateApprovalReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.approvalCreate
	return req
}

type CreateApprovalReq struct {
	apiReq         *larkcore.ApiReq
	ApprovalCreate *ApprovalCreate `body:""`
}

type CreateApprovalRespData struct {
	ApprovalCode *string `json:"approval_code,omitempty"` // 审批定义 Code
	ApprovalId   *string `json:"approval_id,omitempty"`   // 审批定义 id
}

type CreateApprovalResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *CreateApprovalRespData `json:"data"` // 业务数据
}

func (resp *CreateApprovalResp) Success() bool {
	return resp.Code == 0
}

type GetApprovalReqBuilder struct {
	apiReq *larkcore.ApiReq
}

func NewGetApprovalReqBuilder() *GetApprovalReqBuilder {
	builder := &GetApprovalReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 审批定义 Code
//
// 示例值：7C468A54-8745-2245-9675-08B7C63E7A85
func (builder *GetApprovalReqBuilder) ApprovalCode(approvalCode string) *GetApprovalReqBuilder {
	builder.apiReq.PathParams.Set("approval_code", fmt.Sprint(approvalCode))
	return builder
}

// 语言可选值
//
// 示例值：zh-CN
func (builder *GetApprovalReqBuilder) Locale(locale string) *GetApprovalReqBuilder {
	builder.apiReq.QueryParams.Set("locale", fmt.Sprint(locale))
	return builder
}

func (builder *GetApprovalReqBuilder) Build() *GetApprovalReq {
	req := &GetApprovalReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type GetApprovalReq struct {
	apiReq *larkcore.ApiReq
}

type GetApprovalRespData struct {
	ApprovalName *string               `json:"approval_name,omitempty"` // 审批名称
	Status       *string               `json:"status,omitempty"`        // 审批定义状态
	Form         *string               `json:"form,omitempty"`          // 控件信息，见下方form字段说明
	NodeList     []*ApprovalNodeInfo   `json:"node_list,omitempty"`     // 节点信息
	Viewers      []*ApprovalViewerInfo `json:"viewers,omitempty"`       // 可见人列表
}

type GetApprovalResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *GetApprovalRespData `json:"data"` // 业务数据
}

func (resp *GetApprovalResp) Success() bool {
	return resp.Code == 0
}

type SubscribeApprovalReqBuilder struct {
	apiReq *larkcore.ApiReq
}

func NewSubscribeApprovalReqBuilder() *SubscribeApprovalReqBuilder {
	builder := &SubscribeApprovalReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 审批定义唯一标识
//
// 示例值：7C468A54-8745-2245-9675-08B7C63E7A85
func (builder *SubscribeApprovalReqBuilder) ApprovalCode(approvalCode string) *SubscribeApprovalReqBuilder {
	builder.apiReq.PathParams.Set("approval_code", fmt.Sprint(approvalCode))
	return builder
}

func (builder *SubscribeApprovalReqBuilder) Build() *SubscribeApprovalReq {
	req := &SubscribeApprovalReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	return req
}

type SubscribeApprovalReq struct {
	apiReq *larkcore.ApiReq
}

type SubscribeApprovalResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *SubscribeApprovalResp) Success() bool {
	return resp.Code == 0
}

type UnsubscribeApprovalReqBuilder struct {
	apiReq *larkcore.ApiReq
}

func NewUnsubscribeApprovalReqBuilder() *UnsubscribeApprovalReqBuilder {
	builder := &UnsubscribeApprovalReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 审批定义唯一标识
//
// 示例值：7C468A54-8745-2245-9675-08B7C63E7A85
func (builder *UnsubscribeApprovalReqBuilder) ApprovalCode(approvalCode string) *UnsubscribeApprovalReqBuilder {
	builder.apiReq.PathParams.Set("approval_code", fmt.Sprint(approvalCode))
	return builder
}

func (builder *UnsubscribeApprovalReqBuilder) Build() *UnsubscribeApprovalReq {
	req := &UnsubscribeApprovalReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	return req
}

type UnsubscribeApprovalReq struct {
	apiReq *larkcore.ApiReq
}

type UnsubscribeApprovalResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *UnsubscribeApprovalResp) Success() bool {
	return resp.Code == 0
}

type CreateExternalApprovalReqBuilder struct {
	apiReq           *larkcore.ApiReq
	externalApproval *ExternalApproval
}

func NewCreateExternalApprovalReqBuilder() *CreateExternalApprovalReqBuilder {
	builder := &CreateExternalApprovalReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 此次调用中使用的部门ID的类型
//
// 示例值：open_department_id
func (builder *CreateExternalApprovalReqBuilder) DepartmentIdType(departmentIdType string) *CreateExternalApprovalReqBuilder {
	builder.apiReq.QueryParams.Set("department_id_type", fmt.Sprint(departmentIdType))
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *CreateExternalApprovalReqBuilder) UserIdType(userIdType string) *CreateExternalApprovalReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 审批定义是审批的描述，包括审批名称、图标、描述等基础信息。创建好审批定义，用户就可以在审批应用的发起页中看到审批，如果用户点击发起，则会跳转到配置的发起三方系统地址去发起审批。;;另外，审批定义还配置了审批操作时的回调地址：审批人在待审批列表中进行【同意】【拒绝】操作时，审批中心会调用回调地址通知三方系统。
func (builder *CreateExternalApprovalReqBuilder) ExternalApproval(externalApproval *ExternalApproval) *CreateExternalApprovalReqBuilder {
	builder.externalApproval = externalApproval
	return builder
}

func (builder *CreateExternalApprovalReqBuilder) Build() *CreateExternalApprovalReq {
	req := &CreateExternalApprovalReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.externalApproval
	return req
}

type CreateExternalApprovalReq struct {
	apiReq           *larkcore.ApiReq
	ExternalApproval *ExternalApproval `body:""`
}

type CreateExternalApprovalRespData struct {
	ApprovalCode *string `json:"approval_code,omitempty"` // 审批定义 code，用户自定义，定义的唯一标识
}

type CreateExternalApprovalResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *CreateExternalApprovalRespData `json:"data"` // 业务数据
}

func (resp *CreateExternalApprovalResp) Success() bool {
	return resp.Code == 0
}

type CheckExternalInstanceReqBodyBuilder struct {
	instances     []*ExteranlInstanceCheck // 校验的实例信息
	instancesFlag bool
}

func NewCheckExternalInstanceReqBodyBuilder() *CheckExternalInstanceReqBodyBuilder {
	builder := &CheckExternalInstanceReqBodyBuilder{}
	return builder
}

// 校验的实例信息
//
//示例值：
func (builder *CheckExternalInstanceReqBodyBuilder) Instances(instances []*ExteranlInstanceCheck) *CheckExternalInstanceReqBodyBuilder {
	builder.instances = instances
	builder.instancesFlag = true
	return builder
}

func (builder *CheckExternalInstanceReqBodyBuilder) Build() *CheckExternalInstanceReqBody {
	req := &CheckExternalInstanceReqBody{}
	if builder.instancesFlag {
		req.Instances = builder.instances
	}
	return req
}

type CheckExternalInstancePathReqBodyBuilder struct {
	instances     []*ExteranlInstanceCheck // 校验的实例信息
	instancesFlag bool
}

func NewCheckExternalInstancePathReqBodyBuilder() *CheckExternalInstancePathReqBodyBuilder {
	builder := &CheckExternalInstancePathReqBodyBuilder{}
	return builder
}

// 校验的实例信息
//
// 示例值：
func (builder *CheckExternalInstancePathReqBodyBuilder) Instances(instances []*ExteranlInstanceCheck) *CheckExternalInstancePathReqBodyBuilder {
	builder.instances = instances
	builder.instancesFlag = true
	return builder
}

func (builder *CheckExternalInstancePathReqBodyBuilder) Build() (*CheckExternalInstanceReqBody, error) {
	req := &CheckExternalInstanceReqBody{}
	if builder.instancesFlag {
		req.Instances = builder.instances
	}
	return req, nil
}

type CheckExternalInstanceReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *CheckExternalInstanceReqBody
}

func NewCheckExternalInstanceReqBuilder() *CheckExternalInstanceReqBuilder {
	builder := &CheckExternalInstanceReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 校验三方审批实例数据，用于判断服务端数据是否为最新的。用户提交实例最新更新时间，如果服务端不存在该实例，或者服务端实例更新时间不是最新的，则返回对应实例 id。;;例如，用户可以每隔5分钟，将最近5分钟产生的实例使用该接口进行对比。
func (builder *CheckExternalInstanceReqBuilder) Body(body *CheckExternalInstanceReqBody) *CheckExternalInstanceReqBuilder {
	builder.body = body
	return builder
}

func (builder *CheckExternalInstanceReqBuilder) Build() *CheckExternalInstanceReq {
	req := &CheckExternalInstanceReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.Body = builder.body
	return req
}

type CheckExternalInstanceReqBody struct {
	Instances []*ExteranlInstanceCheck `json:"instances,omitempty"` // 校验的实例信息
}

type CheckExternalInstanceReq struct {
	apiReq *larkcore.ApiReq
	Body   *CheckExternalInstanceReqBody `body:""`
}

type CheckExternalInstanceRespData struct {
	DiffInstances []*ExteranlInstanceCheckResponse `json:"diff_instances,omitempty"` // 更新时间不一致的实例信息
}

type CheckExternalInstanceResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *CheckExternalInstanceRespData `json:"data"` // 业务数据
}

func (resp *CheckExternalInstanceResp) Success() bool {
	return resp.Code == 0
}

type CreateExternalInstanceReqBuilder struct {
	apiReq           *larkcore.ApiReq
	externalInstance *ExternalInstance
}

func NewCreateExternalInstanceReqBuilder() *CreateExternalInstanceReqBuilder {
	builder := &CreateExternalInstanceReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 审批中心不负责审批的流转，审批的流转在三方系统，三方系统在审批流转后生成的审批实例、审批任务、审批抄送数据同步到审批中心。;;用户可以在审批中心中浏览三方系统同步过来的实例、任务、抄送信息，并且可以跳转回三方系统进行更详细的查看和操作，其中实例信息在【已发起】列表，任务信息在【待审批】和【已审批】列表，抄送信息在【抄送我】列表;;:::html;<img src="//sf3-cn.feishucdn.com/obj/open-platform-opendoc/9dff4434afbeb0ef69de7f36b9a6e995_z5iwmTzEgg.png" alt="" style="zoom:17%;" />;;;<img src="//sf3-cn.feishucdn.com/obj/open-platform-opendoc/ca6e0e984a7a6d64e1b16a0bac4bf868_tfqjCiaJQM.png" alt="" style="zoom:17%;" />;;;<img src="//sf3-cn.feishucdn.com/obj/open-platform-opendoc/529377e238df78d391bbd22e962ad195_T7eefLI1GA.png" alt="" style="zoom:17%;" />;:::;;对于审批任务，三方系统也可以配置审批任务的回调接口，这样审批人可以在审批中心中直接进行审批操作，审批中心会回调三方系统，三方系统收到回调后更新任务信息，并将新的任务信息同步回审批中心，形成闭环。;;:::html;<img src="//sf3-cn.feishucdn.com/obj/open-platform-opendoc/721c35428bc1187db3318c572f9979ad_je75QpElcg.png" alt=""  style="zoom:25%;" />;:::;<br>
func (builder *CreateExternalInstanceReqBuilder) ExternalInstance(externalInstance *ExternalInstance) *CreateExternalInstanceReqBuilder {
	builder.externalInstance = externalInstance
	return builder
}

func (builder *CreateExternalInstanceReqBuilder) Build() *CreateExternalInstanceReq {
	req := &CreateExternalInstanceReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.Body = builder.externalInstance
	return req
}

type CreateExternalInstanceReq struct {
	apiReq           *larkcore.ApiReq
	ExternalInstance *ExternalInstance `body:""`
}

type CreateExternalInstanceRespData struct {
	Data *ExternalInstance `json:"data,omitempty"` // 同步的实例数据
}

type CreateExternalInstanceResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *CreateExternalInstanceRespData `json:"data"` // 业务数据
}

func (resp *CreateExternalInstanceResp) Success() bool {
	return resp.Code == 0
}

type ListExternalTaskReqBodyBuilder struct {
	approvalCodes     []string // 审批定义 Code，用于指定只获取这些定义下的数据
	approvalCodesFlag bool
	instanceIds       []string // 审批实例 ID, 用于指定只获取这些实例下的数据，最多支持 20 个
	instanceIdsFlag   bool
	userIds           []string // 审批人 user_id，用于指定只获取这些用户的数据
	userIdsFlag       bool
	status            string // 审批任务状态，用于指定获取该状态下的数据
	statusFlag        bool
}

func NewListExternalTaskReqBodyBuilder() *ListExternalTaskReqBodyBuilder {
	builder := &ListExternalTaskReqBodyBuilder{}
	return builder
}

// 审批定义 Code，用于指定只获取这些定义下的数据
//
//示例值：B7B65FFE-C2GC-452F-9F0F-9AA8352363D6
func (builder *ListExternalTaskReqBodyBuilder) ApprovalCodes(approvalCodes []string) *ListExternalTaskReqBodyBuilder {
	builder.approvalCodes = approvalCodes
	builder.approvalCodesFlag = true
	return builder
}

// 审批实例 ID, 用于指定只获取这些实例下的数据，最多支持 20 个
//
//示例值：oa_159160304
func (builder *ListExternalTaskReqBodyBuilder) InstanceIds(instanceIds []string) *ListExternalTaskReqBodyBuilder {
	builder.instanceIds = instanceIds
	builder.instanceIdsFlag = true
	return builder
}

// 审批人 user_id，用于指定只获取这些用户的数据
//
//示例值：112321
func (builder *ListExternalTaskReqBodyBuilder) UserIds(userIds []string) *ListExternalTaskReqBodyBuilder {
	builder.userIds = userIds
	builder.userIdsFlag = true
	return builder
}

// 审批任务状态，用于指定获取该状态下的数据
//
//示例值：PENDING
func (builder *ListExternalTaskReqBodyBuilder) Status(status string) *ListExternalTaskReqBodyBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

func (builder *ListExternalTaskReqBodyBuilder) Build() *ListExternalTaskReqBody {
	req := &ListExternalTaskReqBody{}
	if builder.approvalCodesFlag {
		req.ApprovalCodes = builder.approvalCodes
	}
	if builder.instanceIdsFlag {
		req.InstanceIds = builder.instanceIds
	}
	if builder.userIdsFlag {
		req.UserIds = builder.userIds
	}
	if builder.statusFlag {
		req.Status = &builder.status
	}
	return req
}

type ListExternalTaskPathReqBodyBuilder struct {
	approvalCodes     []string // 审批定义 Code，用于指定只获取这些定义下的数据
	approvalCodesFlag bool
	instanceIds       []string // 审批实例 ID, 用于指定只获取这些实例下的数据，最多支持 20 个
	instanceIdsFlag   bool
	userIds           []string // 审批人 user_id，用于指定只获取这些用户的数据
	userIdsFlag       bool
	status            string // 审批任务状态，用于指定获取该状态下的数据
	statusFlag        bool
}

func NewListExternalTaskPathReqBodyBuilder() *ListExternalTaskPathReqBodyBuilder {
	builder := &ListExternalTaskPathReqBodyBuilder{}
	return builder
}

// 审批定义 Code，用于指定只获取这些定义下的数据
//
// 示例值：B7B65FFE-C2GC-452F-9F0F-9AA8352363D6
func (builder *ListExternalTaskPathReqBodyBuilder) ApprovalCodes(approvalCodes []string) *ListExternalTaskPathReqBodyBuilder {
	builder.approvalCodes = approvalCodes
	builder.approvalCodesFlag = true
	return builder
}

// 审批实例 ID, 用于指定只获取这些实例下的数据，最多支持 20 个
//
// 示例值：oa_159160304
func (builder *ListExternalTaskPathReqBodyBuilder) InstanceIds(instanceIds []string) *ListExternalTaskPathReqBodyBuilder {
	builder.instanceIds = instanceIds
	builder.instanceIdsFlag = true
	return builder
}

// 审批人 user_id，用于指定只获取这些用户的数据
//
// 示例值：112321
func (builder *ListExternalTaskPathReqBodyBuilder) UserIds(userIds []string) *ListExternalTaskPathReqBodyBuilder {
	builder.userIds = userIds
	builder.userIdsFlag = true
	return builder
}

// 审批任务状态，用于指定获取该状态下的数据
//
// 示例值：PENDING
func (builder *ListExternalTaskPathReqBodyBuilder) Status(status string) *ListExternalTaskPathReqBodyBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

func (builder *ListExternalTaskPathReqBodyBuilder) Build() (*ListExternalTaskReqBody, error) {
	req := &ListExternalTaskReqBody{}
	if builder.approvalCodesFlag {
		req.ApprovalCodes = builder.approvalCodes
	}
	if builder.instanceIdsFlag {
		req.InstanceIds = builder.instanceIds
	}
	if builder.userIdsFlag {
		req.UserIds = builder.userIds
	}
	if builder.statusFlag {
		req.Status = &builder.status
	}
	return req, nil
}

type ListExternalTaskReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *ListExternalTaskReqBody
	limit  int // 最大返回多少记录，当使用迭代器访问时才有效
}

func NewListExternalTaskReqBuilder() *ListExternalTaskReqBuilder {
	builder := &ListExternalTaskReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 最大返回多少记录，当使用迭代器访问时才有效
func (builder *ListExternalTaskReqBuilder) Limit(limit int) *ListExternalTaskReqBuilder {
	builder.limit = limit
	return builder
}

// 分页大小
//
// 示例值：100
func (builder *ListExternalTaskReqBuilder) PageSize(pageSize int) *ListExternalTaskReqBuilder {
	builder.apiReq.QueryParams.Set("page_size", fmt.Sprint(pageSize))
	return builder
}

// 分页标记，第一次请求不填，表示从头开始遍历；分页查询结果还有更多项时会同时返回新的 page_token，下次遍历可采用该 page_token 获取查询结果
//
// 示例值：nF1ZXJ5VGhlbkZldGNoCgAAAAAA6PZwFmUzSldvTC1yU
func (builder *ListExternalTaskReqBuilder) PageToken(pageToken string) *ListExternalTaskReqBuilder {
	builder.apiReq.QueryParams.Set("page_token", fmt.Sprint(pageToken))
	return builder
}

// 该接口用于获取三方审批的状态。用户传入查询条件，接口返回满足条件的审批实例的状态。该接口支持多种参数的组合，包括如下组合：;;1.通过 instance_ids 获取指定实例的任务状态;;2.通过 user_ids 获取指定用户的任务状态;;3.通过 status 获取指定状态的所有任务;;4.通过page_token获取下一批数据
func (builder *ListExternalTaskReqBuilder) Body(body *ListExternalTaskReqBody) *ListExternalTaskReqBuilder {
	builder.body = body
	return builder
}

func (builder *ListExternalTaskReqBuilder) Build() *ListExternalTaskReq {
	req := &ListExternalTaskReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.Limit = builder.limit
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type ListExternalTaskReqBody struct {
	ApprovalCodes []string `json:"approval_codes,omitempty"` // 审批定义 Code，用于指定只获取这些定义下的数据
	InstanceIds   []string `json:"instance_ids,omitempty"`   // 审批实例 ID, 用于指定只获取这些实例下的数据，最多支持 20 个
	UserIds       []string `json:"user_ids,omitempty"`       // 审批人 user_id，用于指定只获取这些用户的数据
	Status        *string  `json:"status,omitempty"`         // 审批任务状态，用于指定获取该状态下的数据
}

type ListExternalTaskReq struct {
	apiReq *larkcore.ApiReq
	Body   *ListExternalTaskReqBody `body:""`
	Limit  int                      // 最多返回多少记录，只有在使用迭代器访问时，才有效

}

type ListExternalTaskRespData struct {
	Data      []*ExternalTaskList `json:"data,omitempty"`       // 返回数据
	PageToken *string             `json:"page_token,omitempty"` // 翻页 Token
	HasMore   *bool               `json:"has_more,omitempty"`   // 是否有更多任务可供拉取
}

type ListExternalTaskResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *ListExternalTaskRespData `json:"data"` // 业务数据
}

func (resp *ListExternalTaskResp) Success() bool {
	return resp.Code == 0
}

type AddSignInstanceReqBodyBuilder struct {
	userId             string //
	userIdFlag         bool
	approvalCode       string //
	approvalCodeFlag   bool
	instanceCode       string //
	instanceCodeFlag   bool
	taskId             string //
	taskIdFlag         bool
	comment            string //
	commentFlag        bool
	addSignUserIds     []string //
	addSignUserIdsFlag bool
	addSignType        int //
	addSignTypeFlag    bool
	approvalMethod     int //
	approvalMethodFlag bool
}

func NewAddSignInstanceReqBodyBuilder() *AddSignInstanceReqBodyBuilder {
	builder := &AddSignInstanceReqBodyBuilder{}
	return builder
}

//
//
//示例值：
func (builder *AddSignInstanceReqBodyBuilder) UserId(userId string) *AddSignInstanceReqBodyBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

//
//
//示例值：
func (builder *AddSignInstanceReqBodyBuilder) ApprovalCode(approvalCode string) *AddSignInstanceReqBodyBuilder {
	builder.approvalCode = approvalCode
	builder.approvalCodeFlag = true
	return builder
}

//
//
//示例值：
func (builder *AddSignInstanceReqBodyBuilder) InstanceCode(instanceCode string) *AddSignInstanceReqBodyBuilder {
	builder.instanceCode = instanceCode
	builder.instanceCodeFlag = true
	return builder
}

//
//
//示例值：
func (builder *AddSignInstanceReqBodyBuilder) TaskId(taskId string) *AddSignInstanceReqBodyBuilder {
	builder.taskId = taskId
	builder.taskIdFlag = true
	return builder
}

//
//
//示例值：
func (builder *AddSignInstanceReqBodyBuilder) Comment(comment string) *AddSignInstanceReqBodyBuilder {
	builder.comment = comment
	builder.commentFlag = true
	return builder
}

//
//
//示例值：
func (builder *AddSignInstanceReqBodyBuilder) AddSignUserIds(addSignUserIds []string) *AddSignInstanceReqBodyBuilder {
	builder.addSignUserIds = addSignUserIds
	builder.addSignUserIdsFlag = true
	return builder
}

//
//
//示例值：1
func (builder *AddSignInstanceReqBodyBuilder) AddSignType(addSignType int) *AddSignInstanceReqBodyBuilder {
	builder.addSignType = addSignType
	builder.addSignTypeFlag = true
	return builder
}

//
//
//示例值：1
func (builder *AddSignInstanceReqBodyBuilder) ApprovalMethod(approvalMethod int) *AddSignInstanceReqBodyBuilder {
	builder.approvalMethod = approvalMethod
	builder.approvalMethodFlag = true
	return builder
}

func (builder *AddSignInstanceReqBodyBuilder) Build() *AddSignInstanceReqBody {
	req := &AddSignInstanceReqBody{}
	if builder.userIdFlag {
		req.UserId = &builder.userId
	}
	if builder.approvalCodeFlag {
		req.ApprovalCode = &builder.approvalCode
	}
	if builder.instanceCodeFlag {
		req.InstanceCode = &builder.instanceCode
	}
	if builder.taskIdFlag {
		req.TaskId = &builder.taskId
	}
	if builder.commentFlag {
		req.Comment = &builder.comment
	}
	if builder.addSignUserIdsFlag {
		req.AddSignUserIds = builder.addSignUserIds
	}
	if builder.addSignTypeFlag {
		req.AddSignType = &builder.addSignType
	}
	if builder.approvalMethodFlag {
		req.ApprovalMethod = &builder.approvalMethod
	}
	return req
}

type AddSignInstancePathReqBodyBuilder struct {
	userId             string //
	userIdFlag         bool
	approvalCode       string //
	approvalCodeFlag   bool
	instanceCode       string //
	instanceCodeFlag   bool
	taskId             string //
	taskIdFlag         bool
	comment            string //
	commentFlag        bool
	addSignUserIds     []string //
	addSignUserIdsFlag bool
	addSignType        int //
	addSignTypeFlag    bool
	approvalMethod     int //
	approvalMethodFlag bool
}

func NewAddSignInstancePathReqBodyBuilder() *AddSignInstancePathReqBodyBuilder {
	builder := &AddSignInstancePathReqBodyBuilder{}
	return builder
}

//
//
// 示例值：
func (builder *AddSignInstancePathReqBodyBuilder) UserId(userId string) *AddSignInstancePathReqBodyBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

//
//
// 示例值：
func (builder *AddSignInstancePathReqBodyBuilder) ApprovalCode(approvalCode string) *AddSignInstancePathReqBodyBuilder {
	builder.approvalCode = approvalCode
	builder.approvalCodeFlag = true
	return builder
}

//
//
// 示例值：
func (builder *AddSignInstancePathReqBodyBuilder) InstanceCode(instanceCode string) *AddSignInstancePathReqBodyBuilder {
	builder.instanceCode = instanceCode
	builder.instanceCodeFlag = true
	return builder
}

//
//
// 示例值：
func (builder *AddSignInstancePathReqBodyBuilder) TaskId(taskId string) *AddSignInstancePathReqBodyBuilder {
	builder.taskId = taskId
	builder.taskIdFlag = true
	return builder
}

//
//
// 示例值：
func (builder *AddSignInstancePathReqBodyBuilder) Comment(comment string) *AddSignInstancePathReqBodyBuilder {
	builder.comment = comment
	builder.commentFlag = true
	return builder
}

//
//
// 示例值：
func (builder *AddSignInstancePathReqBodyBuilder) AddSignUserIds(addSignUserIds []string) *AddSignInstancePathReqBodyBuilder {
	builder.addSignUserIds = addSignUserIds
	builder.addSignUserIdsFlag = true
	return builder
}

//
//
// 示例值：1
func (builder *AddSignInstancePathReqBodyBuilder) AddSignType(addSignType int) *AddSignInstancePathReqBodyBuilder {
	builder.addSignType = addSignType
	builder.addSignTypeFlag = true
	return builder
}

//
//
// 示例值：1
func (builder *AddSignInstancePathReqBodyBuilder) ApprovalMethod(approvalMethod int) *AddSignInstancePathReqBodyBuilder {
	builder.approvalMethod = approvalMethod
	builder.approvalMethodFlag = true
	return builder
}

func (builder *AddSignInstancePathReqBodyBuilder) Build() (*AddSignInstanceReqBody, error) {
	req := &AddSignInstanceReqBody{}
	if builder.userIdFlag {
		req.UserId = &builder.userId
	}
	if builder.approvalCodeFlag {
		req.ApprovalCode = &builder.approvalCode
	}
	if builder.instanceCodeFlag {
		req.InstanceCode = &builder.instanceCode
	}
	if builder.taskIdFlag {
		req.TaskId = &builder.taskId
	}
	if builder.commentFlag {
		req.Comment = &builder.comment
	}
	if builder.addSignUserIdsFlag {
		req.AddSignUserIds = builder.addSignUserIds
	}
	if builder.addSignTypeFlag {
		req.AddSignType = &builder.addSignType
	}
	if builder.approvalMethodFlag {
		req.ApprovalMethod = &builder.approvalMethod
	}
	return req, nil
}

type AddSignInstanceReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *AddSignInstanceReqBody
}

func NewAddSignInstanceReqBuilder() *AddSignInstanceReqBuilder {
	builder := &AddSignInstanceReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

//
func (builder *AddSignInstanceReqBuilder) Body(body *AddSignInstanceReqBody) *AddSignInstanceReqBuilder {
	builder.body = body
	return builder
}

func (builder *AddSignInstanceReqBuilder) Build() *AddSignInstanceReq {
	req := &AddSignInstanceReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.Body = builder.body
	return req
}

type AddSignInstanceReqBody struct {
	UserId         *string  `json:"user_id,omitempty"`           //
	ApprovalCode   *string  `json:"approval_code,omitempty"`     //
	InstanceCode   *string  `json:"instance_code,omitempty"`     //
	TaskId         *string  `json:"task_id,omitempty"`           //
	Comment        *string  `json:"comment,omitempty"`           //
	AddSignUserIds []string `json:"add_sign_user_ids,omitempty"` //
	AddSignType    *int     `json:"add_sign_type,omitempty"`     //
	ApprovalMethod *int     `json:"approval_method,omitempty"`   //
}

type AddSignInstanceReq struct {
	apiReq *larkcore.ApiReq
	Body   *AddSignInstanceReqBody `body:""`
}

type AddSignInstanceResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *AddSignInstanceResp) Success() bool {
	return resp.Code == 0
}

type CancelInstanceReqBuilder struct {
	apiReq         *larkcore.ApiReq
	instanceCancel *InstanceCancel
}

func NewCancelInstanceReqBuilder() *CancelInstanceReqBuilder {
	builder := &CancelInstanceReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *CancelInstanceReqBuilder) UserIdType(userIdType string) *CancelInstanceReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 对于状态为“审批中”的单个审批实例进行撤销操作，撤销后审批流程结束
func (builder *CancelInstanceReqBuilder) InstanceCancel(instanceCancel *InstanceCancel) *CancelInstanceReqBuilder {
	builder.instanceCancel = instanceCancel
	return builder
}

func (builder *CancelInstanceReqBuilder) Build() *CancelInstanceReq {
	req := &CancelInstanceReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.instanceCancel
	return req
}

type CancelInstanceReq struct {
	apiReq         *larkcore.ApiReq
	InstanceCancel *InstanceCancel `body:""`
}

type CancelInstanceResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *CancelInstanceResp) Success() bool {
	return resp.Code == 0
}

type CcInstanceReqBuilder struct {
	apiReq     *larkcore.ApiReq
	instanceCc *InstanceCc
}

func NewCcInstanceReqBuilder() *CcInstanceReqBuilder {
	builder := &CcInstanceReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *CcInstanceReqBuilder) UserIdType(userIdType string) *CcInstanceReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 通过接口可以将当前审批实例抄送给其他人。
func (builder *CcInstanceReqBuilder) InstanceCc(instanceCc *InstanceCc) *CcInstanceReqBuilder {
	builder.instanceCc = instanceCc
	return builder
}

func (builder *CcInstanceReqBuilder) Build() *CcInstanceReq {
	req := &CcInstanceReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.instanceCc
	return req
}

type CcInstanceReq struct {
	apiReq     *larkcore.ApiReq
	InstanceCc *InstanceCc `body:""`
}

type CcInstanceResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *CcInstanceResp) Success() bool {
	return resp.Code == 0
}

type CreateInstanceReqBuilder struct {
	apiReq         *larkcore.ApiReq
	instanceCreate *InstanceCreate
}

func NewCreateInstanceReqBuilder() *CreateInstanceReqBuilder {
	builder := &CreateInstanceReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 创建一个审批实例，调用方需对审批定义的表单有详细了解，将按照定义的表单结构，将表单 Value 通过接口传入
func (builder *CreateInstanceReqBuilder) InstanceCreate(instanceCreate *InstanceCreate) *CreateInstanceReqBuilder {
	builder.instanceCreate = instanceCreate
	return builder
}

func (builder *CreateInstanceReqBuilder) Build() *CreateInstanceReq {
	req := &CreateInstanceReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.Body = builder.instanceCreate
	return req
}

type CreateInstanceReq struct {
	apiReq         *larkcore.ApiReq
	InstanceCreate *InstanceCreate `body:""`
}

type CreateInstanceRespData struct {
	InstanceCode *string `json:"instance_code,omitempty"` // 审批实例 Code
}

type CreateInstanceResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *CreateInstanceRespData `json:"data"` // 业务数据
}

func (resp *CreateInstanceResp) Success() bool {
	return resp.Code == 0
}

type GetInstanceReqBuilder struct {
	apiReq *larkcore.ApiReq
}

func NewGetInstanceReqBuilder() *GetInstanceReqBuilder {
	builder := &GetInstanceReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 审批实例 Code, 若在创建的时候传了uuid, 也可以通过传uuid获取
//
// 示例值：81D31358-93AF-92D6-7425-01A5D67C4E71
func (builder *GetInstanceReqBuilder) InstanceId(instanceId string) *GetInstanceReqBuilder {
	builder.apiReq.PathParams.Set("instance_id", fmt.Sprint(instanceId))
	return builder
}

// 语言
//
// 示例值：zh-CN
func (builder *GetInstanceReqBuilder) Locale(locale string) *GetInstanceReqBuilder {
	builder.apiReq.QueryParams.Set("locale", fmt.Sprint(locale))
	return builder
}

// 发起审批用户id，仅自建应用可返回
//
// 示例值：f7cb567e
func (builder *GetInstanceReqBuilder) UserId(userId string) *GetInstanceReqBuilder {
	builder.apiReq.QueryParams.Set("user_id", fmt.Sprint(userId))
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：user_id
func (builder *GetInstanceReqBuilder) UserIdType(userIdType string) *GetInstanceReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

func (builder *GetInstanceReqBuilder) Build() *GetInstanceReq {
	req := &GetInstanceReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type GetInstanceReq struct {
	apiReq *larkcore.ApiReq
}

type GetInstanceRespData struct {
	ApprovalName         *string             `json:"approval_name,omitempty"`          // 审批名称
	StartTime            *string             `json:"start_time,omitempty"`             // 审批创建时间
	EndTime              *string             `json:"end_time,omitempty"`               // 审批完成时间，未完成为 0
	UserId               *string             `json:"user_id,omitempty"`                // 发起审批用户
	OpenId               *string             `json:"open_id,omitempty"`                // 发起审批用户 open id
	SerialNumber         *string             `json:"serial_number,omitempty"`          // 审批单编号
	DepartmentId         *string             `json:"department_id,omitempty"`          // 发起审批用户所在部门
	Status               *string             `json:"status,omitempty"`                 // 审批实例状态
	Uuid                 *string             `json:"uuid,omitempty"`                   // 用户的唯一标识id
	Form                 *string             `json:"form,omitempty"`                   // json字符串，控件值详情见下方
	TaskList             []*InstanceTask     `json:"task_list,omitempty"`              // 审批任务列表
	CommentList          []*InstanceComment  `json:"comment_list,omitempty"`           // 评论列表
	Timeline             []*InstanceTimeline `json:"timeline,omitempty"`               // 审批动态
	ModifiedInstanceCode *string             `json:"modified_instance_code,omitempty"` // 修改的原实例 code,仅在查询修改实例时显示该字段
	RevertedInstanceCode *string             `json:"reverted_instance_code,omitempty"` // 撤销的原实例 code,仅在查询撤销实例时显示该字段
	ApprovalCode         *string             `json:"approval_code,omitempty"`          // 审批定义 Code
	Reverted             *bool               `json:"reverted,omitempty"`               // 单据是否被撤销
}

type GetInstanceResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *GetInstanceRespData `json:"data"` // 业务数据
}

func (resp *GetInstanceResp) Success() bool {
	return resp.Code == 0
}

type ListInstanceReqBuilder struct {
	apiReq *larkcore.ApiReq
	limit  int // 最大返回多少记录，当使用迭代器访问时才有效
}

func NewListInstanceReqBuilder() *ListInstanceReqBuilder {
	builder := &ListInstanceReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 最大返回多少记录，当使用迭代器访问时才有效
func (builder *ListInstanceReqBuilder) Limit(limit int) *ListInstanceReqBuilder {
	builder.limit = limit
	return builder
}

// 分页大小
//
// 示例值：100
func (builder *ListInstanceReqBuilder) PageSize(pageSize int) *ListInstanceReqBuilder {
	builder.apiReq.QueryParams.Set("page_size", fmt.Sprint(pageSize))
	return builder
}

// 分页标记，第一次请求不填，表示从头开始遍历；分页查询结果还有更多项时会同时返回新的 page_token，下次遍历可采用该 page_token 获取查询结果
//
// 示例值：nF1ZXJ5VGhlbkZldGNoCgAAAAAA6PZwFmUzSldvTC1yU
func (builder *ListInstanceReqBuilder) PageToken(pageToken string) *ListInstanceReqBuilder {
	builder.apiReq.QueryParams.Set("page_token", fmt.Sprint(pageToken))
	return builder
}

// 审批定义唯一标识
//
// 示例值：7C468A54-8745-2245-9675-08B7C63E7A85
func (builder *ListInstanceReqBuilder) ApprovalCode(approvalCode string) *ListInstanceReqBuilder {
	builder.apiReq.QueryParams.Set("approval_code", fmt.Sprint(approvalCode))
	return builder
}

// 审批实例创建时间区间（毫秒）
//
// 示例值：1567690398020
func (builder *ListInstanceReqBuilder) StartTime(startTime string) *ListInstanceReqBuilder {
	builder.apiReq.QueryParams.Set("start_time", fmt.Sprint(startTime))
	return builder
}

// 审批实例创建时间区间（毫秒）
//
// 示例值：1567690398020
func (builder *ListInstanceReqBuilder) EndTime(endTime string) *ListInstanceReqBuilder {
	builder.apiReq.QueryParams.Set("end_time", fmt.Sprint(endTime))
	return builder
}

func (builder *ListInstanceReqBuilder) Build() *ListInstanceReq {
	req := &ListInstanceReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.Limit = builder.limit
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type ListInstanceReq struct {
	apiReq *larkcore.ApiReq
	Limit  int // 最多返回多少记录，只有在使用迭代器访问时，才有效

}

type ListInstanceRespData struct {
	InstanceCodeList []string `json:"instance_code_list,omitempty"` // 审批实例 Code
	PageToken        *string  `json:"page_token,omitempty"`         // 翻页 Token
	HasMore          *bool    `json:"has_more,omitempty"`           // 是否有更多任务可供拉取
}

type ListInstanceResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *ListInstanceRespData `json:"data"` // 业务数据
}

func (resp *ListInstanceResp) Success() bool {
	return resp.Code == 0
}

type PreviewInstanceReqBodyBuilder struct {
	userId           string // 用户id
	userIdFlag       bool
	approvalCode     string // 审批定义code
	approvalCodeFlag bool
	departmentId     string // 部门id
	departmentIdFlag bool
	form             string // 表单数据
	formFlag         bool
	instanceCode     string // 审批实例code
	instanceCodeFlag bool
	locale           string // 语言类型
	localeFlag       bool
	taskId           string // 任务id
	taskIdFlag       bool
}

func NewPreviewInstanceReqBodyBuilder() *PreviewInstanceReqBodyBuilder {
	builder := &PreviewInstanceReqBodyBuilder{}
	return builder
}

// 用户id
//
//示例值：
func (builder *PreviewInstanceReqBodyBuilder) UserId(userId string) *PreviewInstanceReqBodyBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 审批定义code
//
//示例值：
func (builder *PreviewInstanceReqBodyBuilder) ApprovalCode(approvalCode string) *PreviewInstanceReqBodyBuilder {
	builder.approvalCode = approvalCode
	builder.approvalCodeFlag = true
	return builder
}

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

// 表单数据
//
//示例值：
func (builder *PreviewInstanceReqBodyBuilder) Form(form string) *PreviewInstanceReqBodyBuilder {
	builder.form = form
	builder.formFlag = true
	return builder
}

// 审批实例code
//
//示例值：
func (builder *PreviewInstanceReqBodyBuilder) InstanceCode(instanceCode string) *PreviewInstanceReqBodyBuilder {
	builder.instanceCode = instanceCode
	builder.instanceCodeFlag = true
	return builder
}

// 语言类型
//
//示例值：zh-CN: 中文 en-US: 英文
func (builder *PreviewInstanceReqBodyBuilder) Locale(locale string) *PreviewInstanceReqBodyBuilder {
	builder.locale = locale
	builder.localeFlag = true
	return builder
}

// 任务id
//
//示例值：
func (builder *PreviewInstanceReqBodyBuilder) TaskId(taskId string) *PreviewInstanceReqBodyBuilder {
	builder.taskId = taskId
	builder.taskIdFlag = true
	return builder
}

func (builder *PreviewInstanceReqBodyBuilder) Build() *PreviewInstanceReqBody {
	req := &PreviewInstanceReqBody{}
	if builder.userIdFlag {
		req.UserId = &builder.userId
	}
	if builder.approvalCodeFlag {
		req.ApprovalCode = &builder.approvalCode
	}
	if builder.departmentIdFlag {
		req.DepartmentId = &builder.departmentId
	}
	if builder.formFlag {
		req.Form = &builder.form
	}
	if builder.instanceCodeFlag {
		req.InstanceCode = &builder.instanceCode
	}
	if builder.localeFlag {
		req.Locale = &builder.locale
	}
	if builder.taskIdFlag {
		req.TaskId = &builder.taskId
	}
	return req
}

type PreviewInstancePathReqBodyBuilder struct {
	userId           string // 用户id
	userIdFlag       bool
	approvalCode     string // 审批定义code
	approvalCodeFlag bool
	departmentId     string // 部门id
	departmentIdFlag bool
	form             string // 表单数据
	formFlag         bool
	instanceCode     string // 审批实例code
	instanceCodeFlag bool
	locale           string // 语言类型
	localeFlag       bool
	taskId           string // 任务id
	taskIdFlag       bool
}

func NewPreviewInstancePathReqBodyBuilder() *PreviewInstancePathReqBodyBuilder {
	builder := &PreviewInstancePathReqBodyBuilder{}
	return builder
}

// 用户id
//
// 示例值：
func (builder *PreviewInstancePathReqBodyBuilder) UserId(userId string) *PreviewInstancePathReqBodyBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 审批定义code
//
// 示例值：
func (builder *PreviewInstancePathReqBodyBuilder) ApprovalCode(approvalCode string) *PreviewInstancePathReqBodyBuilder {
	builder.approvalCode = approvalCode
	builder.approvalCodeFlag = true
	return builder
}

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

// 表单数据
//
// 示例值：
func (builder *PreviewInstancePathReqBodyBuilder) Form(form string) *PreviewInstancePathReqBodyBuilder {
	builder.form = form
	builder.formFlag = true
	return builder
}

// 审批实例code
//
// 示例值：
func (builder *PreviewInstancePathReqBodyBuilder) InstanceCode(instanceCode string) *PreviewInstancePathReqBodyBuilder {
	builder.instanceCode = instanceCode
	builder.instanceCodeFlag = true
	return builder
}

// 语言类型
//
// 示例值：zh-CN: 中文 en-US: 英文
func (builder *PreviewInstancePathReqBodyBuilder) Locale(locale string) *PreviewInstancePathReqBodyBuilder {
	builder.locale = locale
	builder.localeFlag = true
	return builder
}

// 任务id
//
// 示例值：
func (builder *PreviewInstancePathReqBodyBuilder) TaskId(taskId string) *PreviewInstancePathReqBodyBuilder {
	builder.taskId = taskId
	builder.taskIdFlag = true
	return builder
}

func (builder *PreviewInstancePathReqBodyBuilder) Build() (*PreviewInstanceReqBody, error) {
	req := &PreviewInstanceReqBody{}
	if builder.userIdFlag {
		req.UserId = &builder.userId
	}
	if builder.approvalCodeFlag {
		req.ApprovalCode = &builder.approvalCode
	}
	if builder.departmentIdFlag {
		req.DepartmentId = &builder.departmentId
	}
	if builder.formFlag {
		req.Form = &builder.form
	}
	if builder.instanceCodeFlag {
		req.InstanceCode = &builder.instanceCode
	}
	if builder.localeFlag {
		req.Locale = &builder.locale
	}
	if builder.taskIdFlag {
		req.TaskId = &builder.taskId
	}
	return req, nil
}

type PreviewInstanceReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *PreviewInstanceReqBody
}

func NewPreviewInstanceReqBuilder() *PreviewInstanceReqBuilder {
	builder := &PreviewInstanceReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// open_id(ou_开头)，union_id(on_开头)，user_id(字符串)。user_id_type不填默认为open_id
//
// 示例值：
func (builder *PreviewInstanceReqBuilder) UserIdType(userIdType string) *PreviewInstanceReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

//
func (builder *PreviewInstanceReqBuilder) Body(body *PreviewInstanceReqBody) *PreviewInstanceReqBuilder {
	builder.body = body
	return builder
}

func (builder *PreviewInstanceReqBuilder) Build() *PreviewInstanceReq {
	req := &PreviewInstanceReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.body
	return req
}

type PreviewInstanceReqBody struct {
	UserId       *string `json:"user_id,omitempty"`       // 用户id
	ApprovalCode *string `json:"approval_code,omitempty"` // 审批定义code
	DepartmentId *string `json:"department_id,omitempty"` // 部门id
	Form         *string `json:"form,omitempty"`          // 表单数据
	InstanceCode *string `json:"instance_code,omitempty"` // 审批实例code
	Locale       *string `json:"locale,omitempty"`        // 语言类型
	TaskId       *string `json:"task_id,omitempty"`       // 任务id
}

type PreviewInstanceReq struct {
	apiReq *larkcore.ApiReq
	Body   *PreviewInstanceReqBody `body:""`
}

type PreviewInstanceRespData struct {
	PreviewNodes []*PreviewNode `json:"preview_nodes,omitempty"` //
}

type PreviewInstanceResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *PreviewInstanceRespData `json:"data"` // 业务数据
}

func (resp *PreviewInstanceResp) Success() bool {
	return resp.Code == 0
}

type QueryInstanceReqBuilder struct {
	apiReq         *larkcore.ApiReq
	instanceSearch *InstanceSearch
	limit          int // 最大返回多少记录，当使用迭代器访问时才有效
}

func NewQueryInstanceReqBuilder() *QueryInstanceReqBuilder {
	builder := &QueryInstanceReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 最大返回多少记录，当使用迭代器访问时才有效
func (builder *QueryInstanceReqBuilder) Limit(limit int) *QueryInstanceReqBuilder {
	builder.limit = limit
	return builder
}

// 分页大小
//
// 示例值：10
func (builder *QueryInstanceReqBuilder) PageSize(pageSize int) *QueryInstanceReqBuilder {
	builder.apiReq.QueryParams.Set("page_size", fmt.Sprint(pageSize))
	return builder
}

// 分页标记，第一次请求不填，表示从头开始遍历；分页查询结果还有更多项时会同时返回新的 page_token，下次遍历可采用该 page_token 获取查询结果
//
// 示例值：nF1ZXJ5VGhlbkZldGNoCgAAAAAA6PZwFmUzSldvTC1yU
func (builder *QueryInstanceReqBuilder) PageToken(pageToken string) *QueryInstanceReqBuilder {
	builder.apiReq.QueryParams.Set("page_token", fmt.Sprint(pageToken))
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *QueryInstanceReqBuilder) UserIdType(userIdType string) *QueryInstanceReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 该接口通过不同条件查询审批系统中符合条件的审批实例列表。
func (builder *QueryInstanceReqBuilder) InstanceSearch(instanceSearch *InstanceSearch) *QueryInstanceReqBuilder {
	builder.instanceSearch = instanceSearch
	return builder
}

func (builder *QueryInstanceReqBuilder) Build() *QueryInstanceReq {
	req := &QueryInstanceReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.Limit = builder.limit
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.instanceSearch
	return req
}

type QueryInstanceReq struct {
	apiReq         *larkcore.ApiReq
	InstanceSearch *InstanceSearch `body:""`
	Limit          int             // 最多返回多少记录，只有在使用迭代器访问时，才有效

}

type QueryInstanceRespData struct {
	Count        *int                  `json:"count,omitempty"`         // 查询返回条数
	InstanceList []*InstanceSearchItem `json:"instance_list,omitempty"` // 审批实例列表
	PageToken    *string               `json:"page_token,omitempty"`    // 翻页 Token
	HasMore      *bool                 `json:"has_more,omitempty"`      // 是否有更多任务可供拉取
}

type QueryInstanceResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *QueryInstanceRespData `json:"data"` // 业务数据
}

func (resp *QueryInstanceResp) Success() bool {
	return resp.Code == 0
}

type SearchCcInstanceReqBuilder struct {
	apiReq   *larkcore.ApiReq
	ccSearch *CcSearch
}

func NewSearchCcInstanceReqBuilder() *SearchCcInstanceReqBuilder {
	builder := &SearchCcInstanceReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 分页大小
//
// 示例值：10
func (builder *SearchCcInstanceReqBuilder) PageSize(pageSize int) *SearchCcInstanceReqBuilder {
	builder.apiReq.QueryParams.Set("page_size", fmt.Sprint(pageSize))
	return builder
}

// 分页标记，第一次请求不填，表示从头开始遍历；分页查询结果还有更多项时会同时返回新的 page_token，下次遍历可采用该 page_token 获取查询结果
//
// 示例值：nF1ZXJ5VGhlbkZldGNoCgAAAAAA6PZwFmUzSldvTC1yU
func (builder *SearchCcInstanceReqBuilder) PageToken(pageToken string) *SearchCcInstanceReqBuilder {
	builder.apiReq.QueryParams.Set("page_token", fmt.Sprint(pageToken))
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *SearchCcInstanceReqBuilder) UserIdType(userIdType string) *SearchCcInstanceReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 该接口通过不同条件查询审批系统中符合条件的审批抄送列表。
func (builder *SearchCcInstanceReqBuilder) CcSearch(ccSearch *CcSearch) *SearchCcInstanceReqBuilder {
	builder.ccSearch = ccSearch
	return builder
}

func (builder *SearchCcInstanceReqBuilder) Build() *SearchCcInstanceReq {
	req := &SearchCcInstanceReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.ccSearch
	return req
}

type SearchCcInstanceReq struct {
	apiReq   *larkcore.ApiReq
	CcSearch *CcSearch `body:""`
}

type SearchCcInstanceRespData struct {
	Count     *int            `json:"count,omitempty"`      // 查询返回条数
	CcList    []*CcSearchItem `json:"cc_list,omitempty"`    // 审批实例列表
	PageToken *string         `json:"page_token,omitempty"` // 翻页 Token
	HasMore   *bool           `json:"has_more,omitempty"`   // 是否有更多任务可供拉取
}

type SearchCcInstanceResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *SearchCcInstanceRespData `json:"data"` // 业务数据
}

func (resp *SearchCcInstanceResp) Success() bool {
	return resp.Code == 0
}

type SpecifiedRollbackInstanceReqBuilder struct {
	apiReq            *larkcore.ApiReq
	specifiedRollback *SpecifiedRollback
}

func NewSpecifiedRollbackInstanceReqBuilder() *SpecifiedRollbackInstanceReqBuilder {
	builder := &SpecifiedRollbackInstanceReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *SpecifiedRollbackInstanceReqBuilder) UserIdType(userIdType string) *SpecifiedRollbackInstanceReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 从当前审批任务，退回到已审批的一个或多个任务节点。退回后，已审批节点重新生成审批任务
func (builder *SpecifiedRollbackInstanceReqBuilder) SpecifiedRollback(specifiedRollback *SpecifiedRollback) *SpecifiedRollbackInstanceReqBuilder {
	builder.specifiedRollback = specifiedRollback
	return builder
}

func (builder *SpecifiedRollbackInstanceReqBuilder) Build() *SpecifiedRollbackInstanceReq {
	req := &SpecifiedRollbackInstanceReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.specifiedRollback
	return req
}

type SpecifiedRollbackInstanceReq struct {
	apiReq            *larkcore.ApiReq
	SpecifiedRollback *SpecifiedRollback `body:""`
}

type SpecifiedRollbackInstanceResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *SpecifiedRollbackInstanceResp) Success() bool {
	return resp.Code == 0
}

type CreateInstanceCommentReqBuilder struct {
	apiReq         *larkcore.ApiReq
	commentRequest *CommentRequest
}

func NewCreateInstanceCommentReqBuilder() *CreateInstanceCommentReqBuilder {
	builder := &CreateInstanceCommentReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 审批实例code（或租户自定义审批实例ID）
//
// 示例值：6A123516-FB88-470D-A428-9AF58B71B3C0
func (builder *CreateInstanceCommentReqBuilder) InstanceId(instanceId string) *CreateInstanceCommentReqBuilder {
	builder.apiReq.PathParams.Set("instance_id", fmt.Sprint(instanceId))
	return builder
}

// 用户ID类型，不填默认为open_id
//
// 示例值：user_id
func (builder *CreateInstanceCommentReqBuilder) UserIdType(userIdType string) *CreateInstanceCommentReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 用户ID
//
// 示例值：e5286g26
func (builder *CreateInstanceCommentReqBuilder) UserId(userId string) *CreateInstanceCommentReqBuilder {
	builder.apiReq.QueryParams.Set("user_id", fmt.Sprint(userId))
	return builder
}

// 在某审批实例下创建、修改评论或评论回复（不包含审批同意、拒绝、转交等附加的理由或意见）。
func (builder *CreateInstanceCommentReqBuilder) CommentRequest(commentRequest *CommentRequest) *CreateInstanceCommentReqBuilder {
	builder.commentRequest = commentRequest
	return builder
}

func (builder *CreateInstanceCommentReqBuilder) Build() *CreateInstanceCommentReq {
	req := &CreateInstanceCommentReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.commentRequest
	return req
}

type CreateInstanceCommentReq struct {
	apiReq         *larkcore.ApiReq
	CommentRequest *CommentRequest `body:""`
}

type CreateInstanceCommentRespData struct {
	CommentId *string `json:"comment_id,omitempty"` // 保存成功的comment_id
}

type CreateInstanceCommentResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *CreateInstanceCommentRespData `json:"data"` // 业务数据
}

func (resp *CreateInstanceCommentResp) Success() bool {
	return resp.Code == 0
}

type DeleteInstanceCommentReqBuilder struct {
	apiReq *larkcore.ApiReq
}

func NewDeleteInstanceCommentReqBuilder() *DeleteInstanceCommentReqBuilder {
	builder := &DeleteInstanceCommentReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 审批实例code（或者租户自定义审批实例ID）
//
// 示例值：6A123516-FB88-470D-A428-9AF58B71B3C0
func (builder *DeleteInstanceCommentReqBuilder) InstanceId(instanceId string) *DeleteInstanceCommentReqBuilder {
	builder.apiReq.PathParams.Set("instance_id", fmt.Sprint(instanceId))
	return builder
}

// 评论ID
//
// 示例值：7081516627711606803
func (builder *DeleteInstanceCommentReqBuilder) CommentId(commentId string) *DeleteInstanceCommentReqBuilder {
	builder.apiReq.PathParams.Set("comment_id", fmt.Sprint(commentId))
	return builder
}

// 用户ID类型，不填默认为open_id
//
// 示例值：user_id
func (builder *DeleteInstanceCommentReqBuilder) UserIdType(userIdType string) *DeleteInstanceCommentReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 根据user_id_type填写用户ID
//
// 示例值：ou_806a18fb5bdf525e38ba219733bdbd73
func (builder *DeleteInstanceCommentReqBuilder) UserId(userId string) *DeleteInstanceCommentReqBuilder {
	builder.apiReq.QueryParams.Set("user_id", fmt.Sprint(userId))
	return builder
}

func (builder *DeleteInstanceCommentReqBuilder) Build() *DeleteInstanceCommentReq {
	req := &DeleteInstanceCommentReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type DeleteInstanceCommentReq struct {
	apiReq *larkcore.ApiReq
}

type DeleteInstanceCommentRespData struct {
	CommentId *string `json:"comment_id,omitempty"` // 删除的评论ID
}

type DeleteInstanceCommentResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *DeleteInstanceCommentRespData `json:"data"` // 业务数据
}

func (resp *DeleteInstanceCommentResp) Success() bool {
	return resp.Code == 0
}

type ListInstanceCommentReqBuilder struct {
	apiReq *larkcore.ApiReq
}

func NewListInstanceCommentReqBuilder() *ListInstanceCommentReqBuilder {
	builder := &ListInstanceCommentReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 审批实例code（或者租户自定义审批实例ID）
//
// 示例值：6A123516-FB88-470D-A428-9AF58B71B3C0
func (builder *ListInstanceCommentReqBuilder) InstanceId(instanceId string) *ListInstanceCommentReqBuilder {
	builder.apiReq.PathParams.Set("instance_id", fmt.Sprint(instanceId))
	return builder
}

// 用户ID类型，不填默认为open_id
//
// 示例值：user_id
func (builder *ListInstanceCommentReqBuilder) UserIdType(userIdType string) *ListInstanceCommentReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 用户ID
//
// 示例值：e5286g26
func (builder *ListInstanceCommentReqBuilder) UserId(userId string) *ListInstanceCommentReqBuilder {
	builder.apiReq.QueryParams.Set("user_id", fmt.Sprint(userId))
	return builder
}

//
//
// 示例值：nF1ZXJ5VGhlbkZldGNoCgAAAAAA6PZwFmUzSldvTC1yU
func (builder *ListInstanceCommentReqBuilder) PageToken(pageToken string) *ListInstanceCommentReqBuilder {
	builder.apiReq.QueryParams.Set("page_token", fmt.Sprint(pageToken))
	return builder
}

//
//
// 示例值：10
func (builder *ListInstanceCommentReqBuilder) PageSize(pageSize int) *ListInstanceCommentReqBuilder {
	builder.apiReq.QueryParams.Set("page_size", fmt.Sprint(pageSize))
	return builder
}

func (builder *ListInstanceCommentReqBuilder) Build() *ListInstanceCommentReq {
	req := &ListInstanceCommentReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type ListInstanceCommentReq struct {
	apiReq *larkcore.ApiReq
}

type ListInstanceCommentRespData struct {
	Comments []*Comment `json:"comments,omitempty"` // 评论数据列表
}

type ListInstanceCommentResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *ListInstanceCommentRespData `json:"data"` // 业务数据
}

func (resp *ListInstanceCommentResp) Success() bool {
	return resp.Code == 0
}

type RemoveInstanceCommentReqBuilder struct {
	apiReq *larkcore.ApiReq
}

func NewRemoveInstanceCommentReqBuilder() *RemoveInstanceCommentReqBuilder {
	builder := &RemoveInstanceCommentReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 审批实例code（或者租户自定义审批实例ID）
//
// 示例值：6A123516-FB88-470D-A428-9AF58B71B3C0
func (builder *RemoveInstanceCommentReqBuilder) InstanceId(instanceId string) *RemoveInstanceCommentReqBuilder {
	builder.apiReq.PathParams.Set("instance_id", fmt.Sprint(instanceId))
	return builder
}

// 用户ID类型，不填默认为open_id
//
// 示例值：user_id
func (builder *RemoveInstanceCommentReqBuilder) UserIdType(userIdType string) *RemoveInstanceCommentReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 根据user_id_type填写用户ID
//
// 示例值：ou_806a18fb5bdf525e38ba219733bdbd73
func (builder *RemoveInstanceCommentReqBuilder) UserId(userId string) *RemoveInstanceCommentReqBuilder {
	builder.apiReq.QueryParams.Set("user_id", fmt.Sprint(userId))
	return builder
}

func (builder *RemoveInstanceCommentReqBuilder) Build() *RemoveInstanceCommentReq {
	req := &RemoveInstanceCommentReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type RemoveInstanceCommentReq struct {
	apiReq *larkcore.ApiReq
}

type RemoveInstanceCommentRespData struct {
	InstanceId *string `json:"instance_id,omitempty"` // 审批实例code
	ExternalId *string `json:"external_id,omitempty"` // 租户自定义审批实例ID
}

type RemoveInstanceCommentResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *RemoveInstanceCommentRespData `json:"data"` // 业务数据
}

func (resp *RemoveInstanceCommentResp) Success() bool {
	return resp.Code == 0
}

type ApproveTaskReqBuilder struct {
	apiReq      *larkcore.ApiReq
	taskApprove *TaskApprove
}

func NewApproveTaskReqBuilder() *ApproveTaskReqBuilder {
	builder := &ApproveTaskReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *ApproveTaskReqBuilder) UserIdType(userIdType string) *ApproveTaskReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 对于单个审批任务进行同意操作。同意后审批流程会流转到下一个审批人。
func (builder *ApproveTaskReqBuilder) TaskApprove(taskApprove *TaskApprove) *ApproveTaskReqBuilder {
	builder.taskApprove = taskApprove
	return builder
}

func (builder *ApproveTaskReqBuilder) Build() *ApproveTaskReq {
	req := &ApproveTaskReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.taskApprove
	return req
}

type ApproveTaskReq struct {
	apiReq      *larkcore.ApiReq
	TaskApprove *TaskApprove `body:""`
}

type ApproveTaskResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *ApproveTaskResp) Success() bool {
	return resp.Code == 0
}

type QueryTaskReqBuilder struct {
	apiReq *larkcore.ApiReq
	limit  int // 最大返回多少记录，当使用迭代器访问时才有效
}

func NewQueryTaskReqBuilder() *QueryTaskReqBuilder {
	builder := &QueryTaskReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 最大返回多少记录，当使用迭代器访问时才有效
func (builder *QueryTaskReqBuilder) Limit(limit int) *QueryTaskReqBuilder {
	builder.limit = limit
	return builder
}

// 分页大小
//
// 示例值：100
func (builder *QueryTaskReqBuilder) PageSize(pageSize int) *QueryTaskReqBuilder {
	builder.apiReq.QueryParams.Set("page_size", fmt.Sprint(pageSize))
	return builder
}

// 分页标记，第一次请求不填，表示从头开始遍历；分页查询结果还有更多项时会同时返回新的 page_token，下次遍历可采用该 page_token 获取查询结果
//
// 示例值：1
func (builder *QueryTaskReqBuilder) PageToken(pageToken string) *QueryTaskReqBuilder {
	builder.apiReq.QueryParams.Set("page_token", fmt.Sprint(pageToken))
	return builder
}

// 需要查询的 User ID
//
// 示例值：example_user_id
func (builder *QueryTaskReqBuilder) UserId(userId string) *QueryTaskReqBuilder {
	builder.apiReq.QueryParams.Set("user_id", fmt.Sprint(userId))
	return builder
}

// 需要查询的任务分组主题，如「待办」、「已办」等
//
// 示例值：1
func (builder *QueryTaskReqBuilder) Topic(topic string) *QueryTaskReqBuilder {
	builder.apiReq.QueryParams.Set("topic", fmt.Sprint(topic))
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *QueryTaskReqBuilder) UserIdType(userIdType string) *QueryTaskReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

func (builder *QueryTaskReqBuilder) Build() *QueryTaskReq {
	req := &QueryTaskReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.Limit = builder.limit
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type QueryTaskReq struct {
	apiReq *larkcore.ApiReq
	Limit  int // 最多返回多少记录，只有在使用迭代器访问时，才有效

}

type QueryTaskRespData struct {
	Tasks     []*Task `json:"tasks,omitempty"`      // 任务列表
	PageToken *string `json:"page_token,omitempty"` // 翻页 Token
	HasMore   *bool   `json:"has_more,omitempty"`   // 是否有更多任务可供拉取
	Count     *Count  `json:"count,omitempty"`      // 列表计数，只在分页第一页返回
}

type QueryTaskResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *QueryTaskRespData `json:"data"` // 业务数据
}

func (resp *QueryTaskResp) Success() bool {
	return resp.Code == 0
}

type RejectTaskReqBuilder struct {
	apiReq      *larkcore.ApiReq
	taskApprove *TaskApprove
}

func NewRejectTaskReqBuilder() *RejectTaskReqBuilder {
	builder := &RejectTaskReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *RejectTaskReqBuilder) UserIdType(userIdType string) *RejectTaskReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 对于单个审批任务进行拒绝操作。拒绝后审批流程结束。
func (builder *RejectTaskReqBuilder) TaskApprove(taskApprove *TaskApprove) *RejectTaskReqBuilder {
	builder.taskApprove = taskApprove
	return builder
}

func (builder *RejectTaskReqBuilder) Build() *RejectTaskReq {
	req := &RejectTaskReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.taskApprove
	return req
}

type RejectTaskReq struct {
	apiReq      *larkcore.ApiReq
	TaskApprove *TaskApprove `body:""`
}

type RejectTaskResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *RejectTaskResp) Success() bool {
	return resp.Code == 0
}

type ResubmitTaskReqBuilder struct {
	apiReq       *larkcore.ApiReq
	taskResubmit *TaskResubmit
}

func NewResubmitTaskReqBuilder() *ResubmitTaskReqBuilder {
	builder := &ResubmitTaskReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *ResubmitTaskReqBuilder) UserIdType(userIdType string) *ResubmitTaskReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 对于单个退回到发起人的审批任务进行重新发起操作。发起后审批流程会流转到下一个审批人。
func (builder *ResubmitTaskReqBuilder) TaskResubmit(taskResubmit *TaskResubmit) *ResubmitTaskReqBuilder {
	builder.taskResubmit = taskResubmit
	return builder
}

func (builder *ResubmitTaskReqBuilder) Build() *ResubmitTaskReq {
	req := &ResubmitTaskReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.taskResubmit
	return req
}

type ResubmitTaskReq struct {
	apiReq       *larkcore.ApiReq
	TaskResubmit *TaskResubmit `body:""`
}

type ResubmitTaskResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *ResubmitTaskResp) Success() bool {
	return resp.Code == 0
}

type SearchTaskReqBuilder struct {
	apiReq     *larkcore.ApiReq
	taskSearch *TaskSearch
}

func NewSearchTaskReqBuilder() *SearchTaskReqBuilder {
	builder := &SearchTaskReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 分页大小
//
// 示例值：10
func (builder *SearchTaskReqBuilder) PageSize(pageSize int) *SearchTaskReqBuilder {
	builder.apiReq.QueryParams.Set("page_size", fmt.Sprint(pageSize))
	return builder
}

// 分页标记，第一次请求不填，表示从头开始遍历；分页查询结果还有更多项时会同时返回新的 page_token，下次遍历可采用该 page_token 获取查询结果
//
// 示例值：nF1ZXJ5VGhlbkZldGNoCgAAAAAA6PZwFmUzSldvTC1yU
func (builder *SearchTaskReqBuilder) PageToken(pageToken string) *SearchTaskReqBuilder {
	builder.apiReq.QueryParams.Set("page_token", fmt.Sprint(pageToken))
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *SearchTaskReqBuilder) UserIdType(userIdType string) *SearchTaskReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 该接口通过不同条件查询审批系统中符合条件的审批任务列表
func (builder *SearchTaskReqBuilder) TaskSearch(taskSearch *TaskSearch) *SearchTaskReqBuilder {
	builder.taskSearch = taskSearch
	return builder
}

func (builder *SearchTaskReqBuilder) Build() *SearchTaskReq {
	req := &SearchTaskReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.taskSearch
	return req
}

type SearchTaskReq struct {
	apiReq     *larkcore.ApiReq
	TaskSearch *TaskSearch `body:""`
}

type SearchTaskRespData struct {
	Count     *int              `json:"count,omitempty"`      // 查询返回条数
	TaskList  []*TaskSearchItem `json:"task_list,omitempty"`  // 审批任务列表
	PageToken *string           `json:"page_token,omitempty"` // 翻页 Token
	HasMore   *bool             `json:"has_more,omitempty"`   // 是否有更多任务可供拉取
}

type SearchTaskResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *SearchTaskRespData `json:"data"` // 业务数据
}

func (resp *SearchTaskResp) Success() bool {
	return resp.Code == 0
}

type TransferTaskReqBuilder struct {
	apiReq       *larkcore.ApiReq
	taskTransfer *TaskTransfer
}

func NewTransferTaskReqBuilder() *TransferTaskReqBuilder {
	builder := &TransferTaskReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *TransferTaskReqBuilder) UserIdType(userIdType string) *TransferTaskReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 对于单个审批任务进行转交操作。转交后审批流程流转给被转交人。
func (builder *TransferTaskReqBuilder) TaskTransfer(taskTransfer *TaskTransfer) *TransferTaskReqBuilder {
	builder.taskTransfer = taskTransfer
	return builder
}

func (builder *TransferTaskReqBuilder) Build() *TransferTaskReq {
	req := &TransferTaskReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.taskTransfer
	return req
}

type TransferTaskReq struct {
	apiReq       *larkcore.ApiReq
	TaskTransfer *TaskTransfer `body:""`
}

type TransferTaskResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *TransferTaskResp) Success() bool {
	return resp.Code == 0
}

type P2ApprovalUpdatedV4Data struct {
	Object *ApprovalEvent `json:"object,omitempty"` //
}

type P2ApprovalUpdatedV4 struct {
	*larkevent.EventV2Base                          // 事件基础数据
	*larkevent.EventReq                             // 请求原生数据
	Event                  *P2ApprovalUpdatedV4Data `json:"event"` // 事件内容
}

func (m *P2ApprovalUpdatedV4) RawReq(req *larkevent.EventReq) {
	m.EventReq = req
}

type ListExternalTaskIterator struct {
	nextPageToken *string
	items         []*ExternalTaskList
	index         int
	limit         int
	ctx           context.Context
	req           *ListExternalTaskReq
	listFunc      func(ctx context.Context, req *ListExternalTaskReq, options ...larkcore.RequestOptionFunc) (*ListExternalTaskResp, error)
	options       []larkcore.RequestOptionFunc
	curlNum       int
}

func (iterator *ListExternalTaskIterator) Next() (bool, *ExternalTaskList, 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.Data) == 0 {
			return false, nil, nil
		}

		iterator.nextPageToken = resp.Data.PageToken
		iterator.items = resp.Data.Data
		iterator.index = 0
	}

	block := iterator.items[iterator.index]
	iterator.index++
	iterator.curlNum++
	return true, block, nil
}

func (iterator *ListExternalTaskIterator) NextPageToken() *string {
	return iterator.nextPageToken
}

type ListInstanceIterator struct {
	nextPageToken *string
	items         []string
	index         int
	limit         int
	ctx           context.Context
	req           *ListInstanceReq
	listFunc      func(ctx context.Context, req *ListInstanceReq, options ...larkcore.RequestOptionFunc) (*ListInstanceResp, error)
	options       []larkcore.RequestOptionFunc
	curlNum       int
}

func (iterator *ListInstanceIterator) Next() (bool, string, error) {
	// 达到最大量，则返回
	if iterator.limit > 0 && iterator.curlNum >= iterator.limit {
		return false, "", nil
	}

	// 为0则拉取数据
	if iterator.index == 0 || iterator.index >= len(iterator.items) {
		if iterator.index != 0 && iterator.nextPageToken == nil {
			return false, "", 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, "", err
		}

		if resp.Code != 0 {
			return false, "", errors.New(fmt.Sprintf("Code:%d,Msg:%s", resp.Code, resp.Msg))
		}

		if len(resp.Data.InstanceCodeList) == 0 {
			return false, "", nil
		}

		iterator.nextPageToken = resp.Data.PageToken
		iterator.items = resp.Data.InstanceCodeList
		iterator.index = 0
	}

	block := iterator.items[iterator.index]
	iterator.index++
	iterator.curlNum++
	return true, block, nil
}

func (iterator *ListInstanceIterator) NextPageToken() *string {
	return iterator.nextPageToken
}

type QueryInstanceIterator struct {
	nextPageToken *string
	items         []*InstanceSearchItem
	index         int
	limit         int
	ctx           context.Context
	req           *QueryInstanceReq
	listFunc      func(ctx context.Context, req *QueryInstanceReq, options ...larkcore.RequestOptionFunc) (*QueryInstanceResp, error)
	options       []larkcore.RequestOptionFunc
	curlNum       int
}

func (iterator *QueryInstanceIterator) Next() (bool, *InstanceSearchItem, 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.InstanceList) == 0 {
			return false, nil, nil
		}

		iterator.nextPageToken = resp.Data.PageToken
		iterator.items = resp.Data.InstanceList
		iterator.index = 0
	}

	block := iterator.items[iterator.index]
	iterator.index++
	iterator.curlNum++
	return true, block, nil
}

func (iterator *QueryInstanceIterator) NextPageToken() *string {
	return iterator.nextPageToken
}

type QueryTaskIterator struct {
	nextPageToken *string
	items         []*Task
	index         int
	limit         int
	ctx           context.Context
	req           *QueryTaskReq
	listFunc      func(ctx context.Context, req *QueryTaskReq, options ...larkcore.RequestOptionFunc) (*QueryTaskResp, error)
	options       []larkcore.RequestOptionFunc
	curlNum       int
}

func (iterator *QueryTaskIterator) Next() (bool, *Task, 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.Tasks) == 0 {
			return false, nil, nil
		}

		iterator.nextPageToken = resp.Data.PageToken
		iterator.items = resp.Data.Tasks
		iterator.index = 0
	}

	block := iterator.items[iterator.index]
	iterator.index++
	iterator.curlNum++
	return true, block, nil
}

func (iterator *QueryTaskIterator) NextPageToken() *string {
	return iterator.nextPageToken
}