gitee.com/larksuite/oapi-sdk-go/v3@v3.0.3/service/mail/v1/model.go

// Package mail 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 larkmail

import (
	"fmt"

	"context"
	"errors"

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

const (
	WhoCanSendMailANYONE           = "ANYONE"             // Any Internet user can send mail to this mail group
	WhoCanSendMailALLINTERNALUSERS = "ALL_INTERNAL_USERS" // Anyone in the team can send mail to this mail group
	WhoCanSendMailALLGROUPMEMBERS  = "ALL_GROUP_MEMBERS"  // Any group member can send mail to this mail group
	WhoCanSendMailCUSTOMMEMBERS    = "CUSTOM_MEMBERS"     // Only custom members can send mail to this mail group, define in mailgroup.permission_members resoure
)

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

const (
	WhoCanSendMailPatchMailgroupANYONE           = "ANYONE"             // Any Internet user can send mail to this mail group
	WhoCanSendMailPatchMailgroupALLINTERNALUSERS = "ALL_INTERNAL_USERS" // Anyone in the team can send mail to this mail group
	WhoCanSendMailPatchMailgroupALLGROUPMEMBERS  = "ALL_GROUP_MEMBERS"  // Any group member can send mail to this mail group
	WhoCanSendMailPatchMailgroupCUSTOMMEMBERS    = "CUSTOM_MEMBERS"     // Only custom members can send mail to this mail group, define in mailgroup.permission_members resoure
)

const (
	WhoCanSendMailUpdateMailgroupANYONE           = "ANYONE"             // Any Internet user can send mail to this mail group
	WhoCanSendMailUpdateMailgroupALLINTERNALUSERS = "ALL_INTERNAL_USERS" // Anyone in the team can send mail to this mail group
	WhoCanSendMailUpdateMailgroupALLGROUPMEMBERS  = "ALL_GROUP_MEMBERS"  // Any group member can send mail to this mail group
	WhoCanSendMailUpdateMailgroupCUSTOMMEMBERS    = "CUSTOM_MEMBERS"     // Only custom members can send mail to this mail group, define in mailgroup.permission_members resoure
)

const (
	TypeUSER          = "USER"           // internal user in the team
	TypeDEPARTMENT    = "DEPARTMENT"     // member is a department
	TypeCOMPANY       = "COMPANY"        // member is the company
	TypeEXTERNALUSER  = "EXTERNAL_USER"  // internet user outside the organization
	TypeMAILGROUP     = "MAIL_GROUP"     // member is another mail group
	TypePUBLICMAILBOX = "PUBLIC_MAILBOX" // member is a public mailbox
	TypeOTHERMEMBER   = "OTHER_MEMBER"   // other internal member
)

const (
	UserIdTypeCreateMailgroupMemberUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeCreateMailgroupMemberUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeCreateMailgroupMemberOpenId  = "open_id"  // 以open_id来识别用户
)

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

const (
	UserIdTypeGetMailgroupMemberUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeGetMailgroupMemberUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeGetMailgroupMemberOpenId  = "open_id"  // 以open_id来识别用户
)

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

const (
	UserIdTypeListMailgroupMemberUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeListMailgroupMemberUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeListMailgroupMemberOpenId  = "open_id"  // 以open_id来识别用户
)

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

const (
	TypeCreateMailgroupPermissionMemberUSER       = "USER"       // internal user in the team
	TypeCreateMailgroupPermissionMemberDEPARTMENT = "DEPARTMENT" // member is a department
)

const (
	UserIdTypeCreateMailgroupPermissionMemberUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeCreateMailgroupPermissionMemberUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeCreateMailgroupPermissionMemberOpenId  = "open_id"  // 以open_id来识别用户
)

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

const (
	UserIdTypeGetMailgroupPermissionMemberUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeGetMailgroupPermissionMemberUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeGetMailgroupPermissionMemberOpenId  = "open_id"  // 以open_id来识别用户
)

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

const (
	UserIdTypeListMailgroupPermissionMemberUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeListMailgroupPermissionMemberUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeListMailgroupPermissionMemberOpenId  = "open_id"  // 以open_id来识别用户
)

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

const (
	TypeCreatePublicMailboxMemberUSER = "USER" // internal user in the team
)

const (
	UserIdTypeCreatePublicMailboxMemberUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeCreatePublicMailboxMemberUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeCreatePublicMailboxMemberOpenId  = "open_id"  // 以open_id来识别用户
)

const (
	UserIdTypeGetPublicMailboxMemberUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeGetPublicMailboxMemberUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeGetPublicMailboxMemberOpenId  = "open_id"  // 以open_id来识别用户
)

const (
	UserIdTypeListPublicMailboxMemberUserId  = "user_id"  // 以user_id来识别用户
	UserIdTypeListPublicMailboxMemberUnionId = "union_id" // 以union_id来识别用户
	UserIdTypeListPublicMailboxMemberOpenId  = "open_id"  // 以open_id来识别用户
)

type EmailAlias struct {
	PrimaryEmail *string `json:"primary_email,omitempty"` // 主邮箱地址
	EmailAlias   *string `json:"email_alias,omitempty"`   // 邮箱别名
}

type EmailAliasBuilder struct {
	primaryEmail     string // 主邮箱地址
	primaryEmailFlag bool
	emailAlias       string // 邮箱别名
	emailAliasFlag   bool
}

func NewEmailAliasBuilder() *EmailAliasBuilder {
	builder := &EmailAliasBuilder{}
	return builder
}

// 主邮箱地址
//
// 示例值：xxx@xx.xxx
func (builder *EmailAliasBuilder) PrimaryEmail(primaryEmail string) *EmailAliasBuilder {
	builder.primaryEmail = primaryEmail
	builder.primaryEmailFlag = true
	return builder
}

// 邮箱别名
//
// 示例值：xxx@xx.xxx
func (builder *EmailAliasBuilder) EmailAlias(emailAlias string) *EmailAliasBuilder {
	builder.emailAlias = emailAlias
	builder.emailAliasFlag = true
	return builder
}

func (builder *EmailAliasBuilder) Build() *EmailAlias {
	req := &EmailAlias{}
	if builder.primaryEmailFlag {
		req.PrimaryEmail = &builder.primaryEmail

	}
	if builder.emailAliasFlag {
		req.EmailAlias = &builder.emailAlias

	}
	return req
}

type Mailgroup struct {
	MailgroupId             *string `json:"mailgroup_id,omitempty"`               // 邮件组ID
	Email                   *string `json:"email,omitempty"`                      // 邮件组地址
	Name                    *string `json:"name,omitempty"`                       // 邮件组名称
	Description             *string `json:"description,omitempty"`                // 邮件组描述
	DirectMembersCount      *string `json:"direct_members_count,omitempty"`       // 邮件组成员数量
	IncludeExternalMember   *bool   `json:"include_external_member,omitempty"`    // 是否包含外部成员
	IncludeAllCompanyMember *bool   `json:"include_all_company_member,omitempty"` // 是否是全员邮件组
	WhoCanSendMail          *string `json:"who_can_send_mail,omitempty"`          // 谁可发送邮件到此邮件组
}

type MailgroupBuilder struct {
	mailgroupId                 string // 邮件组ID
	mailgroupIdFlag             bool
	email                       string // 邮件组地址
	emailFlag                   bool
	name                        string // 邮件组名称
	nameFlag                    bool
	description                 string // 邮件组描述
	descriptionFlag             bool
	directMembersCount          string // 邮件组成员数量
	directMembersCountFlag      bool
	includeExternalMember       bool // 是否包含外部成员
	includeExternalMemberFlag   bool
	includeAllCompanyMember     bool // 是否是全员邮件组
	includeAllCompanyMemberFlag bool
	whoCanSendMail              string // 谁可发送邮件到此邮件组
	whoCanSendMailFlag          bool
}

func NewMailgroupBuilder() *MailgroupBuilder {
	builder := &MailgroupBuilder{}
	return builder
}

// 邮件组ID
//
// 示例值：xxxxxxxxxxxxxxx
func (builder *MailgroupBuilder) MailgroupId(mailgroupId string) *MailgroupBuilder {
	builder.mailgroupId = mailgroupId
	builder.mailgroupIdFlag = true
	return builder
}

// 邮件组地址
//
// 示例值：test_mail_group@xxx.xx
func (builder *MailgroupBuilder) Email(email string) *MailgroupBuilder {
	builder.email = email
	builder.emailFlag = true
	return builder
}

// 邮件组名称
//
// 示例值：test mail group
func (builder *MailgroupBuilder) Name(name string) *MailgroupBuilder {
	builder.name = name
	builder.nameFlag = true
	return builder
}

// 邮件组描述
//
// 示例值：mail group for testing
func (builder *MailgroupBuilder) Description(description string) *MailgroupBuilder {
	builder.description = description
	builder.descriptionFlag = true
	return builder
}

// 邮件组成员数量
//
// 示例值：10
func (builder *MailgroupBuilder) DirectMembersCount(directMembersCount string) *MailgroupBuilder {
	builder.directMembersCount = directMembersCount
	builder.directMembersCountFlag = true
	return builder
}

// 是否包含外部成员
//
// 示例值：true
func (builder *MailgroupBuilder) IncludeExternalMember(includeExternalMember bool) *MailgroupBuilder {
	builder.includeExternalMember = includeExternalMember
	builder.includeExternalMemberFlag = true
	return builder
}

// 是否是全员邮件组
//
// 示例值：false
func (builder *MailgroupBuilder) IncludeAllCompanyMember(includeAllCompanyMember bool) *MailgroupBuilder {
	builder.includeAllCompanyMember = includeAllCompanyMember
	builder.includeAllCompanyMemberFlag = true
	return builder
}

// 谁可发送邮件到此邮件组
//
// 示例值：ALL_INTERNAL_USERS
func (builder *MailgroupBuilder) WhoCanSendMail(whoCanSendMail string) *MailgroupBuilder {
	builder.whoCanSendMail = whoCanSendMail
	builder.whoCanSendMailFlag = true
	return builder
}

func (builder *MailgroupBuilder) Build() *Mailgroup {
	req := &Mailgroup{}
	if builder.mailgroupIdFlag {
		req.MailgroupId = &builder.mailgroupId

	}
	if builder.emailFlag {
		req.Email = &builder.email

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

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

	}
	if builder.directMembersCountFlag {
		req.DirectMembersCount = &builder.directMembersCount

	}
	if builder.includeExternalMemberFlag {
		req.IncludeExternalMember = &builder.includeExternalMember

	}
	if builder.includeAllCompanyMemberFlag {
		req.IncludeAllCompanyMember = &builder.includeAllCompanyMember

	}
	if builder.whoCanSendMailFlag {
		req.WhoCanSendMail = &builder.whoCanSendMail

	}
	return req
}

type MailgroupMember struct {
	MemberId     *string `json:"member_id,omitempty"`     // 邮件组内成员唯一标识
	Email        *string `json:"email,omitempty"`         // 成员邮箱地址（当成员类型是EXTERNAL_USER/MAIL_GROUP/OTHER_MEMBER时有值）
	UserId       *string `json:"user_id,omitempty"`       // 租户内用户的唯一标识（当成员类型是USER时有值）
	DepartmentId *string `json:"department_id,omitempty"` // 租户内部门的唯一标识（当成员类型是DEPARTMENT时有值）
	Type         *string `json:"type,omitempty"`          // 成员类型
}

type MailgroupMemberBuilder struct {
	memberId         string // 邮件组内成员唯一标识
	memberIdFlag     bool
	email            string // 成员邮箱地址（当成员类型是EXTERNAL_USER/MAIL_GROUP/OTHER_MEMBER时有值）
	emailFlag        bool
	userId           string // 租户内用户的唯一标识（当成员类型是USER时有值）
	userIdFlag       bool
	departmentId     string // 租户内部门的唯一标识（当成员类型是DEPARTMENT时有值）
	departmentIdFlag bool
	type_            string // 成员类型
	typeFlag         bool
}

func NewMailgroupMemberBuilder() *MailgroupMemberBuilder {
	builder := &MailgroupMemberBuilder{}
	return builder
}

// 邮件组内成员唯一标识
//
// 示例值：xxxxxxxxxxxxxxx
func (builder *MailgroupMemberBuilder) MemberId(memberId string) *MailgroupMemberBuilder {
	builder.memberId = memberId
	builder.memberIdFlag = true
	return builder
}

// 成员邮箱地址（当成员类型是EXTERNAL_USER/MAIL_GROUP/OTHER_MEMBER时有值）
//
// 示例值：test_memeber@xxx.xx
func (builder *MailgroupMemberBuilder) Email(email string) *MailgroupMemberBuilder {
	builder.email = email
	builder.emailFlag = true
	return builder
}

// 租户内用户的唯一标识（当成员类型是USER时有值）
//
// 示例值：xxxxxxxxxx
func (builder *MailgroupMemberBuilder) UserId(userId string) *MailgroupMemberBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 租户内部门的唯一标识（当成员类型是DEPARTMENT时有值）
//
// 示例值：xxxxxxxxxx
func (builder *MailgroupMemberBuilder) DepartmentId(departmentId string) *MailgroupMemberBuilder {
	builder.departmentId = departmentId
	builder.departmentIdFlag = true
	return builder
}

// 成员类型
//
// 示例值：USER
func (builder *MailgroupMemberBuilder) Type(type_ string) *MailgroupMemberBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

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

	}
	if builder.emailFlag {
		req.Email = &builder.email

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

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

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

	}
	return req
}

type MailgroupPermissionMember struct {
	PermissionMemberId *string `json:"permission_member_id,omitempty"` // 权限组内成员唯一标识
	UserId             *string `json:"user_id,omitempty"`              // 租户内用户的唯一标识（当成员类型是USER时有值）
	DepartmentId       *string `json:"department_id,omitempty"`        // 租户内部门的唯一标识（当成员类型是DEPARTMENT时有值）
	Type               *string `json:"type,omitempty"`                 // 成员类型
}

type MailgroupPermissionMemberBuilder struct {
	permissionMemberId     string // 权限组内成员唯一标识
	permissionMemberIdFlag bool
	userId                 string // 租户内用户的唯一标识（当成员类型是USER时有值）
	userIdFlag             bool
	departmentId           string // 租户内部门的唯一标识（当成员类型是DEPARTMENT时有值）
	departmentIdFlag       bool
	type_                  string // 成员类型
	typeFlag               bool
}

func NewMailgroupPermissionMemberBuilder() *MailgroupPermissionMemberBuilder {
	builder := &MailgroupPermissionMemberBuilder{}
	return builder
}

// 权限组内成员唯一标识
//
// 示例值：xxxxxxxxxxxxxxx
func (builder *MailgroupPermissionMemberBuilder) PermissionMemberId(permissionMemberId string) *MailgroupPermissionMemberBuilder {
	builder.permissionMemberId = permissionMemberId
	builder.permissionMemberIdFlag = true
	return builder
}

// 租户内用户的唯一标识（当成员类型是USER时有值）
//
// 示例值：xxxxxxxxxx
func (builder *MailgroupPermissionMemberBuilder) UserId(userId string) *MailgroupPermissionMemberBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 租户内部门的唯一标识（当成员类型是DEPARTMENT时有值）
//
// 示例值：xxxxxxxxxx
func (builder *MailgroupPermissionMemberBuilder) DepartmentId(departmentId string) *MailgroupPermissionMemberBuilder {
	builder.departmentId = departmentId
	builder.departmentIdFlag = true
	return builder
}

// 成员类型
//
// 示例值：USER
func (builder *MailgroupPermissionMemberBuilder) Type(type_ string) *MailgroupPermissionMemberBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

func (builder *MailgroupPermissionMemberBuilder) Build() *MailgroupPermissionMember {
	req := &MailgroupPermissionMember{}
	if builder.permissionMemberIdFlag {
		req.PermissionMemberId = &builder.permissionMemberId

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

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

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

	}
	return req
}

type Message struct {
	Raw *string `json:"raw,omitempty"` // MIME邮件数据，基于base64url编码
}

type MessageBuilder struct {
	raw     string // MIME邮件数据，基于base64url编码
	rawFlag bool
}

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

// MIME邮件数据，基于base64url编码
//
// 示例值：Q29udGVudC1UeXBlOiB0ZXh0L3BsYWluOyBjaGFyc2V0PSJ1cy1hc2NpaSIKTUlNRS1WZXJzaW9uOiAxLjAKQ29udGVudC1UcmFuc2Zlci1FbmNvZGluZzogN2JpdAp0bzogdG9AeHh4Lnh4CmZyb206IHNlbmRlckB4eHgueHgKc3ViamVjdDogdGhpcyBpcyBhIHN1YmplY3QKCnRoaXMgaXMgdGhlIG1lc3NhZ2UgYm9keS4=
func (builder *MessageBuilder) Raw(raw string) *MessageBuilder {
	builder.raw = raw
	builder.rawFlag = true
	return builder
}

func (builder *MessageBuilder) Build() *Message {
	req := &Message{}
	if builder.rawFlag {
		req.Raw = &builder.raw

	}
	return req
}

type PublicMailbox struct {
	PublicMailboxId *string `json:"public_mailbox_id,omitempty"` // 公共邮箱唯一标识
	Email           *string `json:"email,omitempty"`             // 公共邮箱地址
	Name            *string `json:"name,omitempty"`              // 公共邮箱名称
}

type PublicMailboxBuilder struct {
	publicMailboxId     string // 公共邮箱唯一标识
	publicMailboxIdFlag bool
	email               string // 公共邮箱地址
	emailFlag           bool
	name                string // 公共邮箱名称
	nameFlag            bool
}

func NewPublicMailboxBuilder() *PublicMailboxBuilder {
	builder := &PublicMailboxBuilder{}
	return builder
}

// 公共邮箱唯一标识
//
// 示例值：xxxxxxxxxxxxxxx
func (builder *PublicMailboxBuilder) PublicMailboxId(publicMailboxId string) *PublicMailboxBuilder {
	builder.publicMailboxId = publicMailboxId
	builder.publicMailboxIdFlag = true
	return builder
}

// 公共邮箱地址
//
// 示例值：test_public_mailbox@xxx.xx
func (builder *PublicMailboxBuilder) Email(email string) *PublicMailboxBuilder {
	builder.email = email
	builder.emailFlag = true
	return builder
}

// 公共邮箱名称
//
// 示例值：test public mailbox
func (builder *PublicMailboxBuilder) Name(name string) *PublicMailboxBuilder {
	builder.name = name
	builder.nameFlag = true
	return builder
}

func (builder *PublicMailboxBuilder) Build() *PublicMailbox {
	req := &PublicMailbox{}
	if builder.publicMailboxIdFlag {
		req.PublicMailboxId = &builder.publicMailboxId

	}
	if builder.emailFlag {
		req.Email = &builder.email

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

	}
	return req
}

type PublicMailboxMember struct {
	MemberId *string `json:"member_id,omitempty"` // 公共邮箱内成员唯一标识
	UserId   *string `json:"user_id,omitempty"`   // 租户内用户的唯一标识（当成员类型是USER时有值）
	Type     *string `json:"type,omitempty"`      // 成员类型
}

type PublicMailboxMemberBuilder struct {
	memberId     string // 公共邮箱内成员唯一标识
	memberIdFlag bool
	userId       string // 租户内用户的唯一标识（当成员类型是USER时有值）
	userIdFlag   bool
	type_        string // 成员类型
	typeFlag     bool
}

func NewPublicMailboxMemberBuilder() *PublicMailboxMemberBuilder {
	builder := &PublicMailboxMemberBuilder{}
	return builder
}

// 公共邮箱内成员唯一标识
//
// 示例值：xxxxxxxxxxxxxxx
func (builder *PublicMailboxMemberBuilder) MemberId(memberId string) *PublicMailboxMemberBuilder {
	builder.memberId = memberId
	builder.memberIdFlag = true
	return builder
}

// 租户内用户的唯一标识（当成员类型是USER时有值）
//
// 示例值：xxxxxxxxxx
func (builder *PublicMailboxMemberBuilder) UserId(userId string) *PublicMailboxMemberBuilder {
	builder.userId = userId
	builder.userIdFlag = true
	return builder
}

// 成员类型
//
// 示例值：USER
func (builder *PublicMailboxMemberBuilder) Type(type_ string) *PublicMailboxMemberBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

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

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

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

	}
	return req
}

type User struct {
	Email  *string `json:"email,omitempty"`  // 邮箱地址
	Status *int    `json:"status,omitempty"` // 邮箱地址状态
	Type   *int    `json:"type,omitempty"`   // 邮箱地址类型
}

type UserBuilder struct {
	email      string // 邮箱地址
	emailFlag  bool
	status     int // 邮箱地址状态
	statusFlag bool
	type_      int // 邮箱地址类型
	typeFlag   bool
}

func NewUserBuilder() *UserBuilder {
	builder := &UserBuilder{}
	return builder
}

// 邮箱地址
//
// 示例值：aaa@lark.com
func (builder *UserBuilder) Email(email string) *UserBuilder {
	builder.email = email
	builder.emailFlag = true
	return builder
}

// 邮箱地址状态
//
// 示例值：4
func (builder *UserBuilder) Status(status int) *UserBuilder {
	builder.status = status
	builder.statusFlag = true
	return builder
}

// 邮箱地址类型
//
// 示例值：1
func (builder *UserBuilder) Type(type_ int) *UserBuilder {
	builder.type_ = type_
	builder.typeFlag = true
	return builder
}

func (builder *UserBuilder) Build() *User {
	req := &User{}
	if builder.emailFlag {
		req.Email = &builder.email

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

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

	}
	return req
}

type CreateMailgroupReqBuilder struct {
	apiReq    *larkcore.ApiReq
	mailgroup *Mailgroup
}

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

// 创建一个邮件组
func (builder *CreateMailgroupReqBuilder) Mailgroup(mailgroup *Mailgroup) *CreateMailgroupReqBuilder {
	builder.mailgroup = mailgroup
	return builder
}

func (builder *CreateMailgroupReqBuilder) Build() *CreateMailgroupReq {
	req := &CreateMailgroupReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.Body = builder.mailgroup
	return req
}

type CreateMailgroupReq struct {
	apiReq    *larkcore.ApiReq
	Mailgroup *Mailgroup `body:""`
}

type CreateMailgroupRespData struct {
	MailgroupId             *string `json:"mailgroup_id,omitempty"`               // The unique ID of a mail group
	Email                   *string `json:"email,omitempty"`                      // The mail group's email address
	Name                    *string `json:"name,omitempty"`                       // The mail group's display name
	Description             *string `json:"description,omitempty"`                // The mail group's description
	DirectMembersCount      *string `json:"direct_members_count,omitempty"`       // The number of mail group's direct members
	IncludeExternalMember   *bool   `json:"include_external_member,omitempty"`    // Value is true if this mail group has external member
	IncludeAllCompanyMember *bool   `json:"include_all_company_member,omitempty"` // Value is true if all company members are in this mail group
	WhoCanSendMail          *string `json:"who_can_send_mail,omitempty"`          // Who can send mail to this mail group. Possible values are:;- ANYONE: Any Internet user can send mail to this mail group;- ALL_INTERNAL_USERS: Anyone in the team can send mail to this mail group;- ALL_GROUP_MEMBERS: Any group member can send mail to this mail group;- CUSTOM_MEMBERS: Only custom members can send mail to this mail group, define in mailgroup.permission_members resoure
}

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

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

type DeleteMailgroupReqBuilder struct {
	apiReq *larkcore.ApiReq
}

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

// 邮件组ID或者邮件组地址
//
// 示例值：xxxxxxxxxxxxxxx 或 test_mail_group@xxx.xx
func (builder *DeleteMailgroupReqBuilder) MailgroupId(mailgroupId string) *DeleteMailgroupReqBuilder {
	builder.apiReq.PathParams.Set("mailgroup_id", fmt.Sprint(mailgroupId))
	return builder
}

func (builder *DeleteMailgroupReqBuilder) Build() *DeleteMailgroupReq {
	req := &DeleteMailgroupReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	return req
}

type DeleteMailgroupReq struct {
	apiReq *larkcore.ApiReq
}

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

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

type GetMailgroupReqBuilder struct {
	apiReq *larkcore.ApiReq
}

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

// 邮件组ID或者邮件组地址
//
// 示例值：xxxxxxxxxxxxxxx 或 test_mail_group@xxx.xx
func (builder *GetMailgroupReqBuilder) MailgroupId(mailgroupId string) *GetMailgroupReqBuilder {
	builder.apiReq.PathParams.Set("mailgroup_id", fmt.Sprint(mailgroupId))
	return builder
}

func (builder *GetMailgroupReqBuilder) Build() *GetMailgroupReq {
	req := &GetMailgroupReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	return req
}

type GetMailgroupReq struct {
	apiReq *larkcore.ApiReq
}

type GetMailgroupRespData struct {
	MailgroupId             *string `json:"mailgroup_id,omitempty"`               // The unique ID of a mail group
	Email                   *string `json:"email,omitempty"`                      // The mail group's email address
	Name                    *string `json:"name,omitempty"`                       // The mail group's display name
	Description             *string `json:"description,omitempty"`                // The mail group's description
	DirectMembersCount      *string `json:"direct_members_count,omitempty"`       // The number of mail group's direct members
	IncludeExternalMember   *bool   `json:"include_external_member,omitempty"`    // Value is true if this mail group has external member
	IncludeAllCompanyMember *bool   `json:"include_all_company_member,omitempty"` // Value is true if all company members are in this mail group
	WhoCanSendMail          *string `json:"who_can_send_mail,omitempty"`          // Who can send mail to this mail group. Possible values are:;- ANYONE: Any Internet user can send mail to this mail group;- ALL_INTERNAL_USERS: Anyone in the team can send mail to this mail group;- ALL_GROUP_MEMBERS: Any group member can send mail to this mail group;- CUSTOM_MEMBERS: Only custom members can send mail to this mail group, define in mailgroup.permission_members resoure
}

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

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

type ListMailgroupReqBuilder struct {
	apiReq *larkcore.ApiReq
	limit  int // 最大返回多少记录，当使用迭代器访问时才有效
}

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

// 最大返回多少记录，当使用迭代器访问时才有效
func (builder *ListMailgroupReqBuilder) Limit(limit int) *ListMailgroupReqBuilder {
	builder.limit = limit
	return builder
}

// 邮件组管理员用户ID，用于获取该用户有管理权限的邮件组
//
// 示例值：ou_xxxxxx
func (builder *ListMailgroupReqBuilder) ManagerUserId(managerUserId string) *ListMailgroupReqBuilder {
	builder.apiReq.QueryParams.Set("manager_user_id", fmt.Sprint(managerUserId))
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *ListMailgroupReqBuilder) UserIdType(userIdType string) *ListMailgroupReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

//
//
// 示例值：xxx
func (builder *ListMailgroupReqBuilder) PageToken(pageToken string) *ListMailgroupReqBuilder {
	builder.apiReq.QueryParams.Set("page_token", fmt.Sprint(pageToken))
	return builder
}

//
//
// 示例值：10
func (builder *ListMailgroupReqBuilder) PageSize(pageSize int) *ListMailgroupReqBuilder {
	builder.apiReq.QueryParams.Set("page_size", fmt.Sprint(pageSize))
	return builder
}

func (builder *ListMailgroupReqBuilder) Build() *ListMailgroupReq {
	req := &ListMailgroupReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.Limit = builder.limit
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type ListMailgroupReq struct {
	apiReq *larkcore.ApiReq
	Limit  int // 最多返回多少记录，只有在使用迭代器访问时，才有效

}

type ListMailgroupRespData struct {
	HasMore   *bool        `json:"has_more,omitempty"`   // 是否有下一页数据
	PageToken *string      `json:"page_token,omitempty"` // 下一页分页的token
	Items     []*Mailgroup `json:"items,omitempty"`      // 邮件组列表
}

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

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

type PatchMailgroupReqBuilder struct {
	apiReq    *larkcore.ApiReq
	mailgroup *Mailgroup
}

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

// 邮件组ID或者邮件组地址
//
// 示例值：xxxxxxxxxxxxxxx 或 test_mail_group@xxx.xx
func (builder *PatchMailgroupReqBuilder) MailgroupId(mailgroupId string) *PatchMailgroupReqBuilder {
	builder.apiReq.PathParams.Set("mailgroup_id", fmt.Sprint(mailgroupId))
	return builder
}

// 更新邮件组部分字段，没有填写的字段不会被更新
func (builder *PatchMailgroupReqBuilder) Mailgroup(mailgroup *Mailgroup) *PatchMailgroupReqBuilder {
	builder.mailgroup = mailgroup
	return builder
}

func (builder *PatchMailgroupReqBuilder) Build() *PatchMailgroupReq {
	req := &PatchMailgroupReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.Body = builder.mailgroup
	return req
}

type PatchMailgroupReq struct {
	apiReq    *larkcore.ApiReq
	Mailgroup *Mailgroup `body:""`
}

type PatchMailgroupRespData struct {
	MailgroupId             *string `json:"mailgroup_id,omitempty"`               // The unique ID of a mail group
	Email                   *string `json:"email,omitempty"`                      // The mail group's email address
	Name                    *string `json:"name,omitempty"`                       // The mail group's display name
	Description             *string `json:"description,omitempty"`                // The mail group's description
	DirectMembersCount      *string `json:"direct_members_count,omitempty"`       // The number of mail group's direct members
	IncludeExternalMember   *bool   `json:"include_external_member,omitempty"`    // Value is true if this mail group has external member
	IncludeAllCompanyMember *bool   `json:"include_all_company_member,omitempty"` // Value is true if all company members are in this mail group
	WhoCanSendMail          *string `json:"who_can_send_mail,omitempty"`          // Who can send mail to this mail group. Possible values are:;- ANYONE: Any Internet user can send mail to this mail group;- ALL_INTERNAL_USERS: Anyone in the team can send mail to this mail group;- ALL_GROUP_MEMBERS: Any group member can send mail to this mail group;- CUSTOM_MEMBERS: Only custom members can send mail to this mail group, define in mailgroup.permission_members resoure
}

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

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

type UpdateMailgroupReqBuilder struct {
	apiReq    *larkcore.ApiReq
	mailgroup *Mailgroup
}

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

// 邮件组ID或者邮件组地址
//
// 示例值：xxxxxxxxxxxxxxx 或 test_mail_group@xxx.xx
func (builder *UpdateMailgroupReqBuilder) MailgroupId(mailgroupId string) *UpdateMailgroupReqBuilder {
	builder.apiReq.PathParams.Set("mailgroup_id", fmt.Sprint(mailgroupId))
	return builder
}

// 更新邮件组所有信息
func (builder *UpdateMailgroupReqBuilder) Mailgroup(mailgroup *Mailgroup) *UpdateMailgroupReqBuilder {
	builder.mailgroup = mailgroup
	return builder
}

func (builder *UpdateMailgroupReqBuilder) Build() *UpdateMailgroupReq {
	req := &UpdateMailgroupReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.Body = builder.mailgroup
	return req
}

type UpdateMailgroupReq struct {
	apiReq    *larkcore.ApiReq
	Mailgroup *Mailgroup `body:""`
}

type UpdateMailgroupRespData struct {
	MailgroupId             *string `json:"mailgroup_id,omitempty"`               // The unique ID of a mail group
	Email                   *string `json:"email,omitempty"`                      // The mail group's email address
	Name                    *string `json:"name,omitempty"`                       // The mail group's display name
	Description             *string `json:"description,omitempty"`                // The mail group's description
	DirectMembersCount      *string `json:"direct_members_count,omitempty"`       // The number of mail group's direct members
	IncludeExternalMember   *bool   `json:"include_external_member,omitempty"`    // Value is true if this mail group has external member
	IncludeAllCompanyMember *bool   `json:"include_all_company_member,omitempty"` // Value is true if all company members are in this mail group
	WhoCanSendMail          *string `json:"who_can_send_mail,omitempty"`          // Who can send mail to this mail group. Possible values are:;- ANYONE: Any Internet user can send mail to this mail group;- ALL_INTERNAL_USERS: Anyone in the team can send mail to this mail group;- ALL_GROUP_MEMBERS: Any group member can send mail to this mail group;- CUSTOM_MEMBERS: Only custom members can send mail to this mail group, define in mailgroup.permission_members resoure
}

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

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

type CreateMailgroupAliasReqBuilder struct {
	apiReq     *larkcore.ApiReq
	emailAlias *EmailAlias
}

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

// 邮件组id或邮件组邮箱地址
//
// 示例值：xxxxxx 或者 xxx@xx.xxx
func (builder *CreateMailgroupAliasReqBuilder) MailgroupId(mailgroupId string) *CreateMailgroupAliasReqBuilder {
	builder.apiReq.PathParams.Set("mailgroup_id", fmt.Sprint(mailgroupId))
	return builder
}

// 创建邮件组别名
func (builder *CreateMailgroupAliasReqBuilder) EmailAlias(emailAlias *EmailAlias) *CreateMailgroupAliasReqBuilder {
	builder.emailAlias = emailAlias
	return builder
}

func (builder *CreateMailgroupAliasReqBuilder) Build() *CreateMailgroupAliasReq {
	req := &CreateMailgroupAliasReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.Body = builder.emailAlias
	return req
}

type CreateMailgroupAliasReq struct {
	apiReq     *larkcore.ApiReq
	EmailAlias *EmailAlias `body:""`
}

type CreateMailgroupAliasRespData struct {
	MailgroupAlias *EmailAlias `json:"mailgroup_alias,omitempty"` // 邮件组别名
}

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

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

type DeleteMailgroupAliasReqBuilder struct {
	apiReq *larkcore.ApiReq
}

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

// 邮件组id或邮件组邮箱地址
//
// 示例值：xxxxxx 或 test_group@xx.xxx
func (builder *DeleteMailgroupAliasReqBuilder) MailgroupId(mailgroupId string) *DeleteMailgroupAliasReqBuilder {
	builder.apiReq.PathParams.Set("mailgroup_id", fmt.Sprint(mailgroupId))
	return builder
}

// 邮件组别名邮箱地址
//
// 示例值：xxx@xx.xxx
func (builder *DeleteMailgroupAliasReqBuilder) AliasId(aliasId string) *DeleteMailgroupAliasReqBuilder {
	builder.apiReq.PathParams.Set("alias_id", fmt.Sprint(aliasId))
	return builder
}

func (builder *DeleteMailgroupAliasReqBuilder) Build() *DeleteMailgroupAliasReq {
	req := &DeleteMailgroupAliasReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	return req
}

type DeleteMailgroupAliasReq struct {
	apiReq *larkcore.ApiReq
}

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

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

type ListMailgroupAliasReqBuilder struct {
	apiReq *larkcore.ApiReq
}

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

// 邮件组id或邮件组邮箱地址
//
// 示例值：xxxxxxxxxxxxxxx 或 test_mail_group@xxx.xx
func (builder *ListMailgroupAliasReqBuilder) MailgroupId(mailgroupId string) *ListMailgroupAliasReqBuilder {
	builder.apiReq.PathParams.Set("mailgroup_id", fmt.Sprint(mailgroupId))
	return builder
}

func (builder *ListMailgroupAliasReqBuilder) Build() *ListMailgroupAliasReq {
	req := &ListMailgroupAliasReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	return req
}

type ListMailgroupAliasReq struct {
	apiReq *larkcore.ApiReq
}

type ListMailgroupAliasRespData struct {
	Items []*EmailAlias `json:"items,omitempty"` // 邮件组别名
}

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

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

type CreateMailgroupMemberReqBuilder struct {
	apiReq          *larkcore.ApiReq
	mailgroupMember *MailgroupMember
}

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

// 邮件组ID或者邮件组地址
//
// 示例值：xxxxxxxxxxxxxxx 或 test_mail_group@xxx.xx
func (builder *CreateMailgroupMemberReqBuilder) MailgroupId(mailgroupId string) *CreateMailgroupMemberReqBuilder {
	builder.apiReq.PathParams.Set("mailgroup_id", fmt.Sprint(mailgroupId))
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *CreateMailgroupMemberReqBuilder) UserIdType(userIdType string) *CreateMailgroupMemberReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 此次调用中使用的部门ID的类型
//
// 示例值：open_department_id
func (builder *CreateMailgroupMemberReqBuilder) DepartmentIdType(departmentIdType string) *CreateMailgroupMemberReqBuilder {
	builder.apiReq.QueryParams.Set("department_id_type", fmt.Sprint(departmentIdType))
	return builder
}

// 向邮件组添加单个成员
func (builder *CreateMailgroupMemberReqBuilder) MailgroupMember(mailgroupMember *MailgroupMember) *CreateMailgroupMemberReqBuilder {
	builder.mailgroupMember = mailgroupMember
	return builder
}

func (builder *CreateMailgroupMemberReqBuilder) Build() *CreateMailgroupMemberReq {
	req := &CreateMailgroupMemberReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.mailgroupMember
	return req
}

type CreateMailgroupMemberReq struct {
	apiReq          *larkcore.ApiReq
	MailgroupMember *MailgroupMember `body:""`
}

type CreateMailgroupMemberRespData struct {
	MemberId     *string `json:"member_id,omitempty"`     // The unique ID of a member in this mail group
	Email        *string `json:"email,omitempty"`         // The member's email address. Value is valid when type is one of USER/EXTERNAL_USER/MAIL_GROUP/PUBLIC_MAILBOX/OTHER_MEMBER
	UserId       *string `json:"user_id,omitempty"`       // The member's user id. Value is valid when type is USER
	DepartmentId *string `json:"department_id,omitempty"` // The member's department id. Value is valid when type is DEPARTMENT
	Type         *string `json:"type,omitempty"`          // The type of member. Possible values are:;- USER: internal user in the team;- DEPARTMENT: member is a department;- COMPANY: member is the company;- EXTERNAL_USER: internet user outside the organization;- MAIL_GROUP: member is another mail group;- PUBLIC_MAILBOX: member is a public mailbox;- OTHER_MEMBER: other internal member
}

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

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

type DeleteMailgroupMemberReqBuilder struct {
	apiReq *larkcore.ApiReq
}

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

// The unique ID or email address of a mail group
//
// 示例值：xxxxxxxxxxxxxxx or test_mail_group@xxx.xx
func (builder *DeleteMailgroupMemberReqBuilder) MailgroupId(mailgroupId string) *DeleteMailgroupMemberReqBuilder {
	builder.apiReq.PathParams.Set("mailgroup_id", fmt.Sprint(mailgroupId))
	return builder
}

// The unique ID of a member in this mail group
//
// 示例值：xxxxxxxxxxxxxxx
func (builder *DeleteMailgroupMemberReqBuilder) MemberId(memberId string) *DeleteMailgroupMemberReqBuilder {
	builder.apiReq.PathParams.Set("member_id", fmt.Sprint(memberId))
	return builder
}

func (builder *DeleteMailgroupMemberReqBuilder) Build() *DeleteMailgroupMemberReq {
	req := &DeleteMailgroupMemberReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	return req
}

type DeleteMailgroupMemberReq struct {
	apiReq *larkcore.ApiReq
}

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

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

type GetMailgroupMemberReqBuilder struct {
	apiReq *larkcore.ApiReq
}

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

// 邮件组ID或者邮件组地址
//
// 示例值：xxxxxxxxxxxxxxx 或 test_mail_group@xxx.xx
func (builder *GetMailgroupMemberReqBuilder) MailgroupId(mailgroupId string) *GetMailgroupMemberReqBuilder {
	builder.apiReq.PathParams.Set("mailgroup_id", fmt.Sprint(mailgroupId))
	return builder
}

// 邮件组内成员唯一标识
//
// 示例值：xxxxxxxxxxxxxxx
func (builder *GetMailgroupMemberReqBuilder) MemberId(memberId string) *GetMailgroupMemberReqBuilder {
	builder.apiReq.PathParams.Set("member_id", fmt.Sprint(memberId))
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *GetMailgroupMemberReqBuilder) UserIdType(userIdType string) *GetMailgroupMemberReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 此次调用中使用的部门ID的类型
//
// 示例值：open_department_id
func (builder *GetMailgroupMemberReqBuilder) DepartmentIdType(departmentIdType string) *GetMailgroupMemberReqBuilder {
	builder.apiReq.QueryParams.Set("department_id_type", fmt.Sprint(departmentIdType))
	return builder
}

func (builder *GetMailgroupMemberReqBuilder) Build() *GetMailgroupMemberReq {
	req := &GetMailgroupMemberReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type GetMailgroupMemberReq struct {
	apiReq *larkcore.ApiReq
}

type GetMailgroupMemberRespData struct {
	MemberId     *string `json:"member_id,omitempty"`     // The unique ID of a member in this mail group
	Email        *string `json:"email,omitempty"`         // The member's email address. Value is valid when type is one of USER/EXTERNAL_USER/MAIL_GROUP/PUBLIC_MAILBOX/OTHER_MEMBER
	UserId       *string `json:"user_id,omitempty"`       // The member's user id. Value is valid when type is USER
	DepartmentId *string `json:"department_id,omitempty"` // The member's department id. Value is valid when type is DEPARTMENT
	Type         *string `json:"type,omitempty"`          // The type of member. Possible values are:;- USER: internal user in the team;- DEPARTMENT: member is a department;- COMPANY: member is the company;- EXTERNAL_USER: internet user outside the organization;- MAIL_GROUP: member is another mail group;- PUBLIC_MAILBOX: member is a public mailbox;- OTHER_MEMBER: other internal member
}

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

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

type ListMailgroupMemberReqBuilder struct {
	apiReq *larkcore.ApiReq
	limit  int // 最大返回多少记录，当使用迭代器访问时才有效
}

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

// 最大返回多少记录，当使用迭代器访问时才有效
func (builder *ListMailgroupMemberReqBuilder) Limit(limit int) *ListMailgroupMemberReqBuilder {
	builder.limit = limit
	return builder
}

// The unique ID or email address of a mail group
//
// 示例值：xxxxxxxxxxxxxxx or test_mail_group@xxx.xx
func (builder *ListMailgroupMemberReqBuilder) MailgroupId(mailgroupId string) *ListMailgroupMemberReqBuilder {
	builder.apiReq.PathParams.Set("mailgroup_id", fmt.Sprint(mailgroupId))
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *ListMailgroupMemberReqBuilder) UserIdType(userIdType string) *ListMailgroupMemberReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 此次调用中使用的部门ID的类型
//
// 示例值：open_department_id
func (builder *ListMailgroupMemberReqBuilder) DepartmentIdType(departmentIdType string) *ListMailgroupMemberReqBuilder {
	builder.apiReq.QueryParams.Set("department_id_type", fmt.Sprint(departmentIdType))
	return builder
}

//
//
// 示例值：xxx
func (builder *ListMailgroupMemberReqBuilder) PageToken(pageToken string) *ListMailgroupMemberReqBuilder {
	builder.apiReq.QueryParams.Set("page_token", fmt.Sprint(pageToken))
	return builder
}

//
//
// 示例值：10
func (builder *ListMailgroupMemberReqBuilder) PageSize(pageSize int) *ListMailgroupMemberReqBuilder {
	builder.apiReq.QueryParams.Set("page_size", fmt.Sprint(pageSize))
	return builder
}

func (builder *ListMailgroupMemberReqBuilder) Build() *ListMailgroupMemberReq {
	req := &ListMailgroupMemberReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.Limit = builder.limit
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type ListMailgroupMemberReq struct {
	apiReq *larkcore.ApiReq
	Limit  int // 最多返回多少记录，只有在使用迭代器访问时，才有效

}

type ListMailgroupMemberRespData struct {
	HasMore   *bool              `json:"has_more,omitempty"`   // 是否有下一页数据
	PageToken *string            `json:"page_token,omitempty"` // 下一页分页的token
	Items     []*MailgroupMember `json:"items,omitempty"`      // 邮件组成员列表
}

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

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

type CreateMailgroupPermissionMemberReqBuilder struct {
	apiReq                    *larkcore.ApiReq
	mailgroupPermissionMember *MailgroupPermissionMember
}

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

// 邮件组ID或者邮件组地址
//
// 示例值：xxxxxxxxxxxxxxx 或 test_mail_group@xxx.xx
func (builder *CreateMailgroupPermissionMemberReqBuilder) MailgroupId(mailgroupId string) *CreateMailgroupPermissionMemberReqBuilder {
	builder.apiReq.PathParams.Set("mailgroup_id", fmt.Sprint(mailgroupId))
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *CreateMailgroupPermissionMemberReqBuilder) UserIdType(userIdType string) *CreateMailgroupPermissionMemberReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 此次调用中使用的部门ID的类型
//
// 示例值：xxx
func (builder *CreateMailgroupPermissionMemberReqBuilder) DepartmentIdType(departmentIdType string) *CreateMailgroupPermissionMemberReqBuilder {
	builder.apiReq.QueryParams.Set("department_id_type", fmt.Sprint(departmentIdType))
	return builder
}

// 向邮件组添加单个自定义权限成员，添加后该成员可发送邮件到该邮件组
func (builder *CreateMailgroupPermissionMemberReqBuilder) MailgroupPermissionMember(mailgroupPermissionMember *MailgroupPermissionMember) *CreateMailgroupPermissionMemberReqBuilder {
	builder.mailgroupPermissionMember = mailgroupPermissionMember
	return builder
}

func (builder *CreateMailgroupPermissionMemberReqBuilder) Build() *CreateMailgroupPermissionMemberReq {
	req := &CreateMailgroupPermissionMemberReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.mailgroupPermissionMember
	return req
}

type CreateMailgroupPermissionMemberReq struct {
	apiReq                    *larkcore.ApiReq
	MailgroupPermissionMember *MailgroupPermissionMember `body:""`
}

type CreateMailgroupPermissionMemberRespData struct {
	PermissionMemberId *string `json:"permission_member_id,omitempty"` // The unique ID of a member in this permission group
	UserId             *string `json:"user_id,omitempty"`              // The member's user id. Value is valid when type is USER
	DepartmentId       *string `json:"department_id,omitempty"`        // The member's department id. Value is valid when type is DEPARTMENT
	Type               *string `json:"type,omitempty"`                 // The type of member. Possible values are:;- USER: internal user in the team;- DEPARTMENT: member is a department
}

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

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

type DeleteMailgroupPermissionMemberReqBuilder struct {
	apiReq *larkcore.ApiReq
}

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

// The unique ID or email address of a mail group
//
// 示例值：xxxxxxxxxxxxxxx or test_mail_group@xxx.xx
func (builder *DeleteMailgroupPermissionMemberReqBuilder) MailgroupId(mailgroupId string) *DeleteMailgroupPermissionMemberReqBuilder {
	builder.apiReq.PathParams.Set("mailgroup_id", fmt.Sprint(mailgroupId))
	return builder
}

// The unique ID of a member in this permission group
//
// 示例值：xxxxxxxxxxxxxxx
func (builder *DeleteMailgroupPermissionMemberReqBuilder) PermissionMemberId(permissionMemberId string) *DeleteMailgroupPermissionMemberReqBuilder {
	builder.apiReq.PathParams.Set("permission_member_id", fmt.Sprint(permissionMemberId))
	return builder
}

func (builder *DeleteMailgroupPermissionMemberReqBuilder) Build() *DeleteMailgroupPermissionMemberReq {
	req := &DeleteMailgroupPermissionMemberReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	return req
}

type DeleteMailgroupPermissionMemberReq struct {
	apiReq *larkcore.ApiReq
}

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

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

type GetMailgroupPermissionMemberReqBuilder struct {
	apiReq *larkcore.ApiReq
}

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

// 邮件组ID或者邮件组地址
//
// 示例值：xxxxxxxxxxxxxxx 或 test_mail_group@xxx.xx
func (builder *GetMailgroupPermissionMemberReqBuilder) MailgroupId(mailgroupId string) *GetMailgroupPermissionMemberReqBuilder {
	builder.apiReq.PathParams.Set("mailgroup_id", fmt.Sprint(mailgroupId))
	return builder
}

// 权限组内成员唯一标识
//
// 示例值：xxxxxxxxxxxxxxx
func (builder *GetMailgroupPermissionMemberReqBuilder) PermissionMemberId(permissionMemberId string) *GetMailgroupPermissionMemberReqBuilder {
	builder.apiReq.PathParams.Set("permission_member_id", fmt.Sprint(permissionMemberId))
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *GetMailgroupPermissionMemberReqBuilder) UserIdType(userIdType string) *GetMailgroupPermissionMemberReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 此次调用中使用的部门ID的类型
//
// 示例值：open_department_id
func (builder *GetMailgroupPermissionMemberReqBuilder) DepartmentIdType(departmentIdType string) *GetMailgroupPermissionMemberReqBuilder {
	builder.apiReq.QueryParams.Set("department_id_type", fmt.Sprint(departmentIdType))
	return builder
}

func (builder *GetMailgroupPermissionMemberReqBuilder) Build() *GetMailgroupPermissionMemberReq {
	req := &GetMailgroupPermissionMemberReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type GetMailgroupPermissionMemberReq struct {
	apiReq *larkcore.ApiReq
}

type GetMailgroupPermissionMemberRespData struct {
	PermissionMemberId *string `json:"permission_member_id,omitempty"` // The unique ID of a member in this permission group
	UserId             *string `json:"user_id,omitempty"`              // The member's user id. Value is valid when type is USER
	DepartmentId       *string `json:"department_id,omitempty"`        // The member's department id. Value is valid when type is DEPARTMENT
	Type               *string `json:"type,omitempty"`                 // The type of member. Possible values are:;- USER: internal user in the team;- DEPARTMENT: member is a department
}

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

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

type ListMailgroupPermissionMemberReqBuilder struct {
	apiReq *larkcore.ApiReq
	limit  int // 最大返回多少记录，当使用迭代器访问时才有效
}

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

// 最大返回多少记录，当使用迭代器访问时才有效
func (builder *ListMailgroupPermissionMemberReqBuilder) Limit(limit int) *ListMailgroupPermissionMemberReqBuilder {
	builder.limit = limit
	return builder
}

// 邮件组ID或者邮件组地址
//
// 示例值：xxxxxxxxxxxxxxx 或 test_mail_group@xxx.xx
func (builder *ListMailgroupPermissionMemberReqBuilder) MailgroupId(mailgroupId string) *ListMailgroupPermissionMemberReqBuilder {
	builder.apiReq.PathParams.Set("mailgroup_id", fmt.Sprint(mailgroupId))
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *ListMailgroupPermissionMemberReqBuilder) UserIdType(userIdType string) *ListMailgroupPermissionMemberReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 此次调用中使用的部门ID的类型
//
// 示例值：open_department_id
func (builder *ListMailgroupPermissionMemberReqBuilder) DepartmentIdType(departmentIdType string) *ListMailgroupPermissionMemberReqBuilder {
	builder.apiReq.QueryParams.Set("department_id_type", fmt.Sprint(departmentIdType))
	return builder
}

//
//
// 示例值：xxx
func (builder *ListMailgroupPermissionMemberReqBuilder) PageToken(pageToken string) *ListMailgroupPermissionMemberReqBuilder {
	builder.apiReq.QueryParams.Set("page_token", fmt.Sprint(pageToken))
	return builder
}

//
//
// 示例值：10
func (builder *ListMailgroupPermissionMemberReqBuilder) PageSize(pageSize int) *ListMailgroupPermissionMemberReqBuilder {
	builder.apiReq.QueryParams.Set("page_size", fmt.Sprint(pageSize))
	return builder
}

func (builder *ListMailgroupPermissionMemberReqBuilder) Build() *ListMailgroupPermissionMemberReq {
	req := &ListMailgroupPermissionMemberReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.Limit = builder.limit
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type ListMailgroupPermissionMemberReq struct {
	apiReq *larkcore.ApiReq
	Limit  int // 最多返回多少记录，只有在使用迭代器访问时，才有效

}

type ListMailgroupPermissionMemberRespData struct {
	HasMore   *bool                        `json:"has_more,omitempty"`   // 是否有下一页数据
	PageToken *string                      `json:"page_token,omitempty"` // 下一页分页的token
	Items     []*MailgroupPermissionMember `json:"items,omitempty"`      // 邮件组权限成员列表
}

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

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

type CreatePublicMailboxReqBuilder struct {
	apiReq        *larkcore.ApiReq
	publicMailbox *PublicMailbox
}

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

// 创建一个公共邮箱
func (builder *CreatePublicMailboxReqBuilder) PublicMailbox(publicMailbox *PublicMailbox) *CreatePublicMailboxReqBuilder {
	builder.publicMailbox = publicMailbox
	return builder
}

func (builder *CreatePublicMailboxReqBuilder) Build() *CreatePublicMailboxReq {
	req := &CreatePublicMailboxReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.Body = builder.publicMailbox
	return req
}

type CreatePublicMailboxReq struct {
	apiReq        *larkcore.ApiReq
	PublicMailbox *PublicMailbox `body:""`
}

type CreatePublicMailboxRespData struct {
	PublicMailboxId *string `json:"public_mailbox_id,omitempty"` // The unique ID of a public mailbox
	Email           *string `json:"email,omitempty"`             // The public mailbox's email address
	Name            *string `json:"name,omitempty"`              // The public mailbox's display name
}

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

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

type DeletePublicMailboxReqBuilder struct {
	apiReq *larkcore.ApiReq
}

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

// 要释放的公共邮箱地址
//
// 示例值：xxxxxx@abc.com
func (builder *DeletePublicMailboxReqBuilder) PublicMailboxId(publicMailboxId string) *DeletePublicMailboxReqBuilder {
	builder.apiReq.PathParams.Set("public_mailbox_id", fmt.Sprint(publicMailboxId))
	return builder
}

func (builder *DeletePublicMailboxReqBuilder) Build() *DeletePublicMailboxReq {
	req := &DeletePublicMailboxReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	return req
}

type DeletePublicMailboxReq struct {
	apiReq *larkcore.ApiReq
}

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

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

type GetPublicMailboxReqBuilder struct {
	apiReq *larkcore.ApiReq
}

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

// 公共邮箱唯一标识或公共邮箱地址
//
// 示例值：xxxxxxxxxxxxxxx 或 test_public_mailbox@xxx.xx
func (builder *GetPublicMailboxReqBuilder) PublicMailboxId(publicMailboxId string) *GetPublicMailboxReqBuilder {
	builder.apiReq.PathParams.Set("public_mailbox_id", fmt.Sprint(publicMailboxId))
	return builder
}

func (builder *GetPublicMailboxReqBuilder) Build() *GetPublicMailboxReq {
	req := &GetPublicMailboxReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	return req
}

type GetPublicMailboxReq struct {
	apiReq *larkcore.ApiReq
}

type GetPublicMailboxRespData struct {
	PublicMailboxId *string `json:"public_mailbox_id,omitempty"` // The unique ID of a public mailbox
	Email           *string `json:"email,omitempty"`             // The public mailbox's email address
	Name            *string `json:"name,omitempty"`              // The public mailbox's display name
}

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

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

type ListPublicMailboxReqBuilder struct {
	apiReq *larkcore.ApiReq
	limit  int // 最大返回多少记录，当使用迭代器访问时才有效
}

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

// 最大返回多少记录，当使用迭代器访问时才有效
func (builder *ListPublicMailboxReqBuilder) Limit(limit int) *ListPublicMailboxReqBuilder {
	builder.limit = limit
	return builder
}

//
//
// 示例值：xxx
func (builder *ListPublicMailboxReqBuilder) PageToken(pageToken string) *ListPublicMailboxReqBuilder {
	builder.apiReq.QueryParams.Set("page_token", fmt.Sprint(pageToken))
	return builder
}

//
//
// 示例值：10
func (builder *ListPublicMailboxReqBuilder) PageSize(pageSize int) *ListPublicMailboxReqBuilder {
	builder.apiReq.QueryParams.Set("page_size", fmt.Sprint(pageSize))
	return builder
}

func (builder *ListPublicMailboxReqBuilder) Build() *ListPublicMailboxReq {
	req := &ListPublicMailboxReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.Limit = builder.limit
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type ListPublicMailboxReq struct {
	apiReq *larkcore.ApiReq
	Limit  int // 最多返回多少记录，只有在使用迭代器访问时，才有效

}

type ListPublicMailboxRespData struct {
	HasMore   *bool            `json:"has_more,omitempty"`   // 是否有下一页数据
	PageToken *string          `json:"page_token,omitempty"` // 下一页分页的token
	Items     []*PublicMailbox `json:"items,omitempty"`      // 公共邮箱列表
}

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

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

type PatchPublicMailboxReqBuilder struct {
	apiReq        *larkcore.ApiReq
	publicMailbox *PublicMailbox
}

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

// 公共邮箱唯一标识或公共邮箱地址
//
// 示例值：xxxxxxxxxxxxxxx 或 test_public_mailbox@xxx.xx
func (builder *PatchPublicMailboxReqBuilder) PublicMailboxId(publicMailboxId string) *PatchPublicMailboxReqBuilder {
	builder.apiReq.PathParams.Set("public_mailbox_id", fmt.Sprint(publicMailboxId))
	return builder
}

// 更新公共邮箱部分字段，没有填写的字段不会被更新
func (builder *PatchPublicMailboxReqBuilder) PublicMailbox(publicMailbox *PublicMailbox) *PatchPublicMailboxReqBuilder {
	builder.publicMailbox = publicMailbox
	return builder
}

func (builder *PatchPublicMailboxReqBuilder) Build() *PatchPublicMailboxReq {
	req := &PatchPublicMailboxReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.Body = builder.publicMailbox
	return req
}

type PatchPublicMailboxReq struct {
	apiReq        *larkcore.ApiReq
	PublicMailbox *PublicMailbox `body:""`
}

type PatchPublicMailboxRespData struct {
	PublicMailboxId *string `json:"public_mailbox_id,omitempty"` // The unique ID of a public mailbox
	Email           *string `json:"email,omitempty"`             // The public mailbox's email address
	Name            *string `json:"name,omitempty"`              // The public mailbox's display name
}

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

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

type UpdatePublicMailboxReqBuilder struct {
	apiReq        *larkcore.ApiReq
	publicMailbox *PublicMailbox
}

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

// 公共邮箱唯一标识或公共邮箱地址
//
// 示例值：xxxxxxxxxxxxxxx 或 test_public_mailbox@xxx.xx
func (builder *UpdatePublicMailboxReqBuilder) PublicMailboxId(publicMailboxId string) *UpdatePublicMailboxReqBuilder {
	builder.apiReq.PathParams.Set("public_mailbox_id", fmt.Sprint(publicMailboxId))
	return builder
}

// 更新公共邮箱所有信息
func (builder *UpdatePublicMailboxReqBuilder) PublicMailbox(publicMailbox *PublicMailbox) *UpdatePublicMailboxReqBuilder {
	builder.publicMailbox = publicMailbox
	return builder
}

func (builder *UpdatePublicMailboxReqBuilder) Build() *UpdatePublicMailboxReq {
	req := &UpdatePublicMailboxReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.Body = builder.publicMailbox
	return req
}

type UpdatePublicMailboxReq struct {
	apiReq        *larkcore.ApiReq
	PublicMailbox *PublicMailbox `body:""`
}

type UpdatePublicMailboxRespData struct {
	PublicMailboxId *string `json:"public_mailbox_id,omitempty"` // The unique ID of a public mailbox
	Email           *string `json:"email,omitempty"`             // The public mailbox's email address
	Name            *string `json:"name,omitempty"`              // The public mailbox's display name
}

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

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

type CreatePublicMailboxAliasReqBuilder struct {
	apiReq     *larkcore.ApiReq
	emailAlias *EmailAlias
}

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

// 公共邮箱id或公共邮箱地址
//
// 示例值：xxxxxx 或 xxx@xx.xxx
func (builder *CreatePublicMailboxAliasReqBuilder) PublicMailboxId(publicMailboxId string) *CreatePublicMailboxAliasReqBuilder {
	builder.apiReq.PathParams.Set("public_mailbox_id", fmt.Sprint(publicMailboxId))
	return builder
}

// 创建公共邮箱别名
func (builder *CreatePublicMailboxAliasReqBuilder) EmailAlias(emailAlias *EmailAlias) *CreatePublicMailboxAliasReqBuilder {
	builder.emailAlias = emailAlias
	return builder
}

func (builder *CreatePublicMailboxAliasReqBuilder) Build() *CreatePublicMailboxAliasReq {
	req := &CreatePublicMailboxAliasReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.Body = builder.emailAlias
	return req
}

type CreatePublicMailboxAliasReq struct {
	apiReq     *larkcore.ApiReq
	EmailAlias *EmailAlias `body:""`
}

type CreatePublicMailboxAliasRespData struct {
	PublicMailboxAlias *EmailAlias `json:"public_mailbox_alias,omitempty"` // 公共邮箱别名
}

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

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

type DeletePublicMailboxAliasReqBuilder struct {
	apiReq *larkcore.ApiReq
}

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

// 公共邮箱id或公共邮箱地址
//
// 示例值：xxxxxx 或 xxx@xx.xxx
func (builder *DeletePublicMailboxAliasReqBuilder) PublicMailboxId(publicMailboxId string) *DeletePublicMailboxAliasReqBuilder {
	builder.apiReq.PathParams.Set("public_mailbox_id", fmt.Sprint(publicMailboxId))
	return builder
}

// 公共邮箱别名
//
// 示例值：xxx@xx.xxx
func (builder *DeletePublicMailboxAliasReqBuilder) AliasId(aliasId string) *DeletePublicMailboxAliasReqBuilder {
	builder.apiReq.PathParams.Set("alias_id", fmt.Sprint(aliasId))
	return builder
}

func (builder *DeletePublicMailboxAliasReqBuilder) Build() *DeletePublicMailboxAliasReq {
	req := &DeletePublicMailboxAliasReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	return req
}

type DeletePublicMailboxAliasReq struct {
	apiReq *larkcore.ApiReq
}

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

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

type ListPublicMailboxAliasReqBuilder struct {
	apiReq *larkcore.ApiReq
}

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

// 公共邮箱id或公共邮箱邮件地址
//
// 示例值：xxxxxx 或 xxx@xx.xxx
func (builder *ListPublicMailboxAliasReqBuilder) PublicMailboxId(publicMailboxId string) *ListPublicMailboxAliasReqBuilder {
	builder.apiReq.PathParams.Set("public_mailbox_id", fmt.Sprint(publicMailboxId))
	return builder
}

func (builder *ListPublicMailboxAliasReqBuilder) Build() *ListPublicMailboxAliasReq {
	req := &ListPublicMailboxAliasReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	return req
}

type ListPublicMailboxAliasReq struct {
	apiReq *larkcore.ApiReq
}

type ListPublicMailboxAliasRespData struct {
	Items []*EmailAlias `json:"items,omitempty"` // 公共邮箱别名
}

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

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

type ClearPublicMailboxMemberReqBuilder struct {
	apiReq *larkcore.ApiReq
}

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

// 公共邮箱唯一标识或公共邮箱地址
//
// 示例值：xxxxxxxxxxxxxxx 或 test_public_mailbox@xxx.xx
func (builder *ClearPublicMailboxMemberReqBuilder) PublicMailboxId(publicMailboxId string) *ClearPublicMailboxMemberReqBuilder {
	builder.apiReq.PathParams.Set("public_mailbox_id", fmt.Sprint(publicMailboxId))
	return builder
}

func (builder *ClearPublicMailboxMemberReqBuilder) Build() *ClearPublicMailboxMemberReq {
	req := &ClearPublicMailboxMemberReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	return req
}

type ClearPublicMailboxMemberReq struct {
	apiReq *larkcore.ApiReq
}

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

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

type CreatePublicMailboxMemberReqBuilder struct {
	apiReq              *larkcore.ApiReq
	publicMailboxMember *PublicMailboxMember
}

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

// 公共邮箱唯一标识或公共邮箱地址
//
// 示例值：xxxxxxxxxxxxxxx 或 test_public_mailbox@xxx.xx
func (builder *CreatePublicMailboxMemberReqBuilder) PublicMailboxId(publicMailboxId string) *CreatePublicMailboxMemberReqBuilder {
	builder.apiReq.PathParams.Set("public_mailbox_id", fmt.Sprint(publicMailboxId))
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *CreatePublicMailboxMemberReqBuilder) UserIdType(userIdType string) *CreatePublicMailboxMemberReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

// 向公共邮箱添加单个成员
func (builder *CreatePublicMailboxMemberReqBuilder) PublicMailboxMember(publicMailboxMember *PublicMailboxMember) *CreatePublicMailboxMemberReqBuilder {
	builder.publicMailboxMember = publicMailboxMember
	return builder
}

func (builder *CreatePublicMailboxMemberReqBuilder) Build() *CreatePublicMailboxMemberReq {
	req := &CreatePublicMailboxMemberReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	req.apiReq.Body = builder.publicMailboxMember
	return req
}

type CreatePublicMailboxMemberReq struct {
	apiReq              *larkcore.ApiReq
	PublicMailboxMember *PublicMailboxMember `body:""`
}

type CreatePublicMailboxMemberRespData struct {
	MemberId *string `json:"member_id,omitempty"` // The unique ID of a member in this public mailbox
	UserId   *string `json:"user_id,omitempty"`   // The member's user id. Value is valid when type is USER
	Type     *string `json:"type,omitempty"`      // The type of member. Possible values are:;- USER: internal user in the team
}

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

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

type DeletePublicMailboxMemberReqBuilder struct {
	apiReq *larkcore.ApiReq
}

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

// 公共邮箱唯一标识或公共邮箱地址
//
// 示例值：xxxxxxxxxxxxxxx 或 test_public_mailbox@xxx.xx
func (builder *DeletePublicMailboxMemberReqBuilder) PublicMailboxId(publicMailboxId string) *DeletePublicMailboxMemberReqBuilder {
	builder.apiReq.PathParams.Set("public_mailbox_id", fmt.Sprint(publicMailboxId))
	return builder
}

// 公共邮箱内成员唯一标识
//
// 示例值：xxxxxxxxxxxxxxx
func (builder *DeletePublicMailboxMemberReqBuilder) MemberId(memberId string) *DeletePublicMailboxMemberReqBuilder {
	builder.apiReq.PathParams.Set("member_id", fmt.Sprint(memberId))
	return builder
}

func (builder *DeletePublicMailboxMemberReqBuilder) Build() *DeletePublicMailboxMemberReq {
	req := &DeletePublicMailboxMemberReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	return req
}

type DeletePublicMailboxMemberReq struct {
	apiReq *larkcore.ApiReq
}

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

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

type GetPublicMailboxMemberReqBuilder struct {
	apiReq *larkcore.ApiReq
}

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

// 公共邮箱唯一标识或公共邮箱地址
//
// 示例值：xxxxxxxxxxxxxxx 或 test_public_mailbox@xxx.xx
func (builder *GetPublicMailboxMemberReqBuilder) PublicMailboxId(publicMailboxId string) *GetPublicMailboxMemberReqBuilder {
	builder.apiReq.PathParams.Set("public_mailbox_id", fmt.Sprint(publicMailboxId))
	return builder
}

// 公共邮箱内成员唯一标识
//
// 示例值：xxxxxxxxxxxxxxx
func (builder *GetPublicMailboxMemberReqBuilder) MemberId(memberId string) *GetPublicMailboxMemberReqBuilder {
	builder.apiReq.PathParams.Set("member_id", fmt.Sprint(memberId))
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *GetPublicMailboxMemberReqBuilder) UserIdType(userIdType string) *GetPublicMailboxMemberReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

func (builder *GetPublicMailboxMemberReqBuilder) Build() *GetPublicMailboxMemberReq {
	req := &GetPublicMailboxMemberReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type GetPublicMailboxMemberReq struct {
	apiReq *larkcore.ApiReq
}

type GetPublicMailboxMemberRespData struct {
	MemberId *string `json:"member_id,omitempty"` // The unique ID of a member in this public mailbox
	UserId   *string `json:"user_id,omitempty"`   // The member's user id. Value is valid when type is USER
	Type     *string `json:"type,omitempty"`      // The type of member. Possible values are:;- USER: internal user in the team
}

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

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

type ListPublicMailboxMemberReqBuilder struct {
	apiReq *larkcore.ApiReq
	limit  int // 最大返回多少记录，当使用迭代器访问时才有效
}

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

// 最大返回多少记录，当使用迭代器访问时才有效
func (builder *ListPublicMailboxMemberReqBuilder) Limit(limit int) *ListPublicMailboxMemberReqBuilder {
	builder.limit = limit
	return builder
}

// The unique ID or email address of a public mailbox
//
// 示例值：xxxxxxxxxxxxxxx or test_public_mailbox@xxx.xx
func (builder *ListPublicMailboxMemberReqBuilder) PublicMailboxId(publicMailboxId string) *ListPublicMailboxMemberReqBuilder {
	builder.apiReq.PathParams.Set("public_mailbox_id", fmt.Sprint(publicMailboxId))
	return builder
}

// 此次调用中使用的用户ID的类型
//
// 示例值：
func (builder *ListPublicMailboxMemberReqBuilder) UserIdType(userIdType string) *ListPublicMailboxMemberReqBuilder {
	builder.apiReq.QueryParams.Set("user_id_type", fmt.Sprint(userIdType))
	return builder
}

//
//
// 示例值：xxx
func (builder *ListPublicMailboxMemberReqBuilder) PageToken(pageToken string) *ListPublicMailboxMemberReqBuilder {
	builder.apiReq.QueryParams.Set("page_token", fmt.Sprint(pageToken))
	return builder
}

//
//
// 示例值：10
func (builder *ListPublicMailboxMemberReqBuilder) PageSize(pageSize int) *ListPublicMailboxMemberReqBuilder {
	builder.apiReq.QueryParams.Set("page_size", fmt.Sprint(pageSize))
	return builder
}

func (builder *ListPublicMailboxMemberReqBuilder) Build() *ListPublicMailboxMemberReq {
	req := &ListPublicMailboxMemberReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.Limit = builder.limit
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type ListPublicMailboxMemberReq struct {
	apiReq *larkcore.ApiReq
	Limit  int // 最多返回多少记录，只有在使用迭代器访问时，才有效

}

type ListPublicMailboxMemberRespData struct {
	HasMore   *bool                  `json:"has_more,omitempty"`   // 是否有下一页数据
	PageToken *string                `json:"page_token,omitempty"` // 下一页分页的token
	Items     []*PublicMailboxMember `json:"items,omitempty"`      // 公共邮箱成员列表
}

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

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

type QueryUserReqBodyBuilder struct {
	emailList     []string // 需要查询的邮箱地址列表
	emailListFlag bool
}

func NewQueryUserReqBodyBuilder() *QueryUserReqBodyBuilder {
	builder := &QueryUserReqBodyBuilder{}
	return builder
}

// 需要查询的邮箱地址列表
//
//示例值：["aaa@lark.com","bbb@lark.com"]
func (builder *QueryUserReqBodyBuilder) EmailList(emailList []string) *QueryUserReqBodyBuilder {
	builder.emailList = emailList
	builder.emailListFlag = true
	return builder
}

func (builder *QueryUserReqBodyBuilder) Build() *QueryUserReqBody {
	req := &QueryUserReqBody{}
	if builder.emailListFlag {
		req.EmailList = builder.emailList
	}
	return req
}

type QueryUserPathReqBodyBuilder struct {
	emailList     []string // 需要查询的邮箱地址列表
	emailListFlag bool
}

func NewQueryUserPathReqBodyBuilder() *QueryUserPathReqBodyBuilder {
	builder := &QueryUserPathReqBodyBuilder{}
	return builder
}

// 需要查询的邮箱地址列表
//
// 示例值：["aaa@lark.com","bbb@lark.com"]
func (builder *QueryUserPathReqBodyBuilder) EmailList(emailList []string) *QueryUserPathReqBodyBuilder {
	builder.emailList = emailList
	builder.emailListFlag = true
	return builder
}

func (builder *QueryUserPathReqBodyBuilder) Build() (*QueryUserReqBody, error) {
	req := &QueryUserReqBody{}
	if builder.emailListFlag {
		req.EmailList = builder.emailList
	}
	return req, nil
}

type QueryUserReqBuilder struct {
	apiReq *larkcore.ApiReq
	body   *QueryUserReqBody
}

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

// 使用邮箱状态查询接口，可以输入邮箱地址，查询出该邮箱地址对应的类型以及状态
func (builder *QueryUserReqBuilder) Body(body *QueryUserReqBody) *QueryUserReqBuilder {
	builder.body = body
	return builder
}

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

type QueryUserReqBody struct {
	EmailList []string `json:"email_list,omitempty"` // 需要查询的邮箱地址列表
}

type QueryUserReq struct {
	apiReq *larkcore.ApiReq
	Body   *QueryUserReqBody `body:""`
}

type QueryUserRespData struct {
	UserList []*User `json:"user_list,omitempty"` // 邮箱地址以及其对应的类型类型和状态
}

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

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

type DeleteUserMailboxReqBuilder struct {
	apiReq *larkcore.ApiReq
}

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

// 要释放的邮箱地址
//
// 示例值：111111@abc.com
func (builder *DeleteUserMailboxReqBuilder) UserMailboxId(userMailboxId string) *DeleteUserMailboxReqBuilder {
	builder.apiReq.PathParams.Set("user_mailbox_id", fmt.Sprint(userMailboxId))
	return builder
}

// 用于接受转移的邮箱地址
//
// 示例值：888888@abc.com
func (builder *DeleteUserMailboxReqBuilder) TransferMailbox(transferMailbox string) *DeleteUserMailboxReqBuilder {
	builder.apiReq.QueryParams.Set("transfer_mailbox", fmt.Sprint(transferMailbox))
	return builder
}

func (builder *DeleteUserMailboxReqBuilder) Build() *DeleteUserMailboxReq {
	req := &DeleteUserMailboxReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type DeleteUserMailboxReq struct {
	apiReq *larkcore.ApiReq
}

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

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

type CreateUserMailboxAliasReqBuilder struct {
	apiReq     *larkcore.ApiReq
	emailAlias *EmailAlias
}

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

// 用户邮箱地址
//
// 示例值：user@xxx.xx
func (builder *CreateUserMailboxAliasReqBuilder) UserMailboxId(userMailboxId string) *CreateUserMailboxAliasReqBuilder {
	builder.apiReq.PathParams.Set("user_mailbox_id", fmt.Sprint(userMailboxId))
	return builder
}

// 创建用户邮箱别名
func (builder *CreateUserMailboxAliasReqBuilder) EmailAlias(emailAlias *EmailAlias) *CreateUserMailboxAliasReqBuilder {
	builder.emailAlias = emailAlias
	return builder
}

func (builder *CreateUserMailboxAliasReqBuilder) Build() *CreateUserMailboxAliasReq {
	req := &CreateUserMailboxAliasReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.Body = builder.emailAlias
	return req
}

type CreateUserMailboxAliasReq struct {
	apiReq     *larkcore.ApiReq
	EmailAlias *EmailAlias `body:""`
}

type CreateUserMailboxAliasRespData struct {
	UserMailboxAlias *EmailAlias `json:"user_mailbox_alias,omitempty"` // 用户邮箱别名
}

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

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

type DeleteUserMailboxAliasReqBuilder struct {
	apiReq *larkcore.ApiReq
}

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

// 用户邮箱地址
//
// 示例值：user@xxx.xx
func (builder *DeleteUserMailboxAliasReqBuilder) UserMailboxId(userMailboxId string) *DeleteUserMailboxAliasReqBuilder {
	builder.apiReq.PathParams.Set("user_mailbox_id", fmt.Sprint(userMailboxId))
	return builder
}

// 别名邮箱地址
//
// 示例值：user_alias@xxx.xx
func (builder *DeleteUserMailboxAliasReqBuilder) AliasId(aliasId string) *DeleteUserMailboxAliasReqBuilder {
	builder.apiReq.PathParams.Set("alias_id", fmt.Sprint(aliasId))
	return builder
}

func (builder *DeleteUserMailboxAliasReqBuilder) Build() *DeleteUserMailboxAliasReq {
	req := &DeleteUserMailboxAliasReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	return req
}

type DeleteUserMailboxAliasReq struct {
	apiReq *larkcore.ApiReq
}

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

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

type ListUserMailboxAliasReqBuilder struct {
	apiReq *larkcore.ApiReq
}

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

// 用户邮箱地址
//
// 示例值：user@xxx.xx
func (builder *ListUserMailboxAliasReqBuilder) UserMailboxId(userMailboxId string) *ListUserMailboxAliasReqBuilder {
	builder.apiReq.PathParams.Set("user_mailbox_id", fmt.Sprint(userMailboxId))
	return builder
}

//
//
// 示例值：xxx
func (builder *ListUserMailboxAliasReqBuilder) PageToken(pageToken string) *ListUserMailboxAliasReqBuilder {
	builder.apiReq.QueryParams.Set("page_token", fmt.Sprint(pageToken))
	return builder
}

//
//
// 示例值：10
func (builder *ListUserMailboxAliasReqBuilder) PageSize(pageSize int) *ListUserMailboxAliasReqBuilder {
	builder.apiReq.QueryParams.Set("page_size", fmt.Sprint(pageSize))
	return builder
}

func (builder *ListUserMailboxAliasReqBuilder) Build() *ListUserMailboxAliasReq {
	req := &ListUserMailboxAliasReq{}
	req.apiReq = &larkcore.ApiReq{}
	req.apiReq.PathParams = builder.apiReq.PathParams
	req.apiReq.QueryParams = builder.apiReq.QueryParams
	return req
}

type ListUserMailboxAliasReq struct {
	apiReq *larkcore.ApiReq
}

type ListUserMailboxAliasRespData struct {
	Items []*EmailAlias `json:"items,omitempty"` // 用户邮箱别名
}

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

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

type ListMailgroupIterator struct {
	nextPageToken *string
	items         []*Mailgroup
	index         int
	limit         int
	ctx           context.Context
	req           *ListMailgroupReq
	listFunc      func(ctx context.Context, req *ListMailgroupReq, options ...larkcore.RequestOptionFunc) (*ListMailgroupResp, error)
	options       []larkcore.RequestOptionFunc
	curlNum       int
}

func (iterator *ListMailgroupIterator) Next() (bool, *Mailgroup, error) {
	// 达到最大量，则返回
	if iterator.limit > 0 && iterator.curlNum >= iterator.limit {
		return false, nil, nil
	}

	// 为0则拉取数据
	if iterator.index == 0 || iterator.index >= len(iterator.items) {
		if iterator.index != 0 && iterator.nextPageToken == nil {
			return false, nil, nil
		}
		if iterator.nextPageToken != nil {
			iterator.req.apiReq.QueryParams.Set("page_token", *iterator.nextPageToken)
		}
		resp, err := iterator.listFunc(iterator.ctx, iterator.req, iterator.options...)
		if err != nil {
			return false, nil, err
		}

		if resp.Code != 0 {
			return false, nil, errors.New(fmt.Sprintf("Code:%d,Msg:%s", resp.Code, resp.Msg))
		}

		if len(resp.Data.Items) == 0 {
			return false, nil, nil
		}

		iterator.nextPageToken = resp.Data.PageToken
		iterator.items = resp.Data.Items
		iterator.index = 0
	}

	block := iterator.items[iterator.index]
	iterator.index++
	iterator.curlNum++
	return true, block, nil
}

func (iterator *ListMailgroupIterator) NextPageToken() *string {
	return iterator.nextPageToken
}

type ListMailgroupMemberIterator struct {
	nextPageToken *string
	items         []*MailgroupMember
	index         int
	limit         int
	ctx           context.Context
	req           *ListMailgroupMemberReq
	listFunc      func(ctx context.Context, req *ListMailgroupMemberReq, options ...larkcore.RequestOptionFunc) (*ListMailgroupMemberResp, error)
	options       []larkcore.RequestOptionFunc
	curlNum       int
}

func (iterator *ListMailgroupMemberIterator) Next() (bool, *MailgroupMember, error) {
	// 达到最大量，则返回
	if iterator.limit > 0 && iterator.curlNum >= iterator.limit {
		return false, nil, nil
	}

	// 为0则拉取数据
	if iterator.index == 0 || iterator.index >= len(iterator.items) {
		if iterator.index != 0 && iterator.nextPageToken == nil {
			return false, nil, nil
		}
		if iterator.nextPageToken != nil {
			iterator.req.apiReq.QueryParams.Set("page_token", *iterator.nextPageToken)
		}
		resp, err := iterator.listFunc(iterator.ctx, iterator.req, iterator.options...)
		if err != nil {
			return false, nil, err
		}

		if resp.Code != 0 {
			return false, nil, errors.New(fmt.Sprintf("Code:%d,Msg:%s", resp.Code, resp.Msg))
		}

		if len(resp.Data.Items) == 0 {
			return false, nil, nil
		}

		iterator.nextPageToken = resp.Data.PageToken
		iterator.items = resp.Data.Items
		iterator.index = 0
	}

	block := iterator.items[iterator.index]
	iterator.index++
	iterator.curlNum++
	return true, block, nil
}

func (iterator *ListMailgroupMemberIterator) NextPageToken() *string {
	return iterator.nextPageToken
}

type ListMailgroupPermissionMemberIterator struct {
	nextPageToken *string
	items         []*MailgroupPermissionMember
	index         int
	limit         int
	ctx           context.Context
	req           *ListMailgroupPermissionMemberReq
	listFunc      func(ctx context.Context, req *ListMailgroupPermissionMemberReq, options ...larkcore.RequestOptionFunc) (*ListMailgroupPermissionMemberResp, error)
	options       []larkcore.RequestOptionFunc
	curlNum       int
}

func (iterator *ListMailgroupPermissionMemberIterator) Next() (bool, *MailgroupPermissionMember, error) {
	// 达到最大量，则返回
	if iterator.limit > 0 && iterator.curlNum >= iterator.limit {
		return false, nil, nil
	}

	// 为0则拉取数据
	if iterator.index == 0 || iterator.index >= len(iterator.items) {
		if iterator.index != 0 && iterator.nextPageToken == nil {
			return false, nil, nil
		}
		if iterator.nextPageToken != nil {
			iterator.req.apiReq.QueryParams.Set("page_token", *iterator.nextPageToken)
		}
		resp, err := iterator.listFunc(iterator.ctx, iterator.req, iterator.options...)
		if err != nil {
			return false, nil, err
		}

		if resp.Code != 0 {
			return false, nil, errors.New(fmt.Sprintf("Code:%d,Msg:%s", resp.Code, resp.Msg))
		}

		if len(resp.Data.Items) == 0 {
			return false, nil, nil
		}

		iterator.nextPageToken = resp.Data.PageToken
		iterator.items = resp.Data.Items
		iterator.index = 0
	}

	block := iterator.items[iterator.index]
	iterator.index++
	iterator.curlNum++
	return true, block, nil
}

func (iterator *ListMailgroupPermissionMemberIterator) NextPageToken() *string {
	return iterator.nextPageToken
}

type ListPublicMailboxIterator struct {
	nextPageToken *string
	items         []*PublicMailbox
	index         int
	limit         int
	ctx           context.Context
	req           *ListPublicMailboxReq
	listFunc      func(ctx context.Context, req *ListPublicMailboxReq, options ...larkcore.RequestOptionFunc) (*ListPublicMailboxResp, error)
	options       []larkcore.RequestOptionFunc
	curlNum       int
}

func (iterator *ListPublicMailboxIterator) Next() (bool, *PublicMailbox, error) {
	// 达到最大量，则返回
	if iterator.limit > 0 && iterator.curlNum >= iterator.limit {
		return false, nil, nil
	}

	// 为0则拉取数据
	if iterator.index == 0 || iterator.index >= len(iterator.items) {
		if iterator.index != 0 && iterator.nextPageToken == nil {
			return false, nil, nil
		}
		if iterator.nextPageToken != nil {
			iterator.req.apiReq.QueryParams.Set("page_token", *iterator.nextPageToken)
		}
		resp, err := iterator.listFunc(iterator.ctx, iterator.req, iterator.options...)
		if err != nil {
			return false, nil, err
		}

		if resp.Code != 0 {
			return false, nil, errors.New(fmt.Sprintf("Code:%d,Msg:%s", resp.Code, resp.Msg))
		}

		if len(resp.Data.Items) == 0 {
			return false, nil, nil
		}

		iterator.nextPageToken = resp.Data.PageToken
		iterator.items = resp.Data.Items
		iterator.index = 0
	}

	block := iterator.items[iterator.index]
	iterator.index++
	iterator.curlNum++
	return true, block, nil
}

func (iterator *ListPublicMailboxIterator) NextPageToken() *string {
	return iterator.nextPageToken
}

type ListPublicMailboxMemberIterator struct {
	nextPageToken *string
	items         []*PublicMailboxMember
	index         int
	limit         int
	ctx           context.Context
	req           *ListPublicMailboxMemberReq
	listFunc      func(ctx context.Context, req *ListPublicMailboxMemberReq, options ...larkcore.RequestOptionFunc) (*ListPublicMailboxMemberResp, error)
	options       []larkcore.RequestOptionFunc
	curlNum       int
}

func (iterator *ListPublicMailboxMemberIterator) Next() (bool, *PublicMailboxMember, error) {
	// 达到最大量，则返回
	if iterator.limit > 0 && iterator.curlNum >= iterator.limit {
		return false, nil, nil
	}

	// 为0则拉取数据
	if iterator.index == 0 || iterator.index >= len(iterator.items) {
		if iterator.index != 0 && iterator.nextPageToken == nil {
			return false, nil, nil
		}
		if iterator.nextPageToken != nil {
			iterator.req.apiReq.QueryParams.Set("page_token", *iterator.nextPageToken)
		}
		resp, err := iterator.listFunc(iterator.ctx, iterator.req, iterator.options...)
		if err != nil {
			return false, nil, err
		}

		if resp.Code != 0 {
			return false, nil, errors.New(fmt.Sprintf("Code:%d,Msg:%s", resp.Code, resp.Msg))
		}

		if len(resp.Data.Items) == 0 {
			return false, nil, nil
		}

		iterator.nextPageToken = resp.Data.PageToken
		iterator.items = resp.Data.Items
		iterator.index = 0
	}

	block := iterator.items[iterator.index]
	iterator.index++
	iterator.curlNum++
	return true, block, nil
}

func (iterator *ListPublicMailboxMemberIterator) NextPageToken() *string {
	return iterator.nextPageToken
}