wechatpay-go/services/refunddomestic/models.go

// Copyright 2021 Tencent Inc. All rights reserved.
//
// 境内普通商户退款API
//
// 境内普通商户退款功能涉及的API文档
//
// API version: 1.1.1

// Code generated by WechatPay APIv3 Generator based on [OpenAPI Generator](https://openapi-generator.tech); DO NOT EDIT.

package refunddomestic

import (
	"encoding/json"
	"fmt"
)

// Account * `AVAILABLE` - 可用余额, 多账户资金准备退款可用余额出资账户类型 * `UNAVAILABLE` - 不可用余额, 多账户资金准备退款不可用余额出资账户类型
type Account string

func (e Account) Ptr() *Account {
	return &e
}

// Enums of Account
const (
	ACCOUNT_AVAILABLE   Account = "AVAILABLE"
	ACCOUNT_UNAVAILABLE Account = "UNAVAILABLE"
)

// Amount
type Amount struct {
	// 订单总金额，单位为分
	Total *int64 `json:"total"`
	// 退款标价金额，单位为分，可以做部分退款
	Refund *int64 `json:"refund"`

	// 退款出资的账户类型及金额信息
	From []FundsFromItem `json:"from,omitempty"`

	// 符合ISO 4217标准的三位字母代码，目前只支持人民币：CNY。
	Currency *string `json:"currency"`
}

func (o Amount) MarshalJSON() ([]byte, error) {
	toSerialize := map[string]interface{}{}

	if o.Total == nil {
		return nil, fmt.Errorf("field `Total` is required and must be specified in Amount")
	}
	toSerialize["total"] = o.Total

	if o.Refund == nil {
		return nil, fmt.Errorf("field `Refund` is required and must be specified in Amount")
	}
	toSerialize["refund"] = o.Refund

	if o.From != nil {
		toSerialize["from"] = o.From
	}



	if o.Currency == nil {
		return nil, fmt.Errorf("field `Currency` is required and must be specified in Amount")
	}
	toSerialize["currency"] = o.Currency
	return json.Marshal(toSerialize)
}

func (o Amount) String() string {
	var ret string
	if o.Total == nil {
		ret += "Total:<nil>, "
	} else {
		ret += fmt.Sprintf("Total:%v, ", *o.Total)
	}

	if o.Refund == nil {
		ret += "Refund:<nil>, "
	} else {
		ret += fmt.Sprintf("Refund:%v, ", *o.Refund)
	}

	ret += fmt.Sprintf("From:%v, ", o.From)

	if o.Currency == nil {
		ret += "Currency:<nil>"
	} else {
		ret += fmt.Sprintf("Currency:%v", *o.Currency)
	}

	return fmt.Sprintf("Amount{%s}", ret)
}

func (o Amount) Clone() *Amount {
	ret := Amount{}

	if o.Total != nil {
		ret.Total = new(int64)
		*ret.Total = *o.Total
	}

	if o.Refund != nil {
		ret.Refund = new(int64)
		*ret.Refund = *o.Refund
	}

	if o.From != nil {
		ret.From = make([]FundsFromItem, len(o.From))
		for i, item := range o.From {
			ret.From[i] = *item.Clone()
		}
	}


	if o.Currency != nil {
		ret.Currency = new(string)
		*ret.Currency = *o.Currency
	}

	return &ret
}

// AmountReq
type AmountReq struct {
	// 退款金额，币种的最小单位，只能为整数，不能超过原订单支付金额。
	Refund *int64 `json:"refund"`
	// 退款需要从指定账户出资时，传递此参数指定出资金额（币种的最小单位，只能为整数）。 同时指定多个账户出资退款的使用场景需要满足以下条件：1、未开通退款支出分离产品功能；2、订单属于分账订单，且分账处于待分账或分账中状态。 参数传递需要满足条件：1、基本账户可用余额出资金额与基本账户不可用余额出资金额之和等于退款金额；2、账户类型不能重复。 上述任一条件不满足将返回错误
	From []FundsFromItem `json:"from,omitempty"`
	// 原支付交易的订单总金额，币种的最小单位，只能为整数。
	Total *int64 `json:"total"`
	// 符合ISO 4217标准的三位字母代码，目前只支持人民币：CNY。
	Currency *string `json:"currency"`
}

func (o AmountReq) MarshalJSON() ([]byte, error) {
	toSerialize := map[string]interface{}{}

	if o.Refund == nil {
		return nil, fmt.Errorf("field `Refund` is required and must be specified in AmountReq")
	}
	toSerialize["refund"] = o.Refund

	if o.From != nil {
		toSerialize["from"] = o.From
	}

	if o.Total == nil {
		return nil, fmt.Errorf("field `Total` is required and must be specified in AmountReq")
	}
	toSerialize["total"] = o.Total

	if o.Currency == nil {
		return nil, fmt.Errorf("field `Currency` is required and must be specified in AmountReq")
	}
	toSerialize["currency"] = o.Currency
	return json.Marshal(toSerialize)
}

func (o AmountReq) String() string {
	var ret string
	if o.Refund == nil {
		ret += "Refund:<nil>, "
	} else {
		ret += fmt.Sprintf("Refund:%v, ", *o.Refund)
	}

	ret += fmt.Sprintf("From:%v, ", o.From)

	if o.Total == nil {
		ret += "Total:<nil>, "
	} else {
		ret += fmt.Sprintf("Total:%v, ", *o.Total)
	}

	if o.Currency == nil {
		ret += "Currency:<nil>"
	} else {
		ret += fmt.Sprintf("Currency:%v", *o.Currency)
	}

	return fmt.Sprintf("AmountReq{%s}", ret)
}

func (o AmountReq) Clone() *AmountReq {
	ret := AmountReq{}

	if o.Refund != nil {
		ret.Refund = new(int64)
		*ret.Refund = *o.Refund
	}

	if o.From != nil {
		ret.From = make([]FundsFromItem, len(o.From))
		for i, item := range o.From {
			ret.From[i] = *item.Clone()
		}
	}

	if o.Total != nil {
		ret.Total = new(int64)
		*ret.Total = *o.Total
	}

	if o.Currency != nil {
		ret.Currency = new(string)
		*ret.Currency = *o.Currency
	}

	return &ret
}

// Channel * `ORIGINAL` - 原路退款, 退款渠道 * `BALANCE` - 退回到余额, 退款渠道 * `OTHER_BALANCE` - 原账户异常退到其他余额账户, 退款渠道 * `OTHER_BANKCARD` - 原银行卡异常退到其他银行卡, 退款渠道
type Channel string

func (e Channel) Ptr() *Channel {
	return &e
}

// Enums of Channel
const (
	CHANNEL_ORIGINAL       Channel = "ORIGINAL"
	CHANNEL_BALANCE        Channel = "BALANCE"
	CHANNEL_OTHER_BALANCE  Channel = "OTHER_BALANCE"
	CHANNEL_OTHER_BANKCARD Channel = "OTHER_BANKCARD"
)

// CreateRequest
type CreateRequest struct {
	// 子商户的商户号，由微信支付生成并下发。服务商模式下必须传递此参数
	SubMchid *string `json:"sub_mchid,omitempty"`
	// 原支付交易对应的微信订单号
	TransactionId *string `json:"transaction_id,omitempty"`
	// 原支付交易对应的商户订单号
	OutTradeNo *string `json:"out_trade_no,omitempty"`
	// 商户系统内部的退款单号，商户系统内部唯一，只能是数字、大小写字母_-|*@ ，同一退款单号多次请求只退一笔。
	OutRefundNo *string `json:"out_refund_no"`
	// 若商户传入，会在下发给用户的退款消息中体现退款原因
	Reason *string `json:"reason,omitempty"`
	// 异步接收微信支付退款结果通知的回调地址，通知url必须为外网可访问的url，不能携带参数。 如果参数中传了notify_url，则商户平台上配置的回调地址将不会生效，优先回调当前传的这个地址。
	NotifyUrl *string `json:"notify_url,omitempty"`
	// 若传递此参数则使用对应的资金账户退款，否则默认使用未结算资金退款（仅对老资金流商户适用）  枚举值： - AVAILABLE：可用余额账户    * `AVAILABLE` - 可用余额
	FundsAccount *ReqFundsAccount `json:"funds_account,omitempty"`
	// 订单金额信息
	Amount *AmountReq `json:"amount"`
	// 指定商品退款需要传此参数，其他场景无需传递
	GoodsDetail []GoodsDetail `json:"goods_detail,omitempty"`
}

func (o CreateRequest) MarshalJSON() ([]byte, error) {
	toSerialize := map[string]interface{}{}

	if o.SubMchid != nil {
		toSerialize["sub_mchid"] = o.SubMchid
	}

	if o.TransactionId != nil {
		toSerialize["transaction_id"] = o.TransactionId
	}

	if o.OutTradeNo != nil {
		toSerialize["out_trade_no"] = o.OutTradeNo
	}

	if o.OutRefundNo == nil {
		return nil, fmt.Errorf("field `OutRefundNo` is required and must be specified in CreateRequest")
	}
	toSerialize["out_refund_no"] = o.OutRefundNo

	if o.Reason != nil {
		toSerialize["reason"] = o.Reason
	}

	if o.NotifyUrl != nil {
		toSerialize["notify_url"] = o.NotifyUrl
	}

	if o.FundsAccount != nil {
		toSerialize["funds_account"] = o.FundsAccount
	}

	if o.Amount == nil {
		return nil, fmt.Errorf("field `Amount` is required and must be specified in CreateRequest")
	}
	toSerialize["amount"] = o.Amount

	if o.GoodsDetail != nil {
		toSerialize["goods_detail"] = o.GoodsDetail
	}
	return json.Marshal(toSerialize)
}

func (o CreateRequest) String() string {
	var ret string
	if o.SubMchid == nil {
		ret += "SubMchid:<nil>, "
	} else {
		ret += fmt.Sprintf("SubMchid:%v, ", *o.SubMchid)
	}

	if o.TransactionId == nil {
		ret += "TransactionId:<nil>, "
	} else {
		ret += fmt.Sprintf("TransactionId:%v, ", *o.TransactionId)
	}

	if o.OutTradeNo == nil {
		ret += "OutTradeNo:<nil>, "
	} else {
		ret += fmt.Sprintf("OutTradeNo:%v, ", *o.OutTradeNo)
	}

	if o.OutRefundNo == nil {
		ret += "OutRefundNo:<nil>, "
	} else {
		ret += fmt.Sprintf("OutRefundNo:%v, ", *o.OutRefundNo)
	}

	if o.Reason == nil {
		ret += "Reason:<nil>, "
	} else {
		ret += fmt.Sprintf("Reason:%v, ", *o.Reason)
	}

	if o.NotifyUrl == nil {
		ret += "NotifyUrl:<nil>, "
	} else {
		ret += fmt.Sprintf("NotifyUrl:%v, ", *o.NotifyUrl)
	}

	if o.FundsAccount == nil {
		ret += "FundsAccount:<nil>, "
	} else {
		ret += fmt.Sprintf("FundsAccount:%v, ", *o.FundsAccount)
	}

	ret += fmt.Sprintf("Amount:%v, ", o.Amount)

	ret += fmt.Sprintf("GoodsDetail:%v", o.GoodsDetail)

	return fmt.Sprintf("CreateRequest{%s}", ret)
}

func (o CreateRequest) Clone() *CreateRequest {
	ret := CreateRequest{}

	if o.SubMchid != nil {
		ret.SubMchid = new(string)
		*ret.SubMchid = *o.SubMchid
	}

	if o.TransactionId != nil {
		ret.TransactionId = new(string)
		*ret.TransactionId = *o.TransactionId
	}

	if o.OutTradeNo != nil {
		ret.OutTradeNo = new(string)
		*ret.OutTradeNo = *o.OutTradeNo
	}

	if o.OutRefundNo != nil {
		ret.OutRefundNo = new(string)
		*ret.OutRefundNo = *o.OutRefundNo
	}

	if o.Reason != nil {
		ret.Reason = new(string)
		*ret.Reason = *o.Reason
	}

	if o.NotifyUrl != nil {
		ret.NotifyUrl = new(string)
		*ret.NotifyUrl = *o.NotifyUrl
	}

	if o.FundsAccount != nil {
		ret.FundsAccount = new(ReqFundsAccount)
		*ret.FundsAccount = *o.FundsAccount
	}

	if o.Amount != nil {
		ret.Amount = o.Amount.Clone()
	}

	if o.GoodsDetail != nil {
		ret.GoodsDetail = make([]GoodsDetail, len(o.GoodsDetail))
		for i, item := range o.GoodsDetail {
			ret.GoodsDetail[i] = *item.Clone()
		}
	}

	return &ret
}

// FundsAccount * `UNSETTLED` - 未结算资金, 退款所使用资金对应的资金账户类型 * `AVAILABLE` - 可用余额, 退款所使用资金对应的资金账户类型 * `UNAVAILABLE` - 不可用余额, 退款所使用资金对应的资金账户类型 * `OPERATION` - 运营户, 退款所使用资金对应的资金账户类型 * `BASIC` - 基本账户（含可用余额和不可用余额）, 退款所使用资金对应的资金账户类型
type FundsAccount string

func (e FundsAccount) Ptr() *FundsAccount {
	return &e
}

// Enums of FundsAccount
const (
	FUNDSACCOUNT_UNSETTLED   FundsAccount = "UNSETTLED"
	FUNDSACCOUNT_AVAILABLE   FundsAccount = "AVAILABLE"
	FUNDSACCOUNT_UNAVAILABLE FundsAccount = "UNAVAILABLE"
	FUNDSACCOUNT_OPERATION   FundsAccount = "OPERATION"
	FUNDSACCOUNT_BASIC       FundsAccount = "BASIC"
)

// FundsFromItem
type FundsFromItem struct {
	FundSource *string `json:"funds_source"`
	Amount *int64 `json:"amount"`
}

func (o FundsFromItem) MarshalJSON() ([]byte, error) {
	toSerialize := map[string]interface{}{}

	if o.FundSource == nil {
		return nil, fmt.Errorf("field `FundSource` is required and must be specified in FundsFromItem")
	}
	toSerialize["funds_source"] = o.FundSource

	if o.Amount == nil {
		return nil, fmt.Errorf("field `Amount` is required and must be specified in FundsFromItem")
	}
	toSerialize["amount"] = o.Amount
	return json.Marshal(toSerialize)
}

func (o FundsFromItem) String() string {
	var ret string
	if o.FundSource == nil {
		ret += "FundSource:<nil>, "
	} else {
		ret += fmt.Sprintf("FundSource:%v, ", *o.FundSource)
	}
	if o.Amount == nil {
		ret += "Amount:<nil>"
	} else {
		ret += fmt.Sprintf("Amount:%v", *o.Amount)
	}

	return fmt.Sprintf("FundsFromItem{%s}", ret)
}

func (o FundsFromItem) Clone() *FundsFromItem {
	ret := FundsFromItem{}



	if o.Amount != nil {
		ret.Amount = new(int64)
		*ret.Amount = *o.Amount
	}

	return &ret
}

// GoodsDetail
type GoodsDetail struct {
	// 由半角的大小写字母、数字、中划线、下划线中的一种或几种组成
	MerchantGoodsId *string `json:"merchant_goods_id"`
	// 微信支付定义的统一商品编号（没有可不传）
	WechatpayGoodsId *string `json:"wechatpay_goods_id,omitempty"`
	// 商品的实际名称
	GoodsName *string `json:"goods_name,omitempty"`
	// 商品单价金额，单位为分
	UnitPrice *int64 `json:"unit_price"`
	// 商品退款金额，单位为分
	RefundAmount *int64 `json:"refund_amount"`
	// 对应商品的退货数量
	RefundQuantity *int64 `json:"refund_quantity"`
}

func (o GoodsDetail) MarshalJSON() ([]byte, error) {
	toSerialize := map[string]interface{}{}

	if o.MerchantGoodsId == nil {
		return nil, fmt.Errorf("field `MerchantGoodsId` is required and must be specified in GoodsDetail")
	}
	toSerialize["merchant_goods_id"] = o.MerchantGoodsId

	if o.WechatpayGoodsId != nil {
		toSerialize["wechatpay_goods_id"] = o.WechatpayGoodsId
	}

	if o.GoodsName != nil {
		toSerialize["goods_name"] = o.GoodsName
	}

	if o.UnitPrice == nil {
		return nil, fmt.Errorf("field `UnitPrice` is required and must be specified in GoodsDetail")
	}
	toSerialize["unit_price"] = o.UnitPrice

	if o.RefundAmount == nil {
		return nil, fmt.Errorf("field `RefundAmount` is required and must be specified in GoodsDetail")
	}
	toSerialize["refund_amount"] = o.RefundAmount

	if o.RefundQuantity == nil {
		return nil, fmt.Errorf("field `RefundQuantity` is required and must be specified in GoodsDetail")
	}
	toSerialize["refund_quantity"] = o.RefundQuantity
	return json.Marshal(toSerialize)
}

func (o GoodsDetail) String() string {
	var ret string
	if o.MerchantGoodsId == nil {
		ret += "MerchantGoodsId:<nil>, "
	} else {
		ret += fmt.Sprintf("MerchantGoodsId:%v, ", *o.MerchantGoodsId)
	}

	if o.WechatpayGoodsId == nil {
		ret += "WechatpayGoodsId:<nil>, "
	} else {
		ret += fmt.Sprintf("WechatpayGoodsId:%v, ", *o.WechatpayGoodsId)
	}

	if o.GoodsName == nil {
		ret += "GoodsName:<nil>, "
	} else {
		ret += fmt.Sprintf("GoodsName:%v, ", *o.GoodsName)
	}

	if o.UnitPrice == nil {
		ret += "UnitPrice:<nil>, "
	} else {
		ret += fmt.Sprintf("UnitPrice:%v, ", *o.UnitPrice)
	}

	if o.RefundAmount == nil {
		ret += "RefundAmount:<nil>, "
	} else {
		ret += fmt.Sprintf("RefundAmount:%v, ", *o.RefundAmount)
	}

	if o.RefundQuantity == nil {
		ret += "RefundQuantity:<nil>"
	} else {
		ret += fmt.Sprintf("RefundQuantity:%v", *o.RefundQuantity)
	}

	return fmt.Sprintf("GoodsDetail{%s}", ret)
}

func (o GoodsDetail) Clone() *GoodsDetail {
	ret := GoodsDetail{}

	if o.MerchantGoodsId != nil {
		ret.MerchantGoodsId = new(string)
		*ret.MerchantGoodsId = *o.MerchantGoodsId
	}

	if o.WechatpayGoodsId != nil {
		ret.WechatpayGoodsId = new(string)
		*ret.WechatpayGoodsId = *o.WechatpayGoodsId
	}

	if o.GoodsName != nil {
		ret.GoodsName = new(string)
		*ret.GoodsName = *o.GoodsName
	}

	if o.UnitPrice != nil {
		ret.UnitPrice = new(int64)
		*ret.UnitPrice = *o.UnitPrice
	}

	if o.RefundAmount != nil {
		ret.RefundAmount = new(int64)
		*ret.RefundAmount = *o.RefundAmount
	}

	if o.RefundQuantity != nil {
		ret.RefundQuantity = new(int64)
		*ret.RefundQuantity = *o.RefundQuantity
	}

	return &ret
}

// Promotion
type Promotion struct {
	// 券或者立减优惠id
	PromotionId *string `json:"promotion_id"`
	// 枚举值： - GLOBAL- 全场代金券 - SINGLE- 单品优惠 * `GLOBAL` - 全场代金券 * `SINGLE` - 单品优惠
	Scope *Scope `json:"scope"`
	// 枚举值： - COUPON- 代金券，需要走结算资金的充值型代金券 - DISCOUNT- 优惠券，不走结算资金的免充值型优惠券 * `COUPON` - 代金券 * `DISCOUNT` - 优惠券
	Type *Type `json:"type"`
	// 用户享受优惠的金额（优惠券面额=微信出资金额+商家出资金额+其他出资方金额 ），单位为分
	Amount *int64 `json:"amount"`
	// 优惠退款金额<=退款金额，退款金额-代金券或立减优惠退款金额为用户支付的现金，说明详见代金券或立减优惠，单位为分
	RefundAmount *int64 `json:"refund_amount"`
	// 优惠商品发生退款时返回商品信息
	GoodsDetail []GoodsDetail `json:"goods_detail,omitempty"`
}

func (o Promotion) MarshalJSON() ([]byte, error) {
	toSerialize := map[string]interface{}{}

	if o.PromotionId == nil {
		return nil, fmt.Errorf("field `PromotionId` is required and must be specified in Promotion")
	}
	toSerialize["promotion_id"] = o.PromotionId

	if o.Scope == nil {
		return nil, fmt.Errorf("field `Scope` is required and must be specified in Promotion")
	}
	toSerialize["scope"] = o.Scope

	if o.Type == nil {
		return nil, fmt.Errorf("field `Type` is required and must be specified in Promotion")
	}
	toSerialize["type"] = o.Type

	if o.Amount == nil {
		return nil, fmt.Errorf("field `Amount` is required and must be specified in Promotion")
	}
	toSerialize["amount"] = o.Amount

	if o.RefundAmount == nil {
		return nil, fmt.Errorf("field `RefundAmount` is required and must be specified in Promotion")
	}
	toSerialize["refund_amount"] = o.RefundAmount

	if o.GoodsDetail != nil {
		toSerialize["goods_detail"] = o.GoodsDetail
	}
	return json.Marshal(toSerialize)
}

func (o Promotion) String() string {
	var ret string
	if o.PromotionId == nil {
		ret += "PromotionId:<nil>, "
	} else {
		ret += fmt.Sprintf("PromotionId:%v, ", *o.PromotionId)
	}

	if o.Scope == nil {
		ret += "Scope:<nil>, "
	} else {
		ret += fmt.Sprintf("Scope:%v, ", *o.Scope)
	}

	if o.Type == nil {
		ret += "Type:<nil>, "
	} else {
		ret += fmt.Sprintf("Type:%v, ", *o.Type)
	}

	if o.Amount == nil {
		ret += "Amount:<nil>, "
	} else {
		ret += fmt.Sprintf("Amount:%v, ", *o.Amount)
	}

	if o.RefundAmount == nil {
		ret += "RefundAmount:<nil>, "
	} else {
		ret += fmt.Sprintf("RefundAmount:%v, ", *o.RefundAmount)
	}

	ret += fmt.Sprintf("GoodsDetail:%v", o.GoodsDetail)

	return fmt.Sprintf("Promotion{%s}", ret)
}

func (o Promotion) Clone() *Promotion {
	ret := Promotion{}

	if o.PromotionId != nil {
		ret.PromotionId = new(string)
		*ret.PromotionId = *o.PromotionId
	}

	if o.Scope != nil {
		ret.Scope = new(Scope)
		*ret.Scope = *o.Scope
	}

	if o.Type != nil {
		ret.Type = new(Type)
		*ret.Type = *o.Type
	}

	if o.Amount != nil {
		ret.Amount = new(int64)
		*ret.Amount = *o.Amount
	}

	if o.RefundAmount != nil {
		ret.RefundAmount = new(int64)
		*ret.RefundAmount = *o.RefundAmount
	}

	if o.GoodsDetail != nil {
		ret.GoodsDetail = make([]GoodsDetail, len(o.GoodsDetail))
		for i, item := range o.GoodsDetail {
			ret.GoodsDetail[i] = *item.Clone()
		}
	}

	return &ret
}

// QueryByOutRefundNoRequest
type QueryByOutRefundNoRequest struct {
	// 商户系统内部的退款单号，商户系统内部唯一，只能是数字、大小写字母_-|*@ ，同一退款单号多次请求只退一笔。
	OutRefundNo *string `json:"out_refund_no"`
	// 子商户的商户号，由微信支付生成并下发。服务商模式下必须传递此参数
	SubMchid *string `json:"sub_mchid,omitempty"`
}

func (o QueryByOutRefundNoRequest) MarshalJSON() ([]byte, error) {
	toSerialize := map[string]interface{}{}

	if o.OutRefundNo == nil {
		return nil, fmt.Errorf("field `OutRefundNo` is required and must be specified in QueryByOutRefundNoRequest")
	}
	toSerialize["out_refund_no"] = o.OutRefundNo

	if o.SubMchid != nil {
		toSerialize["sub_mchid"] = o.SubMchid
	}
	return json.Marshal(toSerialize)
}

func (o QueryByOutRefundNoRequest) String() string {
	var ret string
	if o.OutRefundNo == nil {
		ret += "OutRefundNo:<nil>, "
	} else {
		ret += fmt.Sprintf("OutRefundNo:%v, ", *o.OutRefundNo)
	}

	if o.SubMchid == nil {
		ret += "SubMchid:<nil>"
	} else {
		ret += fmt.Sprintf("SubMchid:%v", *o.SubMchid)
	}

	return fmt.Sprintf("QueryByOutRefundNoRequest{%s}", ret)
}

func (o QueryByOutRefundNoRequest) Clone() *QueryByOutRefundNoRequest {
	ret := QueryByOutRefundNoRequest{}

	if o.OutRefundNo != nil {
		ret.OutRefundNo = new(string)
		*ret.OutRefundNo = *o.OutRefundNo
	}

	if o.SubMchid != nil {
		ret.SubMchid = new(string)
		*ret.SubMchid = *o.SubMchid
	}

	return &ret
}

// Refund
type Refund struct {
	// 微信支付退款号
	RefundId *string `json:"refund_id"`
	// 商户系统内部的退款单号，商户系统内部唯一，只能是数字、大小写字母_-|*@ ，同一退款单号多次请求只退一笔。
	OutRefundNo *string `json:"out_refund_no"`
	// 微信支付交易订单号
	TransactionId *string `json:"transaction_id"`
	// 原支付交易对应的商户订单号
	OutTradeNo *string `json:"out_trade_no"`
	Reason *string `json:"reason,omitempty"`

	Source *string `json:"source,omitempty"`

	FundsAccount *FundsAccount `json:"funds_account,omitempty"`
	// 金额详细信息
	Amount *Amount `json:"amount"`
	// 优惠退款信息
	PromotionDetail []Promotion `json:"promotion_detail,omitempty"`

	MchId *string `json:"mch_id,omitempty"`
	AppId *string `json:"app_id,omitempty"`

}

func (o Refund) MarshalJSON() ([]byte, error) {
	toSerialize := map[string]interface{}{}

	if o.RefundId == nil {
		return nil, fmt.Errorf("field `RefundId` is required and must be specified in Refund")
	}
	toSerialize["refund_id"] = o.RefundId

	if o.OutRefundNo == nil {
		return nil, fmt.Errorf("field `OutRefundNo` is required and must be specified in Refund")
	}
	toSerialize["out_refund_no"] = o.OutRefundNo

	if o.TransactionId == nil {
		return nil, fmt.Errorf("field `TransactionId` is required and must be specified in Refund")
	}
	toSerialize["transaction_id"] = o.TransactionId

	if o.OutTradeNo == nil {
		return nil, fmt.Errorf("field `OutTradeNo` is required and must be specified in Refund")
	}
	toSerialize["out_trade_no"] = o.OutTradeNo


	if o.FundsAccount != nil {
		toSerialize["funds_account"] = o.FundsAccount
	}

	if o.Amount == nil {
		return nil, fmt.Errorf("field `Amount` is required and must be specified in Refund")
	}
	toSerialize["amount"] = o.Amount

	if o.PromotionDetail != nil {
		toSerialize["promotion_detail"] = o.PromotionDetail
	}
	return json.Marshal(toSerialize)
}

func (o Refund) String() string {
	var ret string
	if o.RefundId == nil {
		ret += "RefundId:<nil>, "
	} else {
		ret += fmt.Sprintf("RefundId:%v, ", *o.RefundId)
	}

	if o.OutRefundNo == nil {
		ret += "OutRefundNo:<nil>, "
	} else {
		ret += fmt.Sprintf("OutRefundNo:%v, ", *o.OutRefundNo)
	}

	if o.TransactionId == nil {
		ret += "TransactionId:<nil>, "
	} else {
		ret += fmt.Sprintf("TransactionId:%v, ", *o.TransactionId)
	}

	if o.OutTradeNo == nil {
		ret += "OutTradeNo:<nil>, "
	} else {
		ret += fmt.Sprintf("OutTradeNo:%v, ", *o.OutTradeNo)
	}



	if o.FundsAccount == nil {
		ret += "FundsAccount:<nil>, "
	} else {
		ret += fmt.Sprintf("FundsAccount:%v, ", *o.FundsAccount)
	}

	ret += fmt.Sprintf("Amount:%v, ", o.Amount)

	ret += fmt.Sprintf("PromotionDetail:%v", o.PromotionDetail)

	return fmt.Sprintf("Refund{%s}", ret)
}

func (o Refund) Clone() *Refund {
	ret := Refund{}

	if o.RefundId != nil {
		ret.RefundId = new(string)
		*ret.RefundId = *o.RefundId
	}

	if o.OutRefundNo != nil {
		ret.OutRefundNo = new(string)
		*ret.OutRefundNo = *o.OutRefundNo
	}

	if o.TransactionId != nil {
		ret.TransactionId = new(string)
		*ret.TransactionId = *o.TransactionId
	}

	if o.OutTradeNo != nil {
		ret.OutTradeNo = new(string)
		*ret.OutTradeNo = *o.OutTradeNo
	}



	if o.FundsAccount != nil {
		ret.FundsAccount = new(FundsAccount)
		*ret.FundsAccount = *o.FundsAccount
	}

	if o.Amount != nil {
		ret.Amount = o.Amount.Clone()
	}

	if o.PromotionDetail != nil {
		ret.PromotionDetail = make([]Promotion, len(o.PromotionDetail))
		for i, item := range o.PromotionDetail {
			ret.PromotionDetail[i] = *item.Clone()
		}
	}

	return &ret
}

// ReqFundsAccount * `AVAILABLE` - 可用余额, 仅对老资金流商户适用，指定从可用余额账户出资
type ReqFundsAccount string

func (e ReqFundsAccount) Ptr() *ReqFundsAccount {
	return &e
}

// Enums of ReqFundsAccount
const (
	REQFUNDSACCOUNT_AVAILABLE ReqFundsAccount = "AVAILABLE"
)

// Scope * `GLOBAL` - 全场代金券, 全场优惠类型 * `SINGLE` - 单品优惠, 单品优惠类型
type Scope string

func (e Scope) Ptr() *Scope {
	return &e
}

// Enums of Scope
const (
	SCOPE_GLOBAL Scope = "GLOBAL"
	SCOPE_SINGLE Scope = "SINGLE"
)

// Status * `SUCCESS` - 退款成功, 退款状态 * `CLOSED` - 退款关闭, 退款状态 * `PROCESSING` - 退款处理中, 退款状态 * `ABNORMAL` - 退款异常, 退款状态
type Status string

func (e Status) Ptr() *Status {
	return &e
}

// Enums of Status
const (
	STATUS_SUCCESS    Status = "SUCCESS"
	STATUS_CLOSED     Status = "CLOSED"
	STATUS_PROCESSING Status = "PROCESSING"
	STATUS_ABNORMAL   Status = "ABNORMAL"
)

// Type * `COUPON` - 代金券, 代金券类型，需要走结算资金的充值型代金券 * `DISCOUNT` - 优惠券, 优惠券类型，不走结算资金的免充值型优惠券
type Type string

func (e Type) Ptr() *Type {
	return &e
}

// Enums of Type
const (
	TYPE_COUPON   Type = "COUPON"
	TYPE_DISCOUNT Type = "DISCOUNT"
)