// Package cardkit 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 larkcardkit

import (
	"fmt"

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

const (
	TypeInsertBefore = "insert_before" // 在目标组件前插入
	TypeInsertAfter  = "insert_after"  // 在目标组件后插入
	TypeAppend       = "append"        // 在卡片或容器组件末尾添加
)

type Action struct {
	Action *string `json:"action,omitempty"` // 操作类型 可选值有： - partial_update_setting：更新卡片设置，此时 parmas 结构参考更新卡片设置接口请求体的 config 和 card_link 字段 - add_elements，此时 parmas 结构参考添加组件接口请求体的 type、target_element_id、element_list 字段 - delete_elements，此时 parmas 结构内仅支持 element_id_list 参数，参数值为组件 ID 数组 - partial_update_element，此时 parmas 结构包括参考局部更新组件接口的路径参数 element_id 和请求体 partial_element 字段 - update_element，此时 parmas 结构参考全量更新组件接口的路径参数 element_id 和请求体 element 字段

	Params *Params `json:"params,omitempty"` // 操作类型对应的参数
}

type ActionBuilder struct {
	action     string // 操作类型 可选值有： - partial_update_setting：更新卡片设置，此时 parmas 结构参考更新卡片设置接口请求体的 config 和 card_link 字段 - add_elements，此时 parmas 结构参考添加组件接口请求体的 type、target_element_id、element_list 字段 - delete_elements，此时 parmas 结构内仅支持 element_id_list 参数，参数值为组件 ID 数组 - partial_update_element，此时 parmas 结构包括参考局部更新组件接口的路径参数 element_id 和请求体 partial_element 字段 - update_element，此时 parmas 结构参考全量更新组件接口的路径参数 element_id 和请求体 element 字段
	actionFlag bool

	params     *Params // 操作类型对应的参数
	paramsFlag bool
}

func NewActionBuilder() *ActionBuilder {
	builder := &ActionBuilder{}
	return builder
}

// 操作类型 可选值有： - partial_update_setting：更新卡片设置，此时 parmas 结构参考更新卡片设置接口请求体的 config 和 card_link 字段 - add_elements，此时 parmas 结构参考添加组件接口请求体的 type、target_element_id、element_list 字段 - delete_elements，此时 parmas 结构内仅支持 element_id_list 参数，参数值为组件 ID 数组 - partial_update_element，此时 parmas 结构包括参考局部更新组件接口的路径参数 element_id 和请求体 partial_element 字段 - update_element，此时 parmas 结构参考全量更新组件接口的路径参数 element_id 和请求体 element 字段
//
// 示例值：partial_update_setting
func (builder *ActionBuilder) Action(action string) *ActionBuilder {
	builder.action = action
	builder.actionFlag = true
	return builder
}

// 操作类型对应的参数
//
// 示例值：
func (builder *ActionBuilder) Params(params *Params) *ActionBuilder {
	builder.params = params
	builder.paramsFlag = true
	return builder
}

func (builder *ActionBuilder) Build() *Action {
	req := &Action{}
	if builder.actionFlag {
		req.Action = &builder.action

	}
	if builder.paramsFlag {
		req.Params = builder.params
	}
	return req
}

type CallbackAction struct {
	Value map[string]string `json:"value,omitempty"` // 交互组件绑定的开发者自定义回传数据，对应组件中的 value 属性。类型为 string 或 object，可由开发者指定

	Tag *string `json:"tag,omitempty"` // 用户操作交互组件的标签

	Option *string `json:"option,omitempty"` // 用户操作单选组件的选项值

	Options []string `json:"options,omitempty"` // 用户操作多选组件的选项值

	Timezone *string `json:"timezone,omitempty"` // 用户当前所在地区的时区。当用户操作日期选择器、时间选择器、或日期时间选择器时返回

	InputValue *string `json:"input_value,omitempty"` // 用户操作输入组件的输入值

	FormValue map[string]string `json:"form_value,omitempty"` // 用户操作表单容器内用户提交的数据

	Name *string `json:"name,omitempty"` // 用户操作交互组件的名称，由开发者自定义

	Checked *bool `json:"checked,omitempty"` // 用户操作勾选器组件的勾选状态
}

type CallbackActionBuilder struct {
	value     map[string]string // 交互组件绑定的开发者自定义回传数据，对应组件中的 value 属性。类型为 string 或 object，可由开发者指定
	valueFlag bool

	tag     string // 用户操作交互组件的标签
	tagFlag bool

	option     string // 用户操作单选组件的选项值
	optionFlag bool

	options     []string // 用户操作多选组件的选项值
	optionsFlag bool

	timezone     string // 用户当前所在地区的时区。当用户操作日期选择器、时间选择器、或日期时间选择器时返回
	timezoneFlag bool

	inputValue     string // 用户操作输入组件的输入值
	inputValueFlag bool

	formValue     map[string]string // 用户操作表单容器内用户提交的数据
	formValueFlag bool

	name     string // 用户操作交互组件的名称，由开发者自定义
	nameFlag bool

	checked     bool // 用户操作勾选器组件的勾选状态
	checkedFlag bool
}

func NewCallbackActionBuilder() *CallbackActionBuilder {
	builder := &CallbackActionBuilder{}
	return builder
}

// 交互组件绑定的开发者自定义回传数据，对应组件中的 value 属性。类型为 string 或 object，可由开发者指定
//
// 示例值：
func (builder *CallbackActionBuilder) Value(value map[string]string) *CallbackActionBuilder {
	builder.value = value
	builder.valueFlag = true
	return builder
}

// 用户操作交互组件的标签
//
// 示例值：button
func (builder *CallbackActionBuilder) Tag(tag string) *CallbackActionBuilder {
	builder.tag = tag
	builder.tagFlag = true
	return builder
}

// 用户操作单选组件的选项值
//
// 示例值：selectDemo1
func (builder *CallbackActionBuilder) Option(option string) *CallbackActionBuilder {
	builder.option = option
	builder.optionFlag = true
	return builder
}

// 用户操作多选组件的选项值
//
// 示例值：
func (builder *CallbackActionBuilder) Options(options []string) *CallbackActionBuilder {
	builder.options = options
	builder.optionsFlag = true
	return builder
}

// 用户当前所在地区的时区。当用户操作日期选择器、时间选择器、或日期时间选择器时返回
//
// 示例值：Asia/Shanghai
func (builder *CallbackActionBuilder) Timezone(timezone string) *CallbackActionBuilder {
	builder.timezone = timezone
	builder.timezoneFlag = true
	return builder
}

// 用户操作输入组件的输入值
//
// 示例值：input_value
func (builder *CallbackActionBuilder) InputValue(inputValue string) *CallbackActionBuilder {
	builder.inputValue = inputValue
	builder.inputValueFlag = true
	return builder
}

// 用户操作表单容器内用户提交的数据
//
// 示例值：
func (builder *CallbackActionBuilder) FormValue(formValue map[string]string) *CallbackActionBuilder {
	builder.formValue = formValue
	builder.formValueFlag = true
	return builder
}

// 用户操作交互组件的名称，由开发者自定义
//
// 示例值：approval_button
func (builder *CallbackActionBuilder) Name(name string) *CallbackActionBuilder {
	builder.name = name
	builder.nameFlag = true
	return builder
}

// 用户操作勾选器组件的勾选状态
//
// 示例值：
func (builder *CallbackActionBuilder) Checked(checked bool) *CallbackActionBuilder {
	builder.checked = checked
	builder.checkedFlag = true
	return builder
}

func (builder *CallbackActionBuilder) Build() *CallbackAction {
	req := &CallbackAction{}
	if builder.valueFlag {
		req.Value = builder.value
	}
	if builder.tagFlag {
		req.Tag = &builder.tag

	}
	if builder.optionFlag {
		req.Option = &builder.option

	}
	if builder.optionsFlag {
		req.Options = builder.options
	}
	if builder.timezoneFlag {
		req.Timezone = &builder.timezone

	}
	if builder.inputValueFlag {
		req.InputValue = &builder.inputValue

	}
	if builder.formValueFlag {
		req.FormValue = builder.formValue
	}
	if builder.nameFlag {
		req.Name = &builder.name

	}
	if builder.checkedFlag {
		req.Checked = &builder.checked

	}
	return req
}

type CallbackActionContext struct {
	OpenMessageId *string `json:"open_message_id,omitempty"` // 卡片所在的消息 ID

	OpenChatId *string `json:"open_chat_id,omitempty"` // 卡片所在的会话 ID
}

type CallbackActionContextBuilder struct {
	openMessageId     string // 卡片所在的消息 ID
	openMessageIdFlag bool

	openChatId     string // 卡片所在的会话 ID
	openChatIdFlag bool
}

func NewCallbackActionContextBuilder() *CallbackActionContextBuilder {
	builder := &CallbackActionContextBuilder{}
	return builder
}

// 卡片所在的消息 ID
//
// 示例值：om_574d639e4a44e4dd646eaf628e2*****
func (builder *CallbackActionContextBuilder) OpenMessageId(openMessageId string) *CallbackActionContextBuilder {
	builder.openMessageId = openMessageId
	builder.openMessageIdFlag = true
	return builder
}

// 卡片所在的会话 ID
//
// 示例值：oc_e4d2605ca917e695f54f11aaf56*****
func (builder *CallbackActionContextBuilder) OpenChatId(openChatId string) *CallbackActionContextBuilder {
	builder.openChatId = openChatId
	builder.openChatIdFlag = true
	return builder
}

func (builder *CallbackActionContextBuilder) Build() *CallbackActionContext {
	req := &CallbackActionContext{}
	if builder.openMessageIdFlag {
		req.OpenMessageId = &builder.openMessageId

	}
	if builder.openChatIdFlag {
		req.OpenChatId = &builder.openChatId

	}
	return req
}

type Card struct {
	Type *string `json:"type,omitempty"` // 卡片数据的类型

	Data *string `json:"data,omitempty"` // 卡片数据内容，与卡片数据的类型相对应
}

type CardBuilder struct {
	type_    string // 卡片数据的类型
	typeFlag bool

	data     string // 卡片数据内容，与卡片数据的类型相对应
	dataFlag bool
}

func NewCardBuilder() *CardBuilder {
	builder := &CardBuilder{}
	return builder
}

// 卡片数据的类型
//
// 示例值：card_json
func (builder *CardBuilder) Type(type_ string) *CardBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

// 卡片数据内容，与卡片数据的类型相对应
//
// 示例值：{\"schema\":\"2.0\",\"header\":{\"title\":{\"content\":\"卡片标题\",\"tag\":\"plain_text\"}},\"body\":{\"elements\":[{\"tag\":\"markdown\",\"content\":\"卡片内容\"}]}}
func (builder *CardBuilder) Data(data string) *CardBuilder {
	builder.data = data
	builder.dataFlag = true
	return builder
}

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

	}
	if builder.dataFlag {
		req.Data = &builder.data

	}
	return req
}

type CardLink struct {
	Url *string `json:"url,omitempty"` // 默认的链接地址

	PcUrl *string `json:"pc_url,omitempty"` // PC端的链接地址

	IosUrl *string `json:"ios_url,omitempty"` // iOS端的链接地址

	AndroidUrl *string `json:"android_url,omitempty"` // Android 端的链接地址
}

type CardLinkBuilder struct {
	url     string // 默认的链接地址
	urlFlag bool

	pcUrl     string // PC端的链接地址
	pcUrlFlag bool

	iosUrl     string // iOS端的链接地址
	iosUrlFlag bool

	androidUrl     string // Android 端的链接地址
	androidUrlFlag bool
}

func NewCardLinkBuilder() *CardLinkBuilder {
	builder := &CardLinkBuilder{}
	return builder
}

// 默认的链接地址
//
// 示例值：https://www.baidu.com
func (builder *CardLinkBuilder) Url(url string) *CardLinkBuilder {
	builder.url = url
	builder.urlFlag = true
	return builder
}

// PC端的链接地址
//
// 示例值：https://developer.windows.com/
func (builder *CardLinkBuilder) PcUrl(pcUrl string) *CardLinkBuilder {
	builder.pcUrl = pcUrl
	builder.pcUrlFlag = true
	return builder
}

// iOS端的链接地址
//
// 示例值：https://developer.apple.com/
func (builder *CardLinkBuilder) IosUrl(iosUrl string) *CardLinkBuilder {
	builder.iosUrl = iosUrl
	builder.iosUrlFlag = true
	return builder
}

// Android 端的链接地址
//
// 示例值：https://developer.android.com/
func (builder *CardLinkBuilder) AndroidUrl(androidUrl string) *CardLinkBuilder {
	builder.androidUrl = androidUrl
	builder.androidUrlFlag = true
	return builder
}

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

	}
	if builder.pcUrlFlag {
		req.PcUrl = &builder.pcUrl

	}
	if builder.iosUrlFlag {
		req.IosUrl = &builder.iosUrl

	}
	if builder.androidUrlFlag {
		req.AndroidUrl = &builder.androidUrl

	}
	return req
}

type CardTemplate struct {
	TemplateId *string `json:"template_id,omitempty"` // 卡片模板 ID

	TemplateName *string `json:"template_name,omitempty"` // 卡片模板名

	TemplateOwner *string `json:"template_owner,omitempty"` // 卡片模板所有者

	TemplateVersionName *string `json:"template_version_name,omitempty"` // 卡片模板版本

	SchemaVersion *string `json:"schema_version,omitempty"` // 卡片 Schema 版本

	Status *string `json:"status,omitempty"` // 卡片模板发布状态

	CreateTime *string `json:"create_time,omitempty"` // 卡片模板创建时间（毫秒）

	UpdateTime *string `json:"update_time,omitempty"` // 卡片模板更新时间（毫秒）
}

type CardTemplateBuilder struct {
	templateId     string // 卡片模板 ID
	templateIdFlag bool

	templateName     string // 卡片模板名
	templateNameFlag bool

	templateOwner     string // 卡片模板所有者
	templateOwnerFlag bool

	templateVersionName     string // 卡片模板版本
	templateVersionNameFlag bool

	schemaVersion     string // 卡片 Schema 版本
	schemaVersionFlag bool

	status     string // 卡片模板发布状态
	statusFlag bool

	createTime     string // 卡片模板创建时间（毫秒）
	createTimeFlag bool

	updateTime     string // 卡片模板更新时间（毫秒）
	updateTimeFlag bool
}

func NewCardTemplateBuilder() *CardTemplateBuilder {
	builder := &CardTemplateBuilder{}
	return builder
}

// 卡片模板 ID
//
// 示例值：AAqSZ3wf5hupo
func (builder *CardTemplateBuilder) TemplateId(templateId string) *CardTemplateBuilder {
	builder.templateId = templateId
	builder.templateIdFlag = true
	return builder
}

// 卡片模板名
//
// 示例值：同事圈分享卡片
func (builder *CardTemplateBuilder) TemplateName(templateName string) *CardTemplateBuilder {
	builder.templateName = templateName
	builder.templateNameFlag = true
	return builder
}

// 卡片模板所有者
//
// 示例值：cli_a62a4fe4e938d01c
func (builder *CardTemplateBuilder) TemplateOwner(templateOwner string) *CardTemplateBuilder {
	builder.templateOwner = templateOwner
	builder.templateOwnerFlag = true
	return builder
}

// 卡片模板版本
//
// 示例值：1.0.0
func (builder *CardTemplateBuilder) TemplateVersionName(templateVersionName string) *CardTemplateBuilder {
	builder.templateVersionName = templateVersionName
	builder.templateVersionNameFlag = true
	return builder
}

// 卡片 Schema 版本
//
// 示例值：2.0
func (builder *CardTemplateBuilder) SchemaVersion(schemaVersion string) *CardTemplateBuilder {
	builder.schemaVersion = schemaVersion
	builder.schemaVersionFlag = true
	return builder
}

// 卡片模板发布状态
//
// 示例值：PUBLISHED
func (builder *CardTemplateBuilder) Status(status string) *CardTemplateBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

// 卡片模板创建时间（毫秒）
//
// 示例值：1675742789470
func (builder *CardTemplateBuilder) CreateTime(createTime string) *CardTemplateBuilder {
	builder.createTime = createTime
	builder.createTimeFlag = true
	return builder
}

// 卡片模板更新时间（毫秒）
//
// 示例值：1675742789470
func (builder *CardTemplateBuilder) UpdateTime(updateTime string) *CardTemplateBuilder {
	builder.updateTime = updateTime
	builder.updateTimeFlag = true
	return builder
}

func (builder *CardTemplateBuilder) Build() *CardTemplate {
	req := &CardTemplate{}
	if builder.templateIdFlag {
		req.TemplateId = &builder.templateId

	}
	if builder.templateNameFlag {
		req.TemplateName = &builder.templateName

	}
	if builder.templateOwnerFlag {
		req.TemplateOwner = &builder.templateOwner

	}
	if builder.templateVersionNameFlag {
		req.TemplateVersionName = &builder.templateVersionName

	}
	if builder.schemaVersionFlag {
		req.SchemaVersion = &builder.schemaVersion

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

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

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

	}
	return req
}

type Config struct {
	EnableForward *bool `json:"enable_forward,omitempty"` // 是否允许转发卡片。取值：  true：允许 false：不允许 默认值为 true，该字段要求飞书客户端的版本为 V3.31.0 及以上

	StreamingMode *bool `json:"streaming_mode,omitempty"` // 标识是否开启流式

	Summary *Summary `json:"summary,omitempty"` // 卡片摘要
}

type ConfigBuilder struct {
	enableForward     bool // 是否允许转发卡片。取值：  true：允许 false：不允许 默认值为 true，该字段要求飞书客户端的版本为 V3.31.0 及以上
	enableForwardFlag bool

	streamingMode     bool // 标识是否开启流式
	streamingModeFlag bool

	summary     *Summary // 卡片摘要
	summaryFlag bool
}

func NewConfigBuilder() *ConfigBuilder {
	builder := &ConfigBuilder{}
	return builder
}

// 是否允许转发卡片。取值：  true：允许 false：不允许 默认值为 true，该字段要求飞书客户端的版本为 V3.31.0 及以上
//
// 示例值：
func (builder *ConfigBuilder) EnableForward(enableForward bool) *ConfigBuilder {
	builder.enableForward = enableForward
	builder.enableForwardFlag = true
	return builder
}

// 标识是否开启流式
//
// 示例值：
func (builder *ConfigBuilder) StreamingMode(streamingMode bool) *ConfigBuilder {
	builder.streamingMode = streamingMode
	builder.streamingModeFlag = true
	return builder
}

// 卡片摘要
//
// 示例值：
func (builder *ConfigBuilder) Summary(summary *Summary) *ConfigBuilder {
	builder.summary = summary
	builder.summaryFlag = true
	return builder
}

func (builder *ConfigBuilder) Build() *Config {
	req := &Config{}
	if builder.enableForwardFlag {
		req.EnableForward = &builder.enableForward

	}
	if builder.streamingModeFlag {
		req.StreamingMode = &builder.streamingMode

	}
	if builder.summaryFlag {
		req.Summary = builder.summary
	}
	return req
}

type Data struct {
	Schema *string `json:"schema,omitempty"` // 卡片规范版本

	Body *Element `json:"body,omitempty"` // 卡片组件

	Header *Header `json:"header,omitempty"` // 用于配置卡片的标题

	CardLink *CardLink `json:"card_link,omitempty"` // 用于指定卡片整体的跳转链接
}

type DataBuilder struct {
	schema     string // 卡片规范版本
	schemaFlag bool

	body     *Element // 卡片组件
	bodyFlag bool

	header     *Header // 用于配置卡片的标题
	headerFlag bool

	cardLink     *CardLink // 用于指定卡片整体的跳转链接
	cardLinkFlag bool
}

func NewDataBuilder() *DataBuilder {
	builder := &DataBuilder{}
	return builder
}

// 卡片规范版本
//
// 示例值：2.0
func (builder *DataBuilder) Schema(schema string) *DataBuilder {
	builder.schema = schema
	builder.schemaFlag = true
	return builder
}

// 卡片组件
//
// 示例值：
func (builder *DataBuilder) Body(body *Element) *DataBuilder {
	builder.body = body
	builder.bodyFlag = true
	return builder
}

// 用于配置卡片的标题
//
// 示例值：
func (builder *DataBuilder) Header(header *Header) *DataBuilder {
	builder.header = header
	builder.headerFlag = true
	return builder
}

// 用于指定卡片整体的跳转链接
//
// 示例值：
func (builder *DataBuilder) CardLink(cardLink *CardLink) *DataBuilder {
	builder.cardLink = cardLink
	builder.cardLinkFlag = true
	return builder
}

func (builder *DataBuilder) Build() *Data {
	req := &Data{}
	if builder.schemaFlag {
		req.Schema = &builder.schema

	}
	if builder.bodyFlag {
		req.Body = builder.body
	}
	if builder.headerFlag {
		req.Header = builder.header
	}
	if builder.cardLinkFlag {
		req.CardLink = builder.cardLink
	}
	return req
}

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

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

type DepartmentIdBuilder struct {
	departmentId     string //
	departmentIdFlag bool

	openDepartmentId     string //
	openDepartmentIdFlag bool
}

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

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

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

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

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

	}
	return req
}

type Element struct {
	Tag *string `json:"tag,omitempty"` // 标识

	ElementId *string `json:"element_id,omitempty"` // 组件id
}

type ElementBuilder struct {
	tag     string // 标识
	tagFlag bool

	elementId     string // 组件id
	elementIdFlag bool
}

func NewElementBuilder() *ElementBuilder {
	builder := &ElementBuilder{}
	return builder
}

// 标识
//
// 示例值：button
func (builder *ElementBuilder) Tag(tag string) *ElementBuilder {
	builder.tag = tag
	builder.tagFlag = true
	return builder
}

// 组件id
//
// 示例值：elem_1
func (builder *ElementBuilder) ElementId(elementId string) *ElementBuilder {
	builder.elementId = elementId
	builder.elementIdFlag = true
	return builder
}

func (builder *ElementBuilder) Build() *Element {
	req := &Element{}
	if builder.tagFlag {
		req.Tag = &builder.tag

	}
	if builder.elementIdFlag {
		req.ElementId = &builder.elementId

	}
	return req
}

type Header struct {
	Title *string `json:"title,omitempty"` // 卡片标题
}

type HeaderBuilder struct {
	title     string // 卡片标题
	titleFlag bool
}

func NewHeaderBuilder() *HeaderBuilder {
	builder := &HeaderBuilder{}
	return builder
}

// 卡片标题
//
// 示例值：卡片标题
func (builder *HeaderBuilder) Title(title string) *HeaderBuilder {
	builder.title = title
	builder.titleFlag = true
	return builder
}

func (builder *HeaderBuilder) Build() *Header {
	req := &Header{}
	if builder.titleFlag {
		req.Title = &builder.title

	}
	return req
}

type KaCardTemplate struct {
	TemplateId *string `json:"template_id,omitempty"` // 卡片模板 ID

	TemplateName *string `json:"template_name,omitempty"` // 卡片模板名

	TemplateOwner *string `json:"template_owner,omitempty"` // 卡片模板所有者

	TemplateVersionName *string `json:"template_version_name,omitempty"` // 卡片模板版本名

	Status *string `json:"status,omitempty"` // 卡片模板发布状态

	CreateTime *string `json:"create_time,omitempty"` // 卡片模板创建时间（毫秒）

	UpdateTime *string `json:"update_time,omitempty"` // 卡片模板更新时间（毫秒）

	HostConfig *string `json:"host_config,omitempty"` // 调用权限配置

	TemplateVersions []string `json:"template_versions,omitempty"` // 未同步的卡片模板版本

	BindApps []string `json:"bind_apps,omitempty"` // 绑定的 APP 列表
}

type KaCardTemplateBuilder struct {
	templateId     string // 卡片模板 ID
	templateIdFlag bool

	templateName     string // 卡片模板名
	templateNameFlag bool

	templateOwner     string // 卡片模板所有者
	templateOwnerFlag bool

	templateVersionName     string // 卡片模板版本名
	templateVersionNameFlag bool

	status     string // 卡片模板发布状态
	statusFlag bool

	createTime     string // 卡片模板创建时间（毫秒）
	createTimeFlag bool

	updateTime     string // 卡片模板更新时间（毫秒）
	updateTimeFlag bool

	hostConfig     string // 调用权限配置
	hostConfigFlag bool

	templateVersions     []string // 未同步的卡片模板版本
	templateVersionsFlag bool

	bindApps     []string // 绑定的 APP 列表
	bindAppsFlag bool
}

func NewKaCardTemplateBuilder() *KaCardTemplateBuilder {
	builder := &KaCardTemplateBuilder{}
	return builder
}

// 卡片模板 ID
//
// 示例值：AAqSZ3wf5hupo
func (builder *KaCardTemplateBuilder) TemplateId(templateId string) *KaCardTemplateBuilder {
	builder.templateId = templateId
	builder.templateIdFlag = true
	return builder
}

// 卡片模板名
//
// 示例值：卡片名称
func (builder *KaCardTemplateBuilder) TemplateName(templateName string) *KaCardTemplateBuilder {
	builder.templateName = templateName
	builder.templateNameFlag = true
	return builder
}

// 卡片模板所有者
//
// 示例值：cli_a62a4fe4e938d01c
func (builder *KaCardTemplateBuilder) TemplateOwner(templateOwner string) *KaCardTemplateBuilder {
	builder.templateOwner = templateOwner
	builder.templateOwnerFlag = true
	return builder
}

// 卡片模板版本名
//
// 示例值：1.0.0
func (builder *KaCardTemplateBuilder) TemplateVersionName(templateVersionName string) *KaCardTemplateBuilder {
	builder.templateVersionName = templateVersionName
	builder.templateVersionNameFlag = true
	return builder
}

// 卡片模板发布状态
//
// 示例值：PUBLISHED
func (builder *KaCardTemplateBuilder) Status(status string) *KaCardTemplateBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

// 卡片模板创建时间（毫秒）
//
// 示例值：1
func (builder *KaCardTemplateBuilder) CreateTime(createTime string) *KaCardTemplateBuilder {
	builder.createTime = createTime
	builder.createTimeFlag = true
	return builder
}

// 卡片模板更新时间（毫秒）
//
// 示例值：1
func (builder *KaCardTemplateBuilder) UpdateTime(updateTime string) *KaCardTemplateBuilder {
	builder.updateTime = updateTime
	builder.updateTimeFlag = true
	return builder
}

// 调用权限配置
//
// 示例值：{"webhook_type":null,"webhook_ids":null,"app_type":2,"app_ids":null,"editor_webhook_ids":null,"editor_app_ids":null}
func (builder *KaCardTemplateBuilder) HostConfig(hostConfig string) *KaCardTemplateBuilder {
	builder.hostConfig = hostConfig
	builder.hostConfigFlag = true
	return builder
}

// 未同步的卡片模板版本
//
// 示例值：
func (builder *KaCardTemplateBuilder) TemplateVersions(templateVersions []string) *KaCardTemplateBuilder {
	builder.templateVersions = templateVersions
	builder.templateVersionsFlag = true
	return builder
}

// 绑定的 APP 列表
//
// 示例值：
func (builder *KaCardTemplateBuilder) BindApps(bindApps []string) *KaCardTemplateBuilder {
	builder.bindApps = bindApps
	builder.bindAppsFlag = true
	return builder
}

func (builder *KaCardTemplateBuilder) Build() *KaCardTemplate {
	req := &KaCardTemplate{}
	if builder.templateIdFlag {
		req.TemplateId = &builder.templateId

	}
	if builder.templateNameFlag {
		req.TemplateName = &builder.templateName

	}
	if builder.templateOwnerFlag {
		req.TemplateOwner = &builder.templateOwner

	}
	if builder.templateVersionNameFlag {
		req.TemplateVersionName = &builder.templateVersionName

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

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

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

	}
	if builder.hostConfigFlag {
		req.HostConfig = &builder.hostConfig

	}
	if builder.templateVersionsFlag {
		req.TemplateVersions = builder.templateVersions
	}
	if builder.bindAppsFlag {
		req.BindApps = builder.bindApps
	}
	return req
}

type KaCardTemplateOld struct {
	TemplateId *string `json:"template_id,omitempty"` // 模板 ID

	Name *string `json:"name,omitempty"` // 模板名

	BizExt *string `json:"biz_ext,omitempty"` //  扩展字段

	LockStatus *int `json:"lock_status,omitempty"` // 锁定状态

	Status *int `json:"status,omitempty"` // 模板状态

	MockData *string `json:"mock_data,omitempty"` // mock 数据

	Content *string `json:"content,omitempty"` // 卡片内容

	DraftContent *string `json:"draft_content,omitempty"` // 草稿内容

	CreateTime *string `json:"create_time,omitempty"` // 创建时间

	UpdateTime *string `json:"update_time,omitempty"` // 更新时间

	CreatorId *string `json:"creator_id,omitempty"` // 创建者

	Variables []*KaCardTemplateVariable `json:"variables,omitempty"` // 变量列表
}

type KaCardTemplateOldBuilder struct {
	templateId     string // 模板 ID
	templateIdFlag bool

	name     string // 模板名
	nameFlag bool

	bizExt     string //  扩展字段
	bizExtFlag bool

	lockStatus     int // 锁定状态
	lockStatusFlag bool

	status     int // 模板状态
	statusFlag bool

	mockData     string // mock 数据
	mockDataFlag bool

	content     string // 卡片内容
	contentFlag bool

	draftContent     string // 草稿内容
	draftContentFlag bool

	createTime     string // 创建时间
	createTimeFlag bool

	updateTime     string // 更新时间
	updateTimeFlag bool

	creatorId     string // 创建者
	creatorIdFlag bool

	variables     []*KaCardTemplateVariable // 变量列表
	variablesFlag bool
}

func NewKaCardTemplateOldBuilder() *KaCardTemplateOldBuilder {
	builder := &KaCardTemplateOldBuilder{}
	return builder
}

// 模板 ID
//
// 示例值：ctp_123
func (builder *KaCardTemplateOldBuilder) TemplateId(templateId string) *KaCardTemplateOldBuilder {
	builder.templateId = templateId
	builder.templateIdFlag = true
	return builder
}

// 模板名
//
// 示例值：123
func (builder *KaCardTemplateOldBuilder) Name(name string) *KaCardTemplateOldBuilder {
	builder.name = name
	builder.nameFlag = true
	return builder
}

//  扩展字段
//
// 示例值：{}
func (builder *KaCardTemplateOldBuilder) BizExt(bizExt string) *KaCardTemplateOldBuilder {
	builder.bizExt = bizExt
	builder.bizExtFlag = true
	return builder
}

// 锁定状态
//
// 示例值：2
func (builder *KaCardTemplateOldBuilder) LockStatus(lockStatus int) *KaCardTemplateOldBuilder {
	builder.lockStatus = lockStatus
	builder.lockStatusFlag = true
	return builder
}

// 模板状态
//
// 示例值：0
func (builder *KaCardTemplateOldBuilder) Status(status int) *KaCardTemplateOldBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

// mock 数据
//
// 示例值：{}
func (builder *KaCardTemplateOldBuilder) MockData(mockData string) *KaCardTemplateOldBuilder {
	builder.mockData = mockData
	builder.mockDataFlag = true
	return builder
}

// 卡片内容
//
// 示例值：{}
func (builder *KaCardTemplateOldBuilder) Content(content string) *KaCardTemplateOldBuilder {
	builder.content = content
	builder.contentFlag = true
	return builder
}

// 草稿内容
//
// 示例值：{}
func (builder *KaCardTemplateOldBuilder) DraftContent(draftContent string) *KaCardTemplateOldBuilder {
	builder.draftContent = draftContent
	builder.draftContentFlag = true
	return builder
}

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

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

// 创建者
//
// 示例值：ou_123
func (builder *KaCardTemplateOldBuilder) CreatorId(creatorId string) *KaCardTemplateOldBuilder {
	builder.creatorId = creatorId
	builder.creatorIdFlag = true
	return builder
}

// 变量列表
//
// 示例值：
func (builder *KaCardTemplateOldBuilder) Variables(variables []*KaCardTemplateVariable) *KaCardTemplateOldBuilder {
	builder.variables = variables
	builder.variablesFlag = true
	return builder
}

func (builder *KaCardTemplateOldBuilder) Build() *KaCardTemplateOld {
	req := &KaCardTemplateOld{}
	if builder.templateIdFlag {
		req.TemplateId = &builder.templateId

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

	}
	if builder.bizExtFlag {
		req.BizExt = &builder.bizExt

	}
	if builder.lockStatusFlag {
		req.LockStatus = &builder.lockStatus

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

	}
	if builder.mockDataFlag {
		req.MockData = &builder.mockData

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

	}
	if builder.draftContentFlag {
		req.DraftContent = &builder.draftContent

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

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

	}
	if builder.creatorIdFlag {
		req.CreatorId = &builder.creatorId

	}
	if builder.variablesFlag {
		req.Variables = builder.variables
	}
	return req
}

type KaCardTemplateVariable struct {
	VariableType *string `json:"variable_type,omitempty"` // 变量类型

	Name *string `json:"name,omitempty"` // 变量名

	Description *string `json:"description,omitempty"` // 变量描述信息

	Config *string `json:"config,omitempty"` // 配置信息
}

type KaCardTemplateVariableBuilder struct {
	variableType     string // 变量类型
	variableTypeFlag bool

	name     string // 变量名
	nameFlag bool

	description     string // 变量描述信息
	descriptionFlag bool

	config     string // 配置信息
	configFlag bool
}

func NewKaCardTemplateVariableBuilder() *KaCardTemplateVariableBuilder {
	builder := &KaCardTemplateVariableBuilder{}
	return builder
}

// 变量类型
//
// 示例值：123
func (builder *KaCardTemplateVariableBuilder) VariableType(variableType string) *KaCardTemplateVariableBuilder {
	builder.variableType = variableType
	builder.variableTypeFlag = true
	return builder
}

// 变量名
//
// 示例值：123
func (builder *KaCardTemplateVariableBuilder) Name(name string) *KaCardTemplateVariableBuilder {
	builder.name = name
	builder.nameFlag = true
	return builder
}

// 变量描述信息
//
// 示例值：123
func (builder *KaCardTemplateVariableBuilder) Description(description string) *KaCardTemplateVariableBuilder {
	builder.description = description
	builder.descriptionFlag = true
	return builder
}

// 配置信息
//
// 示例值：{}
func (builder *KaCardTemplateVariableBuilder) Config(config string) *KaCardTemplateVariableBuilder {
	builder.config = config
	builder.configFlag = true
	return builder
}

func (builder *KaCardTemplateVariableBuilder) Build() *KaCardTemplateVariable {
	req := &KaCardTemplateVariable{}
	if builder.variableTypeFlag {
		req.VariableType = &builder.variableType

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

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

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

	}
	return req
}

type Operator struct {
	TenantKey *string `json:"tenant_key,omitempty"` // 回调触发者的 tenant key，即租户唯一标识

	UserId *string `json:"user_id,omitempty"` // 回调触发者的 user ID

	OpenId *string `json:"open_id,omitempty"` // 回调触发者的 open ID

	UnionId *string `json:"union_id,omitempty"` // 回调触发者的 union ID
}

type OperatorBuilder struct {
	tenantKey     string // 回调触发者的 tenant key，即租户唯一标识
	tenantKeyFlag bool

	userId     string // 回调触发者的 user ID
	userIdFlag bool

	openId     string // 回调触发者的 open ID
	openIdFlag bool

	unionId     string // 回调触发者的 union ID
	unionIdFlag bool
}

func NewOperatorBuilder() *OperatorBuilder {
	builder := &OperatorBuilder{}
	return builder
}

// 回调触发者的 tenant key，即租户唯一标识
//
// 示例值：2af7399175062872
func (builder *OperatorBuilder) TenantKey(tenantKey string) *OperatorBuilder {
	builder.tenantKey = tenantKey
	builder.tenantKeyFlag = true
	return builder
}

// 回调触发者的 user ID
//
// 示例值：
func (builder *OperatorBuilder) UserId(userId string) *OperatorBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 回调触发者的 open ID
//
// 示例值：
func (builder *OperatorBuilder) OpenId(openId string) *OperatorBuilder {
	builder.openId = openId
	builder.openIdFlag = true
	return builder
}

// 回调触发者的 union ID
//
// 示例值：
func (builder *OperatorBuilder) UnionId(unionId string) *OperatorBuilder {
	builder.unionId = unionId
	builder.unionIdFlag = true
	return builder
}

func (builder *OperatorBuilder) Build() *Operator {
	req := &Operator{}
	if builder.tenantKeyFlag {
		req.TenantKey = &builder.tenantKey

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

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

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

	}
	return req
}

type Params struct {
	Type *string `json:"type,omitempty"` // 添加组件的方式，action是add_elements使用。

	TargetElementId *string `json:"target_element_id,omitempty"` // 目标组件的 ID。 当 type 为 insert_before、insert_after 时，为用于定位的目标组件。 当 type 为 append 时，该字段仅支持容器类组件，为用于指定末尾添加的目标组件，未填写默认为在卡片 body 末尾添加。action是add_elements使用。

	Elements []string `json:"elements,omitempty"` // 组件列表，action是add_elements使用。

	ElementIds []string `json:"element_ids,omitempty"` // 删除的组件ID数组，action是delete_elements使用。

	ElementId *string `json:"element_id,omitempty"` // 组件ID，action是partial_update_element或update_element使用

	PartialElement *string `json:"partial_element,omitempty"` // 局部更新组件，action是partial_update_element使用

	Element *string `json:"element,omitempty"` // 全量更新组件，action是update_element使用

	Settings *string `json:"settings,omitempty"` // 卡片设置
}

type ParamsBuilder struct {
	type_    string // 添加组件的方式，action是add_elements使用。
	typeFlag bool

	targetElementId     string // 目标组件的 ID。 当 type 为 insert_before、insert_after 时，为用于定位的目标组件。 当 type 为 append 时，该字段仅支持容器类组件，为用于指定末尾添加的目标组件，未填写默认为在卡片 body 末尾添加。action是add_elements使用。
	targetElementIdFlag bool

	elements     []string // 组件列表，action是add_elements使用。
	elementsFlag bool

	elementIds     []string // 删除的组件ID数组，action是delete_elements使用。
	elementIdsFlag bool

	elementId     string // 组件ID，action是partial_update_element或update_element使用
	elementIdFlag bool

	partialElement     string // 局部更新组件，action是partial_update_element使用
	partialElementFlag bool

	element     string // 全量更新组件，action是update_element使用
	elementFlag bool

	settings     string // 卡片设置
	settingsFlag bool
}

func NewParamsBuilder() *ParamsBuilder {
	builder := &ParamsBuilder{}
	return builder
}

// 添加组件的方式，action是add_elements使用。
//
// 示例值：insert_before
func (builder *ParamsBuilder) Type(type_ string) *ParamsBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

// 目标组件的 ID。 当 type 为 insert_before、insert_after 时，为用于定位的目标组件。 当 type 为 append 时，该字段仅支持容器类组件，为用于指定末尾添加的目标组件，未填写默认为在卡片 body 末尾添加。action是add_elements使用。
//
// 示例值：elem_63529372
func (builder *ParamsBuilder) TargetElementId(targetElementId string) *ParamsBuilder {
	builder.targetElementId = targetElementId
	builder.targetElementIdFlag = true
	return builder
}

// 组件列表，action是add_elements使用。
//
// 示例值：
func (builder *ParamsBuilder) Elements(elements []string) *ParamsBuilder {
	builder.elements = elements
	builder.elementsFlag = true
	return builder
}

// 删除的组件ID数组，action是delete_elements使用。
//
// 示例值：
func (builder *ParamsBuilder) ElementIds(elementIds []string) *ParamsBuilder {
	builder.elementIds = elementIds
	builder.elementIdsFlag = true
	return builder
}

// 组件ID，action是partial_update_element或update_element使用
//
// 示例值：elem_63529372
func (builder *ParamsBuilder) ElementId(elementId string) *ParamsBuilder {
	builder.elementId = elementId
	builder.elementIdFlag = true
	return builder
}

// 局部更新组件，action是partial_update_element使用
//
// 示例值：{\"content\":\"更新后的组件文本\"}
func (builder *ParamsBuilder) PartialElement(partialElement string) *ParamsBuilder {
	builder.partialElement = partialElement
	builder.partialElementFlag = true
	return builder
}

// 全量更新组件，action是update_element使用
//
// 示例值：{\"tag\":\"markdown\",\"id\":\"md_1\",\"content\":\"普通文本\"}
func (builder *ParamsBuilder) Element(element string) *ParamsBuilder {
	builder.element = element
	builder.elementFlag = true
	return builder
}

// 卡片设置
//
// 示例值：{\"config\":{\"streaming_mode\":true,\"enable_forward\":true,\"update_multi\":true,\"width_mode\":\"fill\",\"enable_forward_interaction\":false},\"card_link\":{\"url\":\"https://open.feishu.cn\",\"android_url\":\"https://open.feishu.cn\",\"ios_url\":\"https://open.feishu.cn\",\"pc_url\":\"https://open.feishu.cn\"}}
func (builder *ParamsBuilder) Settings(settings string) *ParamsBuilder {
	builder.settings = settings
	builder.settingsFlag = true
	return builder
}

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

	}
	if builder.targetElementIdFlag {
		req.TargetElementId = &builder.targetElementId

	}
	if builder.elementsFlag {
		req.Elements = builder.elements
	}
	if builder.elementIdsFlag {
		req.ElementIds = builder.elementIds
	}
	if builder.elementIdFlag {
		req.ElementId = &builder.elementId

	}
	if builder.partialElementFlag {
		req.PartialElement = &builder.partialElement

	}
	if builder.elementFlag {
		req.Element = &builder.element

	}
	if builder.settingsFlag {
		req.Settings = &builder.settings

	}
	return req
}

type Settings struct {
	CardLink *CardLink `json:"card_link,omitempty"` // 卡片跳转链接

	Config *Config `json:"config,omitempty"` // 用于配置卡片的属性
}

type SettingsBuilder struct {
	cardLink     *CardLink // 卡片跳转链接
	cardLinkFlag bool

	config     *Config // 用于配置卡片的属性
	configFlag bool
}

func NewSettingsBuilder() *SettingsBuilder {
	builder := &SettingsBuilder{}
	return builder
}

// 卡片跳转链接
//
// 示例值：
func (builder *SettingsBuilder) CardLink(cardLink *CardLink) *SettingsBuilder {
	builder.cardLink = cardLink
	builder.cardLinkFlag = true
	return builder
}

// 用于配置卡片的属性
//
// 示例值：
func (builder *SettingsBuilder) Config(config *Config) *SettingsBuilder {
	builder.config = config
	builder.configFlag = true
	return builder
}

func (builder *SettingsBuilder) Build() *Settings {
	req := &Settings{}
	if builder.cardLinkFlag {
		req.CardLink = builder.cardLink
	}
	if builder.configFlag {
		req.Config = builder.config
	}
	return req
}

type Summary struct {
	Content *string `json:"content,omitempty"` // 卡片摘要
}

type SummaryBuilder struct {
	content     string // 卡片摘要
	contentFlag bool
}

func NewSummaryBuilder() *SummaryBuilder {
	builder := &SummaryBuilder{}
	return builder
}

// 卡片摘要
//
// 示例值：摘要生产中
func (builder *SummaryBuilder) Content(content string) *SummaryBuilder {
	builder.content = content
	builder.contentFlag = true
	return builder
}

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

	}
	return req
}

type BatchUpdateCardReqBodyBuilder struct {
	uuid     string // 幂等 id，最大长度为 64。可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
	uuidFlag bool

	sequence     int // 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
	sequenceFlag bool

	actions     string // 操作列表，可选值有： partial_update_setting：更新卡片设置，此时 parmas 结构参考更新卡片设置接口请求体的 settings 字段 ；add_elements，此时 parmas 结构参考添加组件接口请求体的 type、target_element_id、elements 字段 ； delete_elements，此时 parmas 结构内仅支持 element_ids 参数，参数值为组件 ID 数组 ； partial_update_element，此时 parmas 结构包括参考局部更新组件接口的路径参数 element_id 和请求体 partial_element 字段 ; update_element，此时 parmas 结构参考全量更新组件接口的路径参数 element_id 和请求体 element 字段
	actionsFlag bool
}

func NewBatchUpdateCardReqBodyBuilder() *BatchUpdateCardReqBodyBuilder {
	builder := &BatchUpdateCardReqBodyBuilder{}
	return builder
}

// 幂等 id，最大长度为 64。可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
//
//示例值：191857678434
func (builder *BatchUpdateCardReqBodyBuilder) Uuid(uuid string) *BatchUpdateCardReqBodyBuilder {
	builder.uuid = uuid
	builder.uuidFlag = true
	return builder
}

// 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
//
//示例值：1712578784
func (builder *BatchUpdateCardReqBodyBuilder) Sequence(sequence int) *BatchUpdateCardReqBodyBuilder {
	builder.sequence = sequence
	builder.sequenceFlag = true
	return builder
}

// 操作列表，可选值有： partial_update_setting：更新卡片设置，此时 parmas 结构参考更新卡片设置接口请求体的 settings 字段 ；add_elements，此时 parmas 结构参考添加组件接口请求体的 type、target_element_id、elements 字段 ； delete_elements，此时 parmas 结构内仅支持 element_ids 参数，参数值为组件 ID 数组 ； partial_update_element，此时 parmas 结构包括参考局部更新组件接口的路径参数 element_id 和请求体 partial_element 字段 ; update_element，此时 parmas 结构参考全量更新组件接口的路径参数 element_id 和请求体 element 字段
//
//示例值：[{\"action\":\"partial_update_setting\",\"params\":{\"config\":{\"streaming_mode\":true},\"card_link\":{\"url\":\"https://open.feishu.cn\"}}},{\"action\":\"add_elements\",\"params\":{\"type\":\"insert_before\",\"target_element_id\":\"text_1\",\"elements\":[{\"tag\":\"markdown\",\"id\":\"md_1\",\"content\":\"示例文本\"}]}},{\"action\":\"delete_elements\",\"params\":{\"element_ids\":[\"text_1\",\"text_2\"]}},{\"action\":\"partial_update_element\",\"params\":{\"element_id\":\"target_element\",\"partial_element\":{\"content\":\"更新后的组件文本\"}}},{\"action\":\"update_element\",\"params\":{\"element_id\":\"target_element\",\"element\":{\"tag\":\"markdown\",\"id\":\"md_1\",\"content\":\"普通文本\"}}}]
func (builder *BatchUpdateCardReqBodyBuilder) Actions(actions string) *BatchUpdateCardReqBodyBuilder {
	builder.actions = actions
	builder.actionsFlag = true
	return builder
}

func (builder *BatchUpdateCardReqBodyBuilder) Build() *BatchUpdateCardReqBody {
	req := &BatchUpdateCardReqBody{}
	if builder.uuidFlag {
		req.Uuid = &builder.uuid
	}
	if builder.sequenceFlag {
		req.Sequence = &builder.sequence
	}
	if builder.actionsFlag {
		req.Actions = &builder.actions
	}
	return req
}

type BatchUpdateCardPathReqBodyBuilder struct {
	uuid         string
	uuidFlag     bool
	sequence     int
	sequenceFlag bool
	actions      string
	actionsFlag  bool
}

func NewBatchUpdateCardPathReqBodyBuilder() *BatchUpdateCardPathReqBodyBuilder {
	builder := &BatchUpdateCardPathReqBodyBuilder{}
	return builder
}

// 幂等 id，最大长度为 64。可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
//
// 示例值：191857678434
func (builder *BatchUpdateCardPathReqBodyBuilder) Uuid(uuid string) *BatchUpdateCardPathReqBodyBuilder {
	builder.uuid = uuid
	builder.uuidFlag = true
	return builder
}

// 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
//
// 示例值：1712578784
func (builder *BatchUpdateCardPathReqBodyBuilder) Sequence(sequence int) *BatchUpdateCardPathReqBodyBuilder {
	builder.sequence = sequence
	builder.sequenceFlag = true
	return builder
}

// 操作列表，可选值有： partial_update_setting：更新卡片设置，此时 parmas 结构参考更新卡片设置接口请求体的 settings 字段 ；add_elements，此时 parmas 结构参考添加组件接口请求体的 type、target_element_id、elements 字段 ； delete_elements，此时 parmas 结构内仅支持 element_ids 参数，参数值为组件 ID 数组 ； partial_update_element，此时 parmas 结构包括参考局部更新组件接口的路径参数 element_id 和请求体 partial_element 字段 ; update_element，此时 parmas 结构参考全量更新组件接口的路径参数 element_id 和请求体 element 字段
//
// 示例值：[{\"action\":\"partial_update_setting\",\"params\":{\"config\":{\"streaming_mode\":true},\"card_link\":{\"url\":\"https://open.feishu.cn\"}}},{\"action\":\"add_elements\",\"params\":{\"type\":\"insert_before\",\"target_element_id\":\"text_1\",\"elements\":[{\"tag\":\"markdown\",\"id\":\"md_1\",\"content\":\"示例文本\"}]}},{\"action\":\"delete_elements\",\"params\":{\"element_ids\":[\"text_1\",\"text_2\"]}},{\"action\":\"partial_update_element\",\"params\":{\"element_id\":\"target_element\",\"partial_element\":{\"content\":\"更新后的组件文本\"}}},{\"action\":\"update_element\",\"params\":{\"element_id\":\"target_element\",\"element\":{\"tag\":\"markdown\",\"id\":\"md_1\",\"content\":\"普通文本\"}}}]
func (builder *BatchUpdateCardPathReqBodyBuilder) Actions(actions string) *BatchUpdateCardPathReqBodyBuilder {
	builder.actions = actions
	builder.actionsFlag = true
	return builder
}

func (builder *BatchUpdateCardPathReqBodyBuilder) Build() (*BatchUpdateCardReqBody, error) {
	req := &BatchUpdateCardReqBody{}
	if builder.uuidFlag {
		req.Uuid = &builder.uuid
	}
	if builder.sequenceFlag {
		req.Sequence = &builder.sequence
	}
	if builder.actionsFlag {
		req.Actions = &builder.actions
	}
	return req, nil
}

type BatchUpdateCardReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *BatchUpdateCardReqBody
}

func NewBatchUpdateCardReqBuilder() *BatchUpdateCardReqBuilder {
	builder := &BatchUpdateCardReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 卡片ID
//
// 示例值：7355439197428236291
func (builder *BatchUpdateCardReqBuilder) CardId(cardId string) *BatchUpdateCardReqBuilder {
	builder.apiReq.PathParams.Set("card_id", fmt.Sprint(cardId))
	return builder
}

// 按指定的多个操作批量局部更新卡片，支持更新卡片设置、添加组件、删除组件、更新组件
func (builder *BatchUpdateCardReqBuilder) Body(body *BatchUpdateCardReqBody) *BatchUpdateCardReqBuilder {
	builder.body = body
	return builder
}

func (builder *BatchUpdateCardReqBuilder) Build() *BatchUpdateCardReq {
	req := &BatchUpdateCardReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.Body = builder.body
	return req
}

type BatchUpdateCardReqBody struct {
	Uuid *string `json:"uuid,omitempty"` // 幂等 id，最大长度为 64。可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。

	Sequence *int `json:"sequence,omitempty"` // 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。

	Actions *string `json:"actions,omitempty"` // 操作列表，可选值有： partial_update_setting：更新卡片设置，此时 parmas 结构参考更新卡片设置接口请求体的 settings 字段 ；add_elements，此时 parmas 结构参考添加组件接口请求体的 type、target_element_id、elements 字段 ； delete_elements，此时 parmas 结构内仅支持 element_ids 参数，参数值为组件 ID 数组 ； partial_update_element，此时 parmas 结构包括参考局部更新组件接口的路径参数 element_id 和请求体 partial_element 字段 ; update_element，此时 parmas 结构参考全量更新组件接口的路径参数 element_id 和请求体 element 字段
}

type BatchUpdateCardReq struct {
	apiReq *larkcore.ApiReq
	Body   *BatchUpdateCardReqBody `body:""`
}

type BatchUpdateCardResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *BatchUpdateCardResp) Success() bool {
	return resp.Code == 0
}

type CreateCardReqBodyBuilder struct {
	type_    string // 卡片数据的类型
	typeFlag bool

	data     string // 卡片数据内容，与卡片数据的类型相对应
	dataFlag bool
}

func NewCreateCardReqBodyBuilder() *CreateCardReqBodyBuilder {
	builder := &CreateCardReqBodyBuilder{}
	return builder
}

// 卡片数据的类型
//
//示例值：card_json
func (builder *CreateCardReqBodyBuilder) Type(type_ string) *CreateCardReqBodyBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

// 卡片数据内容，与卡片数据的类型相对应
//
//示例值：{\"schema\":\"2.0\",\"header\":{\"title\":{\"content\":\"卡片标题\",\"tag\":\"plain_text\"}},\"body\":{\"elements\":[{\"tag\":\"markdown\",\"content\":\"卡片内容\"}]}}
func (builder *CreateCardReqBodyBuilder) Data(data string) *CreateCardReqBodyBuilder {
	builder.data = data
	builder.dataFlag = true
	return builder
}

func (builder *CreateCardReqBodyBuilder) Build() *CreateCardReqBody {
	req := &CreateCardReqBody{}
	if builder.typeFlag {
		req.Type = &builder.type_
	}
	if builder.dataFlag {
		req.Data = &builder.data
	}
	return req
}

type CreateCardPathReqBodyBuilder struct {
	type_    string
	typeFlag bool
	data     string
	dataFlag bool
}

func NewCreateCardPathReqBodyBuilder() *CreateCardPathReqBodyBuilder {
	builder := &CreateCardPathReqBodyBuilder{}
	return builder
}

// 卡片数据的类型
//
// 示例值：card_json
func (builder *CreateCardPathReqBodyBuilder) Type(type_ string) *CreateCardPathReqBodyBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

// 卡片数据内容，与卡片数据的类型相对应
//
// 示例值：{\"schema\":\"2.0\",\"header\":{\"title\":{\"content\":\"卡片标题\",\"tag\":\"plain_text\"}},\"body\":{\"elements\":[{\"tag\":\"markdown\",\"content\":\"卡片内容\"}]}}
func (builder *CreateCardPathReqBodyBuilder) Data(data string) *CreateCardPathReqBodyBuilder {
	builder.data = data
	builder.dataFlag = true
	return builder
}

func (builder *CreateCardPathReqBodyBuilder) Build() (*CreateCardReqBody, error) {
	req := &CreateCardReqBody{}
	if builder.typeFlag {
		req.Type = &builder.type_
	}
	if builder.dataFlag {
		req.Data = &builder.data
	}
	return req, nil
}

type CreateCardReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *CreateCardReqBody
}

func NewCreateCardReqBuilder() *CreateCardReqBuilder {
	builder := &CreateCardReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 创建卡片实例，成功后可通过发送消息等接口发送卡片实例
func (builder *CreateCardReqBuilder) Body(body *CreateCardReqBody) *CreateCardReqBuilder {
	builder.body = body
	return builder
}

func (builder *CreateCardReqBuilder) Build() *CreateCardReq {
	req := &CreateCardReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.Body = builder.body
	return req
}

type CreateCardReqBody struct {
	Type *string `json:"type,omitempty"` // 卡片数据的类型

	Data *string `json:"data,omitempty"` // 卡片数据内容，与卡片数据的类型相对应
}

type CreateCardReq struct {
	apiReq *larkcore.ApiReq
	Body   *CreateCardReqBody `body:""`
}

type CreateCardRespData struct {
	CardId *string `json:"card_id,omitempty"` // 卡片ID
}

type CreateCardResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *CreateCardRespData `json:"data"` // 业务数据
}

func (resp *CreateCardResp) Success() bool {
	return resp.Code == 0
}

type IdConvertCardReqBodyBuilder struct {
	messageId     string // 消息ID
	messageIdFlag bool
}

func NewIdConvertCardReqBodyBuilder() *IdConvertCardReqBodyBuilder {
	builder := &IdConvertCardReqBodyBuilder{}
	return builder
}

// 消息ID
//
//示例值：om_fbdf6ed2e17f1d98e78fb26c1370186e
func (builder *IdConvertCardReqBodyBuilder) MessageId(messageId string) *IdConvertCardReqBodyBuilder {
	builder.messageId = messageId
	builder.messageIdFlag = true
	return builder
}

func (builder *IdConvertCardReqBodyBuilder) Build() *IdConvertCardReqBody {
	req := &IdConvertCardReqBody{}
	if builder.messageIdFlag {
		req.MessageId = &builder.messageId
	}
	return req
}

type IdConvertCardPathReqBodyBuilder struct {
	messageId     string
	messageIdFlag bool
}

func NewIdConvertCardPathReqBodyBuilder() *IdConvertCardPathReqBodyBuilder {
	builder := &IdConvertCardPathReqBodyBuilder{}
	return builder
}

// 消息ID
//
// 示例值：om_fbdf6ed2e17f1d98e78fb26c1370186e
func (builder *IdConvertCardPathReqBodyBuilder) MessageId(messageId string) *IdConvertCardPathReqBodyBuilder {
	builder.messageId = messageId
	builder.messageIdFlag = true
	return builder
}

func (builder *IdConvertCardPathReqBodyBuilder) Build() (*IdConvertCardReqBody, error) {
	req := &IdConvertCardReqBody{}
	if builder.messageIdFlag {
		req.MessageId = &builder.messageId
	}
	return req, nil
}

type IdConvertCardReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *IdConvertCardReqBody
}

func NewIdConvertCardReqBuilder() *IdConvertCardReqBuilder {
	builder := &IdConvertCardReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 获取消息 id 对应的卡片 id
func (builder *IdConvertCardReqBuilder) Body(body *IdConvertCardReqBody) *IdConvertCardReqBuilder {
	builder.body = body
	return builder
}

func (builder *IdConvertCardReqBuilder) Build() *IdConvertCardReq {
	req := &IdConvertCardReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.Body = builder.body
	return req
}

type IdConvertCardReqBody struct {
	MessageId *string `json:"message_id,omitempty"` // 消息ID
}

type IdConvertCardReq struct {
	apiReq *larkcore.ApiReq
	Body   *IdConvertCardReqBody `body:""`
}

type IdConvertCardRespData struct {
	CardId *string `json:"card_id,omitempty"` // 消息 ID 对应的卡片 ID
}

type IdConvertCardResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
	Data *IdConvertCardRespData `json:"data"` // 业务数据
}

func (resp *IdConvertCardResp) Success() bool {
	return resp.Code == 0
}

type SettingsCardReqBodyBuilder struct {
	settings     string // 卡片设置
	settingsFlag bool

	uuid     string // UUID
	uuidFlag bool

	sequence     int // 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
	sequenceFlag bool
}

func NewSettingsCardReqBodyBuilder() *SettingsCardReqBodyBuilder {
	builder := &SettingsCardReqBodyBuilder{}
	return builder
}

// 卡片设置
//
//示例值：{\"config\":{\"streaming_mode\":true,\"enable_forward\":true,\"update_multi\":true,\"width_mode\":\"fill\",\"enable_forward_interaction\":false},\"card_link\":{\"url\":\"https://open.feishu.cn\",\"android_url\":\"https://open.feishu.cn\",\"ios_url\":\"https://open.feishu.cn\",\"pc_url\":\"https://open.feishu.cn\"}}
func (builder *SettingsCardReqBodyBuilder) Settings(settings string) *SettingsCardReqBodyBuilder {
	builder.settings = settings
	builder.settingsFlag = true
	return builder
}

// UUID
//
//示例值：191857678434
func (builder *SettingsCardReqBodyBuilder) Uuid(uuid string) *SettingsCardReqBodyBuilder {
	builder.uuid = uuid
	builder.uuidFlag = true
	return builder
}

// 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
//
//示例值：1712578784
func (builder *SettingsCardReqBodyBuilder) Sequence(sequence int) *SettingsCardReqBodyBuilder {
	builder.sequence = sequence
	builder.sequenceFlag = true
	return builder
}

func (builder *SettingsCardReqBodyBuilder) Build() *SettingsCardReqBody {
	req := &SettingsCardReqBody{}
	if builder.settingsFlag {
		req.Settings = &builder.settings
	}
	if builder.uuidFlag {
		req.Uuid = &builder.uuid
	}
	if builder.sequenceFlag {
		req.Sequence = &builder.sequence
	}
	return req
}

type SettingsCardPathReqBodyBuilder struct {
	settings     string
	settingsFlag bool
	uuid         string
	uuidFlag     bool
	sequence     int
	sequenceFlag bool
}

func NewSettingsCardPathReqBodyBuilder() *SettingsCardPathReqBodyBuilder {
	builder := &SettingsCardPathReqBodyBuilder{}
	return builder
}

// 卡片设置
//
// 示例值：{\"config\":{\"streaming_mode\":true,\"enable_forward\":true,\"update_multi\":true,\"width_mode\":\"fill\",\"enable_forward_interaction\":false},\"card_link\":{\"url\":\"https://open.feishu.cn\",\"android_url\":\"https://open.feishu.cn\",\"ios_url\":\"https://open.feishu.cn\",\"pc_url\":\"https://open.feishu.cn\"}}
func (builder *SettingsCardPathReqBodyBuilder) Settings(settings string) *SettingsCardPathReqBodyBuilder {
	builder.settings = settings
	builder.settingsFlag = true
	return builder
}

// UUID
//
// 示例值：191857678434
func (builder *SettingsCardPathReqBodyBuilder) Uuid(uuid string) *SettingsCardPathReqBodyBuilder {
	builder.uuid = uuid
	builder.uuidFlag = true
	return builder
}

// 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
//
// 示例值：1712578784
func (builder *SettingsCardPathReqBodyBuilder) Sequence(sequence int) *SettingsCardPathReqBodyBuilder {
	builder.sequence = sequence
	builder.sequenceFlag = true
	return builder
}

func (builder *SettingsCardPathReqBodyBuilder) Build() (*SettingsCardReqBody, error) {
	req := &SettingsCardReqBody{}
	if builder.settingsFlag {
		req.Settings = &builder.settings
	}
	if builder.uuidFlag {
		req.Uuid = &builder.uuid
	}
	if builder.sequenceFlag {
		req.Sequence = &builder.sequence
	}
	return req, nil
}

type SettingsCardReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *SettingsCardReqBody
}

func NewSettingsCardReqBuilder() *SettingsCardReqBuilder {
	builder := &SettingsCardReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 卡片ID
//
// 示例值：7355372766134157313
func (builder *SettingsCardReqBuilder) CardId(cardId string) *SettingsCardReqBuilder {
	builder.apiReq.PathParams.Set("card_id", fmt.Sprint(cardId))
	return builder
}

// 更新指定的卡片设置
func (builder *SettingsCardReqBuilder) Body(body *SettingsCardReqBody) *SettingsCardReqBuilder {
	builder.body = body
	return builder
}

func (builder *SettingsCardReqBuilder) Build() *SettingsCardReq {
	req := &SettingsCardReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.Body = builder.body
	return req
}

type SettingsCardReqBody struct {
	Settings *string `json:"settings,omitempty"` // 卡片设置

	Uuid *string `json:"uuid,omitempty"` // UUID

	Sequence *int `json:"sequence,omitempty"` // 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
}

type SettingsCardReq struct {
	apiReq *larkcore.ApiReq
	Body   *SettingsCardReqBody `body:""`
}

type SettingsCardResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *SettingsCardResp) Success() bool {
	return resp.Code == 0
}

type UpdateCardReqBodyBuilder struct {
	card     *Card // 卡片内容
	cardFlag bool

	uuid     string // 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
	uuidFlag bool

	sequence     int // 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
	sequenceFlag bool
}

func NewUpdateCardReqBodyBuilder() *UpdateCardReqBodyBuilder {
	builder := &UpdateCardReqBodyBuilder{}
	return builder
}

// 卡片内容
//
//示例值：
func (builder *UpdateCardReqBodyBuilder) Card(card *Card) *UpdateCardReqBodyBuilder {
	builder.card = card
	builder.cardFlag = true
	return builder
}

// 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
//
//示例值：191857678434
func (builder *UpdateCardReqBodyBuilder) Uuid(uuid string) *UpdateCardReqBodyBuilder {
	builder.uuid = uuid
	builder.uuidFlag = true
	return builder
}

// 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
//
//示例值：1712578784
func (builder *UpdateCardReqBodyBuilder) Sequence(sequence int) *UpdateCardReqBodyBuilder {
	builder.sequence = sequence
	builder.sequenceFlag = true
	return builder
}

func (builder *UpdateCardReqBodyBuilder) Build() *UpdateCardReqBody {
	req := &UpdateCardReqBody{}
	if builder.cardFlag {
		req.Card = builder.card
	}
	if builder.uuidFlag {
		req.Uuid = &builder.uuid
	}
	if builder.sequenceFlag {
		req.Sequence = &builder.sequence
	}
	return req
}

type UpdateCardPathReqBodyBuilder struct {
	card         *Card
	cardFlag     bool
	uuid         string
	uuidFlag     bool
	sequence     int
	sequenceFlag bool
}

func NewUpdateCardPathReqBodyBuilder() *UpdateCardPathReqBodyBuilder {
	builder := &UpdateCardPathReqBodyBuilder{}
	return builder
}

// 卡片内容
//
// 示例值：
func (builder *UpdateCardPathReqBodyBuilder) Card(card *Card) *UpdateCardPathReqBodyBuilder {
	builder.card = card
	builder.cardFlag = true
	return builder
}

// 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
//
// 示例值：191857678434
func (builder *UpdateCardPathReqBodyBuilder) Uuid(uuid string) *UpdateCardPathReqBodyBuilder {
	builder.uuid = uuid
	builder.uuidFlag = true
	return builder
}

// 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
//
// 示例值：1712578784
func (builder *UpdateCardPathReqBodyBuilder) Sequence(sequence int) *UpdateCardPathReqBodyBuilder {
	builder.sequence = sequence
	builder.sequenceFlag = true
	return builder
}

func (builder *UpdateCardPathReqBodyBuilder) Build() (*UpdateCardReqBody, error) {
	req := &UpdateCardReqBody{}
	if builder.cardFlag {
		req.Card = builder.card
	}
	if builder.uuidFlag {
		req.Uuid = &builder.uuid
	}
	if builder.sequenceFlag {
		req.Sequence = &builder.sequence
	}
	return req, nil
}

type UpdateCardReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *UpdateCardReqBody
}

func NewUpdateCardReqBuilder() *UpdateCardReqBuilder {
	builder := &UpdateCardReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 卡片ID
//
// 示例值：7355372766134157313
func (builder *UpdateCardReqBuilder) CardId(cardId string) *UpdateCardReqBuilder {
	builder.apiReq.PathParams.Set("card_id", fmt.Sprint(cardId))
	return builder
}

// 对卡片进行全量更新，即：以全新的卡片内容更新已有卡片
func (builder *UpdateCardReqBuilder) Body(body *UpdateCardReqBody) *UpdateCardReqBuilder {
	builder.body = body
	return builder
}

func (builder *UpdateCardReqBuilder) Build() *UpdateCardReq {
	req := &UpdateCardReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.Body = builder.body
	return req
}

type UpdateCardReqBody struct {
	Card *Card `json:"card,omitempty"` // 卡片内容

	Uuid *string `json:"uuid,omitempty"` // 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。

	Sequence *int `json:"sequence,omitempty"` // 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
}

type UpdateCardReq struct {
	apiReq *larkcore.ApiReq
	Body   *UpdateCardReqBody `body:""`
}

type UpdateCardResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *UpdateCardResp) Success() bool {
	return resp.Code == 0
}

type ContentCardElementReqBodyBuilder struct {
	uuid     string // 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
	uuidFlag bool

	content     string // 更新后的文本内容
	contentFlag bool

	sequence     int // 顺序序号，用于保证更新文本内容的时序性。在卡片的单次 streaming 模式周期中（steaming 状态从开始到停止），该值需为递增的正整数，否则将报错。
	sequenceFlag bool
}

func NewContentCardElementReqBodyBuilder() *ContentCardElementReqBodyBuilder {
	builder := &ContentCardElementReqBodyBuilder{}
	return builder
}

// 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
//
//示例值：191857678434
func (builder *ContentCardElementReqBodyBuilder) Uuid(uuid string) *ContentCardElementReqBodyBuilder {
	builder.uuid = uuid
	builder.uuidFlag = true
	return builder
}

// 更新后的文本内容
//
//示例值：{\"content\":\"更新后的文本内容\"}
func (builder *ContentCardElementReqBodyBuilder) Content(content string) *ContentCardElementReqBodyBuilder {
	builder.content = content
	builder.contentFlag = true
	return builder
}

// 顺序序号，用于保证更新文本内容的时序性。在卡片的单次 streaming 模式周期中（steaming 状态从开始到停止），该值需为递增的正整数，否则将报错。
//
//示例值：1712578784
func (builder *ContentCardElementReqBodyBuilder) Sequence(sequence int) *ContentCardElementReqBodyBuilder {
	builder.sequence = sequence
	builder.sequenceFlag = true
	return builder
}

func (builder *ContentCardElementReqBodyBuilder) Build() *ContentCardElementReqBody {
	req := &ContentCardElementReqBody{}
	if builder.uuidFlag {
		req.Uuid = &builder.uuid
	}
	if builder.contentFlag {
		req.Content = &builder.content
	}
	if builder.sequenceFlag {
		req.Sequence = &builder.sequence
	}
	return req
}

type ContentCardElementPathReqBodyBuilder struct {
	uuid         string
	uuidFlag     bool
	content      string
	contentFlag  bool
	sequence     int
	sequenceFlag bool
}

func NewContentCardElementPathReqBodyBuilder() *ContentCardElementPathReqBodyBuilder {
	builder := &ContentCardElementPathReqBodyBuilder{}
	return builder
}

// 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
//
// 示例值：191857678434
func (builder *ContentCardElementPathReqBodyBuilder) Uuid(uuid string) *ContentCardElementPathReqBodyBuilder {
	builder.uuid = uuid
	builder.uuidFlag = true
	return builder
}

// 更新后的文本内容
//
// 示例值：{\"content\":\"更新后的文本内容\"}
func (builder *ContentCardElementPathReqBodyBuilder) Content(content string) *ContentCardElementPathReqBodyBuilder {
	builder.content = content
	builder.contentFlag = true
	return builder
}

// 顺序序号，用于保证更新文本内容的时序性。在卡片的单次 streaming 模式周期中（steaming 状态从开始到停止），该值需为递增的正整数，否则将报错。
//
// 示例值：1712578784
func (builder *ContentCardElementPathReqBodyBuilder) Sequence(sequence int) *ContentCardElementPathReqBodyBuilder {
	builder.sequence = sequence
	builder.sequenceFlag = true
	return builder
}

func (builder *ContentCardElementPathReqBodyBuilder) Build() (*ContentCardElementReqBody, error) {
	req := &ContentCardElementReqBody{}
	if builder.uuidFlag {
		req.Uuid = &builder.uuid
	}
	if builder.contentFlag {
		req.Content = &builder.content
	}
	if builder.sequenceFlag {
		req.Sequence = &builder.sequence
	}
	return req, nil
}

type ContentCardElementReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *ContentCardElementReqBody
}

func NewContentCardElementReqBuilder() *ContentCardElementReqBuilder {
	builder := &ContentCardElementReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 卡片ID
//
// 示例值：7355439197428236291
func (builder *ContentCardElementReqBuilder) CardId(cardId string) *ContentCardElementReqBuilder {
	builder.apiReq.PathParams.Set("card_id", fmt.Sprint(cardId))
	return builder
}

// 组件ID
//
// 示例值：elem_63529372
func (builder *ContentCardElementReqBuilder) ElementId(elementId string) *ContentCardElementReqBuilder {
	builder.apiReq.PathParams.Set("element_id", fmt.Sprint(elementId))
	return builder
}

// 以传入的文本内容覆盖已有卡片组件内容，卡片将自动识别其中的增量变更内容，并以“打字机”效果输出。
func (builder *ContentCardElementReqBuilder) Body(body *ContentCardElementReqBody) *ContentCardElementReqBuilder {
	builder.body = body
	return builder
}

func (builder *ContentCardElementReqBuilder) Build() *ContentCardElementReq {
	req := &ContentCardElementReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.Body = builder.body
	return req
}

type ContentCardElementReqBody struct {
	Uuid *string `json:"uuid,omitempty"` // 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。

	Content *string `json:"content,omitempty"` // 更新后的文本内容

	Sequence *int `json:"sequence,omitempty"` // 顺序序号，用于保证更新文本内容的时序性。在卡片的单次 streaming 模式周期中（steaming 状态从开始到停止），该值需为递增的正整数，否则将报错。
}

type ContentCardElementReq struct {
	apiReq *larkcore.ApiReq
	Body   *ContentCardElementReqBody `body:""`
}

type ContentCardElementResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *ContentCardElementResp) Success() bool {
	return resp.Code == 0
}

type CreateCardElementReqBodyBuilder struct {
	type_    string // 添加组件的方式
	typeFlag bool

	targetElementId     string // 目标组件的 ID。 当 type 为 insert_before、insert_after 时，为用于定位的目标组件。 当 type 为 append 时，该字段仅支持容器类组件，为用于指定末尾添加的目标组件，未填写默认为在卡片 body 末尾添加。
	targetElementIdFlag bool

	uuid     string // 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
	uuidFlag bool

	sequence     int // 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
	sequenceFlag bool

	elements     string // 组件列表
	elementsFlag bool
}

func NewCreateCardElementReqBodyBuilder() *CreateCardElementReqBodyBuilder {
	builder := &CreateCardElementReqBodyBuilder{}
	return builder
}

// 添加组件的方式
//
//示例值：insert_before
func (builder *CreateCardElementReqBodyBuilder) Type(type_ string) *CreateCardElementReqBodyBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

// 目标组件的 ID。 当 type 为 insert_before、insert_after 时，为用于定位的目标组件。 当 type 为 append 时，该字段仅支持容器类组件，为用于指定末尾添加的目标组件，未填写默认为在卡片 body 末尾添加。
//
//示例值：elem_63529372
func (builder *CreateCardElementReqBodyBuilder) TargetElementId(targetElementId string) *CreateCardElementReqBodyBuilder {
	builder.targetElementId = targetElementId
	builder.targetElementIdFlag = true
	return builder
}

// 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
//
//示例值：191857678434
func (builder *CreateCardElementReqBodyBuilder) Uuid(uuid string) *CreateCardElementReqBodyBuilder {
	builder.uuid = uuid
	builder.uuidFlag = true
	return builder
}

// 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
//
//示例值：1712578784
func (builder *CreateCardElementReqBodyBuilder) Sequence(sequence int) *CreateCardElementReqBodyBuilder {
	builder.sequence = sequence
	builder.sequenceFlag = true
	return builder
}

// 组件列表
//
//示例值：[{\"tag\":\"markdown\",\"id\":\"md_1\",\"content\":\"示例文本\"}]
func (builder *CreateCardElementReqBodyBuilder) Elements(elements string) *CreateCardElementReqBodyBuilder {
	builder.elements = elements
	builder.elementsFlag = true
	return builder
}

func (builder *CreateCardElementReqBodyBuilder) Build() *CreateCardElementReqBody {
	req := &CreateCardElementReqBody{}
	if builder.typeFlag {
		req.Type = &builder.type_
	}
	if builder.targetElementIdFlag {
		req.TargetElementId = &builder.targetElementId
	}
	if builder.uuidFlag {
		req.Uuid = &builder.uuid
	}
	if builder.sequenceFlag {
		req.Sequence = &builder.sequence
	}
	if builder.elementsFlag {
		req.Elements = &builder.elements
	}
	return req
}

type CreateCardElementPathReqBodyBuilder struct {
	type_               string
	typeFlag            bool
	targetElementId     string
	targetElementIdFlag bool
	uuid                string
	uuidFlag            bool
	sequence            int
	sequenceFlag        bool
	elements            string
	elementsFlag        bool
}

func NewCreateCardElementPathReqBodyBuilder() *CreateCardElementPathReqBodyBuilder {
	builder := &CreateCardElementPathReqBodyBuilder{}
	return builder
}

// 添加组件的方式
//
// 示例值：insert_before
func (builder *CreateCardElementPathReqBodyBuilder) Type(type_ string) *CreateCardElementPathReqBodyBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

// 目标组件的 ID。 当 type 为 insert_before、insert_after 时，为用于定位的目标组件。 当 type 为 append 时，该字段仅支持容器类组件，为用于指定末尾添加的目标组件，未填写默认为在卡片 body 末尾添加。
//
// 示例值：elem_63529372
func (builder *CreateCardElementPathReqBodyBuilder) TargetElementId(targetElementId string) *CreateCardElementPathReqBodyBuilder {
	builder.targetElementId = targetElementId
	builder.targetElementIdFlag = true
	return builder
}

// 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
//
// 示例值：191857678434
func (builder *CreateCardElementPathReqBodyBuilder) Uuid(uuid string) *CreateCardElementPathReqBodyBuilder {
	builder.uuid = uuid
	builder.uuidFlag = true
	return builder
}

// 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
//
// 示例值：1712578784
func (builder *CreateCardElementPathReqBodyBuilder) Sequence(sequence int) *CreateCardElementPathReqBodyBuilder {
	builder.sequence = sequence
	builder.sequenceFlag = true
	return builder
}

// 组件列表
//
// 示例值：[{\"tag\":\"markdown\",\"id\":\"md_1\",\"content\":\"示例文本\"}]
func (builder *CreateCardElementPathReqBodyBuilder) Elements(elements string) *CreateCardElementPathReqBodyBuilder {
	builder.elements = elements
	builder.elementsFlag = true
	return builder
}

func (builder *CreateCardElementPathReqBodyBuilder) Build() (*CreateCardElementReqBody, error) {
	req := &CreateCardElementReqBody{}
	if builder.typeFlag {
		req.Type = &builder.type_
	}
	if builder.targetElementIdFlag {
		req.TargetElementId = &builder.targetElementId
	}
	if builder.uuidFlag {
		req.Uuid = &builder.uuid
	}
	if builder.sequenceFlag {
		req.Sequence = &builder.sequence
	}
	if builder.elementsFlag {
		req.Elements = &builder.elements
	}
	return req, nil
}

type CreateCardElementReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *CreateCardElementReqBody
}

func NewCreateCardElementReqBuilder() *CreateCardElementReqBuilder {
	builder := &CreateCardElementReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 卡片ID
//
// 示例值：7355439197428236291
func (builder *CreateCardElementReqBuilder) CardId(cardId string) *CreateCardElementReqBuilder {
	builder.apiReq.PathParams.Set("card_id", fmt.Sprint(cardId))
	return builder
}

// 在卡片内指定位置添加组件
func (builder *CreateCardElementReqBuilder) Body(body *CreateCardElementReqBody) *CreateCardElementReqBuilder {
	builder.body = body
	return builder
}

func (builder *CreateCardElementReqBuilder) Build() *CreateCardElementReq {
	req := &CreateCardElementReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.Body = builder.body
	return req
}

type CreateCardElementReqBody struct {
	Type *string `json:"type,omitempty"` // 添加组件的方式

	TargetElementId *string `json:"target_element_id,omitempty"` // 目标组件的 ID。 当 type 为 insert_before、insert_after 时，为用于定位的目标组件。 当 type 为 append 时，该字段仅支持容器类组件，为用于指定末尾添加的目标组件，未填写默认为在卡片 body 末尾添加。

	Uuid *string `json:"uuid,omitempty"` // 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。

	Sequence *int `json:"sequence,omitempty"` // 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。

	Elements *string `json:"elements,omitempty"` // 组件列表
}

type CreateCardElementReq struct {
	apiReq *larkcore.ApiReq
	Body   *CreateCardElementReqBody `body:""`
}

type CreateCardElementResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *CreateCardElementResp) Success() bool {
	return resp.Code == 0
}

type DeleteCardElementReqBodyBuilder struct {
	uuid     string // 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
	uuidFlag bool

	sequence     int // 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
	sequenceFlag bool
}

func NewDeleteCardElementReqBodyBuilder() *DeleteCardElementReqBodyBuilder {
	builder := &DeleteCardElementReqBodyBuilder{}
	return builder
}

// 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
//
//示例值：191857678434
func (builder *DeleteCardElementReqBodyBuilder) Uuid(uuid string) *DeleteCardElementReqBodyBuilder {
	builder.uuid = uuid
	builder.uuidFlag = true
	return builder
}

// 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
//
//示例值：1712578784
func (builder *DeleteCardElementReqBodyBuilder) Sequence(sequence int) *DeleteCardElementReqBodyBuilder {
	builder.sequence = sequence
	builder.sequenceFlag = true
	return builder
}

func (builder *DeleteCardElementReqBodyBuilder) Build() *DeleteCardElementReqBody {
	req := &DeleteCardElementReqBody{}
	if builder.uuidFlag {
		req.Uuid = &builder.uuid
	}
	if builder.sequenceFlag {
		req.Sequence = &builder.sequence
	}
	return req
}

type DeleteCardElementPathReqBodyBuilder struct {
	uuid         string
	uuidFlag     bool
	sequence     int
	sequenceFlag bool
}

func NewDeleteCardElementPathReqBodyBuilder() *DeleteCardElementPathReqBodyBuilder {
	builder := &DeleteCardElementPathReqBodyBuilder{}
	return builder
}

// 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
//
// 示例值：191857678434
func (builder *DeleteCardElementPathReqBodyBuilder) Uuid(uuid string) *DeleteCardElementPathReqBodyBuilder {
	builder.uuid = uuid
	builder.uuidFlag = true
	return builder
}

// 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
//
// 示例值：1712578784
func (builder *DeleteCardElementPathReqBodyBuilder) Sequence(sequence int) *DeleteCardElementPathReqBodyBuilder {
	builder.sequence = sequence
	builder.sequenceFlag = true
	return builder
}

func (builder *DeleteCardElementPathReqBodyBuilder) Build() (*DeleteCardElementReqBody, error) {
	req := &DeleteCardElementReqBody{}
	if builder.uuidFlag {
		req.Uuid = &builder.uuid
	}
	if builder.sequenceFlag {
		req.Sequence = &builder.sequence
	}
	return req, nil
}

type DeleteCardElementReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *DeleteCardElementReqBody
}

func NewDeleteCardElementReqBuilder() *DeleteCardElementReqBuilder {
	builder := &DeleteCardElementReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 卡片ID
//
// 示例值：7355439197428236291
func (builder *DeleteCardElementReqBuilder) CardId(cardId string) *DeleteCardElementReqBuilder {
	builder.apiReq.PathParams.Set("card_id", fmt.Sprint(cardId))
	return builder
}

// 组件ID
//
// 示例值：elem_63529372
func (builder *DeleteCardElementReqBuilder) ElementId(elementId string) *DeleteCardElementReqBuilder {
	builder.apiReq.PathParams.Set("element_id", fmt.Sprint(elementId))
	return builder
}

// 删除卡片内的指定组件
func (builder *DeleteCardElementReqBuilder) Body(body *DeleteCardElementReqBody) *DeleteCardElementReqBuilder {
	builder.body = body
	return builder
}

func (builder *DeleteCardElementReqBuilder) Build() *DeleteCardElementReq {
	req := &DeleteCardElementReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.Body = builder.body
	return req
}

type DeleteCardElementReqBody struct {
	Uuid *string `json:"uuid,omitempty"` // 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。

	Sequence *int `json:"sequence,omitempty"` // 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
}

type DeleteCardElementReq struct {
	apiReq *larkcore.ApiReq
	Body   *DeleteCardElementReqBody `body:""`
}

type DeleteCardElementResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *DeleteCardElementResp) Success() bool {
	return resp.Code == 0
}

type PatchCardElementReqBodyBuilder struct {
	partialElement     string // 要更改的组件部分配置内容，传入 id 参数后将对原有组件的 id 进行更新，不支持修改 tag 参数。
	partialElementFlag bool

	uuid     string // 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
	uuidFlag bool

	sequence     int // 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
	sequenceFlag bool
}

func NewPatchCardElementReqBodyBuilder() *PatchCardElementReqBodyBuilder {
	builder := &PatchCardElementReqBodyBuilder{}
	return builder
}

// 要更改的组件部分配置内容，传入 id 参数后将对原有组件的 id 进行更新，不支持修改 tag 参数。
//
//示例值：{\"content\":\"更新后的组件文本\"}
func (builder *PatchCardElementReqBodyBuilder) PartialElement(partialElement string) *PatchCardElementReqBodyBuilder {
	builder.partialElement = partialElement
	builder.partialElementFlag = true
	return builder
}

// 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
//
//示例值：191857678434
func (builder *PatchCardElementReqBodyBuilder) Uuid(uuid string) *PatchCardElementReqBodyBuilder {
	builder.uuid = uuid
	builder.uuidFlag = true
	return builder
}

// 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
//
//示例值：1712578784
func (builder *PatchCardElementReqBodyBuilder) Sequence(sequence int) *PatchCardElementReqBodyBuilder {
	builder.sequence = sequence
	builder.sequenceFlag = true
	return builder
}

func (builder *PatchCardElementReqBodyBuilder) Build() *PatchCardElementReqBody {
	req := &PatchCardElementReqBody{}
	if builder.partialElementFlag {
		req.PartialElement = &builder.partialElement
	}
	if builder.uuidFlag {
		req.Uuid = &builder.uuid
	}
	if builder.sequenceFlag {
		req.Sequence = &builder.sequence
	}
	return req
}

type PatchCardElementPathReqBodyBuilder struct {
	partialElement     string
	partialElementFlag bool
	uuid               string
	uuidFlag           bool
	sequence           int
	sequenceFlag       bool
}

func NewPatchCardElementPathReqBodyBuilder() *PatchCardElementPathReqBodyBuilder {
	builder := &PatchCardElementPathReqBodyBuilder{}
	return builder
}

// 要更改的组件部分配置内容，传入 id 参数后将对原有组件的 id 进行更新，不支持修改 tag 参数。
//
// 示例值：{\"content\":\"更新后的组件文本\"}
func (builder *PatchCardElementPathReqBodyBuilder) PartialElement(partialElement string) *PatchCardElementPathReqBodyBuilder {
	builder.partialElement = partialElement
	builder.partialElementFlag = true
	return builder
}

// 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
//
// 示例值：191857678434
func (builder *PatchCardElementPathReqBodyBuilder) Uuid(uuid string) *PatchCardElementPathReqBodyBuilder {
	builder.uuid = uuid
	builder.uuidFlag = true
	return builder
}

// 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
//
// 示例值：1712578784
func (builder *PatchCardElementPathReqBodyBuilder) Sequence(sequence int) *PatchCardElementPathReqBodyBuilder {
	builder.sequence = sequence
	builder.sequenceFlag = true
	return builder
}

func (builder *PatchCardElementPathReqBodyBuilder) Build() (*PatchCardElementReqBody, error) {
	req := &PatchCardElementReqBody{}
	if builder.partialElementFlag {
		req.PartialElement = &builder.partialElement
	}
	if builder.uuidFlag {
		req.Uuid = &builder.uuid
	}
	if builder.sequenceFlag {
		req.Sequence = &builder.sequence
	}
	return req, nil
}

type PatchCardElementReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *PatchCardElementReqBody
}

func NewPatchCardElementReqBuilder() *PatchCardElementReqBuilder {
	builder := &PatchCardElementReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 卡片ID
//
// 示例值：7355439197428236291
func (builder *PatchCardElementReqBuilder) CardId(cardId string) *PatchCardElementReqBuilder {
	builder.apiReq.PathParams.Set("card_id", fmt.Sprint(cardId))
	return builder
}

// 组件ID
//
// 示例值：elem_63529372
func (builder *PatchCardElementReqBuilder) ElementId(elementId string) *PatchCardElementReqBuilder {
	builder.apiReq.PathParams.Set("element_id", fmt.Sprint(elementId))
	return builder
}

// 以传入的配置覆盖指定组件的已有配置
func (builder *PatchCardElementReqBuilder) Body(body *PatchCardElementReqBody) *PatchCardElementReqBuilder {
	builder.body = body
	return builder
}

func (builder *PatchCardElementReqBuilder) Build() *PatchCardElementReq {
	req := &PatchCardElementReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.Body = builder.body
	return req
}

type PatchCardElementReqBody struct {
	PartialElement *string `json:"partial_element,omitempty"` // 要更改的组件部分配置内容，传入 id 参数后将对原有组件的 id 进行更新，不支持修改 tag 参数。

	Uuid *string `json:"uuid,omitempty"` // 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。

	Sequence *int `json:"sequence,omitempty"` // 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
}

type PatchCardElementReq struct {
	apiReq *larkcore.ApiReq
	Body   *PatchCardElementReqBody `body:""`
}

type PatchCardElementResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *PatchCardElementResp) Success() bool {
	return resp.Code == 0
}

type UpdateCardElementReqBodyBuilder struct {
	uuid     string // 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
	uuidFlag bool

	element     string // 新的组件
	elementFlag bool

	sequence     int // 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
	sequenceFlag bool
}

func NewUpdateCardElementReqBodyBuilder() *UpdateCardElementReqBodyBuilder {
	builder := &UpdateCardElementReqBodyBuilder{}
	return builder
}

// 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
//
//示例值：191857678434
func (builder *UpdateCardElementReqBodyBuilder) Uuid(uuid string) *UpdateCardElementReqBodyBuilder {
	builder.uuid = uuid
	builder.uuidFlag = true
	return builder
}

// 新的组件
//
//示例值：{\"tag\":\"markdown\",\"id\":\"md_1\",\"content\":\"普通文本\"}
func (builder *UpdateCardElementReqBodyBuilder) Element(element string) *UpdateCardElementReqBodyBuilder {
	builder.element = element
	builder.elementFlag = true
	return builder
}

// 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
//
//示例值：1712578784
func (builder *UpdateCardElementReqBodyBuilder) Sequence(sequence int) *UpdateCardElementReqBodyBuilder {
	builder.sequence = sequence
	builder.sequenceFlag = true
	return builder
}

func (builder *UpdateCardElementReqBodyBuilder) Build() *UpdateCardElementReqBody {
	req := &UpdateCardElementReqBody{}
	if builder.uuidFlag {
		req.Uuid = &builder.uuid
	}
	if builder.elementFlag {
		req.Element = &builder.element
	}
	if builder.sequenceFlag {
		req.Sequence = &builder.sequence
	}
	return req
}

type UpdateCardElementPathReqBodyBuilder struct {
	uuid         string
	uuidFlag     bool
	element      string
	elementFlag  bool
	sequence     int
	sequenceFlag bool
}

func NewUpdateCardElementPathReqBodyBuilder() *UpdateCardElementPathReqBodyBuilder {
	builder := &UpdateCardElementPathReqBodyBuilder{}
	return builder
}

// 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。
//
// 示例值：191857678434
func (builder *UpdateCardElementPathReqBodyBuilder) Uuid(uuid string) *UpdateCardElementPathReqBodyBuilder {
	builder.uuid = uuid
	builder.uuidFlag = true
	return builder
}

// 新的组件
//
// 示例值：{\"tag\":\"markdown\",\"id\":\"md_1\",\"content\":\"普通文本\"}
func (builder *UpdateCardElementPathReqBodyBuilder) Element(element string) *UpdateCardElementPathReqBodyBuilder {
	builder.element = element
	builder.elementFlag = true
	return builder
}

// 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
//
// 示例值：1712578784
func (builder *UpdateCardElementPathReqBodyBuilder) Sequence(sequence int) *UpdateCardElementPathReqBodyBuilder {
	builder.sequence = sequence
	builder.sequenceFlag = true
	return builder
}

func (builder *UpdateCardElementPathReqBodyBuilder) Build() (*UpdateCardElementReqBody, error) {
	req := &UpdateCardElementReqBody{}
	if builder.uuidFlag {
		req.Uuid = &builder.uuid
	}
	if builder.elementFlag {
		req.Element = &builder.element
	}
	if builder.sequenceFlag {
		req.Sequence = &builder.sequence
	}
	return req, nil
}

type UpdateCardElementReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *UpdateCardElementReqBody
}

func NewUpdateCardElementReqBuilder() *UpdateCardElementReqBuilder {
	builder := &UpdateCardElementReqBuilder{}
	builder.apiReq = &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	return builder
}

// 卡片ID
//
// 示例值：7355439197428236291
func (builder *UpdateCardElementReqBuilder) CardId(cardId string) *UpdateCardElementReqBuilder {
	builder.apiReq.PathParams.Set("card_id", fmt.Sprint(cardId))
	return builder
}

// 组件ID
//
// 示例值：elem_63529372
func (builder *UpdateCardElementReqBuilder) ElementId(elementId string) *UpdateCardElementReqBuilder {
	builder.apiReq.PathParams.Set("element_id", fmt.Sprint(elementId))
	return builder
}

// 以新组件全量替换更新指定组件
func (builder *UpdateCardElementReqBuilder) Body(body *UpdateCardElementReqBody) *UpdateCardElementReqBuilder {
	builder.body = body
	return builder
}

func (builder *UpdateCardElementReqBuilder) Build() *UpdateCardElementReq {
	req := &UpdateCardElementReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.Body = builder.body
	return req
}

type UpdateCardElementReqBody struct {
	Uuid *string `json:"uuid,omitempty"` // 幂等 id，可通过传入唯一的 uuid 以保证相同批次的操作只进行一次。

	Element *string `json:"element,omitempty"` // 新的组件

	Sequence *int `json:"sequence,omitempty"` // 卡片处于流式更新模式时，进行卡片操作的顺序序号，用于保证多次更新的时序性。值为正整数，一次流式状态的多次更新操作（streaming_mode 一次从 true 到 false 期间）需要保证 sequence 递增，否则将报错。推荐使用时间戳。
}

type UpdateCardElementReq struct {
	apiReq *larkcore.ApiReq
	Body   *UpdateCardElementReqBody `body:""`
}

type UpdateCardElementResp struct {
	*larkcore.ApiResp `json:"-"`
	larkcore.CodeError
}

func (resp *UpdateCardElementResp) Success() bool {
	return resp.Code == 0
}
