// Package corehr code generated by oapi sdk gen
/*
 * MIT License
 *
 * Copyright (c) 2022 Lark Technologies Pte. Ltd.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice, shall be included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

package larkcorehr

import (
	"context"
)

// 消息处理器定义
type P2ApprovalGroupsUpdatedV2Handler struct {
	handler func(context.Context, *P2ApprovalGroupsUpdatedV2) error
}

func NewP2ApprovalGroupsUpdatedV2Handler(handler func(context.Context, *P2ApprovalGroupsUpdatedV2) error) *P2ApprovalGroupsUpdatedV2Handler {
	h := &P2ApprovalGroupsUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2ApprovalGroupsUpdatedV2Handler) Event() interface{} {
	return &P2ApprovalGroupsUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2ApprovalGroupsUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2ApprovalGroupsUpdatedV2))
}

// 消息处理器定义
type P2CompanyCreatedV2Handler struct {
	handler func(context.Context, *P2CompanyCreatedV2) error
}

func NewP2CompanyCreatedV2Handler(handler func(context.Context, *P2CompanyCreatedV2) error) *P2CompanyCreatedV2Handler {
	h := &P2CompanyCreatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2CompanyCreatedV2Handler) Event() interface{} {
	return &P2CompanyCreatedV2{}
}

// 回调开发者注册的handle
func (h *P2CompanyCreatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2CompanyCreatedV2))
}

// 消息处理器定义
type P2CompanyDeletedV2Handler struct {
	handler func(context.Context, *P2CompanyDeletedV2) error
}

func NewP2CompanyDeletedV2Handler(handler func(context.Context, *P2CompanyDeletedV2) error) *P2CompanyDeletedV2Handler {
	h := &P2CompanyDeletedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2CompanyDeletedV2Handler) Event() interface{} {
	return &P2CompanyDeletedV2{}
}

// 回调开发者注册的handle
func (h *P2CompanyDeletedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2CompanyDeletedV2))
}

// 消息处理器定义
type P2CompanyUpdatedV2Handler struct {
	handler func(context.Context, *P2CompanyUpdatedV2) error
}

func NewP2CompanyUpdatedV2Handler(handler func(context.Context, *P2CompanyUpdatedV2) error) *P2CompanyUpdatedV2Handler {
	h := &P2CompanyUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2CompanyUpdatedV2Handler) Event() interface{} {
	return &P2CompanyUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2CompanyUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2CompanyUpdatedV2))
}

// 消息处理器定义
type P2CostCenterCreatedV2Handler struct {
	handler func(context.Context, *P2CostCenterCreatedV2) error
}

func NewP2CostCenterCreatedV2Handler(handler func(context.Context, *P2CostCenterCreatedV2) error) *P2CostCenterCreatedV2Handler {
	h := &P2CostCenterCreatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2CostCenterCreatedV2Handler) Event() interface{} {
	return &P2CostCenterCreatedV2{}
}

// 回调开发者注册的handle
func (h *P2CostCenterCreatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2CostCenterCreatedV2))
}

// 消息处理器定义
type P2CostCenterDeletedV2Handler struct {
	handler func(context.Context, *P2CostCenterDeletedV2) error
}

func NewP2CostCenterDeletedV2Handler(handler func(context.Context, *P2CostCenterDeletedV2) error) *P2CostCenterDeletedV2Handler {
	h := &P2CostCenterDeletedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2CostCenterDeletedV2Handler) Event() interface{} {
	return &P2CostCenterDeletedV2{}
}

// 回调开发者注册的handle
func (h *P2CostCenterDeletedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2CostCenterDeletedV2))
}

// 消息处理器定义
type P2CostCenterUpdatedV2Handler struct {
	handler func(context.Context, *P2CostCenterUpdatedV2) error
}

func NewP2CostCenterUpdatedV2Handler(handler func(context.Context, *P2CostCenterUpdatedV2) error) *P2CostCenterUpdatedV2Handler {
	h := &P2CostCenterUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2CostCenterUpdatedV2Handler) Event() interface{} {
	return &P2CostCenterUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2CostCenterUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2CostCenterUpdatedV2))
}

// 消息处理器定义
type P2CustomOrgCreatedV2Handler struct {
	handler func(context.Context, *P2CustomOrgCreatedV2) error
}

func NewP2CustomOrgCreatedV2Handler(handler func(context.Context, *P2CustomOrgCreatedV2) error) *P2CustomOrgCreatedV2Handler {
	h := &P2CustomOrgCreatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2CustomOrgCreatedV2Handler) Event() interface{} {
	return &P2CustomOrgCreatedV2{}
}

// 回调开发者注册的handle
func (h *P2CustomOrgCreatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2CustomOrgCreatedV2))
}

// 消息处理器定义
type P2CustomOrgDeletedV2Handler struct {
	handler func(context.Context, *P2CustomOrgDeletedV2) error
}

func NewP2CustomOrgDeletedV2Handler(handler func(context.Context, *P2CustomOrgDeletedV2) error) *P2CustomOrgDeletedV2Handler {
	h := &P2CustomOrgDeletedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2CustomOrgDeletedV2Handler) Event() interface{} {
	return &P2CustomOrgDeletedV2{}
}

// 回调开发者注册的handle
func (h *P2CustomOrgDeletedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2CustomOrgDeletedV2))
}

// 消息处理器定义
type P2CustomOrgUpdatedV2Handler struct {
	handler func(context.Context, *P2CustomOrgUpdatedV2) error
}

func NewP2CustomOrgUpdatedV2Handler(handler func(context.Context, *P2CustomOrgUpdatedV2) error) *P2CustomOrgUpdatedV2Handler {
	h := &P2CustomOrgUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2CustomOrgUpdatedV2Handler) Event() interface{} {
	return &P2CustomOrgUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2CustomOrgUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2CustomOrgUpdatedV2))
}

// 消息处理器定义
type P2DepartmentCreatedV2Handler struct {
	handler func(context.Context, *P2DepartmentCreatedV2) error
}

func NewP2DepartmentCreatedV2Handler(handler func(context.Context, *P2DepartmentCreatedV2) error) *P2DepartmentCreatedV2Handler {
	h := &P2DepartmentCreatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2DepartmentCreatedV2Handler) Event() interface{} {
	return &P2DepartmentCreatedV2{}
}

// 回调开发者注册的handle
func (h *P2DepartmentCreatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2DepartmentCreatedV2))
}

// 消息处理器定义
type P2DepartmentUpdatedV2Handler struct {
	handler func(context.Context, *P2DepartmentUpdatedV2) error
}

func NewP2DepartmentUpdatedV2Handler(handler func(context.Context, *P2DepartmentUpdatedV2) error) *P2DepartmentUpdatedV2Handler {
	h := &P2DepartmentUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2DepartmentUpdatedV2Handler) Event() interface{} {
	return &P2DepartmentUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2DepartmentUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2DepartmentUpdatedV2))
}

// 消息处理器定义
type P2EmployeeDomainEventV2Handler struct {
	handler func(context.Context, *P2EmployeeDomainEventV2) error
}

func NewP2EmployeeDomainEventV2Handler(handler func(context.Context, *P2EmployeeDomainEventV2) error) *P2EmployeeDomainEventV2Handler {
	h := &P2EmployeeDomainEventV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2EmployeeDomainEventV2Handler) Event() interface{} {
	return &P2EmployeeDomainEventV2{}
}

// 回调开发者注册的handle
func (h *P2EmployeeDomainEventV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2EmployeeDomainEventV2))
}

// 消息处理器定义
type P2JobChangeStatusUpdatedV2Handler struct {
	handler func(context.Context, *P2JobChangeStatusUpdatedV2) error
}

func NewP2JobChangeStatusUpdatedV2Handler(handler func(context.Context, *P2JobChangeStatusUpdatedV2) error) *P2JobChangeStatusUpdatedV2Handler {
	h := &P2JobChangeStatusUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2JobChangeStatusUpdatedV2Handler) Event() interface{} {
	return &P2JobChangeStatusUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2JobChangeStatusUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2JobChangeStatusUpdatedV2))
}

// 消息处理器定义
type P2JobChangeUpdatedV2Handler struct {
	handler func(context.Context, *P2JobChangeUpdatedV2) error
}

func NewP2JobChangeUpdatedV2Handler(handler func(context.Context, *P2JobChangeUpdatedV2) error) *P2JobChangeUpdatedV2Handler {
	h := &P2JobChangeUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2JobChangeUpdatedV2Handler) Event() interface{} {
	return &P2JobChangeUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2JobChangeUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2JobChangeUpdatedV2))
}

// 消息处理器定义
type P2JobFamilyCreatedV2Handler struct {
	handler func(context.Context, *P2JobFamilyCreatedV2) error
}

func NewP2JobFamilyCreatedV2Handler(handler func(context.Context, *P2JobFamilyCreatedV2) error) *P2JobFamilyCreatedV2Handler {
	h := &P2JobFamilyCreatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2JobFamilyCreatedV2Handler) Event() interface{} {
	return &P2JobFamilyCreatedV2{}
}

// 回调开发者注册的handle
func (h *P2JobFamilyCreatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2JobFamilyCreatedV2))
}

// 消息处理器定义
type P2JobFamilyDeletedV2Handler struct {
	handler func(context.Context, *P2JobFamilyDeletedV2) error
}

func NewP2JobFamilyDeletedV2Handler(handler func(context.Context, *P2JobFamilyDeletedV2) error) *P2JobFamilyDeletedV2Handler {
	h := &P2JobFamilyDeletedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2JobFamilyDeletedV2Handler) Event() interface{} {
	return &P2JobFamilyDeletedV2{}
}

// 回调开发者注册的handle
func (h *P2JobFamilyDeletedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2JobFamilyDeletedV2))
}

// 消息处理器定义
type P2JobFamilyUpdatedV2Handler struct {
	handler func(context.Context, *P2JobFamilyUpdatedV2) error
}

func NewP2JobFamilyUpdatedV2Handler(handler func(context.Context, *P2JobFamilyUpdatedV2) error) *P2JobFamilyUpdatedV2Handler {
	h := &P2JobFamilyUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2JobFamilyUpdatedV2Handler) Event() interface{} {
	return &P2JobFamilyUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2JobFamilyUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2JobFamilyUpdatedV2))
}

// 消息处理器定义
type P2JobGradeCreatedV2Handler struct {
	handler func(context.Context, *P2JobGradeCreatedV2) error
}

func NewP2JobGradeCreatedV2Handler(handler func(context.Context, *P2JobGradeCreatedV2) error) *P2JobGradeCreatedV2Handler {
	h := &P2JobGradeCreatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2JobGradeCreatedV2Handler) Event() interface{} {
	return &P2JobGradeCreatedV2{}
}

// 回调开发者注册的handle
func (h *P2JobGradeCreatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2JobGradeCreatedV2))
}

// 消息处理器定义
type P2JobGradeDeletedV2Handler struct {
	handler func(context.Context, *P2JobGradeDeletedV2) error
}

func NewP2JobGradeDeletedV2Handler(handler func(context.Context, *P2JobGradeDeletedV2) error) *P2JobGradeDeletedV2Handler {
	h := &P2JobGradeDeletedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2JobGradeDeletedV2Handler) Event() interface{} {
	return &P2JobGradeDeletedV2{}
}

// 回调开发者注册的handle
func (h *P2JobGradeDeletedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2JobGradeDeletedV2))
}

// 消息处理器定义
type P2JobGradeUpdatedV2Handler struct {
	handler func(context.Context, *P2JobGradeUpdatedV2) error
}

func NewP2JobGradeUpdatedV2Handler(handler func(context.Context, *P2JobGradeUpdatedV2) error) *P2JobGradeUpdatedV2Handler {
	h := &P2JobGradeUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2JobGradeUpdatedV2Handler) Event() interface{} {
	return &P2JobGradeUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2JobGradeUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2JobGradeUpdatedV2))
}

// 消息处理器定义
type P2JobLevelCreatedV2Handler struct {
	handler func(context.Context, *P2JobLevelCreatedV2) error
}

func NewP2JobLevelCreatedV2Handler(handler func(context.Context, *P2JobLevelCreatedV2) error) *P2JobLevelCreatedV2Handler {
	h := &P2JobLevelCreatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2JobLevelCreatedV2Handler) Event() interface{} {
	return &P2JobLevelCreatedV2{}
}

// 回调开发者注册的handle
func (h *P2JobLevelCreatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2JobLevelCreatedV2))
}

// 消息处理器定义
type P2JobLevelDeletedV2Handler struct {
	handler func(context.Context, *P2JobLevelDeletedV2) error
}

func NewP2JobLevelDeletedV2Handler(handler func(context.Context, *P2JobLevelDeletedV2) error) *P2JobLevelDeletedV2Handler {
	h := &P2JobLevelDeletedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2JobLevelDeletedV2Handler) Event() interface{} {
	return &P2JobLevelDeletedV2{}
}

// 回调开发者注册的handle
func (h *P2JobLevelDeletedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2JobLevelDeletedV2))
}

// 消息处理器定义
type P2JobLevelUpdatedV2Handler struct {
	handler func(context.Context, *P2JobLevelUpdatedV2) error
}

func NewP2JobLevelUpdatedV2Handler(handler func(context.Context, *P2JobLevelUpdatedV2) error) *P2JobLevelUpdatedV2Handler {
	h := &P2JobLevelUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2JobLevelUpdatedV2Handler) Event() interface{} {
	return &P2JobLevelUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2JobLevelUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2JobLevelUpdatedV2))
}

// 消息处理器定义
type P2LocationCreatedV2Handler struct {
	handler func(context.Context, *P2LocationCreatedV2) error
}

func NewP2LocationCreatedV2Handler(handler func(context.Context, *P2LocationCreatedV2) error) *P2LocationCreatedV2Handler {
	h := &P2LocationCreatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2LocationCreatedV2Handler) Event() interface{} {
	return &P2LocationCreatedV2{}
}

// 回调开发者注册的handle
func (h *P2LocationCreatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2LocationCreatedV2))
}

// 消息处理器定义
type P2LocationDeletedV2Handler struct {
	handler func(context.Context, *P2LocationDeletedV2) error
}

func NewP2LocationDeletedV2Handler(handler func(context.Context, *P2LocationDeletedV2) error) *P2LocationDeletedV2Handler {
	h := &P2LocationDeletedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2LocationDeletedV2Handler) Event() interface{} {
	return &P2LocationDeletedV2{}
}

// 回调开发者注册的handle
func (h *P2LocationDeletedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2LocationDeletedV2))
}

// 消息处理器定义
type P2LocationUpdatedV2Handler struct {
	handler func(context.Context, *P2LocationUpdatedV2) error
}

func NewP2LocationUpdatedV2Handler(handler func(context.Context, *P2LocationUpdatedV2) error) *P2LocationUpdatedV2Handler {
	h := &P2LocationUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2LocationUpdatedV2Handler) Event() interface{} {
	return &P2LocationUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2LocationUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2LocationUpdatedV2))
}

// 消息处理器定义
type P2OffboardingChecklistUpdatedV2Handler struct {
	handler func(context.Context, *P2OffboardingChecklistUpdatedV2) error
}

func NewP2OffboardingChecklistUpdatedV2Handler(handler func(context.Context, *P2OffboardingChecklistUpdatedV2) error) *P2OffboardingChecklistUpdatedV2Handler {
	h := &P2OffboardingChecklistUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2OffboardingChecklistUpdatedV2Handler) Event() interface{} {
	return &P2OffboardingChecklistUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2OffboardingChecklistUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2OffboardingChecklistUpdatedV2))
}

// 消息处理器定义
type P2OffboardingStatusUpdatedV2Handler struct {
	handler func(context.Context, *P2OffboardingStatusUpdatedV2) error
}

func NewP2OffboardingStatusUpdatedV2Handler(handler func(context.Context, *P2OffboardingStatusUpdatedV2) error) *P2OffboardingStatusUpdatedV2Handler {
	h := &P2OffboardingStatusUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2OffboardingStatusUpdatedV2Handler) Event() interface{} {
	return &P2OffboardingStatusUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2OffboardingStatusUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2OffboardingStatusUpdatedV2))
}

// 消息处理器定义
type P2OffboardingUpdatedV2Handler struct {
	handler func(context.Context, *P2OffboardingUpdatedV2) error
}

func NewP2OffboardingUpdatedV2Handler(handler func(context.Context, *P2OffboardingUpdatedV2) error) *P2OffboardingUpdatedV2Handler {
	h := &P2OffboardingUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2OffboardingUpdatedV2Handler) Event() interface{} {
	return &P2OffboardingUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2OffboardingUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2OffboardingUpdatedV2))
}

// 消息处理器定义
type P2PathwayCreatedV2Handler struct {
	handler func(context.Context, *P2PathwayCreatedV2) error
}

func NewP2PathwayCreatedV2Handler(handler func(context.Context, *P2PathwayCreatedV2) error) *P2PathwayCreatedV2Handler {
	h := &P2PathwayCreatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2PathwayCreatedV2Handler) Event() interface{} {
	return &P2PathwayCreatedV2{}
}

// 回调开发者注册的handle
func (h *P2PathwayCreatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2PathwayCreatedV2))
}

// 消息处理器定义
type P2PathwayDeletedV2Handler struct {
	handler func(context.Context, *P2PathwayDeletedV2) error
}

func NewP2PathwayDeletedV2Handler(handler func(context.Context, *P2PathwayDeletedV2) error) *P2PathwayDeletedV2Handler {
	h := &P2PathwayDeletedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2PathwayDeletedV2Handler) Event() interface{} {
	return &P2PathwayDeletedV2{}
}

// 回调开发者注册的handle
func (h *P2PathwayDeletedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2PathwayDeletedV2))
}

// 消息处理器定义
type P2PathwayUpdatedV2Handler struct {
	handler func(context.Context, *P2PathwayUpdatedV2) error
}

func NewP2PathwayUpdatedV2Handler(handler func(context.Context, *P2PathwayUpdatedV2) error) *P2PathwayUpdatedV2Handler {
	h := &P2PathwayUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2PathwayUpdatedV2Handler) Event() interface{} {
	return &P2PathwayUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2PathwayUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2PathwayUpdatedV2))
}

// 消息处理器定义
type P2PositionCreatedV2Handler struct {
	handler func(context.Context, *P2PositionCreatedV2) error
}

func NewP2PositionCreatedV2Handler(handler func(context.Context, *P2PositionCreatedV2) error) *P2PositionCreatedV2Handler {
	h := &P2PositionCreatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2PositionCreatedV2Handler) Event() interface{} {
	return &P2PositionCreatedV2{}
}

// 回调开发者注册的handle
func (h *P2PositionCreatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2PositionCreatedV2))
}

// 消息处理器定义
type P2PositionDeletedV2Handler struct {
	handler func(context.Context, *P2PositionDeletedV2) error
}

func NewP2PositionDeletedV2Handler(handler func(context.Context, *P2PositionDeletedV2) error) *P2PositionDeletedV2Handler {
	h := &P2PositionDeletedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2PositionDeletedV2Handler) Event() interface{} {
	return &P2PositionDeletedV2{}
}

// 回调开发者注册的handle
func (h *P2PositionDeletedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2PositionDeletedV2))
}

// 消息处理器定义
type P2PositionUpdatedV2Handler struct {
	handler func(context.Context, *P2PositionUpdatedV2) error
}

func NewP2PositionUpdatedV2Handler(handler func(context.Context, *P2PositionUpdatedV2) error) *P2PositionUpdatedV2Handler {
	h := &P2PositionUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2PositionUpdatedV2Handler) Event() interface{} {
	return &P2PositionUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2PositionUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2PositionUpdatedV2))
}

// 消息处理器定义
type P2PreHireOnboardingTaskChangedV2Handler struct {
	handler func(context.Context, *P2PreHireOnboardingTaskChangedV2) error
}

func NewP2PreHireOnboardingTaskChangedV2Handler(handler func(context.Context, *P2PreHireOnboardingTaskChangedV2) error) *P2PreHireOnboardingTaskChangedV2Handler {
	h := &P2PreHireOnboardingTaskChangedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2PreHireOnboardingTaskChangedV2Handler) Event() interface{} {
	return &P2PreHireOnboardingTaskChangedV2{}
}

// 回调开发者注册的handle
func (h *P2PreHireOnboardingTaskChangedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2PreHireOnboardingTaskChangedV2))
}

// 消息处理器定义
type P2ProbationUpdatedV2Handler struct {
	handler func(context.Context, *P2ProbationUpdatedV2) error
}

func NewP2ProbationUpdatedV2Handler(handler func(context.Context, *P2ProbationUpdatedV2) error) *P2ProbationUpdatedV2Handler {
	h := &P2ProbationUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2ProbationUpdatedV2Handler) Event() interface{} {
	return &P2ProbationUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2ProbationUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2ProbationUpdatedV2))
}

// 消息处理器定义
type P2ProcessUpdatedV2Handler struct {
	handler func(context.Context, *P2ProcessUpdatedV2) error
}

func NewP2ProcessUpdatedV2Handler(handler func(context.Context, *P2ProcessUpdatedV2) error) *P2ProcessUpdatedV2Handler {
	h := &P2ProcessUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2ProcessUpdatedV2Handler) Event() interface{} {
	return &P2ProcessUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2ProcessUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2ProcessUpdatedV2))
}

// 消息处理器定义
type P2ProcessApproverUpdatedV2Handler struct {
	handler func(context.Context, *P2ProcessApproverUpdatedV2) error
}

func NewP2ProcessApproverUpdatedV2Handler(handler func(context.Context, *P2ProcessApproverUpdatedV2) error) *P2ProcessApproverUpdatedV2Handler {
	h := &P2ProcessApproverUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2ProcessApproverUpdatedV2Handler) Event() interface{} {
	return &P2ProcessApproverUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2ProcessApproverUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2ProcessApproverUpdatedV2))
}

// 消息处理器定义
type P2ProcessCcUpdatedV2Handler struct {
	handler func(context.Context, *P2ProcessCcUpdatedV2) error
}

func NewP2ProcessCcUpdatedV2Handler(handler func(context.Context, *P2ProcessCcUpdatedV2) error) *P2ProcessCcUpdatedV2Handler {
	h := &P2ProcessCcUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2ProcessCcUpdatedV2Handler) Event() interface{} {
	return &P2ProcessCcUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2ProcessCcUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2ProcessCcUpdatedV2))
}

// 消息处理器定义
type P2ProcessNodeUpdatedV2Handler struct {
	handler func(context.Context, *P2ProcessNodeUpdatedV2) error
}

func NewP2ProcessNodeUpdatedV2Handler(handler func(context.Context, *P2ProcessNodeUpdatedV2) error) *P2ProcessNodeUpdatedV2Handler {
	h := &P2ProcessNodeUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2ProcessNodeUpdatedV2Handler) Event() interface{} {
	return &P2ProcessNodeUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2ProcessNodeUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2ProcessNodeUpdatedV2))
}

// 消息处理器定义
type P2ProcessStatusUpdateV2Handler struct {
	handler func(context.Context, *P2ProcessStatusUpdateV2) error
}

func NewP2ProcessStatusUpdateV2Handler(handler func(context.Context, *P2ProcessStatusUpdateV2) error) *P2ProcessStatusUpdateV2Handler {
	h := &P2ProcessStatusUpdateV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2ProcessStatusUpdateV2Handler) Event() interface{} {
	return &P2ProcessStatusUpdateV2{}
}

// 回调开发者注册的handle
func (h *P2ProcessStatusUpdateV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2ProcessStatusUpdateV2))
}

// 消息处理器定义
type P2ProcessCommentInfoUpdatedV2Handler struct {
	handler func(context.Context, *P2ProcessCommentInfoUpdatedV2) error
}

func NewP2ProcessCommentInfoUpdatedV2Handler(handler func(context.Context, *P2ProcessCommentInfoUpdatedV2) error) *P2ProcessCommentInfoUpdatedV2Handler {
	h := &P2ProcessCommentInfoUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2ProcessCommentInfoUpdatedV2Handler) Event() interface{} {
	return &P2ProcessCommentInfoUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2ProcessCommentInfoUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2ProcessCommentInfoUpdatedV2))
}

// 消息处理器定义
type P2SignatureFileStatusUpdatedV2Handler struct {
	handler func(context.Context, *P2SignatureFileStatusUpdatedV2) error
}

func NewP2SignatureFileStatusUpdatedV2Handler(handler func(context.Context, *P2SignatureFileStatusUpdatedV2) error) *P2SignatureFileStatusUpdatedV2Handler {
	h := &P2SignatureFileStatusUpdatedV2Handler{handler: handler}
	return h
}

// 返回事件的消息体的实例，用于反序列化用
func (h *P2SignatureFileStatusUpdatedV2Handler) Event() interface{} {
	return &P2SignatureFileStatusUpdatedV2{}
}

// 回调开发者注册的handle
func (h *P2SignatureFileStatusUpdatedV2Handler) Handle(ctx context.Context, event interface{}) error {
	return h.handler(ctx, event.(*P2SignatureFileStatusUpdatedV2))
}
