// Code generated by Lark OpenAPI.

package larkcorehr

import (
	"bytes"
	"context"
	"github.com/larksuite/oapi-sdk-go/v3/core"
	"net/http"
)

type V2 struct {
	ApprovalGroups                     *approvalGroups                     // approval_groups
	Approver                           *approver                           // approver
	BasicInfoBank                      *basicInfoBank                      // basic_info.bank
	BasicInfoBankBranch                *basicInfoBankBranch                // basic_info.bank_branch
	BasicInfoCity                      *basicInfoCity                      // basic_info.city
	BasicInfoCountryRegion             *basicInfoCountryRegion             // basic_info.country_region
	BasicInfoCountryRegionSubdivision  *basicInfoCountryRegionSubdivision  // basic_info.country_region_subdivision
	BasicInfoCurrency                  *basicInfoCurrency                  // basic_info.currency
	BasicInfoDistrict                  *basicInfoDistrict                  // basic_info.district
	BasicInfoLanguage                  *basicInfoLanguage                  // basic_info.language
	BasicInfoNationality               *basicInfoNationality               // basic_info.nationality
	BasicInfoTimeZone                  *basicInfoTimeZone                  // basic_info.time_zone
	Bp                                 *bp                                 // bp
	Company                            *company                            // company
	Contract                           *contract                           // contract
	CostAllocation                     *costAllocation                     // cost_allocation
	CostCenter                         *costCenter                         // cost_center
	CostCenterVersion                  *costCenterVersion                  // cost_center.version
	CustomOrg                          *customOrg                          // custom_org
	DefaultCostCenter                  *defaultCostCenter                  // default_cost_center
	Department                         *department                         // department
	Draft                              *draft                              // draft
	Employee                           *employee                           // employee
	EmployeesAdditionalJob             *employeesAdditionalJob             // employees.additional_job
	EmployeesBp                        *employeesBp                        // employees.bp
	EmployeesInternationalAssignment   *employeesInternationalAssignment   // employees.international_assignment
	EmployeesJobData                   *employeesJobData                   // employees.job_data
	Enum                               *enum                               // enum
	Job                                *job                                // job
	JobChange                          *jobChange                          // job_change
	JobFamily                          *jobFamily                          // job_family
	JobGrade                           *jobGrade                           // job_grade
	JobLevel                           *jobLevel                           // job_level
	Location                           *location                           // location
	LocationAddress                    *locationAddress                    // location.address
	Offboarding                        *offboarding                        // offboarding
	Pathway                            *pathway                            // pathway
	Person                             *person                             // person
	Position                           *position                           // position
	PreHire                            *preHire                            // 待入职
	Probation                          *probation                          // probation
	ProbationAssessment                *probationAssessment                // probation.assessment
	Process                            *process                            // process
	ProcessApprover                    *processApprover                    // process.approver
	ProcessCc                          *processCc                          // process.cc
	ProcessExtra                       *processExtra                       // process.extra
	ProcessFormVariableData            *processFormVariableData            // process.form_variable_data
	ProcessNode                        *processNode                        // process.node
	ProcessStatus                      *processStatus                      // process.status
	ProcessTransfer                    *processTransfer                    // process.transfer
	ProcessCommentInfo                 *processCommentInfo                 // process_comment_info
	ProcessRevoke                      *processRevoke                      // process_revoke
	ProcessWithdraw                    *processWithdraw                    // process_withdraw
	ReportDetailRow                    *reportDetailRow                    // report_detail_row
	SignatureFile                      *signatureFile                      // signature_file
	SignatureNode                      *signatureNode                      // signature_node
	SignatureTemplate                  *signatureTemplate                  // signature_template
	SignatureTemplateInfoWithThumbnail *signatureTemplateInfoWithThumbnail // signature_template_info_with_thumbnail
	WorkforcePlan                      *workforcePlan                      // workforce_plan
	WorkforcePlanDetail                *workforcePlanDetail                // workforce_plan_detail
	WorkforcePlanDetailRow             *workforcePlanDetailRow             // workforce_plan_detail_row
}

func New(config *larkcore.Config) *V2 {
	return &V2{
		ApprovalGroups:                     &approvalGroups{config: config},
		Approver:                           &approver{config: config},
		BasicInfoBank:                      &basicInfoBank{config: config},
		BasicInfoBankBranch:                &basicInfoBankBranch{config: config},
		BasicInfoCity:                      &basicInfoCity{config: config},
		BasicInfoCountryRegion:             &basicInfoCountryRegion{config: config},
		BasicInfoCountryRegionSubdivision:  &basicInfoCountryRegionSubdivision{config: config},
		BasicInfoCurrency:                  &basicInfoCurrency{config: config},
		BasicInfoDistrict:                  &basicInfoDistrict{config: config},
		BasicInfoLanguage:                  &basicInfoLanguage{config: config},
		BasicInfoNationality:               &basicInfoNationality{config: config},
		BasicInfoTimeZone:                  &basicInfoTimeZone{config: config},
		Bp:                                 &bp{config: config},
		Company:                            &company{config: config},
		Contract:                           &contract{config: config},
		CostAllocation:                     &costAllocation{config: config},
		CostCenter:                         &costCenter{config: config},
		CostCenterVersion:                  &costCenterVersion{config: config},
		CustomOrg:                          &customOrg{config: config},
		DefaultCostCenter:                  &defaultCostCenter{config: config},
		Department:                         &department{config: config},
		Draft:                              &draft{config: config},
		Employee:                           &employee{config: config},
		EmployeesAdditionalJob:             &employeesAdditionalJob{config: config},
		EmployeesBp:                        &employeesBp{config: config},
		EmployeesInternationalAssignment:   &employeesInternationalAssignment{config: config},
		EmployeesJobData:                   &employeesJobData{config: config},
		Enum:                               &enum{config: config},
		Job:                                &job{config: config},
		JobChange:                          &jobChange{config: config},
		JobFamily:                          &jobFamily{config: config},
		JobGrade:                           &jobGrade{config: config},
		JobLevel:                           &jobLevel{config: config},
		Location:                           &location{config: config},
		LocationAddress:                    &locationAddress{config: config},
		Offboarding:                        &offboarding{config: config},
		Pathway:                            &pathway{config: config},
		Person:                             &person{config: config},
		Position:                           &position{config: config},
		PreHire:                            &preHire{config: config},
		Probation:                          &probation{config: config},
		ProbationAssessment:                &probationAssessment{config: config},
		Process:                            &process{config: config},
		ProcessApprover:                    &processApprover{config: config},
		ProcessCc:                          &processCc{config: config},
		ProcessExtra:                       &processExtra{config: config},
		ProcessFormVariableData:            &processFormVariableData{config: config},
		ProcessNode:                        &processNode{config: config},
		ProcessStatus:                      &processStatus{config: config},
		ProcessTransfer:                    &processTransfer{config: config},
		ProcessCommentInfo:                 &processCommentInfo{config: config},
		ProcessRevoke:                      &processRevoke{config: config},
		ProcessWithdraw:                    &processWithdraw{config: config},
		ReportDetailRow:                    &reportDetailRow{config: config},
		SignatureFile:                      &signatureFile{config: config},
		SignatureNode:                      &signatureNode{config: config},
		SignatureTemplate:                  &signatureTemplate{config: config},
		SignatureTemplateInfoWithThumbnail: &signatureTemplateInfoWithThumbnail{config: config},
		WorkforcePlan:                      &workforcePlan{config: config},
		WorkforcePlanDetail:                &workforcePlanDetail{config: config},
		WorkforcePlanDetailRow:             &workforcePlanDetailRow{config: config},
	}
}

type approvalGroups struct {
	config *larkcore.Config
}
type approver struct {
	config *larkcore.Config
}
type basicInfoBank struct {
	config *larkcore.Config
}
type basicInfoBankBranch struct {
	config *larkcore.Config
}
type basicInfoCity struct {
	config *larkcore.Config
}
type basicInfoCountryRegion struct {
	config *larkcore.Config
}
type basicInfoCountryRegionSubdivision struct {
	config *larkcore.Config
}
type basicInfoCurrency struct {
	config *larkcore.Config
}
type basicInfoDistrict struct {
	config *larkcore.Config
}
type basicInfoLanguage struct {
	config *larkcore.Config
}
type basicInfoNationality struct {
	config *larkcore.Config
}
type basicInfoTimeZone struct {
	config *larkcore.Config
}
type bp struct {
	config *larkcore.Config
}
type company struct {
	config *larkcore.Config
}
type contract struct {
	config *larkcore.Config
}
type costAllocation struct {
	config *larkcore.Config
}
type costCenter struct {
	config *larkcore.Config
}
type costCenterVersion struct {
	config *larkcore.Config
}
type customOrg struct {
	config *larkcore.Config
}
type defaultCostCenter struct {
	config *larkcore.Config
}
type department struct {
	config *larkcore.Config
}
type draft struct {
	config *larkcore.Config
}
type employee struct {
	config *larkcore.Config
}
type employeesAdditionalJob struct {
	config *larkcore.Config
}
type employeesBp struct {
	config *larkcore.Config
}
type employeesInternationalAssignment struct {
	config *larkcore.Config
}
type employeesJobData struct {
	config *larkcore.Config
}
type enum struct {
	config *larkcore.Config
}
type job struct {
	config *larkcore.Config
}
type jobChange struct {
	config *larkcore.Config
}
type jobFamily struct {
	config *larkcore.Config
}
type jobGrade struct {
	config *larkcore.Config
}
type jobLevel struct {
	config *larkcore.Config
}
type location struct {
	config *larkcore.Config
}
type locationAddress struct {
	config *larkcore.Config
}
type offboarding struct {
	config *larkcore.Config
}
type pathway struct {
	config *larkcore.Config
}
type person struct {
	config *larkcore.Config
}
type position struct {
	config *larkcore.Config
}
type preHire struct {
	config *larkcore.Config
}
type probation struct {
	config *larkcore.Config
}
type probationAssessment struct {
	config *larkcore.Config
}
type process struct {
	config *larkcore.Config
}
type processApprover struct {
	config *larkcore.Config
}
type processCc struct {
	config *larkcore.Config
}
type processExtra struct {
	config *larkcore.Config
}
type processFormVariableData struct {
	config *larkcore.Config
}
type processNode struct {
	config *larkcore.Config
}
type processStatus struct {
	config *larkcore.Config
}
type processTransfer struct {
	config *larkcore.Config
}
type processCommentInfo struct {
	config *larkcore.Config
}
type processRevoke struct {
	config *larkcore.Config
}
type processWithdraw struct {
	config *larkcore.Config
}
type reportDetailRow struct {
	config *larkcore.Config
}
type signatureFile struct {
	config *larkcore.Config
}
type signatureNode struct {
	config *larkcore.Config
}
type signatureTemplate struct {
	config *larkcore.Config
}
type signatureTemplateInfoWithThumbnail struct {
	config *larkcore.Config
}
type workforcePlan struct {
	config *larkcore.Config
}
type workforcePlanDetail struct {
	config *larkcore.Config
}
type workforcePlanDetailRow struct {
	config *larkcore.Config
}

// Get
//
// - 获取审批组信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=get&project=corehr&resource=approval_groups&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/get_approvalGroups.go
func (a *approvalGroups) Get(ctx context.Context, req *GetApprovalGroupsReq, options ...larkcore.RequestOptionFunc) (*GetApprovalGroupsResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/approval_groups/:process_id"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, a.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &GetApprovalGroupsResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// OpenQueryDepartmentChangeListByIds
//
// - 获取部门调整信息详情
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=open_query_department_change_list_by_ids&project=corehr&resource=approval_groups&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/openQueryDepartmentChangeListByIds_approvalGroups.go
func (a *approvalGroups) OpenQueryDepartmentChangeListByIds(ctx context.Context, req *OpenQueryDepartmentChangeListByIdsApprovalGroupsReq, options ...larkcore.RequestOptionFunc) (*OpenQueryDepartmentChangeListByIdsApprovalGroupsResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/approval_groups/open_query_department_change_list_by_ids"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, a.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &OpenQueryDepartmentChangeListByIdsApprovalGroupsResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// OpenQueryJobChangeListByIds
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=open_query_job_change_list_by_ids&project=corehr&resource=approval_groups&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/openQueryJobChangeListByIds_approvalGroups.go
func (a *approvalGroups) OpenQueryJobChangeListByIds(ctx context.Context, req *OpenQueryJobChangeListByIdsApprovalGroupsReq, options ...larkcore.RequestOptionFunc) (*OpenQueryJobChangeListByIdsApprovalGroupsResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/approval_groups/open_query_job_change_list_by_ids"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, a.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &OpenQueryJobChangeListByIdsApprovalGroupsResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// OpenQueryPositionChangeListByIds
//
// - 获取岗位调整信息详情
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=open_query_position_change_list_by_ids&project=corehr&resource=approval_groups&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/openQueryPositionChangeListByIds_approvalGroups.go
func (a *approvalGroups) OpenQueryPositionChangeListByIds(ctx context.Context, req *OpenQueryPositionChangeListByIdsApprovalGroupsReq, options ...larkcore.RequestOptionFunc) (*OpenQueryPositionChangeListByIdsApprovalGroupsResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/approval_groups/open_query_position_change_list_by_ids"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, a.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &OpenQueryPositionChangeListByIdsApprovalGroupsResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=list&project=corehr&resource=approver&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/list_approver.go
func (a *approver) List(ctx context.Context, req *ListApproverReq, options ...larkcore.RequestOptionFunc) (*ListApproverResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/approvers"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, a.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListApproverResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (a *approver) ListByIterator(ctx context.Context, req *ListApproverReq, options ...larkcore.RequestOptionFunc) (*ListApproverIterator, error) {
	return &ListApproverIterator{
		ctx:      ctx,
		req:      req,
		listFunc: a.List,
		options:  options,
		limit:    req.Limit}, nil
}

// Search
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=search&project=corehr&resource=basic_info.bank&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/search_basicInfoBank.go
func (b *basicInfoBank) Search(ctx context.Context, req *SearchBasicInfoBankReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoBankResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/basic_info/banks/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, b.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchBasicInfoBankResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, b.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (b *basicInfoBank) SearchByIterator(ctx context.Context, req *SearchBasicInfoBankReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoBankIterator, error) {
	return &SearchBasicInfoBankIterator{
		ctx:      ctx,
		req:      req,
		listFunc: b.Search,
		options:  options,
		limit:    req.Limit}, nil
}

// Search
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=search&project=corehr&resource=basic_info.bank_branch&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/search_basicInfoBankBranch.go
func (b *basicInfoBankBranch) Search(ctx context.Context, req *SearchBasicInfoBankBranchReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoBankBranchResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/basic_info/bank_branchs/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, b.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchBasicInfoBankBranchResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, b.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (b *basicInfoBankBranch) SearchByIterator(ctx context.Context, req *SearchBasicInfoBankBranchReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoBankBranchIterator, error) {
	return &SearchBasicInfoBankBranchIterator{
		ctx:      ctx,
		req:      req,
		listFunc: b.Search,
		options:  options,
		limit:    req.Limit}, nil
}

// Search
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=search&project=corehr&resource=basic_info.city&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/search_basicInfoCity.go
func (b *basicInfoCity) Search(ctx context.Context, req *SearchBasicInfoCityReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoCityResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/basic_info/cities/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, b.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchBasicInfoCityResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, b.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (b *basicInfoCity) SearchByIterator(ctx context.Context, req *SearchBasicInfoCityReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoCityIterator, error) {
	return &SearchBasicInfoCityIterator{
		ctx:      ctx,
		req:      req,
		listFunc: b.Search,
		options:  options,
		limit:    req.Limit}, nil
}

// Search
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=search&project=corehr&resource=basic_info.country_region&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/search_basicInfoCountryRegion.go
func (b *basicInfoCountryRegion) Search(ctx context.Context, req *SearchBasicInfoCountryRegionReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoCountryRegionResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/basic_info/country_regions/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, b.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchBasicInfoCountryRegionResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, b.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (b *basicInfoCountryRegion) SearchByIterator(ctx context.Context, req *SearchBasicInfoCountryRegionReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoCountryRegionIterator, error) {
	return &SearchBasicInfoCountryRegionIterator{
		ctx:      ctx,
		req:      req,
		listFunc: b.Search,
		options:  options,
		limit:    req.Limit}, nil
}

// Search
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=search&project=corehr&resource=basic_info.country_region_subdivision&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/search_basicInfoCountryRegionSubdivision.go
func (b *basicInfoCountryRegionSubdivision) Search(ctx context.Context, req *SearchBasicInfoCountryRegionSubdivisionReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoCountryRegionSubdivisionResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/basic_info/country_region_subdivisions/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, b.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchBasicInfoCountryRegionSubdivisionResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, b.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (b *basicInfoCountryRegionSubdivision) SearchByIterator(ctx context.Context, req *SearchBasicInfoCountryRegionSubdivisionReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoCountryRegionSubdivisionIterator, error) {
	return &SearchBasicInfoCountryRegionSubdivisionIterator{
		ctx:      ctx,
		req:      req,
		listFunc: b.Search,
		options:  options,
		limit:    req.Limit}, nil
}

// Search
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=search&project=corehr&resource=basic_info.currency&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/search_basicInfoCurrency.go
func (b *basicInfoCurrency) Search(ctx context.Context, req *SearchBasicInfoCurrencyReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoCurrencyResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/basic_info/currencies/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, b.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchBasicInfoCurrencyResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, b.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (b *basicInfoCurrency) SearchByIterator(ctx context.Context, req *SearchBasicInfoCurrencyReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoCurrencyIterator, error) {
	return &SearchBasicInfoCurrencyIterator{
		ctx:      ctx,
		req:      req,
		listFunc: b.Search,
		options:  options,
		limit:    req.Limit}, nil
}

// Search
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=search&project=corehr&resource=basic_info.district&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/search_basicInfoDistrict.go
func (b *basicInfoDistrict) Search(ctx context.Context, req *SearchBasicInfoDistrictReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoDistrictResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/basic_info/districts/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, b.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchBasicInfoDistrictResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, b.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (b *basicInfoDistrict) SearchByIterator(ctx context.Context, req *SearchBasicInfoDistrictReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoDistrictIterator, error) {
	return &SearchBasicInfoDistrictIterator{
		ctx:      ctx,
		req:      req,
		listFunc: b.Search,
		options:  options,
		limit:    req.Limit}, nil
}

// Search
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=search&project=corehr&resource=basic_info.language&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/search_basicInfoLanguage.go
func (b *basicInfoLanguage) Search(ctx context.Context, req *SearchBasicInfoLanguageReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoLanguageResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/basic_info/languages/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, b.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchBasicInfoLanguageResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, b.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (b *basicInfoLanguage) SearchByIterator(ctx context.Context, req *SearchBasicInfoLanguageReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoLanguageIterator, error) {
	return &SearchBasicInfoLanguageIterator{
		ctx:      ctx,
		req:      req,
		listFunc: b.Search,
		options:  options,
		limit:    req.Limit}, nil
}

// Search
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=search&project=corehr&resource=basic_info.nationality&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/search_basicInfoNationality.go
func (b *basicInfoNationality) Search(ctx context.Context, req *SearchBasicInfoNationalityReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoNationalityResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/basic_info/nationalities/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, b.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchBasicInfoNationalityResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, b.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (b *basicInfoNationality) SearchByIterator(ctx context.Context, req *SearchBasicInfoNationalityReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoNationalityIterator, error) {
	return &SearchBasicInfoNationalityIterator{
		ctx:      ctx,
		req:      req,
		listFunc: b.Search,
		options:  options,
		limit:    req.Limit}, nil
}

// Search
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=search&project=corehr&resource=basic_info.time_zone&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/search_basicInfoTimeZone.go
func (b *basicInfoTimeZone) Search(ctx context.Context, req *SearchBasicInfoTimeZoneReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoTimeZoneResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/basic_info/time_zones/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, b.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchBasicInfoTimeZoneResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, b.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (b *basicInfoTimeZone) SearchByIterator(ctx context.Context, req *SearchBasicInfoTimeZoneReq, options ...larkcore.RequestOptionFunc) (*SearchBasicInfoTimeZoneIterator, error) {
	return &SearchBasicInfoTimeZoneIterator{
		ctx:      ctx,
		req:      req,
		listFunc: b.Search,
		options:  options,
		limit:    req.Limit}, nil
}

// GetByDepartment
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=get_by_department&project=corehr&resource=bp&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/getByDepartment_bp.go
func (b *bp) GetByDepartment(ctx context.Context, req *GetByDepartmentBpReq, options ...larkcore.RequestOptionFunc) (*GetByDepartmentBpResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/bps/get_by_department"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, b.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &GetByDepartmentBpResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, b.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List
//
// - 待补充
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=list&project=corehr&resource=bp&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/list_bp.go
func (b *bp) List(ctx context.Context, req *ListBpReq, options ...larkcore.RequestOptionFunc) (*ListBpResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/bps"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, b.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListBpResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, b.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (b *bp) ListByIterator(ctx context.Context, req *ListBpReq, options ...larkcore.RequestOptionFunc) (*ListBpIterator, error) {
	return &ListBpIterator{
		ctx:      ctx,
		req:      req,
		listFunc: b.List,
		options:  options,
		limit:    req.Limit}, nil
}

// Active
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=active&project=corehr&resource=company&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/active_company.go
func (c *company) Active(ctx context.Context, req *ActiveCompanyReq, options ...larkcore.RequestOptionFunc) (*ActiveCompanyResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/companies/active"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ActiveCompanyResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchGet
//
// - 通过公司 ID 批量获取公司信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batch_get&project=corehr&resource=company&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/batchGet_company.go
func (c *company) BatchGet(ctx context.Context, req *BatchGetCompanyReq, options ...larkcore.RequestOptionFunc) (*BatchGetCompanyResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/companies/batch_get"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchGetCompanyResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// QueryRecentChange
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query_recent_change&project=corehr&resource=company&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/queryRecentChange_company.go
func (c *company) QueryRecentChange(ctx context.Context, req *QueryRecentChangeCompanyReq, options ...larkcore.RequestOptionFunc) (*QueryRecentChangeCompanyResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/companies/query_recent_change"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryRecentChangeCompanyResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Search
//
// - 根据合同 ID 、雇佣 ID 查询合同信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=search&project=corehr&resource=contract&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/search_contract.go
func (c *contract) Search(ctx context.Context, req *SearchContractReq, options ...larkcore.RequestOptionFunc) (*SearchContractResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/contracts/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchContractResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (c *contract) SearchByIterator(ctx context.Context, req *SearchContractReq, options ...larkcore.RequestOptionFunc) (*SearchContractIterator, error) {
	return &SearchContractIterator{
		ctx:      ctx,
		req:      req,
		listFunc: c.Search,
		options:  options,
		limit:    req.Limit}, nil
}

// BatchQuery
//
// - 通过员工ID批量获取通道信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batch_query&project=corehr&resource=cost_allocation&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/batchQuery_costAllocation.go
func (c *costAllocation) BatchQuery(ctx context.Context, req *BatchQueryCostAllocationReq, options ...larkcore.RequestOptionFunc) (*BatchQueryCostAllocationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/cost_allocations/batch_query"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchQueryCostAllocationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// CreateVersion
//
// - 创建成本分摊
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=create_version&project=corehr&resource=cost_allocation&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/createVersion_costAllocation.go
func (c *costAllocation) CreateVersion(ctx context.Context, req *CreateVersionCostAllocationReq, options ...larkcore.RequestOptionFunc) (*CreateVersionCostAllocationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/cost_allocations/create_version"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CreateVersionCostAllocationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// RemoveVersion
//
// - 删除成本分摊
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=remove_version&project=corehr&resource=cost_allocation&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/removeVersion_costAllocation.go
func (c *costAllocation) RemoveVersion(ctx context.Context, req *RemoveVersionCostAllocationReq, options ...larkcore.RequestOptionFunc) (*RemoveVersionCostAllocationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/cost_allocations/remove_version"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &RemoveVersionCostAllocationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// UpdateVersion
//
// - 更新成本分摊
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=update_version&project=corehr&resource=cost_allocation&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/updateVersion_costAllocation.go
func (c *costAllocation) UpdateVersion(ctx context.Context, req *UpdateVersionCostAllocationReq, options ...larkcore.RequestOptionFunc) (*UpdateVersionCostAllocationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/cost_allocations/update_version"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &UpdateVersionCostAllocationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create
//
// - 创建成本中心
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=create&project=corehr&resource=cost_center&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/create_costCenter.go
func (c *costCenter) Create(ctx context.Context, req *CreateCostCenterReq, options ...larkcore.RequestOptionFunc) (*CreateCostCenterResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/cost_centers"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CreateCostCenterResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Delete
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=delete&project=corehr&resource=cost_center&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/delete_costCenter.go
func (c *costCenter) Delete(ctx context.Context, req *DeleteCostCenterReq, options ...larkcore.RequestOptionFunc) (*DeleteCostCenterResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/cost_centers/:cost_center_id"
	apiReq.HttpMethod = http.MethodDelete
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &DeleteCostCenterResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Patch
//
// - 创建成本中心版本
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=patch&project=corehr&resource=cost_center&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/patch_costCenter.go
func (c *costCenter) Patch(ctx context.Context, req *PatchCostCenterReq, options ...larkcore.RequestOptionFunc) (*PatchCostCenterResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/cost_centers/:cost_center_id"
	apiReq.HttpMethod = http.MethodPatch
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &PatchCostCenterResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// QueryRecentChange
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query_recent_change&project=corehr&resource=cost_center&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/queryRecentChange_costCenter.go
func (c *costCenter) QueryRecentChange(ctx context.Context, req *QueryRecentChangeCostCenterReq, options ...larkcore.RequestOptionFunc) (*QueryRecentChangeCostCenterResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/cost_centers/query_recent_change"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryRecentChangeCostCenterResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Search
//
// - 查询成本中心信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=search&project=corehr&resource=cost_center&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/search_costCenter.go
func (c *costCenter) Search(ctx context.Context, req *SearchCostCenterReq, options ...larkcore.RequestOptionFunc) (*SearchCostCenterResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/cost_centers/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchCostCenterResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create
//
// - 创建成本中心版本
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=create&project=corehr&resource=cost_center.version&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/create_costCenterVersion.go
func (c *costCenterVersion) Create(ctx context.Context, req *CreateCostCenterVersionReq, options ...larkcore.RequestOptionFunc) (*CreateCostCenterVersionResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/cost_centers/:cost_center_id/versions"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CreateCostCenterVersionResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Delete
//
// - 撤销成本中心版本
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=delete&project=corehr&resource=cost_center.version&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/delete_costCenterVersion.go
func (c *costCenterVersion) Delete(ctx context.Context, req *DeleteCostCenterVersionReq, options ...larkcore.RequestOptionFunc) (*DeleteCostCenterVersionResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/cost_centers/:cost_center_id/versions/:version_id"
	apiReq.HttpMethod = http.MethodDelete
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &DeleteCostCenterVersionResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Patch
//
// - 创建成本中心版本
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=patch&project=corehr&resource=cost_center.version&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/patch_costCenterVersion.go
func (c *costCenterVersion) Patch(ctx context.Context, req *PatchCostCenterVersionReq, options ...larkcore.RequestOptionFunc) (*PatchCostCenterVersionResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/cost_centers/:cost_center_id/versions/:version_id"
	apiReq.HttpMethod = http.MethodPatch
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &PatchCostCenterVersionResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Active
//
// - 启/停用自定义组织
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=active&project=corehr&resource=custom_org&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/active_customOrg.go
func (c *customOrg) Active(ctx context.Context, req *ActiveCustomOrgReq, options ...larkcore.RequestOptionFunc) (*ActiveCustomOrgResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/custom_orgs/active"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ActiveCustomOrgResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=create&project=corehr&resource=custom_org&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/create_customOrg.go
func (c *customOrg) Create(ctx context.Context, req *CreateCustomOrgReq, options ...larkcore.RequestOptionFunc) (*CreateCustomOrgResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/custom_orgs"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CreateCustomOrgResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// DeleteOrg
//
// - 删除自定义组织
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=delete_org&project=corehr&resource=custom_org&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/deleteOrg_customOrg.go
func (c *customOrg) DeleteOrg(ctx context.Context, req *DeleteOrgCustomOrgReq, options ...larkcore.RequestOptionFunc) (*DeleteOrgCustomOrgResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/custom_orgs/delete_org"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &DeleteOrgCustomOrgResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Patch
//
// - 更新自定义组织
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=patch&project=corehr&resource=custom_org&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/patch_customOrg.go
func (c *customOrg) Patch(ctx context.Context, req *PatchCustomOrgReq, options ...larkcore.RequestOptionFunc) (*PatchCustomOrgResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/custom_orgs/:org_id"
	apiReq.HttpMethod = http.MethodPatch
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &PatchCustomOrgResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Query
//
// - 查询自定义组织信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query&project=corehr&resource=custom_org&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/query_customOrg.go
func (c *customOrg) Query(ctx context.Context, req *QueryCustomOrgReq, options ...larkcore.RequestOptionFunc) (*QueryCustomOrgResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/custom_orgs/query"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryCustomOrgResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// QueryRecentChange
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query_recent_change&project=corehr&resource=custom_org&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/queryRecentChange_customOrg.go
func (c *customOrg) QueryRecentChange(ctx context.Context, req *QueryRecentChangeCustomOrgReq, options ...larkcore.RequestOptionFunc) (*QueryRecentChangeCustomOrgResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/custom_orgs/query_recent_change"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryRecentChangeCustomOrgResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// UpdateRule
//
// - 更新匹配规则
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=update_rule&project=corehr&resource=custom_org&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/updateRule_customOrg.go
func (c *customOrg) UpdateRule(ctx context.Context, req *UpdateRuleCustomOrgReq, options ...larkcore.RequestOptionFunc) (*UpdateRuleCustomOrgResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/custom_orgs/update_rule"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, c.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &UpdateRuleCustomOrgResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, c.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchQuery
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batch_query&project=corehr&resource=default_cost_center&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/batchQuery_defaultCostCenter.go
func (d *defaultCostCenter) BatchQuery(ctx context.Context, req *BatchQueryDefaultCostCenterReq, options ...larkcore.RequestOptionFunc) (*BatchQueryDefaultCostCenterResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/default_cost_centers/batch_query"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, d.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchQueryDefaultCostCenterResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, d.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// CreateVersion
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=create_version&project=corehr&resource=default_cost_center&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/createVersion_defaultCostCenter.go
func (d *defaultCostCenter) CreateVersion(ctx context.Context, req *CreateVersionDefaultCostCenterReq, options ...larkcore.RequestOptionFunc) (*CreateVersionDefaultCostCenterResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/default_cost_centers/create_version"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, d.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CreateVersionDefaultCostCenterResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, d.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// RemoveVersion
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=remove_version&project=corehr&resource=default_cost_center&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/removeVersion_defaultCostCenter.go
func (d *defaultCostCenter) RemoveVersion(ctx context.Context, req *RemoveVersionDefaultCostCenterReq, options ...larkcore.RequestOptionFunc) (*RemoveVersionDefaultCostCenterResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/default_cost_centers/remove_version"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, d.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &RemoveVersionDefaultCostCenterResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, d.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// UpdateVersion
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=update_version&project=corehr&resource=default_cost_center&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/updateVersion_defaultCostCenter.go
func (d *defaultCostCenter) UpdateVersion(ctx context.Context, req *UpdateVersionDefaultCostCenterReq, options ...larkcore.RequestOptionFunc) (*UpdateVersionDefaultCostCenterResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/default_cost_centers/update_version"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, d.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &UpdateVersionDefaultCostCenterResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, d.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchGet
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batch_get&project=corehr&resource=department&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/batchGet_department.go
func (d *department) BatchGet(ctx context.Context, req *BatchGetDepartmentReq, options ...larkcore.RequestOptionFunc) (*BatchGetDepartmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/departments/batch_get"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, d.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchGetDepartmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, d.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Delete
//
// - 删除部门数据
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=delete&project=corehr&resource=department&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/delete_department.go
func (d *department) Delete(ctx context.Context, req *DeleteDepartmentReq, options ...larkcore.RequestOptionFunc) (*DeleteDepartmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/departments/:department_id"
	apiReq.HttpMethod = http.MethodDelete
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, d.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &DeleteDepartmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, d.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Parents
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=parents&project=corehr&resource=department&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/parents_department.go
func (d *department) Parents(ctx context.Context, req *ParentsDepartmentReq, options ...larkcore.RequestOptionFunc) (*ParentsDepartmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/departments/parents"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, d.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ParentsDepartmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, d.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Patch
//
// - 更新部门数据
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=patch&project=corehr&resource=department&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/patch_department.go
func (d *department) Patch(ctx context.Context, req *PatchDepartmentReq, options ...larkcore.RequestOptionFunc) (*PatchDepartmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/departments/:department_id"
	apiReq.HttpMethod = http.MethodPatch
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, d.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &PatchDepartmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, d.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// QueryMultiTimeline
//
// - 查询任意日期部门信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query_multi_timeline&project=corehr&resource=department&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/queryMultiTimeline_department.go
func (d *department) QueryMultiTimeline(ctx context.Context, req *QueryMultiTimelineDepartmentReq, options ...larkcore.RequestOptionFunc) (*QueryMultiTimelineDepartmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/departments/query_multi_timeline"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, d.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryMultiTimelineDepartmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, d.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// QueryOperationLogs
//
// - 查询操作日志
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query_operation_logs&project=corehr&resource=department&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/queryOperationLogs_department.go
func (d *department) QueryOperationLogs(ctx context.Context, req *QueryOperationLogsDepartmentReq, options ...larkcore.RequestOptionFunc) (*QueryOperationLogsDepartmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/departments/query_operation_logs"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, d.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryOperationLogsDepartmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, d.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// QueryRecentChange
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query_recent_change&project=corehr&resource=department&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/queryRecentChange_department.go
func (d *department) QueryRecentChange(ctx context.Context, req *QueryRecentChangeDepartmentReq, options ...larkcore.RequestOptionFunc) (*QueryRecentChangeDepartmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/departments/query_recent_change"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, d.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryRecentChangeDepartmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, d.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// QueryTimeline
//
// - 查询任意日期部门信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query_timeline&project=corehr&resource=department&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/queryTimeline_department.go
func (d *department) QueryTimeline(ctx context.Context, req *QueryTimelineDepartmentReq, options ...larkcore.RequestOptionFunc) (*QueryTimelineDepartmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/departments/query_timeline"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, d.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryTimelineDepartmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, d.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Search
//
// - 根据部门 ID，上级部门查询部门列表
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=search&project=corehr&resource=department&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/search_department.go
func (d *department) Search(ctx context.Context, req *SearchDepartmentReq, options ...larkcore.RequestOptionFunc) (*SearchDepartmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/departments/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, d.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchDepartmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, d.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (d *department) SearchByIterator(ctx context.Context, req *SearchDepartmentReq, options ...larkcore.RequestOptionFunc) (*SearchDepartmentIterator, error) {
	return &SearchDepartmentIterator{
		ctx:      ctx,
		req:      req,
		listFunc: d.Search,
		options:  options,
		limit:    req.Limit}, nil
}

// Tree
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=tree&project=corehr&resource=department&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/tree_department.go
func (d *department) Tree(ctx context.Context, req *TreeDepartmentReq, options ...larkcore.RequestOptionFunc) (*TreeDepartmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/departments/tree"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, d.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &TreeDepartmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, d.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Get
//
// - 根据组织架构调整 ID 查询调整流程信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=get&project=corehr&resource=draft&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/get_draft.go
func (d *draft) Get(ctx context.Context, req *GetDraftReq, options ...larkcore.RequestOptionFunc) (*GetDraftResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/drafts/:draft_id"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, d.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &GetDraftResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, d.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchGet
//
// - 通过员工 ID 批量获取员工信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batch_get&project=corehr&resource=employee&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/batchGet_employee.go
func (e *employee) BatchGet(ctx context.Context, req *BatchGetEmployeeReq, options ...larkcore.RequestOptionFunc) (*BatchGetEmployeeResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/employees/batch_get"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, e.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchGetEmployeeResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=create&project=corehr&resource=employee&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/create_employee.go
func (e *employee) Create(ctx context.Context, req *CreateEmployeeReq, options ...larkcore.RequestOptionFunc) (*CreateEmployeeResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/employees"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, e.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CreateEmployeeResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Search
//
// - 根据 email、工号、个人电话等条件查询员工雇佣信息以及个人基础信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=search&project=corehr&resource=employee&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/search_employee.go
func (e *employee) Search(ctx context.Context, req *SearchEmployeeReq, options ...larkcore.RequestOptionFunc) (*SearchEmployeeResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/employees/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, e.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchEmployeeResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (e *employee) SearchByIterator(ctx context.Context, req *SearchEmployeeReq, options ...larkcore.RequestOptionFunc) (*SearchEmployeeIterator, error) {
	return &SearchEmployeeIterator{
		ctx:      ctx,
		req:      req,
		listFunc: e.Search,
		options:  options,
		limit:    req.Limit}, nil
}

// Batch
//
// - 批量查询兼职信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batch&project=corehr&resource=employees.additional_job&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/batch_employeesAdditionalJob.go
func (e *employeesAdditionalJob) Batch(ctx context.Context, req *BatchEmployeesAdditionalJobReq, options ...larkcore.RequestOptionFunc) (*BatchEmployeesAdditionalJobResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/employees/additional_jobs/batch"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, e.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchEmployeesAdditionalJobResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (e *employeesAdditionalJob) BatchByIterator(ctx context.Context, req *BatchEmployeesAdditionalJobReq, options ...larkcore.RequestOptionFunc) (*BatchEmployeesAdditionalJobIterator, error) {
	return &BatchEmployeesAdditionalJobIterator{
		ctx:      ctx,
		req:      req,
		listFunc: e.Batch,
		options:  options,
		limit:    req.Limit}, nil
}

// Create
//
// - 创建兼职
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=create&project=corehr&resource=employees.additional_job&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/create_employeesAdditionalJob.go
func (e *employeesAdditionalJob) Create(ctx context.Context, req *CreateEmployeesAdditionalJobReq, options ...larkcore.RequestOptionFunc) (*CreateEmployeesAdditionalJobResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/employees/additional_jobs"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, e.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CreateEmployeesAdditionalJobResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Delete
//
// - 删除兼职
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=delete&project=corehr&resource=employees.additional_job&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/delete_employeesAdditionalJob.go
func (e *employeesAdditionalJob) Delete(ctx context.Context, req *DeleteEmployeesAdditionalJobReq, options ...larkcore.RequestOptionFunc) (*DeleteEmployeesAdditionalJobResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/employees/additional_jobs/:additional_job_id"
	apiReq.HttpMethod = http.MethodDelete
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, e.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &DeleteEmployeesAdditionalJobResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Patch
//
// - 更新兼职
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=patch&project=corehr&resource=employees.additional_job&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/patch_employeesAdditionalJob.go
func (e *employeesAdditionalJob) Patch(ctx context.Context, req *PatchEmployeesAdditionalJobReq, options ...larkcore.RequestOptionFunc) (*PatchEmployeesAdditionalJobResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/employees/additional_jobs/:additional_job_id"
	apiReq.HttpMethod = http.MethodPatch
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, e.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &PatchEmployeesAdditionalJobResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchGet
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batch_get&project=corehr&resource=employees.bp&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/batchGet_employeesBp.go
func (e *employeesBp) BatchGet(ctx context.Context, req *BatchGetEmployeesBpReq, options ...larkcore.RequestOptionFunc) (*BatchGetEmployeesBpResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/employees/bps/batch_get"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, e.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchGetEmployeesBpResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=create&project=corehr&resource=employees.international_assignment&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/create_employeesInternationalAssignment.go
func (e *employeesInternationalAssignment) Create(ctx context.Context, req *CreateEmployeesInternationalAssignmentReq, options ...larkcore.RequestOptionFunc) (*CreateEmployeesInternationalAssignmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/employees/international_assignments"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, e.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CreateEmployeesInternationalAssignmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Delete
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=delete&project=corehr&resource=employees.international_assignment&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/delete_employeesInternationalAssignment.go
func (e *employeesInternationalAssignment) Delete(ctx context.Context, req *DeleteEmployeesInternationalAssignmentReq, options ...larkcore.RequestOptionFunc) (*DeleteEmployeesInternationalAssignmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/employees/international_assignments/:international_assignment_id"
	apiReq.HttpMethod = http.MethodDelete
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, e.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &DeleteEmployeesInternationalAssignmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=list&project=corehr&resource=employees.international_assignment&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/list_employeesInternationalAssignment.go
func (e *employeesInternationalAssignment) List(ctx context.Context, req *ListEmployeesInternationalAssignmentReq, options ...larkcore.RequestOptionFunc) (*ListEmployeesInternationalAssignmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/employees/international_assignments"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, e.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListEmployeesInternationalAssignmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Patch
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=patch&project=corehr&resource=employees.international_assignment&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/patch_employeesInternationalAssignment.go
func (e *employeesInternationalAssignment) Patch(ctx context.Context, req *PatchEmployeesInternationalAssignmentReq, options ...larkcore.RequestOptionFunc) (*PatchEmployeesInternationalAssignmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/employees/international_assignments/:international_assignment_id"
	apiReq.HttpMethod = http.MethodPatch
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, e.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &PatchEmployeesInternationalAssignmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchGet
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batch_get&project=corehr&resource=employees.job_data&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/batchGet_employeesJobData.go
func (e *employeesJobData) BatchGet(ctx context.Context, req *BatchGetEmployeesJobDataReq, options ...larkcore.RequestOptionFunc) (*BatchGetEmployeesJobDataResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/employees/job_datas/batch_get"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, e.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchGetEmployeesJobDataResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Query
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query&project=corehr&resource=employees.job_data&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/query_employeesJobData.go
func (e *employeesJobData) Query(ctx context.Context, req *QueryEmployeesJobDataReq, options ...larkcore.RequestOptionFunc) (*QueryEmployeesJobDataResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/employees/job_datas/query"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, e.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryEmployeesJobDataResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Search
//
// - 通过apiname批量获取枚举信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=search&project=corehr&resource=enum&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/search_enum.go
func (e *enum) Search(ctx context.Context, req *SearchEnumReq, options ...larkcore.RequestOptionFunc) (*SearchEnumResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/enums/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, e.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchEnumResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchGet
//
// - 批量获取职务信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batch_get&project=corehr&resource=job&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/batchGet_job.go
func (j *job) BatchGet(ctx context.Context, req *BatchGetJobReq, options ...larkcore.RequestOptionFunc) (*BatchGetJobResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/jobs/batch_get"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, j.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchGetJobResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Get
//
// - 根据 ID 查询单个职务。
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=get&project=corehr&resource=job&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/get_job.go
func (j *job) Get(ctx context.Context, req *GetJobReq, options ...larkcore.RequestOptionFunc) (*GetJobResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/jobs/:job_id"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, j.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &GetJobResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List
//
// - 分页查询职务数据
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=list&project=corehr&resource=job&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/list_job.go
func (j *job) List(ctx context.Context, req *ListJobReq, options ...larkcore.RequestOptionFunc) (*ListJobResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/jobs"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, j.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListJobResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// QueryMultiTimeline
//
// - 查询生效时间在指定时间范围的职务
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query_multi_timeline&project=corehr&resource=job&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/queryMultiTimeline_job.go
func (j *job) QueryMultiTimeline(ctx context.Context, req *QueryMultiTimelineJobReq, options ...larkcore.RequestOptionFunc) (*QueryMultiTimelineJobResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/jobs/query_multi_timeline"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, j.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryMultiTimelineJobResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// QueryRecentChange
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query_recent_change&project=corehr&resource=job&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/queryRecentChange_job.go
func (j *job) QueryRecentChange(ctx context.Context, req *QueryRecentChangeJobReq, options ...larkcore.RequestOptionFunc) (*QueryRecentChangeJobResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/jobs/query_recent_change"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, j.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryRecentChangeJobResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=create&project=corehr&resource=job_change&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/create_jobChange.go
func (j *jobChange) Create(ctx context.Context, req *CreateJobChangeReq, options ...larkcore.RequestOptionFunc) (*CreateJobChangeResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/job_changes"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, j.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CreateJobChangeResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Revoke
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=revoke&project=corehr&resource=job_change&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/revoke_jobChange.go
func (j *jobChange) Revoke(ctx context.Context, req *RevokeJobChangeReq, options ...larkcore.RequestOptionFunc) (*RevokeJobChangeResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/job_changes/:job_change_id/revoke"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, j.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &RevokeJobChangeResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Search
//
// - 获取员工异动列表
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=search&project=corehr&resource=job_change&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/search_jobChange.go
func (j *jobChange) Search(ctx context.Context, req *SearchJobChangeReq, options ...larkcore.RequestOptionFunc) (*SearchJobChangeResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/job_changes/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, j.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchJobChangeResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (j *jobChange) SearchByIterator(ctx context.Context, req *SearchJobChangeReq, options ...larkcore.RequestOptionFunc) (*SearchJobChangeIterator, error) {
	return &SearchJobChangeIterator{
		ctx:      ctx,
		req:      req,
		listFunc: j.Search,
		options:  options,
		limit:    req.Limit}, nil
}

// BatchGet
//
// - 批量获取序列信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batch_get&project=corehr&resource=job_family&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/batchGet_jobFamily.go
func (j *jobFamily) BatchGet(ctx context.Context, req *BatchGetJobFamilyReq, options ...larkcore.RequestOptionFunc) (*BatchGetJobFamilyResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/job_families/batch_get"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, j.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchGetJobFamilyResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// QueryMultiTimeline
//
// - 查询生效时间在指定时间范围的序列
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query_multi_timeline&project=corehr&resource=job_family&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/queryMultiTimeline_jobFamily.go
func (j *jobFamily) QueryMultiTimeline(ctx context.Context, req *QueryMultiTimelineJobFamilyReq, options ...larkcore.RequestOptionFunc) (*QueryMultiTimelineJobFamilyResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/job_families/query_multi_timeline"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, j.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryMultiTimelineJobFamilyResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// QueryRecentChange
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query_recent_change&project=corehr&resource=job_family&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/queryRecentChange_jobFamily.go
func (j *jobFamily) QueryRecentChange(ctx context.Context, req *QueryRecentChangeJobFamilyReq, options ...larkcore.RequestOptionFunc) (*QueryRecentChangeJobFamilyResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/job_families/query_recent_change"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, j.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryRecentChangeJobFamilyResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create
//
// - 创建职等数据
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=create&project=corehr&resource=job_grade&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/create_jobGrade.go
func (j *jobGrade) Create(ctx context.Context, req *CreateJobGradeReq, options ...larkcore.RequestOptionFunc) (*CreateJobGradeResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/job_grades"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, j.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CreateJobGradeResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Delete
//
// - 删除职等信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=delete&project=corehr&resource=job_grade&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/delete_jobGrade.go
func (j *jobGrade) Delete(ctx context.Context, req *DeleteJobGradeReq, options ...larkcore.RequestOptionFunc) (*DeleteJobGradeResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/job_grades/:job_grade_id"
	apiReq.HttpMethod = http.MethodDelete
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, j.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &DeleteJobGradeResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Patch
//
// - 更新职等信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=patch&project=corehr&resource=job_grade&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/patch_jobGrade.go
func (j *jobGrade) Patch(ctx context.Context, req *PatchJobGradeReq, options ...larkcore.RequestOptionFunc) (*PatchJobGradeResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/job_grades/:job_grade_id"
	apiReq.HttpMethod = http.MethodPatch
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, j.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &PatchJobGradeResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Query
//
// - 查询职等信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query&project=corehr&resource=job_grade&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/query_jobGrade.go
func (j *jobGrade) Query(ctx context.Context, req *QueryJobGradeReq, options ...larkcore.RequestOptionFunc) (*QueryJobGradeResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/job_grades/query"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, j.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryJobGradeResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// QueryRecentChange
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query_recent_change&project=corehr&resource=job_grade&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/queryRecentChange_jobGrade.go
func (j *jobGrade) QueryRecentChange(ctx context.Context, req *QueryRecentChangeJobGradeReq, options ...larkcore.RequestOptionFunc) (*QueryRecentChangeJobGradeResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/job_grades/query_recent_change"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, j.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryRecentChangeJobGradeResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchGet
//
// - 批量获取职级信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batch_get&project=corehr&resource=job_level&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/batchGet_jobLevel.go
func (j *jobLevel) BatchGet(ctx context.Context, req *BatchGetJobLevelReq, options ...larkcore.RequestOptionFunc) (*BatchGetJobLevelResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/job_levels/batch_get"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, j.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchGetJobLevelResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// QueryRecentChange
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query_recent_change&project=corehr&resource=job_level&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/queryRecentChange_jobLevel.go
func (j *jobLevel) QueryRecentChange(ctx context.Context, req *QueryRecentChangeJobLevelReq, options ...larkcore.RequestOptionFunc) (*QueryRecentChangeJobLevelResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/job_levels/query_recent_change"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, j.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryRecentChangeJobLevelResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Active
//
// - 启停/停用地点
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=active&project=corehr&resource=location&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/active_location.go
func (l *location) Active(ctx context.Context, req *ActiveLocationReq, options ...larkcore.RequestOptionFunc) (*ActiveLocationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/locations/active"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, l.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ActiveLocationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, l.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchGet
//
// - 通过地点 ID 批量获取地点信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batch_get&project=corehr&resource=location&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/batchGet_location.go
func (l *location) BatchGet(ctx context.Context, req *BatchGetLocationReq, options ...larkcore.RequestOptionFunc) (*BatchGetLocationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/locations/batch_get"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, l.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchGetLocationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, l.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Patch
//
// - 更新地点
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=patch&project=corehr&resource=location&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/patch_location.go
func (l *location) Patch(ctx context.Context, req *PatchLocationReq, options ...larkcore.RequestOptionFunc) (*PatchLocationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/locations/:location_id"
	apiReq.HttpMethod = http.MethodPatch
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, l.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &PatchLocationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, l.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// QueryRecentChange
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query_recent_change&project=corehr&resource=location&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/queryRecentChange_location.go
func (l *location) QueryRecentChange(ctx context.Context, req *QueryRecentChangeLocationReq, options ...larkcore.RequestOptionFunc) (*QueryRecentChangeLocationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/locations/query_recent_change"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, l.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryRecentChangeLocationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, l.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create
//
// - 添加地点地址
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=create&project=corehr&resource=location.address&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/create_locationAddress.go
func (l *locationAddress) Create(ctx context.Context, req *CreateLocationAddressReq, options ...larkcore.RequestOptionFunc) (*CreateLocationAddressResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/locations/:location_id/addresses"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, l.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CreateLocationAddressResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, l.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Delete
//
// - 删除地点地址
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=delete&project=corehr&resource=location.address&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/delete_locationAddress.go
func (l *locationAddress) Delete(ctx context.Context, req *DeleteLocationAddressReq, options ...larkcore.RequestOptionFunc) (*DeleteLocationAddressResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/locations/:location_id/addresses/:address_id"
	apiReq.HttpMethod = http.MethodDelete
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, l.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &DeleteLocationAddressResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, l.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Patch
//
// - 更新地点地址
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=patch&project=corehr&resource=location.address&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/patch_locationAddress.go
func (l *locationAddress) Patch(ctx context.Context, req *PatchLocationAddressReq, options ...larkcore.RequestOptionFunc) (*PatchLocationAddressResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/locations/:location_id/addresses/:address_id"
	apiReq.HttpMethod = http.MethodPatch
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, l.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &PatchLocationAddressResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, l.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Edit
//
// - 编辑离职信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=edit&project=corehr&resource=offboarding&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/edit_offboarding.go
func (o *offboarding) Edit(ctx context.Context, req *EditOffboardingReq, options ...larkcore.RequestOptionFunc) (*EditOffboardingResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/offboardings/edit"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, o.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &EditOffboardingResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, o.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Revoke
//
// - 撤销离职信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=revoke&project=corehr&resource=offboarding&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/revoke_offboarding.go
func (o *offboarding) Revoke(ctx context.Context, req *RevokeOffboardingReq, options ...larkcore.RequestOptionFunc) (*RevokeOffboardingResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/offboardings/revoke"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, o.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &RevokeOffboardingResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, o.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// SubmitV2
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=submit_v2&project=corehr&resource=offboarding&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/submitV2_offboarding.go
func (o *offboarding) SubmitV2(ctx context.Context, req *SubmitV2OffboardingReq, options ...larkcore.RequestOptionFunc) (*SubmitV2OffboardingResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/offboardings/submit_v2"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, o.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SubmitV2OffboardingResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, o.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Active
//
// - 启/停用通道
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=active&project=corehr&resource=pathway&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/active_pathway.go
func (p *pathway) Active(ctx context.Context, req *ActivePathwayReq, options ...larkcore.RequestOptionFunc) (*ActivePathwayResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/pathways/active"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ActivePathwayResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchGet
//
// - 通过通道 ID 批量获取通道信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batch_get&project=corehr&resource=pathway&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/batchGet_pathway.go
func (p *pathway) BatchGet(ctx context.Context, req *BatchGetPathwayReq, options ...larkcore.RequestOptionFunc) (*BatchGetPathwayResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/pathways/batch_get"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchGetPathwayResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create
//
// - 创建通道
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=create&project=corehr&resource=pathway&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/create_pathway.go
func (p *pathway) Create(ctx context.Context, req *CreatePathwayReq, options ...larkcore.RequestOptionFunc) (*CreatePathwayResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/pathways"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CreatePathwayResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Delete
//
// - 删除通道
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=delete&project=corehr&resource=pathway&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/delete_pathway.go
func (p *pathway) Delete(ctx context.Context, req *DeletePathwayReq, options ...larkcore.RequestOptionFunc) (*DeletePathwayResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/pathways/:pathway_id"
	apiReq.HttpMethod = http.MethodDelete
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &DeletePathwayResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Patch
//
// - 更新通道信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=patch&project=corehr&resource=pathway&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/patch_pathway.go
func (p *pathway) Patch(ctx context.Context, req *PatchPathwayReq, options ...larkcore.RequestOptionFunc) (*PatchPathwayResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/pathways/:pathway_id"
	apiReq.HttpMethod = http.MethodPatch
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &PatchPathwayResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create
//
// - 创建个人信息数据
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=create&project=corehr&resource=person&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/create_person.go
func (p *person) Create(ctx context.Context, req *CreatePersonReq, options ...larkcore.RequestOptionFunc) (*CreatePersonResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/persons"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CreatePersonResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Patch
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=patch&project=corehr&resource=person&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/patch_person.go
func (p *person) Patch(ctx context.Context, req *PatchPersonReq, options ...larkcore.RequestOptionFunc) (*PatchPersonResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/persons/:person_id"
	apiReq.HttpMethod = http.MethodPatch
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &PatchPersonResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Active
//
// - 启/停用岗位
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=active&project=corehr&resource=position&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/active_position.go
func (p *position) Active(ctx context.Context, req *ActivePositionReq, options ...larkcore.RequestOptionFunc) (*ActivePositionResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/positions/active"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ActivePositionResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=create&project=corehr&resource=position&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/create_position.go
func (p *position) Create(ctx context.Context, req *CreatePositionReq, options ...larkcore.RequestOptionFunc) (*CreatePositionResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/positions"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CreatePositionResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// DelPosition
//
// - 删除岗位
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=del_position&project=corehr&resource=position&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/delPosition_position.go
func (p *position) DelPosition(ctx context.Context, req *DelPositionPositionReq, options ...larkcore.RequestOptionFunc) (*DelPositionPositionResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/positions/del_position"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &DelPositionPositionResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Patch
//
// - 更新岗位
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=patch&project=corehr&resource=position&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/patch_position.go
func (p *position) Patch(ctx context.Context, req *PatchPositionReq, options ...larkcore.RequestOptionFunc) (*PatchPositionResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/positions/:position_id"
	apiReq.HttpMethod = http.MethodPatch
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &PatchPositionResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Query
//
// - 查询岗位信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query&project=corehr&resource=position&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/query_position.go
func (p *position) Query(ctx context.Context, req *QueryPositionReq, options ...larkcore.RequestOptionFunc) (*QueryPositionResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/positions/query"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryPositionResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// QueryRecentChange
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query_recent_change&project=corehr&resource=position&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/queryRecentChange_position.go
func (p *position) QueryRecentChange(ctx context.Context, req *QueryRecentChangePositionReq, options ...larkcore.RequestOptionFunc) (*QueryRecentChangePositionResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/positions/query_recent_change"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryRecentChangePositionResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Complete
//
// - 完成入职
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=complete&project=corehr&resource=pre_hire&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/complete_preHire.go
func (p *preHire) Complete(ctx context.Context, req *CompletePreHireReq, options ...larkcore.RequestOptionFunc) (*CompletePreHireResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/pre_hires/:pre_hire_id/complete"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CompletePreHireResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create 创建待入职人员
//
// - 创建待入职人员
//
// - 官网API文档链接:https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/corehr-v2/pre_hire/create
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/create_preHire.go
func (p *preHire) Create(ctx context.Context, req *CreatePreHireReq, options ...larkcore.RequestOptionFunc) (*CreatePreHireResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/pre_hires"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CreatePreHireResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Delete
//
// - 删除待入职
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=delete&project=corehr&resource=pre_hire&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/delete_preHire.go
func (p *preHire) Delete(ctx context.Context, req *DeletePreHireReq, options ...larkcore.RequestOptionFunc) (*DeletePreHireResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/pre_hires/:pre_hire_id"
	apiReq.HttpMethod = http.MethodDelete
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &DeletePreHireResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Patch
//
// - 更新待入职
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=patch&project=corehr&resource=pre_hire&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/patch_preHire.go
func (p *preHire) Patch(ctx context.Context, req *PatchPreHireReq, options ...larkcore.RequestOptionFunc) (*PatchPreHireResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/pre_hires/:pre_hire_id"
	apiReq.HttpMethod = http.MethodPatch
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &PatchPreHireResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Query
//
// - 批量查询待入职数据
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query&project=corehr&resource=pre_hire&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/query_preHire.go
func (p *preHire) Query(ctx context.Context, req *QueryPreHireReq, options ...larkcore.RequestOptionFunc) (*QueryPreHireResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/pre_hires/query"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryPreHireResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (p *preHire) QueryByIterator(ctx context.Context, req *QueryPreHireReq, options ...larkcore.RequestOptionFunc) (*QueryPreHireIterator, error) {
	return &QueryPreHireIterator{
		ctx:      ctx,
		req:      req,
		listFunc: p.Query,
		options:  options,
		limit:    req.Limit}, nil
}

// RestoreFlowInstance
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=restore_flow_instance&project=corehr&resource=pre_hire&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/restoreFlowInstance_preHire.go
func (p *preHire) RestoreFlowInstance(ctx context.Context, req *RestoreFlowInstancePreHireReq, options ...larkcore.RequestOptionFunc) (*RestoreFlowInstancePreHireResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/pre_hires/restore_flow_instance"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &RestoreFlowInstancePreHireResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Search
//
// - 根据部门 ID，上级部门查询部门列表
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=search&project=corehr&resource=pre_hire&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/search_preHire.go
func (p *preHire) Search(ctx context.Context, req *SearchPreHireReq, options ...larkcore.RequestOptionFunc) (*SearchPreHireResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/pre_hires/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchPreHireResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (p *preHire) SearchByIterator(ctx context.Context, req *SearchPreHireReq, options ...larkcore.RequestOptionFunc) (*SearchPreHireIterator, error) {
	return &SearchPreHireIterator{
		ctx:      ctx,
		req:      req,
		listFunc: p.Search,
		options:  options,
		limit:    req.Limit}, nil
}

// TransformOnboardingTask
//
// - 入职常规任务的流转，支持手动开启任务，提交任务以及审批任务
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=transform_onboarding_task&project=corehr&resource=pre_hire&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/transformOnboardingTask_preHire.go
func (p *preHire) TransformOnboardingTask(ctx context.Context, req *TransformOnboardingTaskPreHireReq, options ...larkcore.RequestOptionFunc) (*TransformOnboardingTaskPreHireResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/pre_hires/transform_onboarding_task"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &TransformOnboardingTaskPreHireResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// TransitTask
//
// - 任务流转
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=transit_task&project=corehr&resource=pre_hire&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/transitTask_preHire.go
func (p *preHire) TransitTask(ctx context.Context, req *TransitTaskPreHireReq, options ...larkcore.RequestOptionFunc) (*TransitTaskPreHireResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/pre_hires/:pre_hire_id/transit_task"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &TransitTaskPreHireResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// WithdrawOnboarding
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=withdraw_onboarding&project=corehr&resource=pre_hire&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/withdrawOnboarding_preHire.go
func (p *preHire) WithdrawOnboarding(ctx context.Context, req *WithdrawOnboardingPreHireReq, options ...larkcore.RequestOptionFunc) (*WithdrawOnboardingPreHireResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/pre_hires/withdraw_onboarding"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &WithdrawOnboardingPreHireResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// EnableDisableAssessment
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=enable_disable_assessment&project=corehr&resource=probation&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/enableDisableAssessment_probation.go
func (p *probation) EnableDisableAssessment(ctx context.Context, req *EnableDisableAssessmentProbationReq, options ...larkcore.RequestOptionFunc) (*EnableDisableAssessmentProbationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/probation/enable_disable_assessment"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &EnableDisableAssessmentProbationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Search
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=search&project=corehr&resource=probation&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/search_probation.go
func (p *probation) Search(ctx context.Context, req *SearchProbationReq, options ...larkcore.RequestOptionFunc) (*SearchProbationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/probation/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchProbationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (p *probation) SearchByIterator(ctx context.Context, req *SearchProbationReq, options ...larkcore.RequestOptionFunc) (*SearchProbationIterator, error) {
	return &SearchProbationIterator{
		ctx:      ctx,
		req:      req,
		listFunc: p.Search,
		options:  options,
		limit:    req.Limit}, nil
}

// Submit
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=submit&project=corehr&resource=probation&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/submit_probation.go
func (p *probation) Submit(ctx context.Context, req *SubmitProbationReq, options ...larkcore.RequestOptionFunc) (*SubmitProbationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/probation/submit"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SubmitProbationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Withdraw
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=withdraw&project=corehr&resource=probation&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/withdraw_probation.go
func (p *probation) Withdraw(ctx context.Context, req *WithdrawProbationReq, options ...larkcore.RequestOptionFunc) (*WithdrawProbationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/probation/withdraw"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &WithdrawProbationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=create&project=corehr&resource=probation.assessment&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/create_probationAssessment.go
func (p *probationAssessment) Create(ctx context.Context, req *CreateProbationAssessmentReq, options ...larkcore.RequestOptionFunc) (*CreateProbationAssessmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/probation/assessments"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CreateProbationAssessmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Delete
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=delete&project=corehr&resource=probation.assessment&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/delete_probationAssessment.go
func (p *probationAssessment) Delete(ctx context.Context, req *DeleteProbationAssessmentReq, options ...larkcore.RequestOptionFunc) (*DeleteProbationAssessmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/probation/assessments/:assessment_id"
	apiReq.HttpMethod = http.MethodDelete
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &DeleteProbationAssessmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Patch
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=patch&project=corehr&resource=probation.assessment&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/patch_probationAssessment.go
func (p *probationAssessment) Patch(ctx context.Context, req *PatchProbationAssessmentReq, options ...larkcore.RequestOptionFunc) (*PatchProbationAssessmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/probation/assessments/:assessment_id"
	apiReq.HttpMethod = http.MethodPatch
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &PatchProbationAssessmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// FlowVariableData
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=flow_variable_data&project=corehr&resource=process&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/flowVariableData_process.go
func (p *process) FlowVariableData(ctx context.Context, req *FlowVariableDataProcessReq, options ...larkcore.RequestOptionFunc) (*FlowVariableDataProcessResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/processes/:process_id/flow_variable_data"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &FlowVariableDataProcessResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Get
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=get&project=corehr&resource=process&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/get_process.go
func (p *process) Get(ctx context.Context, req *GetProcessReq, options ...larkcore.RequestOptionFunc) (*GetProcessResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/processes/:process_id"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &GetProcessResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=list&project=corehr&resource=process&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/list_process.go
func (p *process) List(ctx context.Context, req *ListProcessReq, options ...larkcore.RequestOptionFunc) (*ListProcessResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/processes"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListProcessResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (p *process) ListByIterator(ctx context.Context, req *ListProcessReq, options ...larkcore.RequestOptionFunc) (*ListProcessIterator, error) {
	return &ListProcessIterator{
		ctx:      ctx,
		req:      req,
		listFunc: p.List,
		options:  options,
		limit:    req.Limit}, nil
}

// Update
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=update&project=corehr&resource=process.approver&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/update_processApprover.go
func (p *processApprover) Update(ctx context.Context, req *UpdateProcessApproverReq, options ...larkcore.RequestOptionFunc) (*UpdateProcessApproverResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/processes/:process_id/approvers/:approver_id"
	apiReq.HttpMethod = http.MethodPut
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &UpdateProcessApproverResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Update
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=update&project=corehr&resource=process.extra&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/update_processExtra.go
func (p *processExtra) Update(ctx context.Context, req *UpdateProcessExtraReq, options ...larkcore.RequestOptionFunc) (*UpdateProcessExtraResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/processes/:process_id/extra"
	apiReq.HttpMethod = http.MethodPut
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &UpdateProcessExtraResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Get
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=get&project=corehr&resource=process.form_variable_data&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/get_processFormVariableData.go
func (p *processFormVariableData) Get(ctx context.Context, req *GetProcessFormVariableDataReq, options ...larkcore.RequestOptionFunc) (*GetProcessFormVariableDataResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/processes/:process_id/form_variable_data"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &GetProcessFormVariableDataResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Update
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=update&project=corehr&resource=process.transfer&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/update_processTransfer.go
func (p *processTransfer) Update(ctx context.Context, req *UpdateProcessTransferReq, options ...larkcore.RequestOptionFunc) (*UpdateProcessTransferResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/processes/:process_id/transfer"
	apiReq.HttpMethod = http.MethodPut
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &UpdateProcessTransferResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Update
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=update&project=corehr&resource=process_revoke&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/update_processRevoke.go
func (p *processRevoke) Update(ctx context.Context, req *UpdateProcessRevokeReq, options ...larkcore.RequestOptionFunc) (*UpdateProcessRevokeResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/process_revoke/:process_id"
	apiReq.HttpMethod = http.MethodPut
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &UpdateProcessRevokeResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Update
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=update&project=corehr&resource=process_withdraw&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/update_processWithdraw.go
func (p *processWithdraw) Update(ctx context.Context, req *UpdateProcessWithdrawReq, options ...larkcore.RequestOptionFunc) (*UpdateProcessWithdrawResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/process_withdraw/:process_id"
	apiReq.HttpMethod = http.MethodPut
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &UpdateProcessWithdrawResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchDelete
//
// - 批量删除填报行
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batchDelete&project=corehr&resource=report_detail_row&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/batchDelete_reportDetailRow.go
func (r *reportDetailRow) BatchDelete(ctx context.Context, req *BatchDeleteReportDetailRowReq, options ...larkcore.RequestOptionFunc) (*BatchDeleteReportDetailRowResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/report_detail_row/batchDelete"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, r.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchDeleteReportDetailRowResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, r.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchSave
//
// - 批量创建/更新填报行
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batchSave&project=corehr&resource=report_detail_row&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/batchSave_reportDetailRow.go
func (r *reportDetailRow) BatchSave(ctx context.Context, req *BatchSaveReportDetailRowReq, options ...larkcore.RequestOptionFunc) (*BatchSaveReportDetailRowResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/report_detail_row/batchSave"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, r.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchSaveReportDetailRowResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, r.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Download
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=download&project=corehr&resource=signature_file&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/download_signatureFile.go
func (s *signatureFile) Download(ctx context.Context, req *DownloadSignatureFileReq, options ...larkcore.RequestOptionFunc) (*DownloadSignatureFileResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/signature_files/:signature_file_id/download"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, s.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &DownloadSignatureFileResp{ApiResp: apiResp}
	// 如果是下载，则设置响应结果
	if apiResp.StatusCode == http.StatusOK {
		resp.File = bytes.NewBuffer(apiResp.RawBody)
		resp.FileName = larkcore.FileNameByHeader(apiResp.Header)
		return resp, err
	}
	err = apiResp.JSONUnmarshalBody(resp, s.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=list&project=corehr&resource=signature_file&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/list_signatureFile.go
func (s *signatureFile) List(ctx context.Context, req *ListSignatureFileReq, options ...larkcore.RequestOptionFunc) (*ListSignatureFileResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/signature_files"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, s.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListSignatureFileResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, s.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (s *signatureFile) ListByIterator(ctx context.Context, req *ListSignatureFileReq, options ...larkcore.RequestOptionFunc) (*ListSignatureFileIterator, error) {
	return &ListSignatureFileIterator{
		ctx:      ctx,
		req:      req,
		listFunc: s.List,
		options:  options,
		limit:    req.Limit}, nil
}

// ListByBizId
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=list_by_biz_id&project=corehr&resource=signature_file&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/listByBizId_signatureFile.go
func (s *signatureFile) ListByBizId(ctx context.Context, req *ListByBizIdSignatureFileReq, options ...larkcore.RequestOptionFunc) (*ListByBizIdSignatureFileResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/signature_files/list_by_biz_id"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, s.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListByBizIdSignatureFileResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, s.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Query
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query&project=corehr&resource=signature_file&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/query_signatureFile.go
func (s *signatureFile) Query(ctx context.Context, req *QuerySignatureFileReq, options ...larkcore.RequestOptionFunc) (*QuerySignatureFileResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/signature_files/query"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, s.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QuerySignatureFileResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, s.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (s *signatureFile) QueryByIterator(ctx context.Context, req *QuerySignatureFileReq, options ...larkcore.RequestOptionFunc) (*QuerySignatureFileIterator, error) {
	return &QuerySignatureFileIterator{
		ctx:      ctx,
		req:      req,
		listFunc: s.Query,
		options:  options,
		limit:    req.Limit}, nil
}

// Terminate
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=terminate&project=corehr&resource=signature_file&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/terminate_signatureFile.go
func (s *signatureFile) Terminate(ctx context.Context, req *TerminateSignatureFileReq, options ...larkcore.RequestOptionFunc) (*TerminateSignatureFileResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/signature_files/terminate"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, s.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &TerminateSignatureFileResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, s.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// ListByFileId
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=list_by_file_id&project=corehr&resource=signature_node&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/listByFileId_signatureNode.go
func (s *signatureNode) ListByFileId(ctx context.Context, req *ListByFileIdSignatureNodeReq, options ...larkcore.RequestOptionFunc) (*ListByFileIdSignatureNodeResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/signature_nodes/list_by_file_id"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, s.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListByFileIdSignatureNodeResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, s.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Search
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=search&project=corehr&resource=signature_template&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/search_signatureTemplate.go
func (s *signatureTemplate) Search(ctx context.Context, req *SearchSignatureTemplateReq, options ...larkcore.RequestOptionFunc) (*SearchSignatureTemplateResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/signature_templates/search"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, s.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchSignatureTemplateResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, s.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=list&project=corehr&resource=signature_template_info_with_thumbnail&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/list_signatureTemplateInfoWithThumbnail.go
func (s *signatureTemplateInfoWithThumbnail) List(ctx context.Context, req *ListSignatureTemplateInfoWithThumbnailReq, options ...larkcore.RequestOptionFunc) (*ListSignatureTemplateInfoWithThumbnailResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/signature_template_info_with_thumbnails"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, s.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListSignatureTemplateInfoWithThumbnailResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, s.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (s *signatureTemplateInfoWithThumbnail) ListByIterator(ctx context.Context, req *ListSignatureTemplateInfoWithThumbnailReq, options ...larkcore.RequestOptionFunc) (*ListSignatureTemplateInfoWithThumbnailIterator, error) {
	return &ListSignatureTemplateInfoWithThumbnailIterator{
		ctx:      ctx,
		req:      req,
		listFunc: s.List,
		options:  options,
		limit:    req.Limit}, nil
}

// List
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=list&project=corehr&resource=workforce_plan&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/list_workforcePlan.go
func (w *workforcePlan) List(ctx context.Context, req *ListWorkforcePlanReq, options ...larkcore.RequestOptionFunc) (*ListWorkforcePlanResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/workforce_plans"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, w.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListWorkforcePlanResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, w.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (w *workforcePlan) ListByIterator(ctx context.Context, req *ListWorkforcePlanReq, options ...larkcore.RequestOptionFunc) (*ListWorkforcePlanIterator, error) {
	return &ListWorkforcePlanIterator{
		ctx:      ctx,
		req:      req,
		listFunc: w.List,
		options:  options,
		limit:    req.Limit}, nil
}

// Batch
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batch&project=corehr&resource=workforce_plan_detail&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/batch_workforcePlanDetail.go
func (w *workforcePlanDetail) Batch(ctx context.Context, req *BatchWorkforcePlanDetailReq, options ...larkcore.RequestOptionFunc) (*BatchWorkforcePlanDetailResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/workforce_plan_details/batch"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, w.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchWorkforcePlanDetailResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, w.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchV2
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batch_v2&project=corehr&resource=workforce_plan_detail&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/batchV2_workforcePlanDetail.go
func (w *workforcePlanDetail) BatchV2(ctx context.Context, req *BatchV2WorkforcePlanDetailReq, options ...larkcore.RequestOptionFunc) (*BatchV2WorkforcePlanDetailResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/workforce_plan_details/batch_v2"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, w.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchV2WorkforcePlanDetailResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, w.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchDelete
//
// - 批量删除明细行
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batchDelete&project=corehr&resource=workforce_plan_detail_row&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/batchDelete_workforcePlanDetailRow.go
func (w *workforcePlanDetailRow) BatchDelete(ctx context.Context, req *BatchDeleteWorkforcePlanDetailRowReq, options ...larkcore.RequestOptionFunc) (*BatchDeleteWorkforcePlanDetailRowResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/workforce_plan_detail_row/batchDelete"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, w.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchDeleteWorkforcePlanDetailRowResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, w.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchSave
//
// - 批量创建/更新明细行
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batchSave&project=corehr&resource=workforce_plan_detail_row&version=v2
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/corehrv2/batchSave_workforcePlanDetailRow.go
func (w *workforcePlanDetailRow) BatchSave(ctx context.Context, req *BatchSaveWorkforcePlanDetailRowReq, options ...larkcore.RequestOptionFunc) (*BatchSaveWorkforcePlanDetailRowResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/corehr/v2/workforce_plan_detail_row/batchSave"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, w.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchSaveWorkforcePlanDetailRowResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, w.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
