// Code generated by ogen, DO NOT EDIT.

package api

import (
	"github.com/go-faster/jx"

	std "encoding/json"
	"testing"

	"github.com/stretchr/testify/require"
)

func TestActionReportItem_EncodeDecode(t *testing.T) {
	var typ ActionReportItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ActionReportItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestActiveInternalSquad_EncodeDecode(t *testing.T) {
	var typ ActiveInternalSquad
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ActiveInternalSquad
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestAllHwidDevices_EncodeDecode(t *testing.T) {
	var typ AllHwidDevices
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 AllHwidDevices
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBadRequestError_EncodeDecode(t *testing.T) {
	var typ BadRequestError
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BadRequestError
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBandwidthLastTwoDays_EncodeDecode(t *testing.T) {
	var typ BandwidthLastTwoDays
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BandwidthLastTwoDays
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBillingHistoryItem_EncodeDecode(t *testing.T) {
	var typ BillingHistoryItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BillingHistoryItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBillingHistoryResponse_EncodeDecode(t *testing.T) {
	var typ BillingHistoryResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BillingHistoryResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBillingHistoryResponseResponse_EncodeDecode(t *testing.T) {
	var typ BillingHistoryResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BillingHistoryResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBillingHistoryResponseResponseRecordsItem_EncodeDecode(t *testing.T) {
	var typ BillingHistoryResponseResponseRecordsItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BillingHistoryResponseResponseRecordsItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBillingHistoryResponseResponseRecordsItemProvider_EncodeDecode(t *testing.T) {
	var typ BillingHistoryResponseResponseRecordsItemProvider
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BillingHistoryResponseResponseRecordsItemProvider
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBillingNode_EncodeDecode(t *testing.T) {
	var typ BillingNode
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BillingNode
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBillingNodesResponse_EncodeDecode(t *testing.T) {
	var typ BillingNodesResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BillingNodesResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBillingNodesResponseResponse_EncodeDecode(t *testing.T) {
	var typ BillingNodesResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BillingNodesResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBillingNodesResponseResponseBillingNodesItem_EncodeDecode(t *testing.T) {
	var typ BillingNodesResponseResponseBillingNodesItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BillingNodesResponseResponseBillingNodesItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBillingNodesResponseResponseBillingNodesItemProvider_EncodeDecode(t *testing.T) {
	var typ BillingNodesResponseResponseBillingNodesItemProvider
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BillingNodesResponseResponseBillingNodesItemProvider
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBillingNodesResponseResponseStats_EncodeDecode(t *testing.T) {
	var typ BillingNodesResponseResponseStats
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BillingNodesResponseResponseStats
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBrandingSettings_EncodeDecode(t *testing.T) {
	var typ BrandingSettings
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BrandingSettings
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkActionResponse_EncodeDecode(t *testing.T) {
	var typ BulkActionResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkActionResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkActionResponseResponse_EncodeDecode(t *testing.T) {
	var typ BulkActionResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkActionResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkAllExtendExpirationDateRequest_EncodeDecode(t *testing.T) {
	var typ BulkAllExtendExpirationDateRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkAllExtendExpirationDateRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkAllUpdateUsersRequest_EncodeDecode(t *testing.T) {
	var typ BulkAllUpdateUsersRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkAllUpdateUsersRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkAllUpdateUsersRequestStatus_EncodeDecode(t *testing.T) {
	var typ BulkAllUpdateUsersRequestStatus
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkAllUpdateUsersRequestStatus
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkAllUpdateUsersRequestTrafficLimitStrategy_EncodeDecode(t *testing.T) {
	var typ BulkAllUpdateUsersRequestTrafficLimitStrategy
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkAllUpdateUsersRequestTrafficLimitStrategy
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkDeleteUsersByStatusRequest_EncodeDecode(t *testing.T) {
	var typ BulkDeleteUsersByStatusRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkDeleteUsersByStatusRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkDeleteUsersByStatusRequestStatus_EncodeDecode(t *testing.T) {
	var typ BulkDeleteUsersByStatusRequestStatus
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkDeleteUsersByStatusRequestStatus
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkExtendExpirationDateRequest_EncodeDecode(t *testing.T) {
	var typ BulkExtendExpirationDateRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkExtendExpirationDateRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkNodesActionsRequest_EncodeDecode(t *testing.T) {
	var typ BulkNodesActionsRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkNodesActionsRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkNodesActionsRequestAction_EncodeDecode(t *testing.T) {
	var typ BulkNodesActionsRequestAction
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkNodesActionsRequestAction
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkNodesUpdateRequest_EncodeDecode(t *testing.T) {
	var typ BulkNodesUpdateRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkNodesUpdateRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkNodesUpdateRequestFields_EncodeDecode(t *testing.T) {
	var typ BulkNodesUpdateRequestFields
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkNodesUpdateRequestFields
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkUpdateUsersRequest_EncodeDecode(t *testing.T) {
	var typ BulkUpdateUsersRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkUpdateUsersRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkUpdateUsersRequestFields_EncodeDecode(t *testing.T) {
	var typ BulkUpdateUsersRequestFields
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkUpdateUsersRequestFields
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkUpdateUsersRequestFieldsStatus_EncodeDecode(t *testing.T) {
	var typ BulkUpdateUsersRequestFieldsStatus
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkUpdateUsersRequestFieldsStatus
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkUpdateUsersRequestFieldsTrafficLimitStrategy_EncodeDecode(t *testing.T) {
	var typ BulkUpdateUsersRequestFieldsTrafficLimitStrategy
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkUpdateUsersRequestFieldsTrafficLimitStrategy
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkUpdateUsersSquadsRequest_EncodeDecode(t *testing.T) {
	var typ BulkUpdateUsersSquadsRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkUpdateUsersSquadsRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkUuidsRequest_EncodeDecode(t *testing.T) {
	var typ BulkUuidsRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkUuidsRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestBulkUuidsRequest2_EncodeDecode(t *testing.T) {
	var typ BulkUuidsRequest2
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 BulkUuidsRequest2
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestByAppItem_EncodeDecode(t *testing.T) {
	var typ ByAppItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ByAppItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCloneNodePluginRequestRequest_EncodeDecode(t *testing.T) {
	var typ CloneNodePluginRequestRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CloneNodePluginRequestRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCondition_EncodeDecode(t *testing.T) {
	var typ Condition
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Condition
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestConditionOperator_EncodeDecode(t *testing.T) {
	var typ ConditionOperator
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ConditionOperator
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestConfig_EncodeDecode(t *testing.T) {
	var typ Config
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Config
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestConfigProfile_EncodeDecode(t *testing.T) {
	var typ ConfigProfile
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ConfigProfile
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestConfigProfileItem_EncodeDecode(t *testing.T) {
	var typ ConfigProfileItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ConfigProfileItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestConfigProfileRef_EncodeDecode(t *testing.T) {
	var typ ConfigProfileRef
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ConfigProfileRef
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestConfigProfileResponse_EncodeDecode(t *testing.T) {
	var typ ConfigProfileResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ConfigProfileResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestConfigProfilesResponse_EncodeDecode(t *testing.T) {
	var typ ConfigProfilesResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ConfigProfilesResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestConfigProfilesResponseResponse_EncodeDecode(t *testing.T) {
	var typ ConfigProfilesResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ConfigProfilesResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateApiTokenRequest_EncodeDecode(t *testing.T) {
	var typ CreateApiTokenRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateApiTokenRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateApiTokenResponse_EncodeDecode(t *testing.T) {
	var typ CreateApiTokenResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateApiTokenResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateApiTokenResponseResponse_EncodeDecode(t *testing.T) {
	var typ CreateApiTokenResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateApiTokenResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateConfigProfileRequest_EncodeDecode(t *testing.T) {
	var typ CreateConfigProfileRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateConfigProfileRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateConfigProfileRequestConfig_EncodeDecode(t *testing.T) {
	var typ CreateConfigProfileRequestConfig
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateConfigProfileRequestConfig
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateExternalSquadRequest_EncodeDecode(t *testing.T) {
	var typ CreateExternalSquadRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateExternalSquadRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateHostRequest_EncodeDecode(t *testing.T) {
	var typ CreateHostRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateHostRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateHostRequestAlpn_EncodeDecode(t *testing.T) {
	var typ CreateHostRequestAlpn
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateHostRequestAlpn
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateHostRequestExcludeFromSubscriptionTypesItem_EncodeDecode(t *testing.T) {
	var typ CreateHostRequestExcludeFromSubscriptionTypesItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateHostRequestExcludeFromSubscriptionTypesItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateHostRequestFingerprint_EncodeDecode(t *testing.T) {
	var typ CreateHostRequestFingerprint
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateHostRequestFingerprint
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateHostRequestSecurityLayer_EncodeDecode(t *testing.T) {
	var typ CreateHostRequestSecurityLayer
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateHostRequestSecurityLayer
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateInfraBillingHistoryRecordRequest_EncodeDecode(t *testing.T) {
	var typ CreateInfraBillingHistoryRecordRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateInfraBillingHistoryRecordRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateInfraBillingNodeRequest_EncodeDecode(t *testing.T) {
	var typ CreateInfraBillingNodeRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateInfraBillingNodeRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateInfraProviderRequest_EncodeDecode(t *testing.T) {
	var typ CreateInfraProviderRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateInfraProviderRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateInternalSquadRequest_EncodeDecode(t *testing.T) {
	var typ CreateInternalSquadRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateInternalSquadRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateNodePluginRequest_EncodeDecode(t *testing.T) {
	var typ CreateNodePluginRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateNodePluginRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateNodePluginResponse_EncodeDecode(t *testing.T) {
	var typ CreateNodePluginResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateNodePluginResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateNodeRequest_EncodeDecode(t *testing.T) {
	var typ CreateNodeRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateNodeRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateSubscriptionPageConfigRequest_EncodeDecode(t *testing.T) {
	var typ CreateSubscriptionPageConfigRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateSubscriptionPageConfigRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateSubscriptionPageConfigResponse_EncodeDecode(t *testing.T) {
	var typ CreateSubscriptionPageConfigResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateSubscriptionPageConfigResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateSubscriptionTemplateRequest_EncodeDecode(t *testing.T) {
	var typ CreateSubscriptionTemplateRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateSubscriptionTemplateRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateSubscriptionTemplateRequestTemplateType_EncodeDecode(t *testing.T) {
	var typ CreateSubscriptionTemplateRequestTemplateType
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateSubscriptionTemplateRequestTemplateType
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateUserHwidDeviceRequest_EncodeDecode(t *testing.T) {
	var typ CreateUserHwidDeviceRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateUserHwidDeviceRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateUserRequest_EncodeDecode(t *testing.T) {
	var typ CreateUserRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateUserRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateUserRequestStatus_EncodeDecode(t *testing.T) {
	var typ CreateUserRequestStatus
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateUserRequestStatus
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCreateUserRequestTrafficLimitStrategy_EncodeDecode(t *testing.T) {
	var typ CreateUserRequestTrafficLimitStrategy
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CreateUserRequestTrafficLimitStrategy
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestCustomRemark_EncodeDecode(t *testing.T) {
	var typ CustomRemark
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 CustomRemark
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDebugSrrMatcherRequest_EncodeDecode(t *testing.T) {
	var typ DebugSrrMatcherRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DebugSrrMatcherRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDebugSrrMatcherResponse_EncodeDecode(t *testing.T) {
	var typ DebugSrrMatcherResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DebugSrrMatcherResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDebugSrrMatcherResponseResponse_EncodeDecode(t *testing.T) {
	var typ DebugSrrMatcherResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DebugSrrMatcherResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDebugSrrMatcherResponseResponseInputHeaders_EncodeDecode(t *testing.T) {
	var typ DebugSrrMatcherResponseResponseInputHeaders
	typ = make(DebugSrrMatcherResponseResponseInputHeaders)
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DebugSrrMatcherResponseResponseInputHeaders
	typ2 = make(DebugSrrMatcherResponseResponseInputHeaders)
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDebugSrrMatcherResponseResponseOutputHeaders_EncodeDecode(t *testing.T) {
	var typ DebugSrrMatcherResponseResponseOutputHeaders
	typ = make(DebugSrrMatcherResponseResponseOutputHeaders)
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DebugSrrMatcherResponseResponseOutputHeaders
	typ2 = make(DebugSrrMatcherResponseResponseOutputHeaders)
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDebugSrrMatcherResponseResponseResponseType_EncodeDecode(t *testing.T) {
	var typ DebugSrrMatcherResponseResponseResponseType
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DebugSrrMatcherResponseResponseResponseType
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDebugSrrMatcherSettings_EncodeDecode(t *testing.T) {
	var typ DebugSrrMatcherSettings
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DebugSrrMatcherSettings
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDeleteAllUserHwidDevicesRequest_EncodeDecode(t *testing.T) {
	var typ DeleteAllUserHwidDevicesRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DeleteAllUserHwidDevicesRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDeleteApiTokenResponse_EncodeDecode(t *testing.T) {
	var typ DeleteApiTokenResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DeleteApiTokenResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDeletePasskeyRequest_EncodeDecode(t *testing.T) {
	var typ DeletePasskeyRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DeletePasskeyRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDeleteResponse_EncodeDecode(t *testing.T) {
	var typ DeleteResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DeleteResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDeleteResponseResponse_EncodeDecode(t *testing.T) {
	var typ DeleteResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DeleteResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDeleteSnippetRequest_EncodeDecode(t *testing.T) {
	var typ DeleteSnippetRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DeleteSnippetRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDeleteUserHwidDeviceRequest_EncodeDecode(t *testing.T) {
	var typ DeleteUserHwidDeviceRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DeleteUserHwidDeviceRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDevice_EncodeDecode(t *testing.T) {
	var typ Device
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Device
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDropConnectionsRequest_EncodeDecode(t *testing.T) {
	var typ DropConnectionsRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DropConnectionsRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDropConnectionsRequestDropBy_EncodeDecode(t *testing.T) {
	var typ DropConnectionsRequestDropBy
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DropConnectionsRequestDropBy
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDropConnectionsRequestDropBy0_EncodeDecode(t *testing.T) {
	var typ DropConnectionsRequestDropBy0
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DropConnectionsRequestDropBy0
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDropConnectionsRequestDropBy0By_EncodeDecode(t *testing.T) {
	var typ DropConnectionsRequestDropBy0By
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DropConnectionsRequestDropBy0By
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDropConnectionsRequestDropBy1_EncodeDecode(t *testing.T) {
	var typ DropConnectionsRequestDropBy1
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DropConnectionsRequestDropBy1
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDropConnectionsRequestDropBy1By_EncodeDecode(t *testing.T) {
	var typ DropConnectionsRequestDropBy1By
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DropConnectionsRequestDropBy1By
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDropConnectionsRequestTargetNodes_EncodeDecode(t *testing.T) {
	var typ DropConnectionsRequestTargetNodes
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DropConnectionsRequestTargetNodes
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDropConnectionsRequestTargetNodes0_EncodeDecode(t *testing.T) {
	var typ DropConnectionsRequestTargetNodes0
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DropConnectionsRequestTargetNodes0
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDropConnectionsRequestTargetNodes0Target_EncodeDecode(t *testing.T) {
	var typ DropConnectionsRequestTargetNodes0Target
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DropConnectionsRequestTargetNodes0Target
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDropConnectionsRequestTargetNodes1_EncodeDecode(t *testing.T) {
	var typ DropConnectionsRequestTargetNodes1
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DropConnectionsRequestTargetNodes1
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestDropConnectionsRequestTargetNodes1Target_EncodeDecode(t *testing.T) {
	var typ DropConnectionsRequestTargetNodes1Target
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 DropConnectionsRequestTargetNodes1Target
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestEncryptHappCryptoLinkRequest_EncodeDecode(t *testing.T) {
	var typ EncryptHappCryptoLinkRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 EncryptHappCryptoLinkRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestEncryptHappCryptoLinkResponse_EncodeDecode(t *testing.T) {
	var typ EncryptHappCryptoLinkResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 EncryptHappCryptoLinkResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestEncryptHappCryptoLinkResponseResponse_EncodeDecode(t *testing.T) {
	var typ EncryptHappCryptoLinkResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 EncryptHappCryptoLinkResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestEventResponse_EncodeDecode(t *testing.T) {
	var typ EventResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 EventResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestEventResponseResponse_EncodeDecode(t *testing.T) {
	var typ EventResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 EventResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestExternalSquad_EncodeDecode(t *testing.T) {
	var typ ExternalSquad
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ExternalSquad
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestExternalSquadResponseHeaders_EncodeDecode(t *testing.T) {
	var typ ExternalSquadResponseHeaders
	typ = make(ExternalSquadResponseHeaders)
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ExternalSquadResponseHeaders
	typ2 = make(ExternalSquadResponseHeaders)
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestExternalSquadResponseResponse_EncodeDecode(t *testing.T) {
	var typ ExternalSquadResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ExternalSquadResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestExternalSquadsResponInfoItem_EncodeDecode(t *testing.T) {
	var typ ExternalSquadsResponInfoItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ExternalSquadsResponInfoItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestExternalSquadsResponse_EncodeDecode(t *testing.T) {
	var typ ExternalSquadsResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ExternalSquadsResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestExternalSquadsResponseResponse_EncodeDecode(t *testing.T) {
	var typ ExternalSquadsResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ExternalSquadsResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestFetchIpsResultResponse_EncodeDecode(t *testing.T) {
	var typ FetchIpsResultResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 FetchIpsResultResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestFetchIpsResultResponseResponse_EncodeDecode(t *testing.T) {
	var typ FetchIpsResultResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 FetchIpsResultResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestFetchIpsResultResponseResponseProgress_EncodeDecode(t *testing.T) {
	var typ FetchIpsResultResponseResponseProgress
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 FetchIpsResultResponseResponseProgress
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestFetchIpsResultResponseResponseResult_EncodeDecode(t *testing.T) {
	var typ FetchIpsResultResponseResponseResult
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 FetchIpsResultResponseResponseResult
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestFetchIpsResultResponseResponseResultNodesItem_EncodeDecode(t *testing.T) {
	var typ FetchIpsResultResponseResponseResultNodesItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 FetchIpsResultResponseResponseResultNodesItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestFetchUsersIpsResultResponse_EncodeDecode(t *testing.T) {
	var typ FetchUsersIpsResultResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 FetchUsersIpsResultResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestFetchUsersIpsResultResponseResponse_EncodeDecode(t *testing.T) {
	var typ FetchUsersIpsResultResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 FetchUsersIpsResultResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestFetchUsersIpsResultResponseResponseResult_EncodeDecode(t *testing.T) {
	var typ FetchUsersIpsResultResponseResponseResult
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 FetchUsersIpsResultResponseResponseResult
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestFetchUsersIpsResultResponseResponseResultUsersItem_EncodeDecode(t *testing.T) {
	var typ FetchUsersIpsResultResponseResponseResultUsersItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 FetchUsersIpsResultResponseResponseResultUsersItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestFindAllApiTokensResponse_EncodeDecode(t *testing.T) {
	var typ FindAllApiTokensResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 FindAllApiTokensResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestFindAllApiTokensResponseResponse_EncodeDecode(t *testing.T) {
	var typ FindAllApiTokensResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 FindAllApiTokensResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestFindAllApiTokensResponseResponseApiKeysItem_EncodeDecode(t *testing.T) {
	var typ FindAllApiTokensResponseResponseApiKeysItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 FindAllApiTokensResponseResponseApiKeysItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestFindAllApiTokensResponseResponseDocs_EncodeDecode(t *testing.T) {
	var typ FindAllApiTokensResponseResponseDocs
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 FindAllApiTokensResponseResponseDocs
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestForbiddenError_EncodeDecode(t *testing.T) {
	var typ ForbiddenError
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ForbiddenError
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGenerateX25519Response_EncodeDecode(t *testing.T) {
	var typ GenerateX25519Response
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GenerateX25519Response
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGenerateX25519ResponseResponse_EncodeDecode(t *testing.T) {
	var typ GenerateX25519ResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GenerateX25519ResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGenerateX25519ResponseResponseKeypairsItem_EncodeDecode(t *testing.T) {
	var typ GenerateX25519ResponseResponseKeypairsItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GenerateX25519ResponseResponseKeypairsItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGeneric_EncodeDecode(t *testing.T) {
	var typ Generic
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Generic
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetAllHwidDevicesResponse_EncodeDecode(t *testing.T) {
	var typ GetAllHwidDevicesResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetAllHwidDevicesResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetAllSubscriptionsResponse_EncodeDecode(t *testing.T) {
	var typ GetAllSubscriptionsResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetAllSubscriptionsResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetAllSubscriptionsResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetAllSubscriptionsResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetAllSubscriptionsResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetAllUsersResponse_EncodeDecode(t *testing.T) {
	var typ GetAllUsersResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetAllUsersResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetAllUsersResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetAllUsersResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetAllUsersResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetBandwidthStatsResponse_EncodeDecode(t *testing.T) {
	var typ GetBandwidthStatsResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetBandwidthStatsResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetBandwidthStatsResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetBandwidthStatsResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetBandwidthStatsResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetConnectionKeysByUuidResponse_EncodeDecode(t *testing.T) {
	var typ GetConnectionKeysByUuidResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetConnectionKeysByUuidResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetConnectionKeysByUuidResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetConnectionKeysByUuidResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetConnectionKeysByUuidResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetHwidDevicesStatsResponse_EncodeDecode(t *testing.T) {
	var typ GetHwidDevicesStatsResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetHwidDevicesStatsResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetHwidDevicesStatsResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetHwidDevicesStatsResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetHwidDevicesStatsResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetHwidDevicesStatsResponseResponseByPlatformItem_EncodeDecode(t *testing.T) {
	var typ GetHwidDevicesStatsResponseResponseByPlatformItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetHwidDevicesStatsResponseResponseByPlatformItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetHwidDevicesStatsResponseResponseStats_EncodeDecode(t *testing.T) {
	var typ GetHwidDevicesStatsResponseResponseStats
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetHwidDevicesStatsResponseResponseStats
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetInfraProvidersResponse_EncodeDecode(t *testing.T) {
	var typ GetInfraProvidersResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetInfraProvidersResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetInfraProvidersResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetInfraProvidersResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetInfraProvidersResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetInternalSquadAccessibleNodesResponse_EncodeDecode(t *testing.T) {
	var typ GetInternalSquadAccessibleNodesResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetInternalSquadAccessibleNodesResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetInternalSquadAccessibleNodesResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetInternalSquadAccessibleNodesResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetInternalSquadAccessibleNodesResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetInternalSquadAccessibleNodesResponseResponseAccessibleNodesItem_EncodeDecode(t *testing.T) {
	var typ GetInternalSquadAccessibleNodesResponseResponseAccessibleNodesItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetInternalSquadAccessibleNodesResponseResponseAccessibleNodesItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetLegacyStatsNodesUsersUsageResponse_EncodeDecode(t *testing.T) {
	var typ GetLegacyStatsNodesUsersUsageResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetLegacyStatsNodesUsersUsageResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetLegacyStatsNodesUsersUsageResponseResponseItem_EncodeDecode(t *testing.T) {
	var typ GetLegacyStatsNodesUsersUsageResponseResponseItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetLegacyStatsNodesUsersUsageResponseResponseItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetLegacyStatsUserUsageResponse_EncodeDecode(t *testing.T) {
	var typ GetLegacyStatsUserUsageResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetLegacyStatsUserUsageResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetLegacyStatsUserUsageResponseResponseItem_EncodeDecode(t *testing.T) {
	var typ GetLegacyStatsUserUsageResponseResponseItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetLegacyStatsUserUsageResponseResponseItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetMetadataResponse_EncodeDecode(t *testing.T) {
	var typ GetMetadataResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetMetadataResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetMetadataResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetMetadataResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetMetadataResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetMetadataResponseResponseBuild_EncodeDecode(t *testing.T) {
	var typ GetMetadataResponseResponseBuild
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetMetadataResponseResponseBuild
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetMetadataResponseResponseGit_EncodeDecode(t *testing.T) {
	var typ GetMetadataResponseResponseGit
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetMetadataResponseResponseGit
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetMetadataResponseResponseGitBackend_EncodeDecode(t *testing.T) {
	var typ GetMetadataResponseResponseGitBackend
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetMetadataResponseResponseGitBackend
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetMetadataResponseResponseGitFrontend_EncodeDecode(t *testing.T) {
	var typ GetMetadataResponseResponseGitFrontend
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetMetadataResponseResponseGitFrontend
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetNodesMetricsResponse_EncodeDecode(t *testing.T) {
	var typ GetNodesMetricsResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetNodesMetricsResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetNodesMetricsResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetNodesMetricsResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetNodesMetricsResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetNodesMetricsResponseResponseNodesItem_EncodeDecode(t *testing.T) {
	var typ GetNodesMetricsResponseResponseNodesItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetNodesMetricsResponseResponseNodesItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetNodesStatisticsResponse_EncodeDecode(t *testing.T) {
	var typ GetNodesStatisticsResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetNodesStatisticsResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetNodesStatisticsResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetNodesStatisticsResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetNodesStatisticsResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetNodesStatisticsResponseResponseLastSevenDaysItem_EncodeDecode(t *testing.T) {
	var typ GetNodesStatisticsResponseResponseLastSevenDaysItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetNodesStatisticsResponseResponseLastSevenDaysItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetPubKeyResponse_EncodeDecode(t *testing.T) {
	var typ GetPubKeyResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetPubKeyResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetPubKeyResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetPubKeyResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetPubKeyResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponse_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseConvertedUserInfo_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseConvertedUserInfo
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseConvertedUserInfo
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseHeaders_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseHeaders
	typ = make(GetRawSubscriptionByShortUuidResponseResponseHeaders)
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseHeaders
	typ2 = make(GetRawSubscriptionByShortUuidResponseResponseHeaders)
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItem_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemClientOverrides_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemClientOverrides
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemClientOverrides
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemMetadata_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemMetadata
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemMetadata
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemMetadataExcludeFromSubscriptionTypesItem_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemMetadataExcludeFromSubscriptionTypesItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemMetadataExcludeFromSubscriptionTypesItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocol_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocol
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocol
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocolOptions_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocolOptions
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocolOptions
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocolOptions0_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocolOptions0
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocolOptions0
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocolOptions0Flow_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocolOptions0Flow
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocolOptions0Flow
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocolOptions1_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocolOptions1
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocolOptions1
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocolOptions2_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocolOptions2
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocolOptions2
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocolOptions3_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocolOptions3
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemProtocolOptions3
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemSecurity_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemSecurity
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemSecurity
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemSecurityOptions_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemSecurityOptions
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemSecurityOptions
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemSecurityOptions0_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemSecurityOptions0
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemSecurityOptions0
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemSecurityOptions1_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemSecurityOptions1
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemSecurityOptions1
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemStreamOverrides_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemStreamOverrides
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemStreamOverrides
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransport_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransport
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransport
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header0_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header0
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header0
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header0Type_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header0Type
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header0Type
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1Request_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1Request
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1Request
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1RequestHeaders_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1RequestHeaders
	typ = make(GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1RequestHeaders)
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1RequestHeaders
	typ2 = make(GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1RequestHeaders)
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1Response_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1Response
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1Response
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1ResponseHeaders_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1ResponseHeaders
	typ = make(GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1ResponseHeaders)
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1ResponseHeaders
	typ2 = make(GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1ResponseHeaders)
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1Type_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1Type
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions0Header1Type
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions1_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions1
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions1
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions1Extra_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions1Extra
	typ = make(GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions1Extra)
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions1Extra
	typ2 = make(GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions1Extra)
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions1Mode_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions1Mode
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions1Mode
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions2_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions2
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions2
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions2Headers_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions2Headers
	typ = make(GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions2Headers)
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions2Headers
	typ2 = make(GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions2Headers)
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions3_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions3
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions3
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions3Headers_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions3Headers
	typ = make(GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions3Headers)
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions3Headers
	typ2 = make(GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions3Headers)
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions4_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions4
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions4
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions5_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions5
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions5
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions6_EncodeDecode(t *testing.T) {
	var typ GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions6
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRawSubscriptionByShortUuidResponseResponseResolvedProxyConfigsItemTransportOptions6
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRecapResponse_EncodeDecode(t *testing.T) {
	var typ GetRecapResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRecapResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRecapResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetRecapResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRecapResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRecapResponseResponseThisMonth_EncodeDecode(t *testing.T) {
	var typ GetRecapResponseResponseThisMonth
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRecapResponseResponseThisMonth
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRecapResponseResponseTotal_EncodeDecode(t *testing.T) {
	var typ GetRecapResponseResponseTotal
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRecapResponseResponseTotal
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRemnawaveHealthResponse_EncodeDecode(t *testing.T) {
	var typ GetRemnawaveHealthResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRemnawaveHealthResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRemnawaveHealthResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetRemnawaveHealthResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRemnawaveHealthResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetRemnawaveHealthResponseResponseRuntimeMetricsItem_EncodeDecode(t *testing.T) {
	var typ GetRemnawaveHealthResponseResponseRuntimeMetricsItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetRemnawaveHealthResponseResponseRuntimeMetricsItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetStatsNodeUsersUsageResponse_EncodeDecode(t *testing.T) {
	var typ GetStatsNodeUsersUsageResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetStatsNodeUsersUsageResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetStatsNodeUsersUsageResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetStatsNodeUsersUsageResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetStatsNodeUsersUsageResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetStatsNodeUsersUsageResponseResponseTopUsersItem_EncodeDecode(t *testing.T) {
	var typ GetStatsNodeUsersUsageResponseResponseTopUsersItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetStatsNodeUsersUsageResponseResponseTopUsersItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetStatsResponse_EncodeDecode(t *testing.T) {
	var typ GetStatsResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetStatsResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetStatsResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetStatsResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetStatsResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetStatsResponseResponseCPU_EncodeDecode(t *testing.T) {
	var typ GetStatsResponseResponseCPU
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetStatsResponseResponseCPU
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetStatsResponseResponseMemory_EncodeDecode(t *testing.T) {
	var typ GetStatsResponseResponseMemory
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetStatsResponseResponseMemory
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetStatsResponseResponseNodes_EncodeDecode(t *testing.T) {
	var typ GetStatsResponseResponseNodes
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetStatsResponseResponseNodes
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetStatsResponseResponseOnlineStats_EncodeDecode(t *testing.T) {
	var typ GetStatsResponseResponseOnlineStats
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetStatsResponseResponseOnlineStats
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetStatsResponseResponseUsers_EncodeDecode(t *testing.T) {
	var typ GetStatsResponseResponseUsers
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetStatsResponseResponseUsers
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetStatsResponseResponseUsersStatusCounts_EncodeDecode(t *testing.T) {
	var typ GetStatsResponseResponseUsersStatusCounts
	typ = make(GetStatsResponseResponseUsersStatusCounts)
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetStatsResponseResponseUsersStatusCounts
	typ2 = make(GetStatsResponseResponseUsersStatusCounts)
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetStatusResponse_EncodeDecode(t *testing.T) {
	var typ GetStatusResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetStatusResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetStatusResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetStatusResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetStatusResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetStatusResponseResponseAuthentication_EncodeDecode(t *testing.T) {
	var typ GetStatusResponseResponseAuthentication
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetStatusResponseResponseAuthentication
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetStatusResponseResponseAuthenticationOAuth2_EncodeDecode(t *testing.T) {
	var typ GetStatusResponseResponseAuthenticationOAuth2
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetStatusResponseResponseAuthenticationOAuth2
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetStatusResponseResponseAuthenticationOAuth2Providers_EncodeDecode(t *testing.T) {
	var typ GetStatusResponseResponseAuthenticationOAuth2Providers
	typ = make(GetStatusResponseResponseAuthenticationOAuth2Providers)
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetStatusResponseResponseAuthenticationOAuth2Providers
	typ2 = make(GetStatusResponseResponseAuthenticationOAuth2Providers)
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetStatusResponseResponseBranding_EncodeDecode(t *testing.T) {
	var typ GetStatusResponseResponseBranding
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetStatusResponseResponseBranding
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetSubpageConfigByShortUuidRequestBody_EncodeDecode(t *testing.T) {
	var typ GetSubpageConfigByShortUuidRequestBody
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetSubpageConfigByShortUuidRequestBody
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetSubpageConfigByShortUuidRequestBodyRequestHeaders_EncodeDecode(t *testing.T) {
	var typ GetSubpageConfigByShortUuidRequestBodyRequestHeaders
	typ = make(GetSubpageConfigByShortUuidRequestBodyRequestHeaders)
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetSubpageConfigByShortUuidRequestBodyRequestHeaders
	typ2 = make(GetSubpageConfigByShortUuidRequestBodyRequestHeaders)
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetSubpageConfigByShortUuidResponse_EncodeDecode(t *testing.T) {
	var typ GetSubpageConfigByShortUuidResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetSubpageConfigByShortUuidResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetSubpageConfigByShortUuidResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetSubpageConfigByShortUuidResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetSubpageConfigByShortUuidResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetSubscriptionRequestHistoryResponse_EncodeDecode(t *testing.T) {
	var typ GetSubscriptionRequestHistoryResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetSubscriptionRequestHistoryResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetSubscriptionRequestHistoryStatsResponse_EncodeDecode(t *testing.T) {
	var typ GetSubscriptionRequestHistoryStatsResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetSubscriptionRequestHistoryStatsResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetSubscriptionRequestHistoryStatsResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetSubscriptionRequestHistoryStatsResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetSubscriptionRequestHistoryStatsResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetSubscriptionRequestHistoryStatsResponseResponseHourlyRequestStatsItem_EncodeDecode(t *testing.T) {
	var typ GetSubscriptionRequestHistoryStatsResponseResponseHourlyRequestStatsItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetSubscriptionRequestHistoryStatsResponseResponseHourlyRequestStatsItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetTopUsersByHwidDevicesResponse_EncodeDecode(t *testing.T) {
	var typ GetTopUsersByHwidDevicesResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetTopUsersByHwidDevicesResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetTopUsersByHwidDevicesResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetTopUsersByHwidDevicesResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetTopUsersByHwidDevicesResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetTopUsersByHwidDevicesResponseResponseUsersItem_EncodeDecode(t *testing.T) {
	var typ GetTopUsersByHwidDevicesResponseResponseUsersItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetTopUsersByHwidDevicesResponseResponseUsersItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetTorrentBlockerReportsStatsResponse_EncodeDecode(t *testing.T) {
	var typ GetTorrentBlockerReportsStatsResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetTorrentBlockerReportsStatsResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetTorrentBlockerReportsStatsResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetTorrentBlockerReportsStatsResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetTorrentBlockerReportsStatsResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetTorrentBlockerReportsStatsResponseResponseStats_EncodeDecode(t *testing.T) {
	var typ GetTorrentBlockerReportsStatsResponseResponseStats
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetTorrentBlockerReportsStatsResponseResponseStats
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetTorrentBlockerReportsStatsResponseResponseTopUsersItem_EncodeDecode(t *testing.T) {
	var typ GetTorrentBlockerReportsStatsResponseResponseTopUsersItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetTorrentBlockerReportsStatsResponseResponseTopUsersItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetUserAccessibleNodesResponse_EncodeDecode(t *testing.T) {
	var typ GetUserAccessibleNodesResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetUserAccessibleNodesResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetUserAccessibleNodesResponseResponse_EncodeDecode(t *testing.T) {
	var typ GetUserAccessibleNodesResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetUserAccessibleNodesResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetUserAccessibleNodesResponseResponseActiveNodesItem_EncodeDecode(t *testing.T) {
	var typ GetUserAccessibleNodesResponseResponseActiveNodesItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetUserAccessibleNodesResponseResponseActiveNodesItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetUserAccessibleNodesResponseResponseActiveNodesItemActiveSquadsItem_EncodeDecode(t *testing.T) {
	var typ GetUserAccessibleNodesResponseResponseActiveNodesItemActiveSquadsItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetUserAccessibleNodesResponseResponseActiveNodesItemActiveSquadsItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGetUserSubscriptionRequestHistoryResponse_EncodeDecode(t *testing.T) {
	var typ GetUserSubscriptionRequestHistoryResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 GetUserSubscriptionRequestHistoryResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestGithub_EncodeDecode(t *testing.T) {
	var typ Github
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Github
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestHeader_EncodeDecode(t *testing.T) {
	var typ Header
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Header
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestHostItem_EncodeDecode(t *testing.T) {
	var typ HostItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 HostItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestHostItemExcludeFromSubscriptionTypesItem_EncodeDecode(t *testing.T) {
	var typ HostItemExcludeFromSubscriptionTypesItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 HostItemExcludeFromSubscriptionTypesItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestHostItemSecurityLayer_EncodeDecode(t *testing.T) {
	var typ HostItemSecurityLayer
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 HostItemSecurityLayer
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestHostListResponse_EncodeDecode(t *testing.T) {
	var typ HostListResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 HostListResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestHostOverride_EncodeDecode(t *testing.T) {
	var typ HostOverride
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 HostOverride
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestHostResponse_EncodeDecode(t *testing.T) {
	var typ HostResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 HostResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestHwidDevicesResponse_EncodeDecode(t *testing.T) {
	var typ HwidDevicesResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 HwidDevicesResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestHwidSettings_EncodeDecode(t *testing.T) {
	var typ HwidSettings
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 HwidSettings
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestInbound_EncodeDecode(t *testing.T) {
	var typ Inbound
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Inbound
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestInboundItem_EncodeDecode(t *testing.T) {
	var typ InboundItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 InboundItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestInboundRef_EncodeDecode(t *testing.T) {
	var typ InboundRef
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 InboundRef
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestInboundsResponse_EncodeDecode(t *testing.T) {
	var typ InboundsResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 InboundsResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestInboundsResponseResponse_EncodeDecode(t *testing.T) {
	var typ InboundsResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 InboundsResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestInboundsResponseResponseInboundsItem_EncodeDecode(t *testing.T) {
	var typ InboundsResponseResponseInboundsItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 InboundsResponseResponseInboundsItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestInboundsStat_EncodeDecode(t *testing.T) {
	var typ InboundsStat
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 InboundsStat
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestInfraProviderResponseResponse_EncodeDecode(t *testing.T) {
	var typ InfraProviderResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 InfraProviderResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestInterfaceItem_EncodeDecode(t *testing.T) {
	var typ InterfaceItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 InterfaceItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestInternalServerError_EncodeDecode(t *testing.T) {
	var typ InternalServerError
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 InternalServerError
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestInternalSquad_EncodeDecode(t *testing.T) {
	var typ InternalSquad
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 InternalSquad
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestInternalSquadResponseResponse_EncodeDecode(t *testing.T) {
	var typ InternalSquadResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 InternalSquadResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestInternalSquadsResponInfoItem_EncodeDecode(t *testing.T) {
	var typ InternalSquadsResponInfoItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 InternalSquadsResponInfoItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestInternalSquadsResponse_EncodeDecode(t *testing.T) {
	var typ InternalSquadsResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 InternalSquadsResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestInternalSquadsResponseResponse_EncodeDecode(t *testing.T) {
	var typ InternalSquadsResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 InternalSquadsResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestIps_EncodeDecode(t *testing.T) {
	var typ Ips
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Ips
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestIpsResponseResponse_EncodeDecode(t *testing.T) {
	var typ IpsResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 IpsResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestIpsResponseResponseResponse_EncodeDecode(t *testing.T) {
	var typ IpsResponseResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 IpsResponseResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestKeycloak_EncodeDecode(t *testing.T) {
	var typ Keycloak
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Keycloak
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestLoginRequest_EncodeDecode(t *testing.T) {
	var typ LoginRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 LoginRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestNode_EncodeDecode(t *testing.T) {
	var typ Node
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Node
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestNodePlugin_EncodeDecode(t *testing.T) {
	var typ NodePlugin
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 NodePlugin
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestNodePluginResponseResponse_EncodeDecode(t *testing.T) {
	var typ NodePluginResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 NodePluginResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestNodePluginResponseResponseResponse_EncodeDecode(t *testing.T) {
	var typ NodePluginResponseResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 NodePluginResponseResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestNodePluginsResponseResponse_EncodeDecode(t *testing.T) {
	var typ NodePluginsResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 NodePluginsResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestNodePluginsResponseResponseResponse_EncodeDecode(t *testing.T) {
	var typ NodePluginsResponseResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 NodePluginsResponseResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestNodeResponse_EncodeDecode(t *testing.T) {
	var typ NodeResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 NodeResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestNodeResponseDataItem_EncodeDecode(t *testing.T) {
	var typ NodeResponseDataItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 NodeResponseDataItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestNodeResponseInfoItem_EncodeDecode(t *testing.T) {
	var typ NodeResponseInfoItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 NodeResponseInfoItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestNodesResponse_EncodeDecode(t *testing.T) {
	var typ NodesResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 NodesResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestNotFoundError_EncodeDecode(t *testing.T) {
	var typ NotFoundError
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 NotFoundError
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestOAuth2AuthorizeRequest_EncodeDecode(t *testing.T) {
	var typ OAuth2AuthorizeRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 OAuth2AuthorizeRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestOAuth2AuthorizeRequestProvider_EncodeDecode(t *testing.T) {
	var typ OAuth2AuthorizeRequestProvider
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 OAuth2AuthorizeRequestProvider
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestOAuth2AuthorizeResponse_EncodeDecode(t *testing.T) {
	var typ OAuth2AuthorizeResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 OAuth2AuthorizeResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestOAuth2AuthorizeResponseResponse_EncodeDecode(t *testing.T) {
	var typ OAuth2AuthorizeResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 OAuth2AuthorizeResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestOAuth2CallbackRequest_EncodeDecode(t *testing.T) {
	var typ OAuth2CallbackRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 OAuth2CallbackRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestOAuth2CallbackRequestProvider_EncodeDecode(t *testing.T) {
	var typ OAuth2CallbackRequestProvider
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 OAuth2CallbackRequestProvider
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestOauth2Settings_EncodeDecode(t *testing.T) {
	var typ Oauth2Settings
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Oauth2Settings
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPasskeyOptions_EncodeDecode(t *testing.T) {
	var typ PasskeyOptions
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PasskeyOptions
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPasskeySettings_EncodeDecode(t *testing.T) {
	var typ PasskeySettings
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PasskeySettings
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPasskeysResponse_EncodeDecode(t *testing.T) {
	var typ PasskeysResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PasskeysResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPasskeysResponseResponse_EncodeDecode(t *testing.T) {
	var typ PasskeysResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PasskeysResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPasskeysResponseResponsePasskeysItem_EncodeDecode(t *testing.T) {
	var typ PasskeysResponseResponsePasskeysItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PasskeysResponseResponsePasskeysItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPasswordSettings_EncodeDecode(t *testing.T) {
	var typ PasswordSettings
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PasswordSettings
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPluginExecutorRequest_EncodeDecode(t *testing.T) {
	var typ PluginExecutorRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PluginExecutorRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPluginExecutorRequestCommand_EncodeDecode(t *testing.T) {
	var typ PluginExecutorRequestCommand
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PluginExecutorRequestCommand
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPluginExecutorRequestCommand0_EncodeDecode(t *testing.T) {
	var typ PluginExecutorRequestCommand0
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PluginExecutorRequestCommand0
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPluginExecutorRequestCommand0Command_EncodeDecode(t *testing.T) {
	var typ PluginExecutorRequestCommand0Command
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PluginExecutorRequestCommand0Command
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPluginExecutorRequestCommand0IpsItem_EncodeDecode(t *testing.T) {
	var typ PluginExecutorRequestCommand0IpsItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PluginExecutorRequestCommand0IpsItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPluginExecutorRequestCommand1_EncodeDecode(t *testing.T) {
	var typ PluginExecutorRequestCommand1
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PluginExecutorRequestCommand1
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPluginExecutorRequestCommand1Command_EncodeDecode(t *testing.T) {
	var typ PluginExecutorRequestCommand1Command
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PluginExecutorRequestCommand1Command
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPluginExecutorRequestCommand2_EncodeDecode(t *testing.T) {
	var typ PluginExecutorRequestCommand2
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PluginExecutorRequestCommand2
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPluginExecutorRequestCommand2Command_EncodeDecode(t *testing.T) {
	var typ PluginExecutorRequestCommand2Command
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PluginExecutorRequestCommand2Command
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPluginExecutorRequestTargetNodes_EncodeDecode(t *testing.T) {
	var typ PluginExecutorRequestTargetNodes
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PluginExecutorRequestTargetNodes
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPluginExecutorRequestTargetNodes0_EncodeDecode(t *testing.T) {
	var typ PluginExecutorRequestTargetNodes0
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PluginExecutorRequestTargetNodes0
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPluginExecutorRequestTargetNodes0Target_EncodeDecode(t *testing.T) {
	var typ PluginExecutorRequestTargetNodes0Target
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PluginExecutorRequestTargetNodes0Target
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPluginExecutorRequestTargetNodes1_EncodeDecode(t *testing.T) {
	var typ PluginExecutorRequestTargetNodes1
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PluginExecutorRequestTargetNodes1
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPluginExecutorRequestTargetNodes1Target_EncodeDecode(t *testing.T) {
	var typ PluginExecutorRequestTargetNodes1Target
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 PluginExecutorRequestTargetNodes1Target
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestPocketid_EncodeDecode(t *testing.T) {
	var typ Pocketid
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Pocketid
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestProfileModificationRequest_EncodeDecode(t *testing.T) {
	var typ ProfileModificationRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ProfileModificationRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestProfileModificationRequestConfigProfile_EncodeDecode(t *testing.T) {
	var typ ProfileModificationRequestConfigProfile
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ProfileModificationRequestConfigProfile
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestProvider_EncodeDecode(t *testing.T) {
	var typ Provider
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Provider
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestProviderItem_EncodeDecode(t *testing.T) {
	var typ ProviderItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ProviderItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestRecord_EncodeDecode(t *testing.T) {
	var typ Record
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Record
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestRegisterRequest_EncodeDecode(t *testing.T) {
	var typ RegisterRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 RegisterRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestReorderHostRequest_EncodeDecode(t *testing.T) {
	var typ ReorderHostRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ReorderHostRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestReorderHostResponse_EncodeDecode(t *testing.T) {
	var typ ReorderHostResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ReorderHostResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestReorderHostResponseResponse_EncodeDecode(t *testing.T) {
	var typ ReorderHostResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ReorderHostResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestReorderNodeRequest_EncodeDecode(t *testing.T) {
	var typ ReorderNodeRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ReorderNodeRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestReorderRequest_EncodeDecode(t *testing.T) {
	var typ ReorderRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ReorderRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestReorderRequestItem_EncodeDecode(t *testing.T) {
	var typ ReorderRequestItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ReorderRequestItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestReportItem_EncodeDecode(t *testing.T) {
	var typ ReportItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ReportItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestResolveUserRequestBody_EncodeDecode(t *testing.T) {
	var typ ResolveUserRequestBody
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ResolveUserRequestBody
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestResolveUserResponse_EncodeDecode(t *testing.T) {
	var typ ResolveUserResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ResolveUserResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestResolveUserResponseResponse_EncodeDecode(t *testing.T) {
	var typ ResolveUserResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ResolveUserResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestResponseModification_EncodeDecode(t *testing.T) {
	var typ ResponseModification
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ResponseModification
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestResponseRules_EncodeDecode(t *testing.T) {
	var typ ResponseRules
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ResponseRules
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestResponseRulesVersion_EncodeDecode(t *testing.T) {
	var typ ResponseRulesVersion
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ResponseRulesVersion
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestRestartAllNodesRequestBody_EncodeDecode(t *testing.T) {
	var typ RestartAllNodesRequestBody
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 RestartAllNodesRequestBody
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestRevokeUserSubscriptionBody_EncodeDecode(t *testing.T) {
	var typ RevokeUserSubscriptionBody
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 RevokeUserSubscriptionBody
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestRule_EncodeDecode(t *testing.T) {
	var typ Rule
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Rule
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestRuleOperator_EncodeDecode(t *testing.T) {
	var typ RuleOperator
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 RuleOperator
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestRuleResponseType_EncodeDecode(t *testing.T) {
	var typ RuleResponseType
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 RuleResponseType
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSetInboundToManyHostsRequest_EncodeDecode(t *testing.T) {
	var typ SetInboundToManyHostsRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SetInboundToManyHostsRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSetPortToManyHostsRequest_EncodeDecode(t *testing.T) {
	var typ SetPortToManyHostsRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SetPortToManyHostsRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSettingsResponse_EncodeDecode(t *testing.T) {
	var typ SettingsResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SettingsResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSettingsResponseResponse_EncodeDecode(t *testing.T) {
	var typ SettingsResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SettingsResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSnippetRequest_EncodeDecode(t *testing.T) {
	var typ SnippetRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SnippetRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSnippetRequestSnippetItem_EncodeDecode(t *testing.T) {
	var typ SnippetRequestSnippetItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SnippetRequestSnippetItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSnippetsResponse_EncodeDecode(t *testing.T) {
	var typ SnippetsResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SnippetsResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSnippetsResponseResponse_EncodeDecode(t *testing.T) {
	var typ SnippetsResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SnippetsResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSnippetsResponseResponseSnippetsItem_EncodeDecode(t *testing.T) {
	var typ SnippetsResponseResponseSnippetsItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SnippetsResponseResponseSnippetsItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestStat_EncodeDecode(t *testing.T) {
	var typ Stat
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Stat
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestStatsUserUsageResponseResponse_EncodeDecode(t *testing.T) {
	var typ StatsUserUsageResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 StatsUserUsageResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestStatsUserUsageResponseResponseResponse_EncodeDecode(t *testing.T) {
	var typ StatsUserUsageResponseResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 StatsUserUsageResponseResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestStatsUserUsageResponseResponseResponseSeriesItem_EncodeDecode(t *testing.T) {
	var typ StatsUserUsageResponseResponseResponseSeriesItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 StatsUserUsageResponseResponseResponseSeriesItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSubscription_EncodeDecode(t *testing.T) {
	var typ Subscription
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Subscription
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSubscriptionPageConfigResponseResponse_EncodeDecode(t *testing.T) {
	var typ SubscriptionPageConfigResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SubscriptionPageConfigResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSubscriptionPageConfigResponseResponseResponse_EncodeDecode(t *testing.T) {
	var typ SubscriptionPageConfigResponseResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SubscriptionPageConfigResponseResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSubscriptionPageConfigsResponseResponse_EncodeDecode(t *testing.T) {
	var typ SubscriptionPageConfigsResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SubscriptionPageConfigsResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSubscriptionPageConfigsResponseResponseResponse_EncodeDecode(t *testing.T) {
	var typ SubscriptionPageConfigsResponseResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SubscriptionPageConfigsResponseResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSubscriptionResponse_EncodeDecode(t *testing.T) {
	var typ SubscriptionResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SubscriptionResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSubscriptionSettings_EncodeDecode(t *testing.T) {
	var typ SubscriptionSettings
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SubscriptionSettings
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSubscriptionSettingsResponse_EncodeDecode(t *testing.T) {
	var typ SubscriptionSettingsResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SubscriptionSettingsResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSubscriptionSettingsResponseResponse_EncodeDecode(t *testing.T) {
	var typ SubscriptionSettingsResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SubscriptionSettingsResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSubscriptionSettingsResponseResponseCustomResponseHeaders_EncodeDecode(t *testing.T) {
	var typ SubscriptionSettingsResponseResponseCustomResponseHeaders
	typ = make(SubscriptionSettingsResponseResponseCustomResponseHeaders)
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SubscriptionSettingsResponseResponseCustomResponseHeaders
	typ2 = make(SubscriptionSettingsResponseResponseCustomResponseHeaders)
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSubscriptionSsConfLinks_EncodeDecode(t *testing.T) {
	var typ SubscriptionSsConfLinks
	typ = make(SubscriptionSsConfLinks)
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SubscriptionSsConfLinks
	typ2 = make(SubscriptionSsConfLinks)
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestSystemItem_EncodeDecode(t *testing.T) {
	var typ SystemItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 SystemItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestTagsResponse_EncodeDecode(t *testing.T) {
	var typ TagsResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 TagsResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestTagsResponseResponse_EncodeDecode(t *testing.T) {
	var typ TagsResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 TagsResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestTelegram_EncodeDecode(t *testing.T) {
	var typ Telegram
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Telegram
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestTemplate_EncodeDecode(t *testing.T) {
	var typ Template
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Template
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestTemplateRef_EncodeDecode(t *testing.T) {
	var typ TemplateRef
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 TemplateRef
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestTemplateRefTemplateType_EncodeDecode(t *testing.T) {
	var typ TemplateRefTemplateType
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 TemplateRefTemplateType
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestTemplateResponse_EncodeDecode(t *testing.T) {
	var typ TemplateResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 TemplateResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestTemplateTemplateType_EncodeDecode(t *testing.T) {
	var typ TemplateTemplateType
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 TemplateTemplateType
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestTemplatesResponse_EncodeDecode(t *testing.T) {
	var typ TemplatesResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 TemplatesResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestTemplatesResponseResponse_EncodeDecode(t *testing.T) {
	var typ TemplatesResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 TemplatesResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestTokenResponse_EncodeDecode(t *testing.T) {
	var typ TokenResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 TokenResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestTokenResponseResponse_EncodeDecode(t *testing.T) {
	var typ TokenResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 TokenResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestTopNode_EncodeDecode(t *testing.T) {
	var typ TopNode
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 TopNode
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestTorrentBlockerReportsResponseResponse_EncodeDecode(t *testing.T) {
	var typ TorrentBlockerReportsResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 TorrentBlockerReportsResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestTorrentBlockerReportsResponseResponseResponse_EncodeDecode(t *testing.T) {
	var typ TorrentBlockerReportsResponseResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 TorrentBlockerReportsResponseResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestTorrentBlockerReportsResponseResponseResponseRecordsItem_EncodeDecode(t *testing.T) {
	var typ TorrentBlockerReportsResponseResponseResponseRecordsItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 TorrentBlockerReportsResponseResponseResponseRecordsItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestTorrentBlockerReportsResponseResponseResponseRecordsItemUser_EncodeDecode(t *testing.T) {
	var typ TorrentBlockerReportsResponseResponseResponseRecordsItemUser
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 TorrentBlockerReportsResponseResponseResponseRecordsItemUser
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUnauthorizedError_EncodeDecode(t *testing.T) {
	var typ UnauthorizedError
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UnauthorizedError
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateConfigProfileRequest_EncodeDecode(t *testing.T) {
	var typ UpdateConfigProfileRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateConfigProfileRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateConfigProfileRequestConfig_EncodeDecode(t *testing.T) {
	var typ UpdateConfigProfileRequestConfig
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateConfigProfileRequestConfig
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateExternalSquadRequest_EncodeDecode(t *testing.T) {
	var typ UpdateExternalSquadRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateExternalSquadRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateExternalSquadRequestResponseHeaders_EncodeDecode(t *testing.T) {
	var typ UpdateExternalSquadRequestResponseHeaders
	typ = make(UpdateExternalSquadRequestResponseHeaders)
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateExternalSquadRequestResponseHeaders
	typ2 = make(UpdateExternalSquadRequestResponseHeaders)
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateHostRequest_EncodeDecode(t *testing.T) {
	var typ UpdateHostRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateHostRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateHostRequestAlpn_EncodeDecode(t *testing.T) {
	var typ UpdateHostRequestAlpn
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateHostRequestAlpn
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateHostRequestExcludeFromSubscriptionTypesItem_EncodeDecode(t *testing.T) {
	var typ UpdateHostRequestExcludeFromSubscriptionTypesItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateHostRequestExcludeFromSubscriptionTypesItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateHostRequestFingerprint_EncodeDecode(t *testing.T) {
	var typ UpdateHostRequestFingerprint
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateHostRequestFingerprint
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateHostRequestSecurityLayer_EncodeDecode(t *testing.T) {
	var typ UpdateHostRequestSecurityLayer
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateHostRequestSecurityLayer
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateInfraBillingNodeRequest_EncodeDecode(t *testing.T) {
	var typ UpdateInfraBillingNodeRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateInfraBillingNodeRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateInfraProviderRequest_EncodeDecode(t *testing.T) {
	var typ UpdateInfraProviderRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateInfraProviderRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateInternalSquadRequest_EncodeDecode(t *testing.T) {
	var typ UpdateInternalSquadRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateInternalSquadRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateNodePluginRequest_EncodeDecode(t *testing.T) {
	var typ UpdateNodePluginRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateNodePluginRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateNodeRequest_EncodeDecode(t *testing.T) {
	var typ UpdateNodeRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateNodeRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdatePasskeyRequest_EncodeDecode(t *testing.T) {
	var typ UpdatePasskeyRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdatePasskeyRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateRemnawaveSettingsRequest_EncodeDecode(t *testing.T) {
	var typ UpdateRemnawaveSettingsRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateRemnawaveSettingsRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateSubscriptionPageConfigRequest_EncodeDecode(t *testing.T) {
	var typ UpdateSubscriptionPageConfigRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateSubscriptionPageConfigRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateSubscriptionSettingsRequest_EncodeDecode(t *testing.T) {
	var typ UpdateSubscriptionSettingsRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateSubscriptionSettingsRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateSubscriptionSettingsRequestCustomResponseHeaders_EncodeDecode(t *testing.T) {
	var typ UpdateSubscriptionSettingsRequestCustomResponseHeaders
	typ = make(UpdateSubscriptionSettingsRequestCustomResponseHeaders)
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateSubscriptionSettingsRequestCustomResponseHeaders
	typ2 = make(UpdateSubscriptionSettingsRequestCustomResponseHeaders)
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateTemplateRequest_EncodeDecode(t *testing.T) {
	var typ UpdateTemplateRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateTemplateRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateTemplateRequestTemplateJson_EncodeDecode(t *testing.T) {
	var typ UpdateTemplateRequestTemplateJson
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateTemplateRequestTemplateJson
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateUserRequest_EncodeDecode(t *testing.T) {
	var typ UpdateUserRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateUserRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateUserRequestStatus_EncodeDecode(t *testing.T) {
	var typ UpdateUserRequestStatus
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateUserRequestStatus
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpdateUserRequestTrafficLimitStrategy_EncodeDecode(t *testing.T) {
	var typ UpdateUserRequestTrafficLimitStrategy
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpdateUserRequestTrafficLimitStrategy
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpsertUserMetadataRequestBodyRequest_EncodeDecode(t *testing.T) {
	var typ UpsertUserMetadataRequestBodyRequest
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpsertUserMetadataRequestBodyRequest
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUpsertUserMetadataRequestBodyRequestMetadata_EncodeDecode(t *testing.T) {
	var typ UpsertUserMetadataRequestBodyRequestMetadata
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UpsertUserMetadataRequestBodyRequestMetadata
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUserItem2_EncodeDecode(t *testing.T) {
	var typ UserItem2
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UserItem2
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUserItem2TrafficLimitStrategy_EncodeDecode(t *testing.T) {
	var typ UserItem2TrafficLimitStrategy
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UserItem2TrafficLimitStrategy
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUserItem2UserStatus_EncodeDecode(t *testing.T) {
	var typ UserItem2UserStatus
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UserItem2UserStatus
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUserItemInfo_EncodeDecode(t *testing.T) {
	var typ UserItemInfo
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UserItemInfo
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUserItemInfoStatus_EncodeDecode(t *testing.T) {
	var typ UserItemInfoStatus
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UserItemInfoStatus
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUserItemInfoTrafficLimitStrategy_EncodeDecode(t *testing.T) {
	var typ UserItemInfoTrafficLimitStrategy
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UserItemInfoTrafficLimitStrategy
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUserMetadataResponseResponse_EncodeDecode(t *testing.T) {
	var typ UserMetadataResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UserMetadataResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUserMetadataResponseResponseResponse_EncodeDecode(t *testing.T) {
	var typ UserMetadataResponseResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UserMetadataResponseResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUserMetadataResponseResponseResponseMetadata_EncodeDecode(t *testing.T) {
	var typ UserMetadataResponseResponseResponseMetadata
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UserMetadataResponseResponseResponseMetadata
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUserResponse_EncodeDecode(t *testing.T) {
	var typ UserResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UserResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUserSubscriptionHistory_EncodeDecode(t *testing.T) {
	var typ UserSubscriptionHistory
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UserSubscriptionHistory
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUserTrafficItem_EncodeDecode(t *testing.T) {
	var typ UserTrafficItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UserTrafficItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestUsersResponse_EncodeDecode(t *testing.T) {
	var typ UsersResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 UsersResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestValidationError_EncodeDecode(t *testing.T) {
	var typ ValidationError
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 ValidationError
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestVerifyPasskeyRegistrationResponse_EncodeDecode(t *testing.T) {
	var typ VerifyPasskeyRegistrationResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 VerifyPasskeyRegistrationResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestVerifyPasskeyRegistrationResponseResponse_EncodeDecode(t *testing.T) {
	var typ VerifyPasskeyRegistrationResponseResponse
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 VerifyPasskeyRegistrationResponseResponse
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestVersion_EncodeDecode(t *testing.T) {
	var typ Version
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 Version
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}
func TestXrayReportItem_EncodeDecode(t *testing.T) {
	var typ XrayReportItem
	typ.SetFake()

	e := jx.Encoder{}
	typ.Encode(&e)
	data := e.Bytes()
	require.True(t, std.Valid(data), "Encoded: %s", data)

	var typ2 XrayReportItem
	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
}