// Code generated by Lark OpenAPI.

package larkhire

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

type V1 struct {
	Advertisement                   *advertisement                   // advertisement
	Agency                          *agency                          // 猎头（灰度租户可见）
	Application                     *application                     // 投递
	ApplicationInterview            *applicationInterview            // application.interview
	Attachment                      *attachment                      // 附件
	BackgroundCheckOrder            *backgroundCheckOrder            // 背调 （灰度租户可见）
	DiversityInclusion              *diversityInclusion              // diversity_inclusion
	EcoAccount                      *ecoAccount                      // 事件
	EcoAccountCustomField           *ecoAccountCustomField           // 生态对接账号自定义字段
	EcoBackgroundCheck              *ecoBackgroundCheck              // 背调订单
	EcoBackgroundCheckCustomField   *ecoBackgroundCheckCustomField   // 背调自定义字段
	EcoBackgroundCheckPackage       *ecoBackgroundCheckPackage       // 背调套餐和附加调查项
	EcoExam                         *ecoExam                         // eco_exam
	EcoExamPaper                    *ecoExamPaper                    // eco_exam_paper
	EhrImportTask                   *ehrImportTask                   // 导入 e-HR
	EhrImportTaskForInternshipOffer *ehrImportTaskForInternshipOffer // ehr_import_task_for_internship_offer
	Employee                        *employee                        // 入职
	Evaluation                      *evaluation                      // 评估（灰度租户可见）
	EvaluationTask                  *evaluationTask                  // 评估任务
	Exam                            *exam                            // 笔试 (灰度租户可见)
	ExamMarkingTask                 *examMarkingTask                 // 笔试阅卷任务
	ExternalApplication             *externalApplication             // 导入外部系统信息（灰度租户可见）
	ExternalBackgroundCheck         *externalBackgroundCheck         // 导入外部系统信息（灰度租户可见）
	ExternalInterview               *externalInterview               // 导入外部系统信息（灰度租户可见）
	ExternalInterviewAssessment     *externalInterviewAssessment     // 导入外部系统信息（灰度租户可见）
	ExternalOffer                   *externalOffer                   // external_offer
	ExternalReferralReward          *externalReferralReward          // external_referral_reward
	Interview                       *interview                       // 面试
	InterviewFeedbackForm           *interviewFeedbackForm           // interview_feedback_form
	InterviewRecord                 *interviewRecord                 // interview_record
	InterviewRecordAttachment       *interviewRecordAttachment       // interview_record.attachment
	InterviewRegistrationSchema     *interviewRegistrationSchema     // interview_registration_schema
	InterviewRoundType              *interviewRoundType              // 面试轮次类型
	InterviewTask                   *interviewTask                   // 面试任务
	Interviewer                     *interviewer                     // interviewer
	Job                             *job                             // 职位
	JobManager                      *jobManager                      // job.manager
	JobFunction                     *jobFunction                     // job_function
	JobProcess                      *jobProcess                      // 流程
	JobPublishRecord                *jobPublishRecord                // job_publish_record
	JobRequirement                  *jobRequirement                  // 招聘需求（灰度租户可见）
	JobRequirementSchema            *jobRequirementSchema            // job_requirement_schema
	JobSchema                       *jobSchema                       // job_schema
	JobType                         *jobType                         // job_type
	Location                        *location                        // 地址（灰度租户可见）
	Minutes                         *minutes                         // minutes
	Note                            *note                            // 备注
	Offer                           *offer                           // Offer
	OfferApplicationForm            *offerApplicationForm            // Offer 申请表（灰度租户可见）
	OfferApprovalTemplate           *offerApprovalTemplate           // Offer 审批流配置（灰度租户可见）
	OfferCustomField                *offerCustomField                // offer_custom_field
	OfferSchema                     *offerSchema                     // offer_schema
	PortalApplySchema               *portalApplySchema               // portal_apply_schema
	Questionnaire                   *questionnaire                   // 问卷（灰度租户可见）
	Referral                        *referral                        // 内推
	ReferralAccount                 *referralAccount                 // referral_account
	ReferralWebsiteJobPost          *referralWebsiteJobPost          // referral_website.job_post
	RegistrationSchema              *registrationSchema              // registration_schema
	ResumeSource                    *resumeSource                    // 简历来源
	Role                            *role                            // 权限
	Subject                         *subject                         // 项目（灰度租户可见）
	Talent                          *talent                          // 人才
	TalentExternalInfo              *talentExternalInfo              // 导入外部系统信息（灰度租户可见）
	TalentBlocklist                 *talentBlocklist                 // talent_blocklist
	TalentFolder                    *talentFolder                    // talent_folder
	TalentObject                    *talentObject                    // talent_object
	TalentOperationLog              *talentOperationLog              // talent_operation_log
	TalentPool                      *talentPool                      // talent_pool
	TalentTag                       *talentTag                       // talent_tag
	TerminationReason               *terminationReason               // termination_reason
	Test                            *test                            // test
	Todo                            *todo                            // 待办
	TripartiteAgreement             *tripartiteAgreement             // tripartite_agreement
	UserRole                        *userRole                        // 权限
	Website                         *website                         // 官网（灰度租户可见）
	WebsiteChannel                  *websiteChannel                  // website.channel
	WebsiteDelivery                 *websiteDelivery                 // website.delivery
	WebsiteDeliveryTask             *websiteDeliveryTask             // website.delivery_task
	WebsiteJobPost                  *websiteJobPost                  // website.job_post
	WebsiteSiteUser                 *websiteSiteUser                 // website.site_user
}

func New(config *larkcore.Config) *V1 {
	return &V1{
		Advertisement:                   &advertisement{config: config},
		Agency:                          &agency{config: config},
		Application:                     &application{config: config},
		ApplicationInterview:            &applicationInterview{config: config},
		Attachment:                      &attachment{config: config},
		BackgroundCheckOrder:            &backgroundCheckOrder{config: config},
		DiversityInclusion:              &diversityInclusion{config: config},
		EcoAccount:                      &ecoAccount{config: config},
		EcoAccountCustomField:           &ecoAccountCustomField{config: config},
		EcoBackgroundCheck:              &ecoBackgroundCheck{config: config},
		EcoBackgroundCheckCustomField:   &ecoBackgroundCheckCustomField{config: config},
		EcoBackgroundCheckPackage:       &ecoBackgroundCheckPackage{config: config},
		EcoExam:                         &ecoExam{config: config},
		EcoExamPaper:                    &ecoExamPaper{config: config},
		EhrImportTask:                   &ehrImportTask{config: config},
		EhrImportTaskForInternshipOffer: &ehrImportTaskForInternshipOffer{config: config},
		Employee:                        &employee{config: config},
		Evaluation:                      &evaluation{config: config},
		EvaluationTask:                  &evaluationTask{config: config},
		Exam:                            &exam{config: config},
		ExamMarkingTask:                 &examMarkingTask{config: config},
		ExternalApplication:             &externalApplication{config: config},
		ExternalBackgroundCheck:         &externalBackgroundCheck{config: config},
		ExternalInterview:               &externalInterview{config: config},
		ExternalInterviewAssessment:     &externalInterviewAssessment{config: config},
		ExternalOffer:                   &externalOffer{config: config},
		ExternalReferralReward:          &externalReferralReward{config: config},
		Interview:                       &interview{config: config},
		InterviewFeedbackForm:           &interviewFeedbackForm{config: config},
		InterviewRecord:                 &interviewRecord{config: config},
		InterviewRecordAttachment:       &interviewRecordAttachment{config: config},
		InterviewRegistrationSchema:     &interviewRegistrationSchema{config: config},
		InterviewRoundType:              &interviewRoundType{config: config},
		InterviewTask:                   &interviewTask{config: config},
		Interviewer:                     &interviewer{config: config},
		Job:                             &job{config: config},
		JobManager:                      &jobManager{config: config},
		JobFunction:                     &jobFunction{config: config},
		JobProcess:                      &jobProcess{config: config},
		JobPublishRecord:                &jobPublishRecord{config: config},
		JobRequirement:                  &jobRequirement{config: config},
		JobRequirementSchema:            &jobRequirementSchema{config: config},
		JobSchema:                       &jobSchema{config: config},
		JobType:                         &jobType{config: config},
		Location:                        &location{config: config},
		Minutes:                         &minutes{config: config},
		Note:                            &note{config: config},
		Offer:                           &offer{config: config},
		OfferApplicationForm:            &offerApplicationForm{config: config},
		OfferApprovalTemplate:           &offerApprovalTemplate{config: config},
		OfferCustomField:                &offerCustomField{config: config},
		OfferSchema:                     &offerSchema{config: config},
		PortalApplySchema:               &portalApplySchema{config: config},
		Questionnaire:                   &questionnaire{config: config},
		Referral:                        &referral{config: config},
		ReferralAccount:                 &referralAccount{config: config},
		ReferralWebsiteJobPost:          &referralWebsiteJobPost{config: config},
		RegistrationSchema:              &registrationSchema{config: config},
		ResumeSource:                    &resumeSource{config: config},
		Role:                            &role{config: config},
		Subject:                         &subject{config: config},
		Talent:                          &talent{config: config},
		TalentExternalInfo:              &talentExternalInfo{config: config},
		TalentBlocklist:                 &talentBlocklist{config: config},
		TalentFolder:                    &talentFolder{config: config},
		TalentObject:                    &talentObject{config: config},
		TalentOperationLog:              &talentOperationLog{config: config},
		TalentPool:                      &talentPool{config: config},
		TalentTag:                       &talentTag{config: config},
		TerminationReason:               &terminationReason{config: config},
		Test:                            &test{config: config},
		Todo:                            &todo{config: config},
		TripartiteAgreement:             &tripartiteAgreement{config: config},
		UserRole:                        &userRole{config: config},
		Website:                         &website{config: config},
		WebsiteChannel:                  &websiteChannel{config: config},
		WebsiteDelivery:                 &websiteDelivery{config: config},
		WebsiteDeliveryTask:             &websiteDeliveryTask{config: config},
		WebsiteJobPost:                  &websiteJobPost{config: config},
		WebsiteSiteUser:                 &websiteSiteUser{config: config},
	}
}

type advertisement struct {
	config *larkcore.Config
}
type agency struct {
	config *larkcore.Config
}
type application struct {
	config *larkcore.Config
}
type applicationInterview struct {
	config *larkcore.Config
}
type attachment struct {
	config *larkcore.Config
}
type backgroundCheckOrder struct {
	config *larkcore.Config
}
type diversityInclusion struct {
	config *larkcore.Config
}
type ecoAccount struct {
	config *larkcore.Config
}
type ecoAccountCustomField struct {
	config *larkcore.Config
}
type ecoBackgroundCheck struct {
	config *larkcore.Config
}
type ecoBackgroundCheckCustomField struct {
	config *larkcore.Config
}
type ecoBackgroundCheckPackage struct {
	config *larkcore.Config
}
type ecoExam struct {
	config *larkcore.Config
}
type ecoExamPaper struct {
	config *larkcore.Config
}
type ehrImportTask struct {
	config *larkcore.Config
}
type ehrImportTaskForInternshipOffer struct {
	config *larkcore.Config
}
type employee struct {
	config *larkcore.Config
}
type evaluation struct {
	config *larkcore.Config
}
type evaluationTask struct {
	config *larkcore.Config
}
type exam struct {
	config *larkcore.Config
}
type examMarkingTask struct {
	config *larkcore.Config
}
type externalApplication struct {
	config *larkcore.Config
}
type externalBackgroundCheck struct {
	config *larkcore.Config
}
type externalInterview struct {
	config *larkcore.Config
}
type externalInterviewAssessment struct {
	config *larkcore.Config
}
type externalOffer struct {
	config *larkcore.Config
}
type externalReferralReward struct {
	config *larkcore.Config
}
type interview struct {
	config *larkcore.Config
}
type interviewFeedbackForm struct {
	config *larkcore.Config
}
type interviewRecord struct {
	config *larkcore.Config
}
type interviewRecordAttachment struct {
	config *larkcore.Config
}
type interviewRegistrationSchema struct {
	config *larkcore.Config
}
type interviewRoundType struct {
	config *larkcore.Config
}
type interviewTask struct {
	config *larkcore.Config
}
type interviewer struct {
	config *larkcore.Config
}
type job struct {
	config *larkcore.Config
}
type jobManager struct {
	config *larkcore.Config
}
type jobFunction struct {
	config *larkcore.Config
}
type jobProcess struct {
	config *larkcore.Config
}
type jobPublishRecord struct {
	config *larkcore.Config
}
type jobRequirement struct {
	config *larkcore.Config
}
type jobRequirementSchema struct {
	config *larkcore.Config
}
type jobSchema struct {
	config *larkcore.Config
}
type jobType struct {
	config *larkcore.Config
}
type location struct {
	config *larkcore.Config
}
type minutes struct {
	config *larkcore.Config
}
type note struct {
	config *larkcore.Config
}
type offer struct {
	config *larkcore.Config
}
type offerApplicationForm struct {
	config *larkcore.Config
}
type offerApprovalTemplate struct {
	config *larkcore.Config
}
type offerCustomField struct {
	config *larkcore.Config
}
type offerSchema struct {
	config *larkcore.Config
}
type portalApplySchema struct {
	config *larkcore.Config
}
type questionnaire struct {
	config *larkcore.Config
}
type referral struct {
	config *larkcore.Config
}
type referralAccount struct {
	config *larkcore.Config
}
type referralWebsiteJobPost struct {
	config *larkcore.Config
}
type registrationSchema struct {
	config *larkcore.Config
}
type resumeSource struct {
	config *larkcore.Config
}
type role struct {
	config *larkcore.Config
}
type subject struct {
	config *larkcore.Config
}
type talent struct {
	config *larkcore.Config
}
type talentExternalInfo struct {
	config *larkcore.Config
}
type talentBlocklist struct {
	config *larkcore.Config
}
type talentFolder struct {
	config *larkcore.Config
}
type talentObject struct {
	config *larkcore.Config
}
type talentOperationLog struct {
	config *larkcore.Config
}
type talentPool struct {
	config *larkcore.Config
}
type talentTag struct {
	config *larkcore.Config
}
type terminationReason struct {
	config *larkcore.Config
}
type test struct {
	config *larkcore.Config
}
type todo struct {
	config *larkcore.Config
}
type tripartiteAgreement struct {
	config *larkcore.Config
}
type userRole struct {
	config *larkcore.Config
}
type website struct {
	config *larkcore.Config
}
type websiteChannel struct {
	config *larkcore.Config
}
type websiteDelivery struct {
	config *larkcore.Config
}
type websiteDeliveryTask struct {
	config *larkcore.Config
}
type websiteJobPost struct {
	config *larkcore.Config
}
type websiteSiteUser struct {
	config *larkcore.Config
}

// Publish 职位发布至官网
//
// - 支持把职位发布至招聘官网、内推平台
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/advertisement/publish
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/publish_advertisement.go
func (a *advertisement) Publish(ctx context.Context, req *PublishAdvertisementReq, options ...larkcore.RequestOptionFunc) (*PublishAdvertisementResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/advertisements/:advertisement_id/publish"
	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 := &PublishAdvertisementResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.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=hire&resource=agency&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/batchQuery_agency.go
func (a *agency) BatchQuery(ctx context.Context, req *BatchQueryAgencyReq, options ...larkcore.RequestOptionFunc) (*BatchQueryAgencyResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/agencies/batch_query"
	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 := &BatchQueryAgencyResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Get 获取猎头供应商信息
//
// - 根据猎头供应商 ID 获取猎头供应商信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/agency/get
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/get_agency.go
func (a *agency) Get(ctx context.Context, req *GetAgencyReq, options ...larkcore.RequestOptionFunc) (*GetAgencyResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/agencies/:agency_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 := &GetAgencyResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// GetAgencyAccount
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=get_agency_account&project=hire&resource=agency&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/getAgencyAccount_agency.go
func (a *agency) GetAgencyAccount(ctx context.Context, req *GetAgencyAccountAgencyReq, options ...larkcore.RequestOptionFunc) (*GetAgencyAccountAgencyResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/agencies/get_agency_account"
	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 := &GetAgencyAccountAgencyResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// OperateAgencyAccount
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=operate_agency_account&project=hire&resource=agency&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/operateAgencyAccount_agency.go
func (a *agency) OperateAgencyAccount(ctx context.Context, req *OperateAgencyAccountAgencyReq, options ...larkcore.RequestOptionFunc) (*OperateAgencyAccountAgencyResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/agencies/operate_agency_account"
	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 := &OperateAgencyAccountAgencyResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Protect 设置猎头保护期
//
// - 设置猎头保护期
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/agency/protect
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/protect_agency.go
func (a *agency) Protect(ctx context.Context, req *ProtectAgencyReq, options ...larkcore.RequestOptionFunc) (*ProtectAgencyResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/agencies/protect"
	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 := &ProtectAgencyResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// ProtectSearch
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=protect_search&project=hire&resource=agency&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/protectSearch_agency.go
func (a *agency) ProtectSearch(ctx context.Context, req *ProtectSearchAgencyReq, options ...larkcore.RequestOptionFunc) (*ProtectSearchAgencyResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/agencies/protection_period/search"
	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 := &ProtectSearchAgencyResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Query 查询猎头供应商信息
//
// - 根据猎头供应商名称查询猎头供应商信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/agency/query
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/query_agency.go
func (a *agency) Query(ctx context.Context, req *QueryAgencyReq, options ...larkcore.RequestOptionFunc) (*QueryAgencyResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/agencies/query"
	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 := &QueryAgencyResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// CancelOnboard 取消候选人入职
//
// - 操作候选人取消入职
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/application/cancel_onboard
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/cancelOnboard_application.go
func (a *application) CancelOnboard(ctx context.Context, req *CancelOnboardApplicationReq, options ...larkcore.RequestOptionFunc) (*CancelOnboardApplicationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/applications/:application_id/cancel_onboard"
	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 := &CancelOnboardApplicationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create 创建投递
//
// - 根据人才 ID 和职位 ID 创建投递
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/application/create
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_application.go
func (a *application) Create(ctx context.Context, req *CreateApplicationReq, options ...larkcore.RequestOptionFunc) (*CreateApplicationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/applications"
	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 := &CreateApplicationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Get 获取投递信息
//
// - 根据投递 ID 获取单个投递信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/application/get
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/get_application.go
func (a *application) Get(ctx context.Context, req *GetApplicationReq, options ...larkcore.RequestOptionFunc) (*GetApplicationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/applications/:application_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 := &GetApplicationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// GetDetail
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=get_detail&project=hire&resource=application&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/getDetail_application.go
func (a *application) GetDetail(ctx context.Context, req *GetDetailApplicationReq, options ...larkcore.RequestOptionFunc) (*GetDetailApplicationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/applications/:application_id/get_detail"
	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 := &GetDetailApplicationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List 获取投递列表
//
// - 根据限定条件获取投递列表信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/application/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_application.go
func (a *application) List(ctx context.Context, req *ListApplicationReq, options ...larkcore.RequestOptionFunc) (*ListApplicationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/applications"
	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 := &ListApplicationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Offer 获取 Offer 信息
//
// - 根据投递 ID 获取 Offer 信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/application/offer
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/offer_application.go
func (a *application) Offer(ctx context.Context, req *OfferApplicationReq, options ...larkcore.RequestOptionFunc) (*OfferApplicationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/applications/:application_id/offer"
	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 := &OfferApplicationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Recover
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=recover&project=hire&resource=application&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/recover_application.go
func (a *application) Recover(ctx context.Context, req *RecoverApplicationReq, options ...larkcore.RequestOptionFunc) (*RecoverApplicationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/applications/:application_id/recover"
	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 := &RecoverApplicationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Terminate 终止投递
//
// - 根据投递 ID 修改投递状态为「已终止」
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/application/terminate
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/terminate_application.go
func (a *application) Terminate(ctx context.Context, req *TerminateApplicationReq, options ...larkcore.RequestOptionFunc) (*TerminateApplicationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/applications/:application_id/terminate"
	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 := &TerminateApplicationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// TransferOnboard 操作候选人入职
//
// - 根据投递 ID 操作候选人入职并创建员工。投递须处于「待入职」阶段，可通过「转移阶段」接口变更投递状态
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/application/transfer_onboard
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/transferOnboard_application.go
func (a *application) TransferOnboard(ctx context.Context, req *TransferOnboardApplicationReq, options ...larkcore.RequestOptionFunc) (*TransferOnboardApplicationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/applications/:application_id/transfer_onboard"
	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 := &TransferOnboardApplicationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// TransferStage 转移阶段
//
// - 转移投递阶段
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/application/transfer_stage
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/transferStage_application.go
func (a *application) TransferStage(ctx context.Context, req *TransferStageApplicationReq, options ...larkcore.RequestOptionFunc) (*TransferStageApplicationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/applications/:application_id/transfer_stage"
	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 := &TransferStageApplicationResp{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=hire&resource=application.interview&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_applicationInterview.go
func (a *applicationInterview) List(ctx context.Context, req *ListApplicationInterviewReq, options ...larkcore.RequestOptionFunc) (*ListApplicationInterviewResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/applications/:application_id/interviews"
	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 := &ListApplicationInterviewResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uIDN1YjLyQTN24iM0UjN/create_attachment
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_attachment.go
func (a *attachment) Create(ctx context.Context, options ...larkcore.RequestOptionFunc) (*CreateAttachmentResp, error) {
	options = append(options, larkcore.WithFileUpload())
	// 发起请求
	apiReq := &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	apiReq.ApiPath = "/open-apis/hire/v1/attachments"
	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 := &CreateAttachmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Get 获取附件信息
//
// - 获取招聘系统中附件的元信息，比如文件名、创建时间、文件url等
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/attachment/get
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/get_attachment.go
func (a *attachment) Get(ctx context.Context, req *GetAttachmentReq, options ...larkcore.RequestOptionFunc) (*GetAttachmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/attachments/:attachment_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 := &GetAttachmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Preview 获取附件预览信息
//
// - 根据附件 ID 获取附件预览信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/attachment/preview
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/preview_attachment.go
func (a *attachment) Preview(ctx context.Context, req *PreviewAttachmentReq, options ...larkcore.RequestOptionFunc) (*PreviewAttachmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/attachments/:attachment_id/preview"
	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 := &PreviewAttachmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, a.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=hire&resource=background_check_order&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/batchQuery_backgroundCheckOrder.go
func (b *backgroundCheckOrder) BatchQuery(ctx context.Context, req *BatchQueryBackgroundCheckOrderReq, options ...larkcore.RequestOptionFunc) (*BatchQueryBackgroundCheckOrderResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/background_check_orders/batch_query"
	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 := &BatchQueryBackgroundCheckOrderResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, b.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List 获取背调信息
//
// - 根据投递ID或背调更新时间获取背调信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/background_check_order/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_backgroundCheckOrder.go
func (b *backgroundCheckOrder) List(ctx context.Context, req *ListBackgroundCheckOrderReq, options ...larkcore.RequestOptionFunc) (*ListBackgroundCheckOrderResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/background_check_orders"
	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 := &ListBackgroundCheckOrderResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, b.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=hire&resource=diversity_inclusion&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/search_diversityInclusion.go
func (d *diversityInclusion) Search(ctx context.Context, req *SearchDiversityInclusionReq, options ...larkcore.RequestOptionFunc) (*SearchDiversityInclusionResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/applications/diversity_inclusions/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 := &SearchDiversityInclusionResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, d.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchDelete 删除帐号自定义字段
//
// - 删除用户在服务商处的身份标示字段（如用户在服务商处的租户 ID）。删除后，不影响已添加帐号对应的自定义字段的值。但在添加新帐号时，将不能再使用此自定义字段。删除不支持撤销，对应的 key 将无法再次复用。
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/eco_account_custom_field/batch_delete
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/batchDelete_ecoAccountCustomField.go
func (e *ecoAccountCustomField) BatchDelete(ctx context.Context, req *BatchDeleteEcoAccountCustomFieldReq, options ...larkcore.RequestOptionFunc) (*BatchDeleteEcoAccountCustomFieldResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/eco_account_custom_fields/batch_delete"
	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 := &BatchDeleteEcoAccountCustomFieldResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchUpdate 更新帐号自定义字段
//
// - 更新用户在服务商处的身份标示字段（如用户在服务商处的租户 ID），此方法只会更新同一 scope 内 key 一致的自定义字段。
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/eco_account_custom_field/batch_update
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/batchUpdate_ecoAccountCustomField.go
func (e *ecoAccountCustomField) BatchUpdate(ctx context.Context, req *BatchUpdateEcoAccountCustomFieldReq, options ...larkcore.RequestOptionFunc) (*BatchUpdateEcoAccountCustomFieldResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/eco_account_custom_fields/batch_update"
	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 := &BatchUpdateEcoAccountCustomFieldResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create 创建帐号自定义字段
//
// - 定制用户在服务商处的身份标示字段（如用户在服务商处的租户 ID）。用户在飞书招聘后台添加帐号后，系统会推送「帐号绑定」事件给开发者，事件将携带用户填写的自定义字段信息，开发者可根据此信息识别飞书招聘用户在服务商处的身份信息，完成飞书招聘用户和服务商帐号的绑定，并以此来推送对应的套餐或试卷列表等。
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/eco_account_custom_field/create
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_ecoAccountCustomField.go
func (e *ecoAccountCustomField) Create(ctx context.Context, req *CreateEcoAccountCustomFieldReq, options ...larkcore.RequestOptionFunc) (*CreateEcoAccountCustomFieldResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/eco_account_custom_fields"
	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 := &CreateEcoAccountCustomFieldResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Cancel 终止背调订单
//
// - 终止背调订单
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/eco_background_check/cancel
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/cancel_ecoBackgroundCheck.go
func (e *ecoBackgroundCheck) Cancel(ctx context.Context, req *CancelEcoBackgroundCheckReq, options ...larkcore.RequestOptionFunc) (*CancelEcoBackgroundCheckResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/eco_background_checks/cancel"
	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 := &CancelEcoBackgroundCheckResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// UpdateProgress 更新背调进度
//
// - 更新指定背调的进度信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/eco_background_check/update_progress
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/updateProgress_ecoBackgroundCheck.go
func (e *ecoBackgroundCheck) UpdateProgress(ctx context.Context, req *UpdateProgressEcoBackgroundCheckReq, options ...larkcore.RequestOptionFunc) (*UpdateProgressEcoBackgroundCheckResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/eco_background_checks/update_progress"
	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 := &UpdateProgressEcoBackgroundCheckResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// UpdateResult 回传背调的最终结果
//
// - 回传背调的最终结果
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/eco_background_check/update_result
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/updateResult_ecoBackgroundCheck.go
func (e *ecoBackgroundCheck) UpdateResult(ctx context.Context, req *UpdateResultEcoBackgroundCheckReq, options ...larkcore.RequestOptionFunc) (*UpdateResultEcoBackgroundCheckResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/eco_background_checks/update_result"
	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 := &UpdateResultEcoBackgroundCheckResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchDelete 删除背调自定义字段
//
// - 删除用户在发起背调时的自定义字段，删除不影响已创建的背调，删除后对应的自定义字段的 key 不能再复用。
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/eco_background_check_custom_field/batch_delete
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/batchDelete_ecoBackgroundCheckCustomField.go
func (e *ecoBackgroundCheckCustomField) BatchDelete(ctx context.Context, req *BatchDeleteEcoBackgroundCheckCustomFieldReq, options ...larkcore.RequestOptionFunc) (*BatchDeleteEcoBackgroundCheckCustomFieldResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/eco_background_check_custom_fields/batch_delete"
	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 := &BatchDeleteEcoBackgroundCheckCustomFieldResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchUpdate 更新背调自定义字段
//
// - 更新用户在发起背调时的自定义字段。更新操作不支持更新自定义字段类型，且将影响已发起的背调表单展示。
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/eco_background_check_custom_field/batch_update
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/batchUpdate_ecoBackgroundCheckCustomField.go
func (e *ecoBackgroundCheckCustomField) BatchUpdate(ctx context.Context, req *BatchUpdateEcoBackgroundCheckCustomFieldReq, options ...larkcore.RequestOptionFunc) (*BatchUpdateEcoBackgroundCheckCustomFieldResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/eco_background_check_custom_fields/batch_update"
	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 := &BatchUpdateEcoBackgroundCheckCustomFieldResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create 创建背调自定义字段
//
// - 定制用户在发起背调时的自定义字段
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/eco_background_check_custom_field/create
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_ecoBackgroundCheckCustomField.go
func (e *ecoBackgroundCheckCustomField) Create(ctx context.Context, req *CreateEcoBackgroundCheckCustomFieldReq, options ...larkcore.RequestOptionFunc) (*CreateEcoBackgroundCheckCustomFieldResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/eco_background_check_custom_fields"
	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 := &CreateEcoBackgroundCheckCustomFieldResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchDelete 删除背调套餐和附加调查项
//
// - 删除指定帐号的指定背调套餐和附加调查项信息，删除不会影响已创建的背调。
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/eco_background_check_package/batch_delete
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/batchDelete_ecoBackgroundCheckPackage.go
func (e *ecoBackgroundCheckPackage) BatchDelete(ctx context.Context, req *BatchDeleteEcoBackgroundCheckPackageReq, options ...larkcore.RequestOptionFunc) (*BatchDeleteEcoBackgroundCheckPackageResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/eco_background_check_packages/batch_delete"
	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 := &BatchDeleteEcoBackgroundCheckPackageResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchUpdate 更新背调套餐和附加调查项
//
// - 更新指定帐号可用的背调套餐和附加调查项信息，更新将影响已发起背调的表单项展示
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/eco_background_check_package/batch_update
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/batchUpdate_ecoBackgroundCheckPackage.go
func (e *ecoBackgroundCheckPackage) BatchUpdate(ctx context.Context, req *BatchUpdateEcoBackgroundCheckPackageReq, options ...larkcore.RequestOptionFunc) (*BatchUpdateEcoBackgroundCheckPackageResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/eco_background_check_packages/batch_update"
	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 := &BatchUpdateEcoBackgroundCheckPackageResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create 推送背调套餐和附加调查项
//
// - 定制指定帐号可用的背调套餐和附加调查项信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/eco_background_check_package/create
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_ecoBackgroundCheckPackage.go
func (e *ecoBackgroundCheckPackage) Create(ctx context.Context, req *CreateEcoBackgroundCheckPackageReq, options ...larkcore.RequestOptionFunc) (*CreateEcoBackgroundCheckPackageResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/eco_background_check_packages"
	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 := &CreateEcoBackgroundCheckPackageResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// LoginInfo
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=login_info&project=hire&resource=eco_exam&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/loginInfo_ecoExam.go
func (e *ecoExam) LoginInfo(ctx context.Context, req *LoginInfoEcoExamReq, options ...larkcore.RequestOptionFunc) (*LoginInfoEcoExamResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/eco_exams/:exam_id/login_info"
	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 := &LoginInfoEcoExamResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// UpdateResult
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=update_result&project=hire&resource=eco_exam&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/updateResult_ecoExam.go
func (e *ecoExam) UpdateResult(ctx context.Context, req *UpdateResultEcoExamReq, options ...larkcore.RequestOptionFunc) (*UpdateResultEcoExamResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/eco_exams/:exam_id/update_result"
	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 := &UpdateResultEcoExamResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchDelete
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batch_delete&project=hire&resource=eco_exam_paper&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/batchDelete_ecoExamPaper.go
func (e *ecoExamPaper) BatchDelete(ctx context.Context, req *BatchDeleteEcoExamPaperReq, options ...larkcore.RequestOptionFunc) (*BatchDeleteEcoExamPaperResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/eco_exam_papers/batch_delete"
	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 := &BatchDeleteEcoExamPaperResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchUpdate
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batch_update&project=hire&resource=eco_exam_paper&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/batchUpdate_ecoExamPaper.go
func (e *ecoExamPaper) BatchUpdate(ctx context.Context, req *BatchUpdateEcoExamPaperReq, options ...larkcore.RequestOptionFunc) (*BatchUpdateEcoExamPaperResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/eco_exam_papers/batch_update"
	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 := &BatchUpdateEcoExamPaperResp{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=hire&resource=eco_exam_paper&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_ecoExamPaper.go
func (e *ecoExamPaper) Create(ctx context.Context, req *CreateEcoExamPaperReq, options ...larkcore.RequestOptionFunc) (*CreateEcoExamPaperResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/eco_exam_papers"
	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 := &CreateEcoExamPaperResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Patch 更新 e-HR 导入任务结果
//
// - 在处理完导入 e-HR 事件后，可调用该接口，更新  e-HR 导入任务结果
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/ehr_import_task/patch
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/patch_ehrImportTask.go
func (e *ehrImportTask) Patch(ctx context.Context, req *PatchEhrImportTaskReq, options ...larkcore.RequestOptionFunc) (*PatchEhrImportTaskResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/ehr_import_tasks/:ehr_import_task_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 := &PatchEhrImportTaskResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Get 通过员工 ID 获取入职信息
//
// - 通过员工 ID 获取入职信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/employee/get
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/get_employee.go
func (e *employee) Get(ctx context.Context, req *GetEmployeeReq, options ...larkcore.RequestOptionFunc) (*GetEmployeeResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/employees/:employee_id"
	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 := &GetEmployeeResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// GetByApplication 通过投递 ID 获取入职信息
//
// - 通过投递 ID 获取入职信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/employee/get_by_application
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/getByApplication_employee.go
func (e *employee) GetByApplication(ctx context.Context, req *GetByApplicationEmployeeReq, options ...larkcore.RequestOptionFunc) (*GetByApplicationEmployeeResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/employees/get_by_application"
	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 := &GetByApplicationEmployeeResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Patch 更新入职状态
//
// - 根据员工 ID 更新员工转正、离职状态
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/employee/patch
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/patch_employee.go
func (e *employee) Patch(ctx context.Context, req *PatchEmployeeReq, options ...larkcore.RequestOptionFunc) (*PatchEmployeeResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/employees/:employee_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 := &PatchEmployeeResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List 获取简历评估信息
//
// - 获取简历评估信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/evaluation/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_evaluation.go
func (e *evaluation) List(ctx context.Context, req *ListEvaluationReq, options ...larkcore.RequestOptionFunc) (*ListEvaluationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/evaluations"
	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 := &ListEvaluationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (e *evaluation) ListByIterator(ctx context.Context, req *ListEvaluationReq, options ...larkcore.RequestOptionFunc) (*ListEvaluationIterator, error) {
	return &ListEvaluationIterator{
		ctx:      ctx,
		req:      req,
		listFunc: e.List,
		options:  options,
		limit:    req.Limit}, nil
}

// List 获取员工评估任务
//
// - 获取员工评估任务
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/evaluation_task/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_evaluationTask.go
func (e *evaluationTask) List(ctx context.Context, req *ListEvaluationTaskReq, options ...larkcore.RequestOptionFunc) (*ListEvaluationTaskResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/evaluation_tasks"
	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 := &ListEvaluationTaskResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (e *evaluationTask) ListByIterator(ctx context.Context, req *ListEvaluationTaskReq, options ...larkcore.RequestOptionFunc) (*ListEvaluationTaskIterator, error) {
	return &ListEvaluationTaskIterator{
		ctx:      ctx,
		req:      req,
		listFunc: e.List,
		options:  options,
		limit:    req.Limit}, nil
}

// Create 添加笔试结果
//
// - 根据投递 ID 添加该投递下的笔试结果
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/exam/create
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_exam.go
func (e *exam) Create(ctx context.Context, req *CreateExamReq, options ...larkcore.RequestOptionFunc) (*CreateExamResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/exams"
	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 := &CreateExamResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List 获取员工笔试阅卷任务
//
// - 获取员工笔试阅卷任务
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/exam_marking_task/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_examMarkingTask.go
func (e *examMarkingTask) List(ctx context.Context, req *ListExamMarkingTaskReq, options ...larkcore.RequestOptionFunc) (*ListExamMarkingTaskResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/exam_marking_tasks"
	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 := &ListExamMarkingTaskResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (e *examMarkingTask) ListByIterator(ctx context.Context, req *ListExamMarkingTaskReq, options ...larkcore.RequestOptionFunc) (*ListExamMarkingTaskIterator, error) {
	return &ListExamMarkingTaskIterator{
		ctx:      ctx,
		req:      req,
		listFunc: e.List,
		options:  options,
		limit:    req.Limit}, nil
}

// Create 创建外部投递
//
// - 导入来自其他系统的投递信息，创建为外部投递
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/external_application/create
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_externalApplication.go
func (e *externalApplication) Create(ctx context.Context, req *CreateExternalApplicationReq, options ...larkcore.RequestOptionFunc) (*CreateExternalApplicationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_applications"
	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 := &CreateExternalApplicationResp{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=hire&resource=external_application&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/delete_externalApplication.go
func (e *externalApplication) Delete(ctx context.Context, req *DeleteExternalApplicationReq, options ...larkcore.RequestOptionFunc) (*DeleteExternalApplicationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_applications/:external_application_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 := &DeleteExternalApplicationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List
//
// - 根据人才 id 获取外部投递列表
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=list&project=hire&resource=external_application&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_externalApplication.go
func (e *externalApplication) List(ctx context.Context, req *ListExternalApplicationReq, options ...larkcore.RequestOptionFunc) (*ListExternalApplicationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_applications"
	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 := &ListExternalApplicationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (e *externalApplication) ListByIterator(ctx context.Context, req *ListExternalApplicationReq, options ...larkcore.RequestOptionFunc) (*ListExternalApplicationIterator, error) {
	return &ListExternalApplicationIterator{
		ctx:      ctx,
		req:      req,
		listFunc: e.List,
		options:  options,
		limit:    req.Limit}, nil
}

// Update
//
// - 更新外部投递
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=update&project=hire&resource=external_application&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/update_externalApplication.go
func (e *externalApplication) Update(ctx context.Context, req *UpdateExternalApplicationReq, options ...larkcore.RequestOptionFunc) (*UpdateExternalApplicationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_applications/:external_application_id"
	apiReq.HttpMethod = http.MethodPut
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, e.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &UpdateExternalApplicationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.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=hire&resource=external_background_check&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/batchQuery_externalBackgroundCheck.go
func (e *externalBackgroundCheck) BatchQuery(ctx context.Context, req *BatchQueryExternalBackgroundCheckReq, options ...larkcore.RequestOptionFunc) (*BatchQueryExternalBackgroundCheckResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_background_checks/batch_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 := &BatchQueryExternalBackgroundCheckResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (e *externalBackgroundCheck) BatchQueryByIterator(ctx context.Context, req *BatchQueryExternalBackgroundCheckReq, options ...larkcore.RequestOptionFunc) (*BatchQueryExternalBackgroundCheckIterator, error) {
	return &BatchQueryExternalBackgroundCheckIterator{
		ctx:      ctx,
		req:      req,
		listFunc: e.BatchQuery,
		options:  options,
		limit:    req.Limit}, nil
}

// Create 创建外部背调
//
// - 导入来自其他系统的背调信息，创建为外部背调
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/external_background_check/create
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_externalBackgroundCheck.go
func (e *externalBackgroundCheck) Create(ctx context.Context, req *CreateExternalBackgroundCheckReq, options ...larkcore.RequestOptionFunc) (*CreateExternalBackgroundCheckResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_background_checks"
	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 := &CreateExternalBackgroundCheckResp{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=hire&resource=external_background_check&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/delete_externalBackgroundCheck.go
func (e *externalBackgroundCheck) Delete(ctx context.Context, req *DeleteExternalBackgroundCheckReq, options ...larkcore.RequestOptionFunc) (*DeleteExternalBackgroundCheckResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_background_checks/:external_background_check_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 := &DeleteExternalBackgroundCheckResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.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=hire&resource=external_background_check&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/update_externalBackgroundCheck.go
func (e *externalBackgroundCheck) Update(ctx context.Context, req *UpdateExternalBackgroundCheckReq, options ...larkcore.RequestOptionFunc) (*UpdateExternalBackgroundCheckResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_background_checks/:external_background_check_id"
	apiReq.HttpMethod = http.MethodPut
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, e.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &UpdateExternalBackgroundCheckResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.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=hire&resource=external_interview&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/batchQuery_externalInterview.go
func (e *externalInterview) BatchQuery(ctx context.Context, req *BatchQueryExternalInterviewReq, options ...larkcore.RequestOptionFunc) (*BatchQueryExternalInterviewResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_interviews/batch_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 := &BatchQueryExternalInterviewResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (e *externalInterview) BatchQueryByIterator(ctx context.Context, req *BatchQueryExternalInterviewReq, options ...larkcore.RequestOptionFunc) (*BatchQueryExternalInterviewIterator, error) {
	return &BatchQueryExternalInterviewIterator{
		ctx:      ctx,
		req:      req,
		listFunc: e.BatchQuery,
		options:  options,
		limit:    req.Limit}, nil
}

// Create 创建外部面试
//
// - 导入来自其他系统的面试信息，创建为外部面试
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/external_interview/create
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_externalInterview.go
func (e *externalInterview) Create(ctx context.Context, req *CreateExternalInterviewReq, options ...larkcore.RequestOptionFunc) (*CreateExternalInterviewResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_interviews"
	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 := &CreateExternalInterviewResp{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=hire&resource=external_interview&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/delete_externalInterview.go
func (e *externalInterview) Delete(ctx context.Context, req *DeleteExternalInterviewReq, options ...larkcore.RequestOptionFunc) (*DeleteExternalInterviewResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_interviews/:external_interview_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 := &DeleteExternalInterviewResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.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=hire&resource=external_interview&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/update_externalInterview.go
func (e *externalInterview) Update(ctx context.Context, req *UpdateExternalInterviewReq, options ...larkcore.RequestOptionFunc) (*UpdateExternalInterviewResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_interviews/:external_interview_id"
	apiReq.HttpMethod = http.MethodPut
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, e.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &UpdateExternalInterviewResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create 创建外部面评
//
// - 导入来自其他系统的面评信息，创建为外部面评
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/external_interview_assessment/create
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_externalInterviewAssessment.go
func (e *externalInterviewAssessment) Create(ctx context.Context, req *CreateExternalInterviewAssessmentReq, options ...larkcore.RequestOptionFunc) (*CreateExternalInterviewAssessmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_interview_assessments"
	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 := &CreateExternalInterviewAssessmentResp{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=hire&resource=external_interview_assessment&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/patch_externalInterviewAssessment.go
func (e *externalInterviewAssessment) Patch(ctx context.Context, req *PatchExternalInterviewAssessmentReq, options ...larkcore.RequestOptionFunc) (*PatchExternalInterviewAssessmentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_interview_assessments/:external_interview_assessment_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 := &PatchExternalInterviewAssessmentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.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=hire&resource=external_offer&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/batchQuery_externalOffer.go
func (e *externalOffer) BatchQuery(ctx context.Context, req *BatchQueryExternalOfferReq, options ...larkcore.RequestOptionFunc) (*BatchQueryExternalOfferResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_offers/batch_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 := &BatchQueryExternalOfferResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (e *externalOffer) BatchQueryByIterator(ctx context.Context, req *BatchQueryExternalOfferReq, options ...larkcore.RequestOptionFunc) (*BatchQueryExternalOfferIterator, error) {
	return &BatchQueryExternalOfferIterator{
		ctx:      ctx,
		req:      req,
		listFunc: e.BatchQuery,
		options:  options,
		limit:    req.Limit}, nil
}

// Create
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=create&project=hire&resource=external_offer&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_externalOffer.go
func (e *externalOffer) Create(ctx context.Context, req *CreateExternalOfferReq, options ...larkcore.RequestOptionFunc) (*CreateExternalOfferResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_offers"
	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 := &CreateExternalOfferResp{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=hire&resource=external_offer&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/delete_externalOffer.go
func (e *externalOffer) Delete(ctx context.Context, req *DeleteExternalOfferReq, options ...larkcore.RequestOptionFunc) (*DeleteExternalOfferResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_offers/:external_offer_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 := &DeleteExternalOfferResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.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=hire&resource=external_offer&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/update_externalOffer.go
func (e *externalOffer) Update(ctx context.Context, req *UpdateExternalOfferReq, options ...larkcore.RequestOptionFunc) (*UpdateExternalOfferResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_offers/:external_offer_id"
	apiReq.HttpMethod = http.MethodPut
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, e.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &UpdateExternalOfferResp{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=hire&resource=external_referral_reward&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_externalReferralReward.go
func (e *externalReferralReward) Create(ctx context.Context, req *CreateExternalReferralRewardReq, options ...larkcore.RequestOptionFunc) (*CreateExternalReferralRewardResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_referral_rewards"
	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 := &CreateExternalReferralRewardResp{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=hire&resource=external_referral_reward&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/delete_externalReferralReward.go
func (e *externalReferralReward) Delete(ctx context.Context, req *DeleteExternalReferralRewardReq, options ...larkcore.RequestOptionFunc) (*DeleteExternalReferralRewardResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/external_referral_rewards/:external_referral_reward_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 := &DeleteExternalReferralRewardResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, e.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// GetByTalent 获取人才面试信息
//
// - 获取人才面试信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/interview/get_by_talent
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/getByTalent_interview.go
func (i *interview) GetByTalent(ctx context.Context, req *GetByTalentInterviewReq, options ...larkcore.RequestOptionFunc) (*GetByTalentInterviewResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/interviews/get_by_talent"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, i.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &GetByTalentInterviewResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, i.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List 获取面试信息
//
// - 根据投递 ID 或面试时间获取面试信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/interview/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_interview.go
func (i *interview) List(ctx context.Context, req *ListInterviewReq, options ...larkcore.RequestOptionFunc) (*ListInterviewResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/interviews"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, i.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListInterviewResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, i.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=hire&resource=interview_feedback_form&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_interviewFeedbackForm.go
func (i *interviewFeedbackForm) List(ctx context.Context, req *ListInterviewFeedbackFormReq, options ...larkcore.RequestOptionFunc) (*ListInterviewFeedbackFormResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/interview_feedback_forms"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, i.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListInterviewFeedbackFormResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, i.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (i *interviewFeedbackForm) ListByIterator(ctx context.Context, req *ListInterviewFeedbackFormReq, options ...larkcore.RequestOptionFunc) (*ListInterviewFeedbackFormIterator, error) {
	return &ListInterviewFeedbackFormIterator{
		ctx:      ctx,
		req:      req,
		listFunc: i.List,
		options:  options,
		limit:    req.Limit}, nil
}

// Get 获取面试评价详细信息
//
// - 获取面试评价详细信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/interview_record/get
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/get_interviewRecord.go
func (i *interviewRecord) Get(ctx context.Context, req *GetInterviewRecordReq, options ...larkcore.RequestOptionFunc) (*GetInterviewRecordResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/interview_records/:interview_record_id"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, i.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &GetInterviewRecordResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, i.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=hire&resource=interview_record&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_interviewRecord.go
func (i *interviewRecord) List(ctx context.Context, req *ListInterviewRecordReq, options ...larkcore.RequestOptionFunc) (*ListInterviewRecordResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/interview_records"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, i.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListInterviewRecordResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, i.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (i *interviewRecord) ListByIterator(ctx context.Context, req *ListInterviewRecordReq, options ...larkcore.RequestOptionFunc) (*ListInterviewRecordIterator, error) {
	return &ListInterviewRecordIterator{
		ctx:      ctx,
		req:      req,
		listFunc: i.List,
		options:  options,
		limit:    req.Limit}, nil
}

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

// List 获取面试登记表模板列表
//
// - 获取面试登记表模板列表
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/interview_registration_schema/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_interviewRegistrationSchema.go
func (i *interviewRegistrationSchema) List(ctx context.Context, req *ListInterviewRegistrationSchemaReq, options ...larkcore.RequestOptionFunc) (*ListInterviewRegistrationSchemaResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/interview_registration_schemas"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, i.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListInterviewRegistrationSchemaResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, i.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (i *interviewRegistrationSchema) ListByIterator(ctx context.Context, req *ListInterviewRegistrationSchemaReq, options ...larkcore.RequestOptionFunc) (*ListInterviewRegistrationSchemaIterator, error) {
	return &ListInterviewRegistrationSchemaIterator{
		ctx:      ctx,
		req:      req,
		listFunc: i.List,
		options:  options,
		limit:    req.Limit}, nil
}

// List 获取面试轮次类型列表
//
// - 获取面试轮次类型列表
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/interview_round_type/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_interviewRoundType.go
func (i *interviewRoundType) List(ctx context.Context, req *ListInterviewRoundTypeReq, options ...larkcore.RequestOptionFunc) (*ListInterviewRoundTypeResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/interview_round_types"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, i.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListInterviewRoundTypeResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, i.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List 获取员工面试任务
//
// - 获取员工面试任务
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/interview_task/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_interviewTask.go
func (i *interviewTask) List(ctx context.Context, req *ListInterviewTaskReq, options ...larkcore.RequestOptionFunc) (*ListInterviewTaskResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/interview_tasks"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, i.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListInterviewTaskResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, i.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (i *interviewTask) ListByIterator(ctx context.Context, req *ListInterviewTaskReq, options ...larkcore.RequestOptionFunc) (*ListInterviewTaskIterator, error) {
	return &ListInterviewTaskIterator{
		ctx:      ctx,
		req:      req,
		listFunc: i.List,
		options:  options,
		limit:    req.Limit}, nil
}

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

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

// Close 关闭职位
//
// - 支持关闭职位，关闭后，职位将同步从官网、内推、猎头渠道下线
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job/close
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/close_job.go
func (j *job) Close(ctx context.Context, req *CloseJobReq, options ...larkcore.RequestOptionFunc) (*CloseJobResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/jobs/:job_id/close"
	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 := &CloseJobResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// CombinedCreate 新建职位
//
// - 新建职位，字段的是否必填，以系统中的「职位字段管理」中的设置为准。
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job/combined_create
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/combinedCreate_job.go
func (j *job) CombinedCreate(ctx context.Context, req *CombinedCreateJobReq, options ...larkcore.RequestOptionFunc) (*CombinedCreateJobResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/jobs/combined_create"
	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 := &CombinedCreateJobResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// CombinedUpdate 更新职位
//
// - 更新职位信息，该接口为全量更新，若字段没有返回值，则原有值将会被清空。字段的是否必填，将以系统中的「职位字段管理」中的设置为准。
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job/combined_update
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/combinedUpdate_job.go
func (j *job) CombinedUpdate(ctx context.Context, req *CombinedUpdateJobReq, options ...larkcore.RequestOptionFunc) (*CombinedUpdateJobResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/jobs/:job_id/combined_update"
	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 := &CombinedUpdateJobResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Config 获取职位设置
//
// - 获取职位设置
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job/config
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/config_job.go
func (j *job) Config(ctx context.Context, req *ConfigJobReq, options ...larkcore.RequestOptionFunc) (*ConfigJobResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/jobs/:job_id/config"
	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 := &ConfigJobResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Get 获取职位信息
//
// - 根据职位 ID 获取职位信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job/get
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/get_job.go
func (j *job) Get(ctx context.Context, req *GetJobReq, options ...larkcore.RequestOptionFunc) (*GetJobResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/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
}

// GetDetail
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=get_detail&project=hire&resource=job&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/getDetail_job.go
func (j *job) GetDetail(ctx context.Context, req *GetDetailJobReq, options ...larkcore.RequestOptionFunc) (*GetDetailJobResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/jobs/:job_id/get_detail"
	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 := &GetDetailJobResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List 获取职位列表
//
// - 根据更新时间获取职位列表，仅支持获取默认字段信息，获取详细信息可调用[获取职位详细](https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job/get)接口
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_job.go
func (j *job) List(ctx context.Context, req *ListJobReq, options ...larkcore.RequestOptionFunc) (*ListJobResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/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
}

// Open 重启职位
//
// - 支持开启职位
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job/open
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/open_job.go
func (j *job) Open(ctx context.Context, req *OpenJobReq, options ...larkcore.RequestOptionFunc) (*OpenJobResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/jobs/:job_id/open"
	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 := &OpenJobResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Recruiter
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=recruiter&project=hire&resource=job&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/recruiter_job.go
func (j *job) Recruiter(ctx context.Context, req *RecruiterJobReq, options ...larkcore.RequestOptionFunc) (*RecruiterJobResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/jobs/:job_id/recruiter"
	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 := &RecruiterJobResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// UpdateConfig 更新职位设置
//
// - 更新职位设置，包括面试评价表、Offer 申请表等。接口将按照所选择的「更新选项」进行设置参数校验和更新。
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job/update_config
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/updateConfig_job.go
func (j *job) UpdateConfig(ctx context.Context, req *UpdateConfigJobReq, options ...larkcore.RequestOptionFunc) (*UpdateConfigJobResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/jobs/:job_id/update_config"
	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 := &UpdateConfigJobResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchUpdate 更新职位相关人员
//
// - 更新职位相关人员
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job-manager/batch_update
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/batchUpdate_jobManager.go
func (j *jobManager) BatchUpdate(ctx context.Context, req *BatchUpdateJobManagerReq, options ...larkcore.RequestOptionFunc) (*BatchUpdateJobManagerResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/jobs/:job_id/managers/batch_update"
	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 := &BatchUpdateJobManagerResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Get 获取职位上的招聘人员信息
//
// - 根据职位 ID 获取职位上的招聘人员信息，如招聘负责人、用人经理
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job-manager/get
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/get_jobManager.go
func (j *jobManager) Get(ctx context.Context, req *GetJobManagerReq, options ...larkcore.RequestOptionFunc) (*GetJobManagerResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/jobs/:job_id/managers/:manager_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 := &GetJobManagerResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List 获取职能分类列表
//
// - 获取职能分类列表
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job_function/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_jobFunction.go
func (j *jobFunction) List(ctx context.Context, req *ListJobFunctionReq, options ...larkcore.RequestOptionFunc) (*ListJobFunctionResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/job_functions"
	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 := &ListJobFunctionResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (j *jobFunction) ListByIterator(ctx context.Context, req *ListJobFunctionReq, options ...larkcore.RequestOptionFunc) (*ListJobFunctionIterator, error) {
	return &ListJobFunctionIterator{
		ctx:      ctx,
		req:      req,
		listFunc: j.List,
		options:  options,
		limit:    req.Limit}, nil
}

// List 获取招聘流程信息
//
// - 获取全部招聘流程信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job_process/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_jobProcess.go
func (j *jobProcess) List(ctx context.Context, req *ListJobProcessReq, options ...larkcore.RequestOptionFunc) (*ListJobProcessResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/job_processes"
	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 := &ListJobProcessResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Search 获取职位广告发布记录
//
// - 获取职位广告发布记录
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job_publish_record/search
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/search_jobPublishRecord.go
func (j *jobPublishRecord) Search(ctx context.Context, req *SearchJobPublishRecordReq, options ...larkcore.RequestOptionFunc) (*SearchJobPublishRecordResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/job_publish_records/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 := &SearchJobPublishRecordResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create 创建招聘需求
//
// - 创建招聘需求，除招聘需求编号为必填外，其他字段是否必填与飞书招聘「招聘需求字段管理」内设置一致
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job_requirement/create
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_jobRequirement.go
func (j *jobRequirement) Create(ctx context.Context, req *CreateJobRequirementReq, options ...larkcore.RequestOptionFunc) (*CreateJobRequirementResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/job_requirements"
	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 := &CreateJobRequirementResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Delete 删除招聘需求
//
// - 删除招聘需求
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job_requirement/delete
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/delete_jobRequirement.go
func (j *jobRequirement) Delete(ctx context.Context, req *DeleteJobRequirementReq, options ...larkcore.RequestOptionFunc) (*DeleteJobRequirementResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/job_requirements/:job_requirement_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 := &DeleteJobRequirementResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List 获取招聘需求列表
//
// - 获取招聘需求列表
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job_requirement/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_jobRequirement.go
func (j *jobRequirement) List(ctx context.Context, req *ListJobRequirementReq, options ...larkcore.RequestOptionFunc) (*ListJobRequirementResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/job_requirements"
	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 := &ListJobRequirementResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// ListById
//
// - 获取招聘需求信息
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=list_by_id&project=hire&resource=job_requirement&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/listById_jobRequirement.go
func (j *jobRequirement) ListById(ctx context.Context, req *ListByIdJobRequirementReq, options ...larkcore.RequestOptionFunc) (*ListByIdJobRequirementResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/job_requirements/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 := &ListByIdJobRequirementResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Update 更新招聘需求
//
// - 更新招聘需求
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job_requirement/update
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/update_jobRequirement.go
func (j *jobRequirement) Update(ctx context.Context, req *UpdateJobRequirementReq, options ...larkcore.RequestOptionFunc) (*UpdateJobRequirementResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/job_requirements/:job_requirement_id"
	apiReq.HttpMethod = http.MethodPut
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, j.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &UpdateJobRequirementResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List 获取招聘需求模板
//
// - 获取招聘需求模板
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job_requirement_schema/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_jobRequirementSchema.go
func (j *jobRequirementSchema) List(ctx context.Context, req *ListJobRequirementSchemaReq, options ...larkcore.RequestOptionFunc) (*ListJobRequirementSchemaResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/job_requirement_schemas"
	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 := &ListJobRequirementSchemaResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List 获取职位模板
//
// - 获取社招、校招职位模板中的职位字段，包括系统默认字段和自定义字段
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/job_schema/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_jobSchema.go
func (j *jobSchema) List(ctx context.Context, req *ListJobSchemaReq, options ...larkcore.RequestOptionFunc) (*ListJobSchemaResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/job_schemas"
	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 := &ListJobSchemaResp{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=hire&resource=job_type&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_jobType.go
func (j *jobType) List(ctx context.Context, req *ListJobTypeReq, options ...larkcore.RequestOptionFunc) (*ListJobTypeResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/job_types"
	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 := &ListJobTypeResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, j.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (j *jobType) ListByIterator(ctx context.Context, req *ListJobTypeReq, options ...larkcore.RequestOptionFunc) (*ListJobTypeIterator, error) {
	return &ListJobTypeIterator{
		ctx:      ctx,
		req:      req,
		listFunc: j.List,
		options:  options,
		limit:    req.Limit}, nil
}

// List 获取地址列表
//
// - 获取地址列表
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/location/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_location.go
func (l *location) List(ctx context.Context, req *ListLocationReq, options ...larkcore.RequestOptionFunc) (*ListLocationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/locations"
	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 := &ListLocationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, l.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (l *location) ListByIterator(ctx context.Context, req *ListLocationReq, options ...larkcore.RequestOptionFunc) (*ListLocationIterator, error) {
	return &ListLocationIterator{
		ctx:      ctx,
		req:      req,
		listFunc: l.List,
		options:  options,
		limit:    req.Limit}, nil
}

// Query
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=query&project=hire&resource=location&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/query_location.go
func (l *location) Query(ctx context.Context, req *QueryLocationReq, options ...larkcore.RequestOptionFunc) (*QueryLocationResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/locations/query"
	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 := &QueryLocationResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, l.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=hire&resource=minutes&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/get_minutes.go
func (m *minutes) Get(ctx context.Context, req *GetMinutesReq, options ...larkcore.RequestOptionFunc) (*GetMinutesResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/minutes"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, m.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &GetMinutesResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, m.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create 创建备注
//
// - 创建备注信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/note/create
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_note.go
func (n *note) Create(ctx context.Context, req *CreateNoteReq, options ...larkcore.RequestOptionFunc) (*CreateNoteResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/notes"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, n.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CreateNoteResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, n.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=hire&resource=note&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/delete_note.go
func (n *note) Delete(ctx context.Context, req *DeleteNoteReq, options ...larkcore.RequestOptionFunc) (*DeleteNoteResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/notes/:note_id"
	apiReq.HttpMethod = http.MethodDelete
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, n.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &DeleteNoteResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, n.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Get 获取备注
//
// - 根据备注 ID 获取备注信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/note/get
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/get_note.go
func (n *note) Get(ctx context.Context, req *GetNoteReq, options ...larkcore.RequestOptionFunc) (*GetNoteResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/notes/:note_id"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, n.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &GetNoteResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, n.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List 获取备注列表
//
// - 获取备注列表
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/note/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_note.go
func (n *note) List(ctx context.Context, req *ListNoteReq, options ...larkcore.RequestOptionFunc) (*ListNoteResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/notes"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, n.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListNoteResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, n.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Patch 更新备注
//
// - 根据备注 ID 更新备注信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/note/patch
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/patch_note.go
func (n *note) Patch(ctx context.Context, req *PatchNoteReq, options ...larkcore.RequestOptionFunc) (*PatchNoteResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/notes/:note_id"
	apiReq.HttpMethod = http.MethodPatch
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, n.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &PatchNoteResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, n.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Create 创建 Offer
//
// - 创建 Offer 时，需传入本文档中标注为必传的参数，其余参数是否必传参考「获取 Offer 申请表模板信息」的参数定义
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/offer/create
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_offer.go
func (o *offer) Create(ctx context.Context, req *CreateOfferReq, options ...larkcore.RequestOptionFunc) (*CreateOfferResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/offers"
	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 := &CreateOfferResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, o.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Get 获取 Offer 详情
//
// - 根据 Offer ID 获取 Offer 详细信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/offer/get
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/get_offer.go
func (o *offer) Get(ctx context.Context, req *GetOfferReq, options ...larkcore.RequestOptionFunc) (*GetOfferResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/offers/:offer_id"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, o.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &GetOfferResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, o.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// InternOfferStatus 更新实习 Offer 入/离职状态
//
// - 对「实习待入职」状态的实习 Offer 确认入职、放弃入职，或对「实习已入职」状态的实习 Offer 操作离职
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/offer/intern_offer_status
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/internOfferStatus_offer.go
func (o *offer) InternOfferStatus(ctx context.Context, req *InternOfferStatusOfferReq, options ...larkcore.RequestOptionFunc) (*InternOfferStatusOfferResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/offers/:offer_id/intern_offer_status"
	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 := &InternOfferStatusOfferResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, o.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List 获取 Offer 列表
//
// - 根据人才 ID 获取 Offer 列表
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/offer/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_offer.go
func (o *offer) List(ctx context.Context, req *ListOfferReq, options ...larkcore.RequestOptionFunc) (*ListOfferResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/offers"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, o.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListOfferResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, o.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// OfferStatus
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=offer_status&project=hire&resource=offer&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/offerStatus_offer.go
func (o *offer) OfferStatus(ctx context.Context, req *OfferStatusOfferReq, options ...larkcore.RequestOptionFunc) (*OfferStatusOfferResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/offers/:offer_id/offer_status"
	apiReq.HttpMethod = http.MethodPatch
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, o.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &OfferStatusOfferResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, o.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Update 更新 Offer 信息
//
// - 1. 更新 Offer 时，需传入本文档中标注为必传的参数，其余参数是否必传参考「获取 Offer 申请表模板信息」的参数定义；;2. 对系统中已存在的 offer 进行更新的，若更新 offer 中含有「修改需审批」的字段，更新后原 Offer 的审批会自动撤回，需要重新发起审批
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/offer/update
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/update_offer.go
func (o *offer) Update(ctx context.Context, req *UpdateOfferReq, options ...larkcore.RequestOptionFunc) (*UpdateOfferResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/offers/:offer_id"
	apiReq.HttpMethod = http.MethodPut
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, o.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &UpdateOfferResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, o.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Get 获取Offer申请表模板信息
//
// - 获取Offer申请表模板信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/offer_application_form/get
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/get_offerApplicationForm.go
func (o *offerApplicationForm) Get(ctx context.Context, req *GetOfferApplicationFormReq, options ...larkcore.RequestOptionFunc) (*GetOfferApplicationFormResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/offer_application_forms/:offer_application_form_id"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, o.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &GetOfferApplicationFormResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, o.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List 获取 Offer 申请表列表
//
// - 获取 Offer 申请表列表
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/offer_application_form/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_offerApplicationForm.go
func (o *offerApplicationForm) List(ctx context.Context, req *ListOfferApplicationFormReq, options ...larkcore.RequestOptionFunc) (*ListOfferApplicationFormResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/offer_application_forms"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, o.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListOfferApplicationFormResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, o.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List 获取 Offer 审批流配置列表
//
// - 获取 Offer 审批流配置列表
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/offer_approval_template/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_offerApprovalTemplate.go
func (o *offerApprovalTemplate) List(ctx context.Context, req *ListOfferApprovalTemplateReq, options ...larkcore.RequestOptionFunc) (*ListOfferApprovalTemplateResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/offer_approval_templates"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, o.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListOfferApprovalTemplateResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, o.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Update 更新 Offer 申请表自定义字段
//
// - - 本文档支持通过接口更新「飞书招聘」-「设置」-「Offer 申请表设置」中 Offer 申请表的自定义字段配置；;- 当前修改申请表信息（包括更新自定义字段）后，所有申请表的 schema_id 均会更新，即所有申请表均会新增一个版本，申请表的 schema_id 会在创建 offer、更新 offer 中使用；;- 「飞书招聘」中 Offer 申请表自定义字段创建后，不支持修改字段类型，本接口亦不支持更新字段类型；;- 当前字段类型为「公式」的，不支持通过接口更新
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/offer_custom_field/update
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/update_offerCustomField.go
func (o *offerCustomField) Update(ctx context.Context, req *UpdateOfferCustomFieldReq, options ...larkcore.RequestOptionFunc) (*UpdateOfferCustomFieldResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/offer_custom_fields/:offer_custom_field_id"
	apiReq.HttpMethod = http.MethodPut
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, o.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &UpdateOfferCustomFieldResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, o.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=hire&resource=offer_schema&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/get_offerSchema.go
func (o *offerSchema) Get(ctx context.Context, req *GetOfferSchemaReq, options ...larkcore.RequestOptionFunc) (*GetOfferSchemaResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/offer_schemas/:offer_schema_id"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, o.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &GetOfferSchemaResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, o.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=hire&resource=portal_apply_schema&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_portalApplySchema.go
func (p *portalApplySchema) List(ctx context.Context, req *ListPortalApplySchemaReq, options ...larkcore.RequestOptionFunc) (*ListPortalApplySchemaResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/portal_apply_schemas"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant, larkcore.AccessTokenTypeUser}
	apiResp, err := larkcore.Request(ctx, apiReq, p.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListPortalApplySchemaResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, p.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (p *portalApplySchema) ListByIterator(ctx context.Context, req *ListPortalApplySchemaReq, options ...larkcore.RequestOptionFunc) (*ListPortalApplySchemaIterator, error) {
	return &ListPortalApplySchemaIterator{
		ctx:      ctx,
		req:      req,
		listFunc: p.List,
		options:  options,
		limit:    req.Limit}, nil
}

// List 获取面试满意度问卷列表
//
// - 获取面试满意度问卷列表
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/questionnaire/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_questionnaire.go
func (q *questionnaire) List(ctx context.Context, req *ListQuestionnaireReq, options ...larkcore.RequestOptionFunc) (*ListQuestionnaireResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/questionnaires"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, q.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListQuestionnaireResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, q.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// GetByApplication 获取内推信息
//
// - 根据投递 ID 获取内推信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/referral/get_by_application
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/getByApplication_referral.go
func (r *referral) GetByApplication(ctx context.Context, req *GetByApplicationReferralReq, options ...larkcore.RequestOptionFunc) (*GetByApplicationReferralResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/referrals/get_by_application"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, r.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &GetByApplicationReferralResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, r.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=hire&resource=referral&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/search_referral.go
func (r *referral) Search(ctx context.Context, req *SearchReferralReq, options ...larkcore.RequestOptionFunc) (*SearchReferralResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/referrals/search"
	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 := &SearchReferralResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, r.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=hire&resource=referral_account&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_referralAccount.go
func (r *referralAccount) Create(ctx context.Context, req *CreateReferralAccountReq, options ...larkcore.RequestOptionFunc) (*CreateReferralAccountResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/referral_account"
	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 := &CreateReferralAccountResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, r.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Deactivate
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=deactivate&project=hire&resource=referral_account&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/deactivate_referralAccount.go
func (r *referralAccount) Deactivate(ctx context.Context, req *DeactivateReferralAccountReq, options ...larkcore.RequestOptionFunc) (*DeactivateReferralAccountResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/referral_account/:referral_account_id/deactivate"
	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 := &DeactivateReferralAccountResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, r.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Enable
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=enable&project=hire&resource=referral_account&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/enable_referralAccount.go
func (r *referralAccount) Enable(ctx context.Context, req *EnableReferralAccountReq, options ...larkcore.RequestOptionFunc) (*EnableReferralAccountResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/referral_account/enable"
	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 := &EnableReferralAccountResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, r.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

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

// Reconciliation
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=reconciliation&project=hire&resource=referral_account&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/reconciliation_referralAccount.go
func (r *referralAccount) Reconciliation(ctx context.Context, req *ReconciliationReferralAccountReq, options ...larkcore.RequestOptionFunc) (*ReconciliationReferralAccountResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/referral_account/reconciliation"
	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 := &ReconciliationReferralAccountResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, r.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=hire&resource=referral_account&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/withdraw_referralAccount.go
func (r *referralAccount) Withdraw(ctx context.Context, req *WithdrawReferralAccountReq, options ...larkcore.RequestOptionFunc) (*WithdrawReferralAccountResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/referral_account/:referral_account_id/withdraw"
	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 := &WithdrawReferralAccountResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, r.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=hire&resource=referral_website.job_post&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/get_referralWebsiteJobPost.go
func (r *referralWebsiteJobPost) Get(ctx context.Context, req *GetReferralWebsiteJobPostReq, options ...larkcore.RequestOptionFunc) (*GetReferralWebsiteJobPostResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/referral_websites/job_posts/:job_post_id"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, r.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &GetReferralWebsiteJobPostResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, r.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=hire&resource=referral_website.job_post&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_referralWebsiteJobPost.go
func (r *referralWebsiteJobPost) List(ctx context.Context, req *ListReferralWebsiteJobPostReq, options ...larkcore.RequestOptionFunc) (*ListReferralWebsiteJobPostResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/referral_websites/job_posts"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, r.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListReferralWebsiteJobPostResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, r.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (r *referralWebsiteJobPost) ListByIterator(ctx context.Context, req *ListReferralWebsiteJobPostReq, options ...larkcore.RequestOptionFunc) (*ListReferralWebsiteJobPostIterator, error) {
	return &ListReferralWebsiteJobPostIterator{
		ctx:      ctx,
		req:      req,
		listFunc: r.List,
		options:  options,
		limit:    req.Limit}, nil
}

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

// List 获取简历来源列表
//
// - 获取简历来源列表
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/resume_source/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_resumeSource.go
func (r *resumeSource) List(ctx context.Context, req *ListResumeSourceReq, options ...larkcore.RequestOptionFunc) (*ListResumeSourceResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/resume_sources"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, r.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListResumeSourceResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, r.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (r *resumeSource) ListByIterator(ctx context.Context, req *ListResumeSourceReq, options ...larkcore.RequestOptionFunc) (*ListResumeSourceIterator, error) {
	return &ListResumeSourceIterator{
		ctx:      ctx,
		req:      req,
		listFunc: r.List,
		options:  options,
		limit:    req.Limit}, nil
}

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

// List 获取角色列表
//
// - 获取角色列表
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/role/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_role.go
func (r *role) List(ctx context.Context, req *ListRoleReq, options ...larkcore.RequestOptionFunc) (*ListRoleResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/roles"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, r.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListRoleResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, r.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (r *role) ListByIterator(ctx context.Context, req *ListRoleReq, options ...larkcore.RequestOptionFunc) (*ListRoleIterator, error) {
	return &ListRoleIterator{
		ctx:      ctx,
		req:      req,
		listFunc: r.List,
		options:  options,
		limit:    req.Limit}, nil
}

// List 获取项目列表
//
// - 获取项目列表（概念上一批集体启动和管理的职位可以定义为一个项目，例如 「2012 秋招项目」）
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/subject/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_subject.go
func (s *subject) List(ctx context.Context, req *ListSubjectReq, options ...larkcore.RequestOptionFunc) (*ListSubjectResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/subjects"
	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 := &ListSubjectResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, s.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// AddToFolder 将人才加入指定文件夹
//
// - 将人才加入指定文件夹
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/talent/add_to_folder
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/addToFolder_talent.go
func (t *talent) AddToFolder(ctx context.Context, req *AddToFolderTalentReq, options ...larkcore.RequestOptionFunc) (*AddToFolderTalentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/talents/add_to_folder"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &AddToFolderTalentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchGetId 通过人才信息获取人才 ID
//
// - 通过人才信息获取人才 ID
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/talent/batch_get_id
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/batchGetId_talent.go
func (t *talent) BatchGetId(ctx context.Context, req *BatchGetIdTalentReq, options ...larkcore.RequestOptionFunc) (*BatchGetIdTalentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/talents/batch_get_id"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchGetIdTalentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// CombinedCreate 创建人才
//
// - 用于在企业内创建一个人才。姓名为系统预设的必填字段，邮箱/电话字段请在飞书招聘标准简历模板设置中确认是否必填。可配合[获取人才字段](https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/talent_object/query)接口获取自定义字段信息。
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/talent/combined_create
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/combinedCreate_talent.go
func (t *talent) CombinedCreate(ctx context.Context, req *CombinedCreateTalentReq, options ...larkcore.RequestOptionFunc) (*CombinedCreateTalentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/talents/combined_create"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CombinedCreateTalentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// CombinedUpdate 更新人才信息
//
// - 用于在企业内更新一个人才。姓名为系统预设的必填字段，邮箱/电话字段请在飞书招聘标准简历模板设置中确认是否必填。可配合[获取人才字段](https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/talent_object/query)接口获取自定义字段信息。
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/talent/combined_update
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/combinedUpdate_talent.go
func (t *talent) CombinedUpdate(ctx context.Context, req *CombinedUpdateTalentReq, options ...larkcore.RequestOptionFunc) (*CombinedUpdateTalentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/talents/combined_update"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CombinedUpdateTalentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Get 获取人才信息
//
// - 根据人才 ID 获取人才信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/talent/get
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/get_talent.go
func (t *talent) Get(ctx context.Context, req *GetTalentReq, options ...larkcore.RequestOptionFunc) (*GetTalentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/talents/:talent_id"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &GetTalentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List 获取人才列表
//
// - 根据更新时间获取人才列表，仅支持获取默认字段信息，获取详细信息可调用「获取人才详细」接口
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/talent/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_talent.go
func (t *talent) List(ctx context.Context, req *ListTalentReq, options ...larkcore.RequestOptionFunc) (*ListTalentResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/talents"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListTalentResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

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

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

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

// Create 创建人才外部信息
//
// - 创建人才外部信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/talent-external_info/create
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_talentExternalInfo.go
func (t *talentExternalInfo) Create(ctx context.Context, req *CreateTalentExternalInfoReq, options ...larkcore.RequestOptionFunc) (*CreateTalentExternalInfoResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/talents/:talent_id/external_info"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CreateTalentExternalInfoResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Update 更新人才外部信息
//
// - 更新人才外部信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/talent-external_info/update
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/update_talentExternalInfo.go
func (t *talentExternalInfo) Update(ctx context.Context, req *UpdateTalentExternalInfoReq, options ...larkcore.RequestOptionFunc) (*UpdateTalentExternalInfoResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/talents/:talent_id/external_info"
	apiReq.HttpMethod = http.MethodPut
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &UpdateTalentExternalInfoResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

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

// List 获取人才文件夹信息
//
// - 用于获取招聘系统中人才文件夹信息
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/talent_folder/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_talentFolder.go
func (t *talentFolder) List(ctx context.Context, req *ListTalentFolderReq, options ...larkcore.RequestOptionFunc) (*ListTalentFolderResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/talent_folders"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListTalentFolderResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (t *talentFolder) ListByIterator(ctx context.Context, req *ListTalentFolderReq, options ...larkcore.RequestOptionFunc) (*ListTalentFolderIterator, error) {
	return &ListTalentFolderIterator{
		ctx:      ctx,
		req:      req,
		listFunc: t.List,
		options:  options,
		limit:    req.Limit}, nil
}

// Query 获取人才字段
//
// - 获取人才字段
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/talent_object/query
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/query_talentObject.go
func (t *talentObject) Query(ctx context.Context, options ...larkcore.RequestOptionFunc) (*QueryTalentObjectResp, error) {
	// 发起请求
	apiReq := &larkcore.ApiReq{
		PathParams:  larkcore.PathParams{},
		QueryParams: larkcore.QueryParams{},
	}
	apiReq.ApiPath = "/open-apis/hire/v1/talent_objects/query"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &QueryTalentObjectResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Search 查询操作人对人才的操作记录
//
// - 查询操作人对人才的操作记录
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/talent/talent_operation_log/search
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/search_talentOperationLog.go
func (t *talentOperationLog) Search(ctx context.Context, req *SearchTalentOperationLogReq, options ...larkcore.RequestOptionFunc) (*SearchTalentOperationLogResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/talent_operation_logs/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchTalentOperationLogResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// BatchChangeTalentPool
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=batch_change_talent_pool&project=hire&resource=talent_pool&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/batchChangeTalentPool_talentPool.go
func (t *talentPool) BatchChangeTalentPool(ctx context.Context, req *BatchChangeTalentPoolTalentPoolReq, options ...larkcore.RequestOptionFunc) (*BatchChangeTalentPoolTalentPoolResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/talent_pools/:talent_pool_id/batch_change_talent_pool"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &BatchChangeTalentPoolTalentPoolResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// MoveTalent
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=move_talent&project=hire&resource=talent_pool&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/moveTalent_talentPool.go
func (t *talentPool) MoveTalent(ctx context.Context, req *MoveTalentTalentPoolReq, options ...larkcore.RequestOptionFunc) (*MoveTalentTalentPoolResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/talent_pools/:talent_pool_id/talent_relationship"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &MoveTalentTalentPoolResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.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=hire&resource=talent_pool&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/search_talentPool.go
func (t *talentPool) Search(ctx context.Context, req *SearchTalentPoolReq, options ...larkcore.RequestOptionFunc) (*SearchTalentPoolResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/talent_pools"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchTalentPoolResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (t *talentPool) SearchByIterator(ctx context.Context, req *SearchTalentPoolReq, options ...larkcore.RequestOptionFunc) (*SearchTalentPoolIterator, error) {
	return &SearchTalentPoolIterator{
		ctx:      ctx,
		req:      req,
		listFunc: t.Search,
		options:  options,
		limit:    req.Limit}, nil
}

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

// List 获取终止投递原因
//
// - 获取终止投递原因
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/termination_reason/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_terminationReason.go
func (t *terminationReason) List(ctx context.Context, req *ListTerminationReasonReq, options ...larkcore.RequestOptionFunc) (*ListTerminationReasonResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/termination_reasons"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListTerminationReasonResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (t *terminationReason) ListByIterator(ctx context.Context, req *ListTerminationReasonReq, options ...larkcore.RequestOptionFunc) (*ListTerminationReasonIterator, error) {
	return &ListTerminationReasonIterator{
		ctx:      ctx,
		req:      req,
		listFunc: t.List,
		options:  options,
		limit:    req.Limit}, nil
}

// Search 获取笔试列表
//
// - 批量获取人才在某投递流程中的笔试信息，如作答状态、笔试得分等。（目前仅支持获取 1w 条数据，若数据量较大，可通过控制 test_start_time 查询条件分批次获取全量数据）
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/test/search
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/search_test.go
func (t *test) Search(ctx context.Context, req *SearchTestReq, options ...larkcore.RequestOptionFunc) (*SearchTestResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/tests/search"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &SearchTestResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (t *test) SearchByIterator(ctx context.Context, req *SearchTestReq, options ...larkcore.RequestOptionFunc) (*SearchTestIterator, error) {
	return &SearchTestIterator{
		ctx:      ctx,
		req:      req,
		listFunc: t.Search,
		options:  options,
		limit:    req.Limit}, nil
}

// List 获取待办列表
//
// - 获取待办列表
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/todo/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_todo.go
func (t *todo) List(ctx context.Context, req *ListTodoReq, options ...larkcore.RequestOptionFunc) (*ListTodoResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/todos"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeUser}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListTodoResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (t *todo) ListByIterator(ctx context.Context, req *ListTodoReq, options ...larkcore.RequestOptionFunc) (*ListTodoIterator, error) {
	return &ListTodoIterator{
		ctx:      ctx,
		req:      req,
		listFunc: t.List,
		options:  options,
		limit:    req.Limit}, nil
}

// Create
//
// -
//
// - 官网API文档链接:https://open.feishu.cn/api-explorer?from=op_doc_tab&apiName=create&project=hire&resource=tripartite_agreement&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_tripartiteAgreement.go
func (t *tripartiteAgreement) Create(ctx context.Context, req *CreateTripartiteAgreementReq, options ...larkcore.RequestOptionFunc) (*CreateTripartiteAgreementResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/tripartite_agreements"
	apiReq.HttpMethod = http.MethodPost
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &CreateTripartiteAgreementResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.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=hire&resource=tripartite_agreement&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/delete_tripartiteAgreement.go
func (t *tripartiteAgreement) Delete(ctx context.Context, req *DeleteTripartiteAgreementReq, options ...larkcore.RequestOptionFunc) (*DeleteTripartiteAgreementResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/tripartite_agreements/:tripartite_agreement_id"
	apiReq.HttpMethod = http.MethodDelete
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &DeleteTripartiteAgreementResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.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=hire&resource=tripartite_agreement&version=v1
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_tripartiteAgreement.go
func (t *tripartiteAgreement) List(ctx context.Context, req *ListTripartiteAgreementReq, options ...larkcore.RequestOptionFunc) (*ListTripartiteAgreementResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/tripartite_agreements"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, t.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListTripartiteAgreementResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, t.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (t *tripartiteAgreement) ListByIterator(ctx context.Context, req *ListTripartiteAgreementReq, options ...larkcore.RequestOptionFunc) (*ListTripartiteAgreementIterator, error) {
	return &ListTripartiteAgreementIterator{
		ctx:      ctx,
		req:      req,
		listFunc: t.List,
		options:  options,
		limit:    req.Limit}, nil
}

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

// List 获取用户角色列表
//
// - 获取用户角色列表
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/user_role/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_userRole.go
func (u *userRole) List(ctx context.Context, req *ListUserRoleReq, options ...larkcore.RequestOptionFunc) (*ListUserRoleResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/user_roles"
	apiReq.HttpMethod = http.MethodGet
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, u.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &ListUserRoleResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, u.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (u *userRole) ListByIterator(ctx context.Context, req *ListUserRoleReq, options ...larkcore.RequestOptionFunc) (*ListUserRoleIterator, error) {
	return &ListUserRoleIterator{
		ctx:      ctx,
		req:      req,
		listFunc: u.List,
		options:  options,
		limit:    req.Limit}, nil
}

// List 获取自定义官网列表
//
// - 获取自定义官网列表
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/website/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_website.go
func (w *website) List(ctx context.Context, req *ListWebsiteReq, options ...larkcore.RequestOptionFunc) (*ListWebsiteResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/websites"
	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 := &ListWebsiteResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, w.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (w *website) ListByIterator(ctx context.Context, req *ListWebsiteReq, options ...larkcore.RequestOptionFunc) (*ListWebsiteIterator, error) {
	return &ListWebsiteIterator{
		ctx:      ctx,
		req:      req,
		listFunc: w.List,
		options:  options,
		limit:    req.Limit}, nil
}

// Create 创建官网推广渠道
//
// - 根据官网 ID 和推广渠道名称创建官网推广渠道
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/website-channel/create
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_websiteChannel.go
func (w *websiteChannel) Create(ctx context.Context, req *CreateWebsiteChannelReq, options ...larkcore.RequestOptionFunc) (*CreateWebsiteChannelResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/websites/:website_id/channels"
	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 := &CreateWebsiteChannelResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, w.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Delete 删除官网推广渠道
//
// - 根据官网 ID 和推广渠道 ID 删除官网推广渠道
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/website-channel/delete
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/delete_websiteChannel.go
func (w *websiteChannel) Delete(ctx context.Context, req *DeleteWebsiteChannelReq, options ...larkcore.RequestOptionFunc) (*DeleteWebsiteChannelResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/websites/:website_id/channels/:channel_id"
	apiReq.HttpMethod = http.MethodDelete
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, w.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &DeleteWebsiteChannelResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, w.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List 获取官网推广渠道列表
//
// - 根据官网 ID 分页获取推广渠道列表
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/website-channel/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_websiteChannel.go
func (w *websiteChannel) List(ctx context.Context, req *ListWebsiteChannelReq, options ...larkcore.RequestOptionFunc) (*ListWebsiteChannelResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/websites/:website_id/channels"
	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 := &ListWebsiteChannelResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, w.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Update 更新官网推广渠道
//
// - 根据官网 ID 和推广渠道 ID 更改推广渠道名称
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/website-channel/update
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/update_websiteChannel.go
func (w *websiteChannel) Update(ctx context.Context, req *UpdateWebsiteChannelReq, options ...larkcore.RequestOptionFunc) (*UpdateWebsiteChannelResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/websites/:website_id/channels/:channel_id"
	apiReq.HttpMethod = http.MethodPut
	apiReq.SupportedAccessTokenTypes = []larkcore.AccessTokenType{larkcore.AccessTokenTypeTenant}
	apiResp, err := larkcore.Request(ctx, apiReq, w.config, options...)
	if err != nil {
		return nil, err
	}
	// 反序列响应结果
	resp := &UpdateWebsiteChannelResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, w.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// CreateByAttachment 根据简历附件解析创建官网投递
//
// - 根据简历附件解析创建官网投递
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/website-delivery/create_by_attachment
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/createByAttachment_websiteDelivery.go
func (w *websiteDelivery) CreateByAttachment(ctx context.Context, req *CreateByAttachmentWebsiteDeliveryReq, options ...larkcore.RequestOptionFunc) (*CreateByAttachmentWebsiteDeliveryResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/websites/:website_id/deliveries/create_by_attachment"
	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 := &CreateByAttachmentWebsiteDeliveryResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, w.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// CreateByResume 创建官网投递
//
// - 创建官网投递。
//
// - 对于自定义字段，若字段类型为单行文本，传值格式为"这是一个单行文本"；若字段类型为多行文本，传值格式为"这是一个多行文本"；若字段类型为单选，传值内容为选项的 ID，格式为"1";若字段类型为多选，传值内容为选项的ID 列表，格式为"["2", "3" ]"；若字段类型为时间段，传值格式为"["1609430400000", "1612108800000" ]"，单位是毫米级时间戳，结束时间是「至今」时，用「"-1"」表示；若字段类型为年份选择，传值格式为"1609430400000"，单位是毫秒级时间戳；若字段类型为月份选择，传值格式为"1625068800000"，单位是毫秒级时间戳；若字段类型为数字，传值格式为"1"
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/website-delivery/create_by_resume
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/createByResume_websiteDelivery.go
func (w *websiteDelivery) CreateByResume(ctx context.Context, req *CreateByResumeWebsiteDeliveryReq, options ...larkcore.RequestOptionFunc) (*CreateByResumeWebsiteDeliveryResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/websites/:website_id/deliveries/create_by_resume"
	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 := &CreateByResumeWebsiteDeliveryResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, w.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Get 获取简历解析创建官网投递任务结果
//
// - 获取官网投递任务信息;，如果获取到的数据data为空，仍然继续轮询，直到data不为空时，再查询data里面的数据
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/website-delivery_task/get
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/get_websiteDeliveryTask.go
func (w *websiteDeliveryTask) Get(ctx context.Context, req *GetWebsiteDeliveryTaskReq, options ...larkcore.RequestOptionFunc) (*GetWebsiteDeliveryTaskResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/websites/:website_id/delivery_tasks/:delivery_task_id"
	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 := &GetWebsiteDeliveryTaskResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, w.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// Get 获取自定义官网下职位广告详情
//
// - 获取自定义官网下职位广告详情
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/website-job_post/get
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/get_websiteJobPost.go
func (w *websiteJobPost) Get(ctx context.Context, req *GetWebsiteJobPostReq, options ...larkcore.RequestOptionFunc) (*GetWebsiteJobPostResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/websites/:website_id/job_posts/:job_post_id"
	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 := &GetWebsiteJobPostResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, w.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}

// List 获取自定义官网下的职位列表
//
// - 获取自定义官网下的职位列表。自定义数据暂不支持列表获取，请从「获取自定义官网下职位广告详情」接口获取。
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/website-job_post/list
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/list_websiteJobPost.go
func (w *websiteJobPost) List(ctx context.Context, req *ListWebsiteJobPostReq, options ...larkcore.RequestOptionFunc) (*ListWebsiteJobPostResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/websites/:website_id/job_posts"
	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 := &ListWebsiteJobPostResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, w.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (w *websiteJobPost) ListByIterator(ctx context.Context, req *ListWebsiteJobPostReq, options ...larkcore.RequestOptionFunc) (*ListWebsiteJobPostIterator, error) {
	return &ListWebsiteJobPostIterator{
		ctx:      ctx,
		req:      req,
		listFunc: w.List,
		options:  options,
		limit:    req.Limit}, nil
}

// Search 搜索自定义官网下的职位列表
//
// - 搜索自定义官网下的职位列表
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/website-job_post/search
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/search_websiteJobPost.go
func (w *websiteJobPost) Search(ctx context.Context, req *SearchWebsiteJobPostReq, options ...larkcore.RequestOptionFunc) (*SearchWebsiteJobPostResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/websites/:website_id/job_posts/search"
	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 := &SearchWebsiteJobPostResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, w.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
func (w *websiteJobPost) SearchByIterator(ctx context.Context, req *SearchWebsiteJobPostReq, options ...larkcore.RequestOptionFunc) (*SearchWebsiteJobPostIterator, error) {
	return &SearchWebsiteJobPostIterator{
		ctx:      ctx,
		req:      req,
		listFunc: w.Search,
		options:  options,
		limit:    req.Limit}, nil
}

// Create 创建官网用户
//
// - 创建官网用户
//
// - 官网API文档链接:https://open.feishu.cn/document/ukTMukTMukTM/uMzM1YjLzMTN24yMzUjN/hire-v1/website-site_user/create
//
// - 使用Demo链接:https://github.com/larksuite/oapi-sdk-go/tree/v3_main/sample/apiall/hirev1/create_websiteSiteUser.go
func (w *websiteSiteUser) Create(ctx context.Context, req *CreateWebsiteSiteUserReq, options ...larkcore.RequestOptionFunc) (*CreateWebsiteSiteUserResp, error) {
	// 发起请求
	apiReq := req.apiReq
	apiReq.ApiPath = "/open-apis/hire/v1/websites/:website_id/site_users"
	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 := &CreateWebsiteSiteUserResp{ApiResp: apiResp}
	err = apiResp.JSONUnmarshalBody(resp, w.config)
	if err != nil {
		return nil, err
	}
	return resp, err
}
