Repository: ogen-go/ogen
Pull request #336 (2022-05-12 14:41:33)

feat: mediatype


Patch:
diff --git a/dsl.go b/dsl.go
index 6ba714c0..3cf99461 100644
--- a/dsl.go
+++ b/dsl.go
@@ -625,7 +625,7 @@ func (p *Parameter) SetDescription(d string) *Parameter {
 // SetSchema sets the Schema of the Parameter.
 func (p *Parameter) SetSchema(s *Schema) *Parameter {
 	if s != nil {
-		p.Schema = *s
+		p.Schema = s
 	}
 	return p
 }
diff --git a/gen/gen_contents.go b/gen/gen_contents.go
index 712cf7ff..2dfd8d21 100644
--- a/gen/gen_contents.go
+++ b/gen/gen_contents.go
@@ -7,10 +7,10 @@ import (
 	"github.com/go-faster/errors"
 
 	"github.com/ogen-go/ogen/gen/ir"
-	"github.com/ogen-go/ogen/jsonschema"
+	"github.com/ogen-go/ogen/openapi"
 )
 
-func filterMostSpecific(contents map[string]*jsonschema.Schema) error {
+func filterMostSpecific(contents map[string]*openapi.MediaType) error {
 	initialLength := len(contents)
 	keep := func(current, mask string) bool {
 		// Special case for "*", "**", etc.
@@ -49,7 +49,7 @@ func filterMostSpecific(contents map[string]*jsonschema.Schema) error {
 	return nil
 }
 
-func (g *Generator) generateContents(ctx *genctx, name string, optional bool, contents map[string]*jsonschema.Schema) (_ map[ir.ContentType]*ir.Type, err error) {
+func (g *Generator) generateContents(ctx *genctx, name string, optional bool, contents map[string]*openapi.MediaType) (_ map[ir.ContentType]*ir.Type, err error) {
 	var (
 		result      = make(map[ir.ContentType]*ir.Type, len(contents))
 		unsupported []string
@@ -58,7 +58,7 @@ func (g *Generator) generateContents(ctx *genctx, name string, optional bool, co
 		return nil, errors.Wrap(err, "filter most specific")
 	}
 
-	for contentType, schema := range contents {
+	for contentType, media := range contents {
 		parsedContentType, _, err := mime.ParseMediaType(contentType)
 		if err != nil {
 			return nil, errors.Wrapf(err, "parse content type %q", contentType)
@@ -76,7 +76,7 @@ func (g *Generator) generateContents(ctx *genctx, name string, optional bool, co
 		if err := func() error {
 			switch parsedContentType {
 			case "application/json":
-				t, err := g.generateSchema(ctx, typeName, schema)
+				t, err := g.generateSchema(ctx, typeName, media.Schema)
 				if err != nil {
 					return errors.Wrap(err, "schema")
 				}
@@ -94,8 +94,8 @@ func (g *Generator) generateContents(ctx *genctx, name string, optional bool, co
 				return nil
 
 			case "application/octet-stream":
-				if schema != nil && !isBinary(schema) {
-					return errors.Errorf("octet stream with %q schema not supported", schema.Type)
+				if media.Schema != nil && !isBinary(media.Schema) {
+					return errors.Errorf("octet stream with %q schema not supported", media.Schema.Type)
 				}
 
 				t := ir.Stream(typeName)
@@ -103,7 +103,7 @@ func (g *Generator) generateContents(ctx *genctx, name string, optional bool, co
 				return ctx.saveType(t)
 
 			default:
-				if isBinary(schema) {
+				if isBinary(media.Schema) {
 					t := ir.Stream(typeName)
 					result[ir.ContentType(contentType)] = t
 					return ctx.saveType(t)
diff --git a/gen/gen_request_body.go b/gen/gen_request_body.go
index bf5f21a3..b166df41 100644
--- a/gen/gen_request_body.go
+++ b/gen/gen_request_body.go
@@ -10,7 +10,7 @@ import (
 func (g *Generator) generateRequest(ctx *genctx, opName string, body *openapi.RequestBody) (*ir.Request, error) {
 	name := opName + "Req"
 
-	contents, err := g.generateContents(ctx, name, !body.Required, body.Contents)
+	contents, err := g.generateContents(ctx, name, !body.Required, body.Content)
 	if err != nil {
 		return nil, errors.Wrap(err, "contents")
 	}
diff --git a/gen/gen_responses.go b/gen/gen_responses.go
index 95c79de1..95f4be58 100644
--- a/gen/gen_responses.go
+++ b/gen/gen_responses.go
@@ -145,7 +145,7 @@ func (g *Generator) responseToIR(ctx *genctx, name, doc string, resp *openapi.Re
 		}()
 	}
 
-	if len(resp.Contents) == 0 {
+	if len(resp.Content) == 0 {
 		t := &ir.Type{
 			Kind: ir.KindStruct,
 			Name: name,
@@ -161,7 +161,7 @@ func (g *Generator) responseToIR(ctx *genctx, name, doc string, resp *openapi.Re
 		}, nil
 	}
 
-	contents, err := g.generateContents(ctx, name, false, resp.Contents)
+	contents, err := g.generateContents(ctx, name, false, resp.Content)
 	if err != nil {
 		return nil, errors.Wrap(err, "contents")
 	}
diff --git a/openapi/mediatype.go b/openapi/mediatype.go
new file mode 100644
index 00000000..929276e4
--- /dev/null
+++ b/openapi/mediatype.go
@@ -0,0 +1,14 @@
+package openapi
+
+import (
+	"encoding/json"
+
+	"github.com/ogen-go/ogen/jsonschema"
+)
+
+type MediaType struct {
+	Schema   *jsonschema.Schema
+	Example  json.RawMessage
+	Examples map[string]*Example
+	// Encoding map[string]*Encoding
+}
diff --git a/openapi/operation.go b/openapi/operation.go
index d2726fd4..64888a99 100644
--- a/openapi/operation.go
+++ b/openapi/operation.go
@@ -1,7 +1,5 @@
 package openapi
 
-import "github.com/ogen-go/ogen/jsonschema"
-
 // Operation is an OpenAPI Operation.
 type Operation struct {
 	OperationID string // optional
@@ -45,12 +43,15 @@ type PathPart struct {
 
 // RequestBody of an OpenAPI Operation.
 type RequestBody struct {
-	Contents map[string]*jsonschema.Schema
+	Content  map[string]*MediaType
 	Required bool
 }
 
 // Response is an OpenAPI Response definition.
 type Response struct {
-	Ref      string
-	Contents map[string]*jsonschema.Schema
+	Ref         string
+	Description string
+	// Headers map[string]*Header
+	Content map[string]*MediaType
+	// Links map[string]*Link
 }
diff --git a/openapi/parameter.go b/openapi/parameter.go
index b667b9b6..d0f6005c 100644
--- a/openapi/parameter.go
+++ b/openapi/parameter.go
@@ -25,11 +25,11 @@ type Parameter struct {
 	Name        string
 	Description string
 	Schema      *jsonschema.Schema
-
-	In       ParameterLocation
-	Style    ParameterStyle
-	Explode  bool
-	Required bool
+	Content     map[string]*MediaType
+	In          ParameterLocation
+	Style       ParameterStyle
+	Explode     bool
+	Required    bool
 }
 
 type ParameterStyle string
diff --git a/openapi/parser/parse_example.go b/openapi/parser/parse_example.go
new file mode 100644
index 00000000..ad7c98e5
--- /dev/null
+++ b/openapi/parser/parse_example.go
@@ -0,0 +1,28 @@
+package parser
+
+import (
+	"github.com/go-faster/errors"
+	"github.com/ogen-go/ogen"
+	"github.com/ogen-go/ogen/openapi"
+)
+
+func (p *parser) parseExample(e *ogen.Example, ctx resolveCtx) (*openapi.Example, error) {
+	if e == nil {
+		return nil, nil
+	}
+
+	if ref := e.Ref; ref != "" {
+		ex, err := p.resolveExample(ref, ctx)
+		if err != nil {
+			return nil, errors.Wrapf(err, "resolve %q", ref)
+		}
+		return ex, nil
+	}
+
+	return &openapi.Example{
+		Summary:       e.Summary,
+		Description:   e.Description,
+		Value:         e.Value,
+		ExternalValue: e.ExternalValue,
+	}, nil
+}
diff --git a/openapi/parser/parse_mediatype.go b/openapi/parser/parse_mediatype.go
new file mode 100644
index 00000000..69ca3d2e
--- /dev/null
+++ b/openapi/parser/parse_mediatype.go
@@ -0,0 +1,43 @@
+package parser
+
+import (
+	"github.com/go-faster/errors"
+	"github.com/ogen-go/ogen"
+	"github.com/ogen-go/ogen/openapi"
+)
+
+func (p *parser) parseMediaType(m ogen.Media) (*openapi.MediaType, error) {
+	s, err := p.schemaParser.Parse(m.Schema.ToJSONSchema())
+	if err != nil {
+		return nil, errors.Wrap(err, "schema")
+	}
+
+	examples := make(map[string]*openapi.Example, len(m.Examples))
+	for name, ex := range m.Examples {
+		e, err := p.parseExample(ex, resolveCtx{})
+		if err != nil {
+			return nil, errors.Wrapf(err, "examples: %q", name)
+		}
+
+		examples[name] = e
+	}
+
+	// OpenAPI 3.0.3 doc says:
+	//
+	//   Furthermore, referencing a schema which contains an example,
+	//   the example value SHALL override the example provided by the schema.
+	//
+	// Probably this will be rewritten later.
+	// Kept for backward compatibility.
+	s.AddExample(m.Example)
+	for _, ex := range examples {
+		s.AddExample(ex.Value)
+
+	}
+
+	return &openapi.MediaType{
+		Schema:   s,
+		Example:  m.Example,
+		Examples: examples,
+	}, nil
+}
diff --git a/openapi/parser/parse_parameter.go b/openapi/parser/parse_parameter.go
index fbbe3df5..5bde73fc 100644
--- a/openapi/parser/parse_parameter.go
+++ b/openapi/parser/parse_parameter.go
@@ -91,7 +91,7 @@ func (p *parser) parseParameter(param *ogen.Parameter, ctx resolveCtx) (*openapi
 		Required:    param.Required,
 	}
 
-	if param.Content != nil {
+	if param.Content != nil || param.Schema == nil {
 		// Incorrect, but used to keep the original behaviour
 		// and not break tests.
 		//
diff --git a/openapi/parser/parse_request_body.go b/openapi/parser/parse_request_body.go
index 7b8be695..13175090 100644
--- a/openapi/parser/parse_request_body.go
+++ b/openapi/parser/parse_request_body.go
@@ -4,7 +4,6 @@ import (
 	"github.com/go-faster/errors"
 
 	"github.com/ogen-go/ogen"
-	"github.com/ogen-go/ogen/jsonschema"
 	"github.com/ogen-go/ogen/openapi"
 )
 
@@ -26,17 +25,17 @@ func (p *parser) parseRequestBody(body *ogen.RequestBody, ctx resolveCtx) (*open
 	}
 
 	result := &openapi.RequestBody{
-		Contents: make(map[string]*jsonschema.Schema, len(body.Content)),
+		Content:  make(map[string]*openapi.MediaType, len(body.Content)),
 		Required: body.Required,
 	}
 
 	for contentType, media := range body.Content {
-		schema, err := p.schemaParser.Parse(media.Schema.ToJSONSchema())
+		m, err := p.parseMediaType(media)
 		if err != nil {
-			return nil, errors.Wrapf(err, "content: %q: parse schema", contentType)
+			return nil, errors.Wrapf(err, "content: %q", contentType)
 		}
 
-		result.Contents[contentType] = schema
+		result.Content[contentType] = m
 	}
 
 	return result, nil
diff --git a/openapi/parser/parse_response.go b/openapi/parser/parse_response.go
index 78d4b2cb..cabfacf5 100644
--- a/openapi/parser/parse_response.go
+++ b/openapi/parser/parse_response.go
@@ -6,7 +6,6 @@ import (
 	"github.com/go-faster/errors"
 
 	"github.com/ogen-go/ogen"
-	"github.com/ogen-go/ogen/jsonschema"
 	"github.com/ogen-go/ogen/openapi"
 )
 
@@ -54,26 +53,15 @@ func (p *parser) parseResponse(resp *ogen.Response, ctx resolveCtx) (*openapi.Re
 	}
 
 	response := &openapi.Response{
-		Contents: make(map[string]*jsonschema.Schema, len(resp.Content)),
+		Content: make(map[string]*openapi.MediaType, len(resp.Content)),
 	}
 	for contentType, media := range resp.Content {
-		schema, err := p.schemaParser.Parse(media.Schema.ToJSONSchema())
+		m, err := p.parseMediaType(media)
 		if err != nil {
-			return nil, errors.Wrapf(err, "content: %q: schema", contentType)
-		}
-		schema.AddExample(media.Example)
-		for _, example := range media.Examples {
-			schema.AddExample(example.Value)
-			if ref := example.Ref; ref != "" {
-				r, err := p.resolveExample(ref)
-				if err != nil {
-					return nil, errors.Wrapf(err, "resolve: %q", ref)
-				}
-				schema.AddExample(r.Value)
-			}
+			return nil, errors.Wrapf(err, "content: %q", contentType)
 		}
 
-		response.Contents[contentType] = schema
+		response.Content[contentType] = m
 	}
 
 	return response, nil
diff --git a/openapi/parser/ref.go b/openapi/parser/ref.go
index c64acd76..95bc2fdc 100644
--- a/openapi/parser/ref.go
+++ b/openapi/parser/ref.go
@@ -102,7 +102,7 @@ func (p *parser) resolveParameter(ref string, ctx resolveCtx) (*openapi.Paramete
 	return param, nil
 }
 
-func (p *parser) resolveExample(ref string) (*openapi.Example, error) {
+func (p *parser) resolveExample(ref string, ctx resolveCtx) (*openapi.Example, error) {
 	const prefix = "#/components/examples/"
 	if !strings.HasPrefix(ref, prefix) {
 		return nil, errors.Errorf("invalid example reference: %q", ref)
@@ -112,21 +112,25 @@ func (p *parser) resolveExample(ref string) (*openapi.Example, error) {
 		return param, nil
 	}
 
+	if _, ok := ctx[ref]; ok {
+		return nil, errors.Errorf("infinite recursion: %q", ref)
+	}
+	ctx[ref] = struct{}{}
+
 	name := strings.TrimPrefix(ref, prefix)
 	component, found := p.spec.Components.Examples[name]
 	if !found {
 		return nil, errors.Errorf("component by reference %q not found", ref)
 	}
-	example := &openapi.Example{
-		Ref:           component.Ref,
-		Summary:       component.Summary,
-		Description:   component.Description,
-		Value:         component.Value,
-		ExternalValue: component.ExternalValue,
+
+	ex, err := p.parseExample(component, ctx)
+	if err != nil {
+		return nil, err
 	}
 
-	p.refs.examples[ref] = example
-	return example, nil
+	ex.Ref = ref
+	p.refs.examples[ref] = ex
+	return ex, nil
 }
 
 func (p *parser) resolveSecuritySchema(ref string, ctx resolveCtx) (*ogen.SecuritySchema, error) {
diff --git a/spec.go b/spec.go
index 366d5fec..82adbe9a 100644
--- a/spec.go
+++ b/spec.go
@@ -196,9 +196,9 @@ type Parameter struct {
 	Name string `json:"name"`
 
 	// The location of the parameter. Possible values are "query", "header", "path" or "cookie".
-	In          string `json:"in"`
-	Description string `json:"description,omitempty"`
-	Schema      Schema `json:"schema"`
+	In          string  `json:"in"`
+	Description string  `json:"description,omitempty"`
+	Schema      *Schema `json:"schema,omitempty"`
 
 	// Determines whether this parameter is mandatory.
 	// If the parameter location is "path", this property is REQUIRED


Test patch:
diff --git a/dsl_test.go b/dsl_test.go
index a5c57abd..856e6853 100644
--- a/dsl_test.go
+++ b/dsl_test.go
@@ -123,7 +123,7 @@ func TestBuilder(t *testing.T) {
 							In:          "path",
 							Description: "ID Parameter in path",
 							Required:    true,
-							Schema:      ogen.Schema{Type: "integer", Format: "int32"},
+							Schema:      &ogen.Schema{Type: "integer", Format: "int32"},
 						},
 					},
 					Responses: ogen.Responses{
diff --git a/examples/ex_github/oas_test_examples_gen_test.go b/examples/ex_github/oas_test_examples_gen_test.go
index f9397c08..c61652ac 100644
--- a/examples/ex_github/oas_test_examples_gen_test.go
+++ b/examples/ex_github/oas_test_examples_gen_test.go
@@ -184,6 +184,36 @@ func TestActionsCreateOrUpdateEnvironmentSecretReq_EncodeDecode(t *testing.T) {
 	var typ2 ActionsCreateOrUpdateEnvironmentSecretReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestActionsCreateOrUpdateEnvironmentSecretReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"encrypted_value\": \"c2VjcmV0\",\n                \"key_id\": \"012345678912345678\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ActionsCreateOrUpdateEnvironmentSecretReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ActionsCreateOrUpdateEnvironmentSecretReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestActionsCreateOrUpdateOrgSecretReq_EncodeDecode(t *testing.T) {
 	var typ ActionsCreateOrUpdateOrgSecretReq
 	typ.SetFake()
@@ -196,6 +226,36 @@ func TestActionsCreateOrUpdateOrgSecretReq_EncodeDecode(t *testing.T) {
 	var typ2 ActionsCreateOrUpdateOrgSecretReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestActionsCreateOrUpdateOrgSecretReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"encrypted_value\": \"c2VjcmV0\",\n                \"key_id\": \"012345678912345678\",\n                \"visibility\": \"selected\",\n                \"selected_repository_ids\": [\n                  \"1296269\",\n                  \"1296280\"\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ActionsCreateOrUpdateOrgSecretReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ActionsCreateOrUpdateOrgSecretReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestActionsCreateOrUpdateOrgSecretReqVisibility_EncodeDecode(t *testing.T) {
 	var typ ActionsCreateOrUpdateOrgSecretReqVisibility
 	typ.SetFake()
@@ -232,6 +292,36 @@ func TestActionsCreateOrUpdateRepoSecretReq_EncodeDecode(t *testing.T) {
 	var typ2 ActionsCreateOrUpdateRepoSecretReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestActionsCreateOrUpdateRepoSecretReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"encrypted_value\": \"c2VjcmV0\",\n                \"key_id\": \"012345678912345678\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ActionsCreateOrUpdateRepoSecretReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ActionsCreateOrUpdateRepoSecretReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestActionsCreateSelfHostedRunnerGroupForOrgReq_EncodeDecode(t *testing.T) {
 	var typ ActionsCreateSelfHostedRunnerGroupForOrgReq
 	typ.SetFake()
@@ -244,6 +334,36 @@ func TestActionsCreateSelfHostedRunnerGroupForOrgReq_EncodeDecode(t *testing.T)
 	var typ2 ActionsCreateSelfHostedRunnerGroupForOrgReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestActionsCreateSelfHostedRunnerGroupForOrgReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"name\": \"Expensive hardware runners\",\n                \"visibility\": \"selected\",\n                \"selected_repository_ids\": [\n                  32,\n                  91\n                ],\n                \"runners\": [\n                  9,\n                  2\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ActionsCreateSelfHostedRunnerGroupForOrgReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ActionsCreateSelfHostedRunnerGroupForOrgReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestActionsCreateSelfHostedRunnerGroupForOrgReqVisibility_EncodeDecode(t *testing.T) {
 	var typ ActionsCreateSelfHostedRunnerGroupForOrgReqVisibility
 	typ.SetFake()
@@ -1198,6 +1318,36 @@ func TestActionsSetGithubActionsPermissionsOrganizationReq_EncodeDecode(t *testi
 	var typ2 ActionsSetGithubActionsPermissionsOrganizationReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestActionsSetGithubActionsPermissionsOrganizationReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"enabled_repositories\": \"all\",\n                \"allowed_actions\": \"selected\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ActionsSetGithubActionsPermissionsOrganizationReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ActionsSetGithubActionsPermissionsOrganizationReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestActionsSetGithubActionsPermissionsRepositoryReq_EncodeDecode(t *testing.T) {
 	var typ ActionsSetGithubActionsPermissionsRepositoryReq
 	typ.SetFake()
@@ -1210,6 +1360,36 @@ func TestActionsSetGithubActionsPermissionsRepositoryReq_EncodeDecode(t *testing
 	var typ2 ActionsSetGithubActionsPermissionsRepositoryReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestActionsSetGithubActionsPermissionsRepositoryReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"enabled\": true,\n                \"allowed_actions\": \"selected\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ActionsSetGithubActionsPermissionsRepositoryReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ActionsSetGithubActionsPermissionsRepositoryReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestActionsSetRepoAccessToSelfHostedRunnerGroupInOrgReq_EncodeDecode(t *testing.T) {
 	var typ ActionsSetRepoAccessToSelfHostedRunnerGroupInOrgReq
 	typ.SetFake()
@@ -1222,6 +1402,36 @@ func TestActionsSetRepoAccessToSelfHostedRunnerGroupInOrgReq_EncodeDecode(t *tes
 	var typ2 ActionsSetRepoAccessToSelfHostedRunnerGroupInOrgReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestActionsSetRepoAccessToSelfHostedRunnerGroupInOrgReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"selected_repository_ids\": [\n                  32,\n                  91\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ActionsSetRepoAccessToSelfHostedRunnerGroupInOrgReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ActionsSetRepoAccessToSelfHostedRunnerGroupInOrgReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestActionsSetSelectedReposForOrgSecretReq_EncodeDecode(t *testing.T) {
 	var typ ActionsSetSelectedReposForOrgSecretReq
 	typ.SetFake()
@@ -1234,6 +1444,36 @@ func TestActionsSetSelectedReposForOrgSecretReq_EncodeDecode(t *testing.T) {
 	var typ2 ActionsSetSelectedReposForOrgSecretReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestActionsSetSelectedReposForOrgSecretReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"selected_repository_ids\": [\n                  64780797\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ActionsSetSelectedReposForOrgSecretReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ActionsSetSelectedReposForOrgSecretReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestActionsSetSelectedRepositoriesEnabledGithubActionsOrganizationReq_EncodeDecode(t *testing.T) {
 	var typ ActionsSetSelectedRepositoriesEnabledGithubActionsOrganizationReq
 	typ.SetFake()
@@ -1246,6 +1486,36 @@ func TestActionsSetSelectedRepositoriesEnabledGithubActionsOrganizationReq_Encod
 	var typ2 ActionsSetSelectedRepositoriesEnabledGithubActionsOrganizationReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestActionsSetSelectedRepositoriesEnabledGithubActionsOrganizationReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"selected_repository_ids\": [\n                  32,\n                  42\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ActionsSetSelectedRepositoriesEnabledGithubActionsOrganizationReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ActionsSetSelectedRepositoriesEnabledGithubActionsOrganizationReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestActionsSetSelfHostedRunnersInGroupForOrgReq_EncodeDecode(t *testing.T) {
 	var typ ActionsSetSelfHostedRunnersInGroupForOrgReq
 	typ.SetFake()
@@ -1258,25 +1528,85 @@ func TestActionsSetSelfHostedRunnersInGroupForOrgReq_EncodeDecode(t *testing.T)
 	var typ2 ActionsSetSelfHostedRunnersInGroupForOrgReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
-func TestActionsUpdateSelfHostedRunnerGroupForOrgReq_EncodeDecode(t *testing.T) {
-	var typ ActionsUpdateSelfHostedRunnerGroupForOrgReq
-	typ.SetFake()
 
-	e := jx.Encoder{}
-	typ.Encode(&e)
-	data := e.Bytes()
-	require.True(t, std.Valid(data), "Encoded: %s", data)
+func TestActionsSetSelfHostedRunnersInGroupForOrgReq_Examples(t *testing.T) {
 
-	var typ2 ActionsUpdateSelfHostedRunnerGroupForOrgReq
-	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
-}
-func TestActionsUpdateSelfHostedRunnerGroupForOrgReqVisibility_EncodeDecode(t *testing.T) {
-	var typ ActionsUpdateSelfHostedRunnerGroupForOrgReqVisibility
-	typ.SetFake()
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"runners\": [\n                  9,\n                  2\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ActionsSetSelfHostedRunnersInGroupForOrgReq
 
-	e := jx.Encoder{}
-	typ.Encode(&e)
-	data := e.Bytes()
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ActionsSetSelfHostedRunnersInGroupForOrgReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
+func TestActionsUpdateSelfHostedRunnerGroupForOrgReq_EncodeDecode(t *testing.T) {
+	var typ ActionsUpdateSelfHostedRunnerGroupForOrgReq
+	typ.SetFake()
+
+	e := jx.Encoder{}
+	typ.Encode(&e)
+	data := e.Bytes()
+	require.True(t, std.Valid(data), "Encoded: %s", data)
+
+	var typ2 ActionsUpdateSelfHostedRunnerGroupForOrgReq
+	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
+}
+
+func TestActionsUpdateSelfHostedRunnerGroupForOrgReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"name\": \"Expensive hardware runners\",\n                \"visibility\": \"selected\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ActionsUpdateSelfHostedRunnerGroupForOrgReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ActionsUpdateSelfHostedRunnerGroupForOrgReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
+func TestActionsUpdateSelfHostedRunnerGroupForOrgReqVisibility_EncodeDecode(t *testing.T) {
+	var typ ActionsUpdateSelfHostedRunnerGroupForOrgReqVisibility
+	typ.SetFake()
+
+	e := jx.Encoder{}
+	typ.Encode(&e)
+	data := e.Bytes()
 	require.True(t, std.Valid(data), "Encoded: %s", data)
 
 	var typ2 ActionsUpdateSelfHostedRunnerGroupForOrgReqVisibility
@@ -2446,6 +2776,36 @@ func TestAppsDeleteAuthorizationReq_EncodeDecode(t *testing.T) {
 	var typ2 AppsDeleteAuthorizationReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestAppsDeleteAuthorizationReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"access_token\": \"e72e16c7e42f292c6912e7710c838347ae178b4a\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ AppsDeleteAuthorizationReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 AppsDeleteAuthorizationReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestAppsDeleteTokenReq_EncodeDecode(t *testing.T) {
 	var typ AppsDeleteTokenReq
 	typ.SetFake()
@@ -2458,6 +2818,36 @@ func TestAppsDeleteTokenReq_EncodeDecode(t *testing.T) {
 	var typ2 AppsDeleteTokenReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestAppsDeleteTokenReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"access_token\": \"e72e16c7e42f292c6912e7710c838347ae178b4a\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ AppsDeleteTokenReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 AppsDeleteTokenReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestAppsGetBySlugApplicationJSONForbidden_EncodeDecode(t *testing.T) {
 	var typ AppsGetBySlugApplicationJSONForbidden
 	typ.SetFake()
@@ -4069,6 +4459,36 @@ func TestChecksCreateSuiteReq_EncodeDecode(t *testing.T) {
 	var typ2 ChecksCreateSuiteReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestChecksCreateSuiteReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"head_sha\": \"d6fde92930d4715a2b49857d24b940956b26d2d3\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ChecksCreateSuiteReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ChecksCreateSuiteReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestChecksListForRefOK_EncodeDecode(t *testing.T) {
 	var typ ChecksListForRefOK
 	typ.SetFake()
@@ -4219,6 +4639,36 @@ func TestChecksSetSuitesPreferencesReq_EncodeDecode(t *testing.T) {
 	var typ2 ChecksSetSuitesPreferencesReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestChecksSetSuitesPreferencesReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"auto_trigger_checks\": [\n                  {\n                    \"app_id\": 4,\n                    \"setting\": false\n                  }\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ChecksSetSuitesPreferencesReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ChecksSetSuitesPreferencesReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestChecksSetSuitesPreferencesReqAutoTriggerChecksItem_EncodeDecode(t *testing.T) {
 	var typ ChecksSetSuitesPreferencesReqAutoTriggerChecksItem
 	typ.SetFake()
@@ -5126,6 +5576,36 @@ func TestCodeScanningUpdateAlertReq_EncodeDecode(t *testing.T) {
 	var typ2 CodeScanningUpdateAlertReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestCodeScanningUpdateAlertReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"state\": \"dismissed\",\n                \"dismissed_reason\": \"false positive\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ CodeScanningUpdateAlertReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 CodeScanningUpdateAlertReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestCodeScanningUploadSarifApplicationJSONForbidden_EncodeDecode(t *testing.T) {
 	var typ CodeScanningUploadSarifApplicationJSONForbidden
 	typ.SetFake()
@@ -6139,6 +6619,36 @@ func TestEnterpriseAdminCreateSelfHostedRunnerGroupForEnterpriseReq_EncodeDecode
 	var typ2 EnterpriseAdminCreateSelfHostedRunnerGroupForEnterpriseReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestEnterpriseAdminCreateSelfHostedRunnerGroupForEnterpriseReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"name\": \"Expensive hardware runners\",\n                \"visibility\": \"selected\",\n                \"selected_organization_ids\": [\n                  32,\n                  91\n                ],\n                \"runners\": [\n                  9,\n                  2\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ EnterpriseAdminCreateSelfHostedRunnerGroupForEnterpriseReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 EnterpriseAdminCreateSelfHostedRunnerGroupForEnterpriseReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestEnterpriseAdminCreateSelfHostedRunnerGroupForEnterpriseReqVisibility_EncodeDecode(t *testing.T) {
 	var typ EnterpriseAdminCreateSelfHostedRunnerGroupForEnterpriseReqVisibility
 	typ.SetFake()
@@ -6373,6 +6883,36 @@ func TestEnterpriseAdminProvisionAndInviteEnterpriseGroupReq_EncodeDecode(t *tes
 	var typ2 EnterpriseAdminProvisionAndInviteEnterpriseGroupReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestEnterpriseAdminProvisionAndInviteEnterpriseGroupReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"schemas\": [\n                  \"urn:ietf:params:scim:schemas:core:2.0:Group\"\n                ],\n                \"displayName\": \"octo-org\",\n                \"members\": [\n                  {\n                    \"value\": \"92b58aaa-a1d6-11ea-8227-b9ce9e023ccc\"\n                  },\n                  {\n                    \"value\": \"aaaa8c34-a6b2-11ea-9d70-bbbbbd1c8fd5\"\n                  }\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ EnterpriseAdminProvisionAndInviteEnterpriseGroupReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 EnterpriseAdminProvisionAndInviteEnterpriseGroupReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestEnterpriseAdminProvisionAndInviteEnterpriseGroupReqMembersItem_EncodeDecode(t *testing.T) {
 	var typ EnterpriseAdminProvisionAndInviteEnterpriseGroupReqMembersItem
 	typ.SetFake()
@@ -6397,20 +6937,50 @@ func TestEnterpriseAdminProvisionAndInviteEnterpriseUserReq_EncodeDecode(t *test
 	var typ2 EnterpriseAdminProvisionAndInviteEnterpriseUserReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
-func TestEnterpriseAdminProvisionAndInviteEnterpriseUserReqEmailsItem_EncodeDecode(t *testing.T) {
-	var typ EnterpriseAdminProvisionAndInviteEnterpriseUserReqEmailsItem
-	typ.SetFake()
 
-	e := jx.Encoder{}
-	typ.Encode(&e)
-	data := e.Bytes()
-	require.True(t, std.Valid(data), "Encoded: %s", data)
+func TestEnterpriseAdminProvisionAndInviteEnterpriseUserReq_Examples(t *testing.T) {
 
-	var typ2 EnterpriseAdminProvisionAndInviteEnterpriseUserReqEmailsItem
-	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
-}
-func TestEnterpriseAdminProvisionAndInviteEnterpriseUserReqGroupsItem_EncodeDecode(t *testing.T) {
-	var typ EnterpriseAdminProvisionAndInviteEnterpriseUserReqGroupsItem
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"schemas\": [\n                  \"urn:ietf:params:scim:schemas:core:2.0:User\"\n                ],\n                \"userName\": \"mona.octocat@okta.example.com\",\n                \"name\": {\n                  \"familyName\": \"Octocat\",\n                  \"givenName\": \"Mona\"\n                },\n                \"emails\": [\n                  {\n                    \"value\": \"mona.octocat@okta.example.com\",\n                    \"type\": \"work\",\n                    \"primary\": true\n                  }\n                ],\n                \"groups\": [\n                  {\n                    \"value\": \"468dd3fa-a1d6-11ea-9031-15a1f0d7811d\"\n                  }\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ EnterpriseAdminProvisionAndInviteEnterpriseUserReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 EnterpriseAdminProvisionAndInviteEnterpriseUserReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
+func TestEnterpriseAdminProvisionAndInviteEnterpriseUserReqEmailsItem_EncodeDecode(t *testing.T) {
+	var typ EnterpriseAdminProvisionAndInviteEnterpriseUserReqEmailsItem
+	typ.SetFake()
+
+	e := jx.Encoder{}
+	typ.Encode(&e)
+	data := e.Bytes()
+	require.True(t, std.Valid(data), "Encoded: %s", data)
+
+	var typ2 EnterpriseAdminProvisionAndInviteEnterpriseUserReqEmailsItem
+	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
+}
+func TestEnterpriseAdminProvisionAndInviteEnterpriseUserReqGroupsItem_EncodeDecode(t *testing.T) {
+	var typ EnterpriseAdminProvisionAndInviteEnterpriseUserReqGroupsItem
 	typ.SetFake()
 
 	e := jx.Encoder{}
@@ -6445,6 +7015,36 @@ func TestEnterpriseAdminSetGithubActionsPermissionsEnterpriseReq_EncodeDecode(t
 	var typ2 EnterpriseAdminSetGithubActionsPermissionsEnterpriseReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestEnterpriseAdminSetGithubActionsPermissionsEnterpriseReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"enabled_organizations\": \"all\",\n                \"allowed_actions\": \"selected\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ EnterpriseAdminSetGithubActionsPermissionsEnterpriseReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 EnterpriseAdminSetGithubActionsPermissionsEnterpriseReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestEnterpriseAdminSetInformationForProvisionedEnterpriseGroupReq_EncodeDecode(t *testing.T) {
 	var typ EnterpriseAdminSetInformationForProvisionedEnterpriseGroupReq
 	typ.SetFake()
@@ -6457,6 +7057,36 @@ func TestEnterpriseAdminSetInformationForProvisionedEnterpriseGroupReq_EncodeDec
 	var typ2 EnterpriseAdminSetInformationForProvisionedEnterpriseGroupReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestEnterpriseAdminSetInformationForProvisionedEnterpriseGroupReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"schemas\": [\n                  \"urn:ietf:params:scim:schemas:core:2.0:Group\"\n                ],\n                \"displayName\": \"octo-org\",\n                \"members\": [\n                  {\n                    \"value\": \"92b58aaa-a1d6-11ea-8227-b9ce9e023ccc\"\n                  },\n                  {\n                    \"value\": \"aaaa8c34-a6b2-11ea-9d70-bbbbbd1c8fd5\"\n                  }\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ EnterpriseAdminSetInformationForProvisionedEnterpriseGroupReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 EnterpriseAdminSetInformationForProvisionedEnterpriseGroupReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestEnterpriseAdminSetInformationForProvisionedEnterpriseGroupReqMembersItem_EncodeDecode(t *testing.T) {
 	var typ EnterpriseAdminSetInformationForProvisionedEnterpriseGroupReqMembersItem
 	typ.SetFake()
@@ -6481,6 +7111,36 @@ func TestEnterpriseAdminSetInformationForProvisionedEnterpriseUserReq_EncodeDeco
 	var typ2 EnterpriseAdminSetInformationForProvisionedEnterpriseUserReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestEnterpriseAdminSetInformationForProvisionedEnterpriseUserReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"schemas\": [\n                  \"urn:ietf:params:scim:schemas:core:2.0:User\"\n                ],\n                \"userName\": \"mona.octocat@okta.example.com\",\n                \"name\": {\n                  \"familyName\": \"Octocat\",\n                  \"givenName\": \"Mona\"\n                },\n                \"emails\": [\n                  {\n                    \"value\": \"mona.octocat@okta.example.com\",\n                    \"type\": \"work\",\n                    \"primary\": true\n                  }\n                ],\n                \"groups\": [\n                  {\n                    \"value\": \"468dd3fa-a1d6-11ea-9031-15a1f0d7811d\"\n                  }\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ EnterpriseAdminSetInformationForProvisionedEnterpriseUserReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 EnterpriseAdminSetInformationForProvisionedEnterpriseUserReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestEnterpriseAdminSetInformationForProvisionedEnterpriseUserReqEmailsItem_EncodeDecode(t *testing.T) {
 	var typ EnterpriseAdminSetInformationForProvisionedEnterpriseUserReqEmailsItem
 	typ.SetFake()
@@ -6529,6 +7189,36 @@ func TestEnterpriseAdminSetOrgAccessToSelfHostedRunnerGroupInEnterpriseReq_Encod
 	var typ2 EnterpriseAdminSetOrgAccessToSelfHostedRunnerGroupInEnterpriseReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestEnterpriseAdminSetOrgAccessToSelfHostedRunnerGroupInEnterpriseReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"selected_organization_ids\": [\n                  32,\n                  91\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ EnterpriseAdminSetOrgAccessToSelfHostedRunnerGroupInEnterpriseReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 EnterpriseAdminSetOrgAccessToSelfHostedRunnerGroupInEnterpriseReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestEnterpriseAdminSetSelectedOrganizationsEnabledGithubActionsEnterpriseReq_EncodeDecode(t *testing.T) {
 	var typ EnterpriseAdminSetSelectedOrganizationsEnabledGithubActionsEnterpriseReq
 	typ.SetFake()
@@ -6541,6 +7231,36 @@ func TestEnterpriseAdminSetSelectedOrganizationsEnabledGithubActionsEnterpriseRe
 	var typ2 EnterpriseAdminSetSelectedOrganizationsEnabledGithubActionsEnterpriseReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestEnterpriseAdminSetSelectedOrganizationsEnabledGithubActionsEnterpriseReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"selected_organization_ids\": [\n                  32,\n                  91\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ EnterpriseAdminSetSelectedOrganizationsEnabledGithubActionsEnterpriseReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 EnterpriseAdminSetSelectedOrganizationsEnabledGithubActionsEnterpriseReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestEnterpriseAdminSetSelfHostedRunnersInGroupForEnterpriseReq_EncodeDecode(t *testing.T) {
 	var typ EnterpriseAdminSetSelfHostedRunnersInGroupForEnterpriseReq
 	typ.SetFake()
@@ -6553,6 +7273,36 @@ func TestEnterpriseAdminSetSelfHostedRunnersInGroupForEnterpriseReq_EncodeDecode
 	var typ2 EnterpriseAdminSetSelfHostedRunnersInGroupForEnterpriseReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestEnterpriseAdminSetSelfHostedRunnersInGroupForEnterpriseReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"runners\": [\n                  9,\n                  2\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ EnterpriseAdminSetSelfHostedRunnersInGroupForEnterpriseReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 EnterpriseAdminSetSelfHostedRunnersInGroupForEnterpriseReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestEnterpriseAdminUpdateAttributeForEnterpriseGroupReq_EncodeDecode(t *testing.T) {
 	var typ EnterpriseAdminUpdateAttributeForEnterpriseGroupReq
 	typ.SetFake()
@@ -6565,6 +7315,36 @@ func TestEnterpriseAdminUpdateAttributeForEnterpriseGroupReq_EncodeDecode(t *tes
 	var typ2 EnterpriseAdminUpdateAttributeForEnterpriseGroupReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestEnterpriseAdminUpdateAttributeForEnterpriseGroupReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"schemas\": [\n                  \"urn:ietf:params:scim:api:messages:2.0:PatchOp\"\n                ],\n                \"Operations\": [\n                  {\n                    \"op\": \"remove\",\n                    \"path\": \"members\",\n                    \"value\": [\n                      {\n                        \"value\": \"aaaa8c34-a6b2-11ea-9d70-bbbbbd1c8fd5\"\n                      }\n                    ]\n                  }\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ EnterpriseAdminUpdateAttributeForEnterpriseGroupReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 EnterpriseAdminUpdateAttributeForEnterpriseGroupReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestEnterpriseAdminUpdateAttributeForEnterpriseGroupReqOperationsItem_EncodeDecode(t *testing.T) {
 	var typ EnterpriseAdminUpdateAttributeForEnterpriseGroupReqOperationsItem
 	typ.SetFake()
@@ -6625,6 +7405,36 @@ func TestEnterpriseAdminUpdateAttributeForEnterpriseUserReq_EncodeDecode(t *test
 	var typ2 EnterpriseAdminUpdateAttributeForEnterpriseUserReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestEnterpriseAdminUpdateAttributeForEnterpriseUserReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"schemas\": [\n                  \"urn:ietf:params:scim:api:messages:2.0:PatchOp\"\n                ],\n                \"Operations\": [\n                  {\n                    \"op\": \"add\",\n                    \"path\": \"emails\",\n                    \"value\": [\n                      {\n                        \"value\": \"monalisa@octocat.github.com\",\n                        \"type\": \"home\"\n                      }\n                    ]\n                  },\n                  {\n                    \"op\": \"replace\",\n                    \"path\": \"name.givenName\",\n                    \"value\": \"Monalisa\"\n                  }\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ EnterpriseAdminUpdateAttributeForEnterpriseUserReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 EnterpriseAdminUpdateAttributeForEnterpriseUserReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestEnterpriseAdminUpdateAttributeForEnterpriseUserReqOperationsItem_EncodeDecode(t *testing.T) {
 	var typ EnterpriseAdminUpdateAttributeForEnterpriseUserReqOperationsItem
 	typ.SetFake()
@@ -6649,6 +7459,36 @@ func TestEnterpriseAdminUpdateSelfHostedRunnerGroupForEnterpriseReq_EncodeDecode
 	var typ2 EnterpriseAdminUpdateSelfHostedRunnerGroupForEnterpriseReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestEnterpriseAdminUpdateSelfHostedRunnerGroupForEnterpriseReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"name\": \"Expensive hardware runners\",\n                \"visibility\": \"selected\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ EnterpriseAdminUpdateSelfHostedRunnerGroupForEnterpriseReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 EnterpriseAdminUpdateSelfHostedRunnerGroupForEnterpriseReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestEnterpriseAdminUpdateSelfHostedRunnerGroupForEnterpriseReqVisibility_EncodeDecode(t *testing.T) {
 	var typ EnterpriseAdminUpdateSelfHostedRunnerGroupForEnterpriseReqVisibility
 	typ.SetFake()
@@ -7999,6 +8839,36 @@ func TestGitCreateBlobReq_EncodeDecode(t *testing.T) {
 	var typ2 GitCreateBlobReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestGitCreateBlobReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"content\": \"Content of the blob\",\n                \"encoding\": \"utf-8\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ GitCreateBlobReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 GitCreateBlobReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestGitCreateCommitReq_EncodeDecode(t *testing.T) {
 	var typ GitCreateCommitReq
 	typ.SetFake()
@@ -8011,6 +8881,36 @@ func TestGitCreateCommitReq_EncodeDecode(t *testing.T) {
 	var typ2 GitCreateCommitReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestGitCreateCommitReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"message\": \"my commit message\",\n                \"author\": {\n                  \"name\": \"Mona Octocat\",\n                  \"email\": \"octocat@github.com\",\n                  \"date\": \"2008-07-09T16:13:30+12:00\"\n                },\n                \"parents\": [\n                  \"7d1b31e74ee336d15cbd21741bc88a537ed063a0\"\n                ],\n                \"tree\": \"827efc6d56897b048c772eb4087f854f46256132\",\n                \"signature\": \"-----BEGIN PGP SIGNATURE-----\\n\\niQIzBAABAQAdFiEESn/54jMNIrGSE6Tp6cQjvhfv7nAFAlnT71cACgkQ6cQjvhfv\\n7nCWwA//XVqBKWO0zF+bZl6pggvky3Oc2j1pNFuRWZ29LXpNuD5WUGXGG209B0hI\\nDkmcGk19ZKUTnEUJV2Xd0R7AW01S/YSub7OYcgBkI7qUE13FVHN5ln1KvH2all2n\\n2+JCV1HcJLEoTjqIFZSSu/sMdhkLQ9/NsmMAzpf/iIM0nQOyU4YRex9eD1bYj6nA\\nOQPIDdAuaTQj1gFPHYLzM4zJnCqGdRlg0sOM/zC5apBNzIwlgREatOYQSCfCKV7k\\nnrU34X8b9BzQaUx48Qa+Dmfn5KQ8dl27RNeWAqlkuWyv3pUauH9UeYW+KyuJeMkU\\n+NyHgAsWFaCFl23kCHThbLStMZOYEnGagrd0hnm1TPS4GJkV4wfYMwnI4KuSlHKB\\njHl3Js9vNzEUQipQJbgCgTiWvRJoK3ENwBTMVkKHaqT4x9U4Jk/XZB6Q8MA09ezJ\\n3QgiTjTAGcum9E9QiJqMYdWQPWkaBIRRz5cET6HPB48YNXAAUsfmuYsGrnVLYbG+\\nUpC6I97VybYHTy2O9XSGoaLeMI9CsFn38ycAxxbWagk5mhclNTP5mezIq6wKSwmr\\nX11FW3n1J23fWZn5HJMBsRnUCgzqzX3871IqLYHqRJ/bpZ4h20RhTyPj5c/z7QXp\\neSakNQMfbbMcljkha+ZMuVQX1K9aRlVqbmv3ZMWh+OijLYVU2bc=\\n=5Io4\\n-----END PGP SIGNATURE-----\\n\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ GitCreateCommitReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 GitCreateCommitReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestGitCreateCommitReqAuthor_EncodeDecode(t *testing.T) {
 	var typ GitCreateCommitReqAuthor
 	typ.SetFake()
@@ -8039,13 +8939,43 @@ func TestGitCreateRefReq_EncodeDecode(t *testing.T) {
 	var typ GitCreateRefReq
 	typ.SetFake()
 
-	e := jx.Encoder{}
-	typ.Encode(&e)
-	data := e.Bytes()
-	require.True(t, std.Valid(data), "Encoded: %s", data)
+	e := jx.Encoder{}
+	typ.Encode(&e)
+	data := e.Bytes()
+	require.True(t, std.Valid(data), "Encoded: %s", data)
+
+	var typ2 GitCreateRefReq
+	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
+}
+
+func TestGitCreateRefReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"ref\": \"refs/heads/featureA\",\n                \"sha\": \"aa218f56b14c9653891f9e74264a383fa43fefbd\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ GitCreateRefReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
 
-	var typ2 GitCreateRefReq
-	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 GitCreateRefReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
 }
 func TestGitCreateTagReq_EncodeDecode(t *testing.T) {
 	var typ GitCreateTagReq
@@ -8059,6 +8989,36 @@ func TestGitCreateTagReq_EncodeDecode(t *testing.T) {
 	var typ2 GitCreateTagReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestGitCreateTagReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"tag\": \"v0.0.1\",\n                \"message\": \"initial version\",\n                \"object\": \"c3d0be41ecbe669545ee3e94d31ed9a4bc91ee3c\",\n                \"type\": \"commit\",\n                \"tagger\": {\n                  \"name\": \"Monalisa Octocat\",\n                  \"email\": \"octocat@github.com\",\n                  \"date\": \"2011-06-17T14:53:35-07:00\"\n                }\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ GitCreateTagReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 GitCreateTagReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestGitCreateTagReqTagger_EncodeDecode(t *testing.T) {
 	var typ GitCreateTagReqTagger
 	typ.SetFake()
@@ -8119,6 +9079,36 @@ func TestGitCreateTreeReq_EncodeDecode(t *testing.T) {
 	var typ2 GitCreateTreeReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestGitCreateTreeReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"base_tree\": \"9fb037999f264ba9a7fc6274d15fa3ae2ab98312\",\n                \"tree\": [\n                  {\n                    \"path\": \"file.rb\",\n                    \"mode\": \"100644\",\n                    \"type\": \"blob\",\n                    \"sha\": \"44b4fc6d56897b048c772eb4087f854f46256132\"\n                  }\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ GitCreateTreeReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 GitCreateTreeReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestGitCreateTreeReqTreeItem_EncodeDecode(t *testing.T) {
 	var typ GitCreateTreeReqTreeItem
 	typ.SetFake()
@@ -8367,6 +9357,36 @@ func TestGitUpdateRefReq_EncodeDecode(t *testing.T) {
 	var typ2 GitUpdateRefReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestGitUpdateRefReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"sha\": \"aa218f56b14c9653891f9e74264a383fa43fefbd\",\n                \"force\": true\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ GitUpdateRefReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 GitUpdateRefReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestGitignoreGetAllTemplatesOKApplicationJSON_EncodeDecode(t *testing.T) {
 	var typ GitignoreGetAllTemplatesOKApplicationJSON
 	typ.SetFake()
@@ -9467,6 +10487,36 @@ func TestIssuesAddAssigneesReq_EncodeDecode(t *testing.T) {
 	var typ2 IssuesAddAssigneesReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestIssuesAddAssigneesReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"assignees\": [\n                  \"hubot\",\n                  \"other_user\"\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ IssuesAddAssigneesReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 IssuesAddAssigneesReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestIssuesCreateApplicationJSONForbidden_EncodeDecode(t *testing.T) {
 	var typ IssuesCreateApplicationJSONForbidden
 	typ.SetFake()
@@ -9551,6 +10601,36 @@ func TestIssuesCreateCommentReq_EncodeDecode(t *testing.T) {
 	var typ2 IssuesCreateCommentReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestIssuesCreateCommentReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"body\": \"Me too\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ IssuesCreateCommentReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 IssuesCreateCommentReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestIssuesCreateLabelReq_EncodeDecode(t *testing.T) {
 	var typ IssuesCreateLabelReq
 	typ.SetFake()
@@ -9563,6 +10643,36 @@ func TestIssuesCreateLabelReq_EncodeDecode(t *testing.T) {
 	var typ2 IssuesCreateLabelReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestIssuesCreateLabelReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"name\": \"bug\",\n                \"description\": \"Something isn't working\",\n                \"color\": \"f29513\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ IssuesCreateLabelReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 IssuesCreateLabelReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestIssuesCreateMilestoneReq_EncodeDecode(t *testing.T) {
 	var typ IssuesCreateMilestoneReq
 	typ.SetFake()
@@ -9575,6 +10685,36 @@ func TestIssuesCreateMilestoneReq_EncodeDecode(t *testing.T) {
 	var typ2 IssuesCreateMilestoneReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestIssuesCreateMilestoneReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"title\": \"v1.0\",\n                \"state\": \"open\",\n                \"description\": \"Tracking milestone for version 1.0\",\n                \"due_on\": \"2012-10-09T23:39:01Z\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ IssuesCreateMilestoneReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 IssuesCreateMilestoneReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestIssuesCreateMilestoneReqState_EncodeDecode(t *testing.T) {
 	var typ IssuesCreateMilestoneReqState
 	typ.SetFake()
@@ -9599,6 +10739,36 @@ func TestIssuesCreateReq_EncodeDecode(t *testing.T) {
 	var typ2 IssuesCreateReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestIssuesCreateReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"title\": \"Found a bug\",\n                \"body\": \"I'm having a problem with this.\",\n                \"assignees\": [\n                  \"octocat\"\n                ],\n                \"milestone\": 1,\n                \"labels\": [\n                  \"bug\"\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ IssuesCreateReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 IssuesCreateReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestIssuesCreateReqLabelsItem_EncodeDecode(t *testing.T) {
 	var typ IssuesCreateReqLabelsItem
 	typ.SetFake()
@@ -9971,6 +11141,36 @@ func TestIssuesRemoveAssigneesReq_EncodeDecode(t *testing.T) {
 	var typ2 IssuesRemoveAssigneesReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestIssuesRemoveAssigneesReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"assignees\": [\n                  \"hubot\",\n                  \"other_user\"\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ IssuesRemoveAssigneesReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 IssuesRemoveAssigneesReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestIssuesRemoveLabelApplicationJSONGone_EncodeDecode(t *testing.T) {
 	var typ IssuesRemoveLabelApplicationJSONGone
 	typ.SetFake()
@@ -10091,6 +11291,36 @@ func TestIssuesUpdateCommentReq_EncodeDecode(t *testing.T) {
 	var typ2 IssuesUpdateCommentReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestIssuesUpdateCommentReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"body\": \"Me too\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ IssuesUpdateCommentReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 IssuesUpdateCommentReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestIssuesUpdateLabelReq_EncodeDecode(t *testing.T) {
 	var typ IssuesUpdateLabelReq
 	typ.SetFake()
@@ -10103,6 +11333,36 @@ func TestIssuesUpdateLabelReq_EncodeDecode(t *testing.T) {
 	var typ2 IssuesUpdateLabelReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestIssuesUpdateLabelReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"new_name\": \"bug :bug:\",\n                \"description\": \"Small bug fix required\",\n                \"color\": \"b01f26\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ IssuesUpdateLabelReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 IssuesUpdateLabelReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestIssuesUpdateMilestoneReq_EncodeDecode(t *testing.T) {
 	var typ IssuesUpdateMilestoneReq
 	typ.SetFake()
@@ -10115,6 +11375,36 @@ func TestIssuesUpdateMilestoneReq_EncodeDecode(t *testing.T) {
 	var typ2 IssuesUpdateMilestoneReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestIssuesUpdateMilestoneReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"title\": \"v1.0\",\n                \"state\": \"open\",\n                \"description\": \"Tracking milestone for version 1.0\",\n                \"due_on\": \"2012-10-09T23:39:01Z\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ IssuesUpdateMilestoneReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 IssuesUpdateMilestoneReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestIssuesUpdateMilestoneReqState_EncodeDecode(t *testing.T) {
 	var typ IssuesUpdateMilestoneReqState
 	typ.SetFake()
@@ -10139,6 +11429,36 @@ func TestIssuesUpdateReq_EncodeDecode(t *testing.T) {
 	var typ2 IssuesUpdateReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestIssuesUpdateReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"title\": \"Found a bug\",\n                \"body\": \"I'm having a problem with this.\",\n                \"assignees\": [\n                  \"octocat\"\n                ],\n                \"milestone\": 1,\n                \"state\": \"open\",\n                \"labels\": [\n                  \"bug\"\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ IssuesUpdateReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 IssuesUpdateReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestIssuesUpdateReqLabelsItem_EncodeDecode(t *testing.T) {
 	var typ IssuesUpdateReqLabelsItem
 	typ.SetFake()
@@ -11041,6 +12361,36 @@ func TestMigrationsMapCommitAuthorReq_EncodeDecode(t *testing.T) {
 	var typ2 MigrationsMapCommitAuthorReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestMigrationsMapCommitAuthorReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"email\": \"hubot@github.com\",\n                \"name\": \"Hubot the Robot\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ MigrationsMapCommitAuthorReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 MigrationsMapCommitAuthorReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestMigrationsSetLfsPreferenceReq_EncodeDecode(t *testing.T) {
 	var typ MigrationsSetLfsPreferenceReq
 	typ.SetFake()
@@ -11053,6 +12403,36 @@ func TestMigrationsSetLfsPreferenceReq_EncodeDecode(t *testing.T) {
 	var typ2 MigrationsSetLfsPreferenceReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestMigrationsSetLfsPreferenceReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"use_lfs\": \"opt_in\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ MigrationsSetLfsPreferenceReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 MigrationsSetLfsPreferenceReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestMigrationsSetLfsPreferenceReqUseLfs_EncodeDecode(t *testing.T) {
 	var typ MigrationsSetLfsPreferenceReqUseLfs
 	typ.SetFake()
@@ -11155,6 +12535,36 @@ func TestMigrationsStartForOrgReq_EncodeDecode(t *testing.T) {
 	var typ2 MigrationsStartForOrgReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestMigrationsStartForOrgReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"repositories\": [\n                  \"github/Hello-World\"\n                ],\n                \"lock_repositories\": true\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ MigrationsStartForOrgReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 MigrationsStartForOrgReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestMigrationsStartForOrgReqExcludeItem_EncodeDecode(t *testing.T) {
 	var typ MigrationsStartForOrgReqExcludeItem
 	typ.SetFake()
@@ -11179,6 +12589,36 @@ func TestMigrationsStartImportReq_EncodeDecode(t *testing.T) {
 	var typ2 MigrationsStartImportReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestMigrationsStartImportReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"vcs\": \"subversion\",\n                \"vcs_url\": \"http://svn.mycompany.com/svn/myproject\",\n                \"vcs_username\": \"octocat\",\n                \"vcs_password\": \"secret\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ MigrationsStartImportReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 MigrationsStartImportReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestMigrationsStartImportReqVcs_EncodeDecode(t *testing.T) {
 	var typ MigrationsStartImportReqVcs
 	typ.SetFake()
@@ -11239,6 +12679,36 @@ func TestMigrationsUpdateImportReq_EncodeDecode(t *testing.T) {
 	var typ2 MigrationsUpdateImportReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestMigrationsUpdateImportReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                    \"vcs_username\": \"octocat\",\n                    \"vcs_password\": \"secret\"\n                  }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ MigrationsUpdateImportReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 MigrationsUpdateImportReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestMilestone_EncodeDecode(t *testing.T) {
 	var typ Milestone
 	typ.SetFake()
@@ -12477,8 +13947,38 @@ func TestOrgsCreateInvitationReq_EncodeDecode(t *testing.T) {
 	data := e.Bytes()
 	require.True(t, std.Valid(data), "Encoded: %s", data)
 
-	var typ2 OrgsCreateInvitationReq
-	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
+	var typ2 OrgsCreateInvitationReq
+	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
+}
+
+func TestOrgsCreateInvitationReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"email\": \"octocat@github.com\",\n                \"role\": \"direct_member\",\n                \"team_ids\": [\n                  12,\n                  26\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ OrgsCreateInvitationReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 OrgsCreateInvitationReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
 }
 func TestOrgsCreateInvitationReqRole_EncodeDecode(t *testing.T) {
 	var typ OrgsCreateInvitationReqRole
@@ -12504,6 +14004,36 @@ func TestOrgsCreateWebhookReq_EncodeDecode(t *testing.T) {
 	var typ2 OrgsCreateWebhookReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestOrgsCreateWebhookReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"name\": \"web\",\n                \"active\": true,\n                \"events\": [\n                  \"push\",\n                  \"pull_request\"\n                ],\n                \"config\": {\n                  \"url\": \"http://example.com/webhook\",\n                  \"content_type\": \"json\"\n                }\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ OrgsCreateWebhookReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 OrgsCreateWebhookReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestOrgsCreateWebhookReqConfig_EncodeDecode(t *testing.T) {
 	var typ OrgsCreateWebhookReqConfig
 	typ.SetFake()
@@ -12858,6 +14388,36 @@ func TestOrgsUpdateMembershipForAuthenticatedUserReq_EncodeDecode(t *testing.T)
 	var typ2 OrgsUpdateMembershipForAuthenticatedUserReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestOrgsUpdateMembershipForAuthenticatedUserReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"state\": \"active\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ OrgsUpdateMembershipForAuthenticatedUserReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 OrgsUpdateMembershipForAuthenticatedUserReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestOrgsUpdateMembershipForAuthenticatedUserReqState_EncodeDecode(t *testing.T) {
 	var typ OrgsUpdateMembershipForAuthenticatedUserReqState
 	typ.SetFake()
@@ -12924,6 +14484,36 @@ func TestOrgsUpdateWebhookReq_EncodeDecode(t *testing.T) {
 	var typ2 OrgsUpdateWebhookReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestOrgsUpdateWebhookReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"active\": true,\n                \"events\": [\n                  \"pull_request\"\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ OrgsUpdateWebhookReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 OrgsUpdateWebhookReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestOrgsUpdateWebhookReqConfig_EncodeDecode(t *testing.T) {
 	var typ OrgsUpdateWebhookReqConfig
 	typ.SetFake()
@@ -14754,6 +16344,36 @@ func TestProjectsCreateForOrgReq_EncodeDecode(t *testing.T) {
 	var typ2 ProjectsCreateForOrgReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestProjectsCreateForOrgReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"name\": \"Organization Roadmap\",\n                \"body\": \"High-level roadmap for the upcoming year.\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ProjectsCreateForOrgReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ProjectsCreateForOrgReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestProjectsCreateForRepoApplicationJSONForbidden_EncodeDecode(t *testing.T) {
 	var typ ProjectsCreateForRepoApplicationJSONForbidden
 	typ.SetFake()
@@ -14814,6 +16434,36 @@ func TestProjectsCreateForRepoReq_EncodeDecode(t *testing.T) {
 	var typ2 ProjectsCreateForRepoReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestProjectsCreateForRepoReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"name\": \"Projects Documentation\",\n                \"body\": \"Developer documentation project for the developer site.\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ProjectsCreateForRepoReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ProjectsCreateForRepoReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestProjectsDeleteApplicationJSONGone_EncodeDecode(t *testing.T) {
 	var typ ProjectsDeleteApplicationJSONGone
 	typ.SetFake()
@@ -16415,8 +18065,134 @@ func TestPullRequestSimpleLinks_EncodeDecode(t *testing.T) {
 	var typ2 PullRequestSimpleLinks
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
-func TestPullRequestState_EncodeDecode(t *testing.T) {
-	var typ PullRequestState
+func TestPullRequestState_EncodeDecode(t *testing.T) {
+	var typ PullRequestState
+	typ.SetFake()
+
+	e := jx.Encoder{}
+	typ.Encode(&e)
+	data := e.Bytes()
+	require.True(t, std.Valid(data), "Encoded: %s", data)
+
+	var typ2 PullRequestState
+	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
+}
+
+func TestPullRequestState_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "\"open\""},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ PullRequestState
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 PullRequestState
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
+func TestPullsCreateReplyForReviewCommentReq_EncodeDecode(t *testing.T) {
+	var typ PullsCreateReplyForReviewCommentReq
+	typ.SetFake()
+
+	e := jx.Encoder{}
+	typ.Encode(&e)
+	data := e.Bytes()
+	require.True(t, std.Valid(data), "Encoded: %s", data)
+
+	var typ2 PullsCreateReplyForReviewCommentReq
+	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
+}
+
+func TestPullsCreateReplyForReviewCommentReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"body\": \"Great stuff!\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ PullsCreateReplyForReviewCommentReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 PullsCreateReplyForReviewCommentReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
+func TestPullsCreateReq_EncodeDecode(t *testing.T) {
+	var typ PullsCreateReq
+	typ.SetFake()
+
+	e := jx.Encoder{}
+	typ.Encode(&e)
+	data := e.Bytes()
+	require.True(t, std.Valid(data), "Encoded: %s", data)
+
+	var typ2 PullsCreateReq
+	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
+}
+
+func TestPullsCreateReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"title\": \"Amazing new feature\",\n                \"body\": \"Please pull these awesome changes in!\",\n                \"head\": \"octocat:new-feature\",\n                \"base\": \"master\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ PullsCreateReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 PullsCreateReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
+func TestPullsCreateReviewCommentReq_EncodeDecode(t *testing.T) {
+	var typ PullsCreateReviewCommentReq
 	typ.SetFake()
 
 	e := jx.Encoder{}
@@ -16424,20 +18200,21 @@ func TestPullRequestState_EncodeDecode(t *testing.T) {
 	data := e.Bytes()
 	require.True(t, std.Valid(data), "Encoded: %s", data)
 
-	var typ2 PullRequestState
+	var typ2 PullsCreateReviewCommentReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
 
-func TestPullRequestState_Examples(t *testing.T) {
+func TestPullsCreateReviewCommentReq_Examples(t *testing.T) {
 
 	for i, tc := range []struct {
 		Input string
 	}{
-		{Input: "\"open\""},
+		{Input: "{\n                    \"body\": \"Great stuff!\",\n                    \"commit_id\": \"6dcb09b5b57875f334f61aebed695e2e4193db5e\",\n                    \"path\": \"file1.txt\",\n                    \"start_line\": 1,\n                    \"start_side\": \"RIGHT\",\n                    \"line\": 2,\n                    \"side\": \"RIGHT\"\n                  }"},
+		{Input: "{\n                    \"body\": \"Let's add this deleted line back.\",\n                    \"commit_id\": \"6dcb09b5b57875f334f61aebed695e2e4193db5e\",\n                    \"path\": \"file1.txt\",\n                    \"line\": 5,\n                    \"side\": \"LEFT\"\n                  }"},
 	} {
 		tc := tc
 		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
-			var typ PullRequestState
+			var typ PullsCreateReviewCommentReq
 
 			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
 				var validateErr *validate.Error
@@ -16452,47 +18229,11 @@ func TestPullRequestState_Examples(t *testing.T) {
 			typ.Encode(&e)
 			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
 
-			var typ2 PullRequestState
+			var typ2 PullsCreateReviewCommentReq
 			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
 		})
 	}
 }
-func TestPullsCreateReplyForReviewCommentReq_EncodeDecode(t *testing.T) {
-	var typ PullsCreateReplyForReviewCommentReq
-	typ.SetFake()
-
-	e := jx.Encoder{}
-	typ.Encode(&e)
-	data := e.Bytes()
-	require.True(t, std.Valid(data), "Encoded: %s", data)
-
-	var typ2 PullsCreateReplyForReviewCommentReq
-	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
-}
-func TestPullsCreateReq_EncodeDecode(t *testing.T) {
-	var typ PullsCreateReq
-	typ.SetFake()
-
-	e := jx.Encoder{}
-	typ.Encode(&e)
-	data := e.Bytes()
-	require.True(t, std.Valid(data), "Encoded: %s", data)
-
-	var typ2 PullsCreateReq
-	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
-}
-func TestPullsCreateReviewCommentReq_EncodeDecode(t *testing.T) {
-	var typ PullsCreateReviewCommentReq
-	typ.SetFake()
-
-	e := jx.Encoder{}
-	typ.Encode(&e)
-	data := e.Bytes()
-	require.True(t, std.Valid(data), "Encoded: %s", data)
-
-	var typ2 PullsCreateReviewCommentReq
-	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
-}
 func TestPullsCreateReviewCommentReqSide_EncodeDecode(t *testing.T) {
 	var typ PullsCreateReviewCommentReqSide
 	typ.SetFake()
@@ -16529,6 +18270,36 @@ func TestPullsCreateReviewReq_EncodeDecode(t *testing.T) {
 	var typ2 PullsCreateReviewReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestPullsCreateReviewReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"commit_id\": \"ecdd80bb57125d7ba9641ffaa4d7d2c19d3f3091\",\n                \"body\": \"This is close to perfect! Please address the suggested inline change.\",\n                \"event\": \"REQUEST_CHANGES\",\n                \"comments\": [\n                  {\n                    \"path\": \"file.md\",\n                    \"position\": 6,\n                    \"body\": \"Please add more information here, and fix this typo.\"\n                  }\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ PullsCreateReviewReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 PullsCreateReviewReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestPullsCreateReviewReqCommentsItem_EncodeDecode(t *testing.T) {
 	var typ PullsCreateReviewReqCommentsItem
 	typ.SetFake()
@@ -16769,6 +18540,36 @@ func TestPullsRemoveRequestedReviewersReq_EncodeDecode(t *testing.T) {
 	var typ2 PullsRemoveRequestedReviewersReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestPullsRemoveRequestedReviewersReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"reviewers\": [\n                  \"octocat\",\n                  \"hubot\",\n                  \"other_user\"\n                ],\n                \"team_reviewers\": [\n                  \"justice-league\"\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ PullsRemoveRequestedReviewersReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 PullsRemoveRequestedReviewersReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestPullsSubmitReviewApplicationJSONForbidden_EncodeDecode(t *testing.T) {
 	var typ PullsSubmitReviewApplicationJSONForbidden
 	typ.SetFake()
@@ -16871,6 +18672,36 @@ func TestPullsUpdateBranchReq_EncodeDecode(t *testing.T) {
 	var typ2 PullsUpdateBranchReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestPullsUpdateBranchReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"expected_head_sha\": \"6dcb09b5b57875f334f61aebed695e2e4193db5e\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ PullsUpdateBranchReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 PullsUpdateBranchReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestPullsUpdateReq_EncodeDecode(t *testing.T) {
 	var typ PullsUpdateReq
 	typ.SetFake()
@@ -16883,6 +18714,36 @@ func TestPullsUpdateReq_EncodeDecode(t *testing.T) {
 	var typ2 PullsUpdateReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestPullsUpdateReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"title\": \"new title\",\n                \"body\": \"updated body\",\n                \"state\": \"open\",\n                \"base\": \"master\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ PullsUpdateReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 PullsUpdateReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestPullsUpdateReqState_EncodeDecode(t *testing.T) {
 	var typ PullsUpdateReqState
 	typ.SetFake()
@@ -16907,6 +18768,36 @@ func TestPullsUpdateReviewCommentReq_EncodeDecode(t *testing.T) {
 	var typ2 PullsUpdateReviewCommentReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestPullsUpdateReviewCommentReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"body\": \"I like this too!\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ PullsUpdateReviewCommentReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 PullsUpdateReviewCommentReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestPullsUpdateReviewReq_EncodeDecode(t *testing.T) {
 	var typ PullsUpdateReviewReq
 	typ.SetFake()
@@ -16919,6 +18810,36 @@ func TestPullsUpdateReviewReq_EncodeDecode(t *testing.T) {
 	var typ2 PullsUpdateReviewReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestPullsUpdateReviewReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"body\": \"This is close to perfect! Please address the suggested inline change. And add more about this.\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ PullsUpdateReviewReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 PullsUpdateReviewReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestRateLimit_EncodeDecode(t *testing.T) {
 	var typ RateLimit
 	typ.SetFake()
@@ -17117,6 +19038,36 @@ func TestReactionsCreateForCommitCommentReq_EncodeDecode(t *testing.T) {
 	var typ2 ReactionsCreateForCommitCommentReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReactionsCreateForCommitCommentReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"content\": \"heart\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReactionsCreateForCommitCommentReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReactionsCreateForCommitCommentReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReactionsCreateForCommitCommentReqContent_EncodeDecode(t *testing.T) {
 	var typ ReactionsCreateForCommitCommentReqContent
 	typ.SetFake()
@@ -17189,6 +19140,36 @@ func TestReactionsCreateForIssueCommentReq_EncodeDecode(t *testing.T) {
 	var typ2 ReactionsCreateForIssueCommentReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReactionsCreateForIssueCommentReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"content\": \"heart\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReactionsCreateForIssueCommentReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReactionsCreateForIssueCommentReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReactionsCreateForIssueCommentReqContent_EncodeDecode(t *testing.T) {
 	var typ ReactionsCreateForIssueCommentReqContent
 	typ.SetFake()
@@ -17213,6 +19194,36 @@ func TestReactionsCreateForIssueReq_EncodeDecode(t *testing.T) {
 	var typ2 ReactionsCreateForIssueReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReactionsCreateForIssueReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"content\": \"heart\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReactionsCreateForIssueReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReactionsCreateForIssueReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReactionsCreateForIssueReqContent_EncodeDecode(t *testing.T) {
 	var typ ReactionsCreateForIssueReqContent
 	typ.SetFake()
@@ -17261,6 +19272,36 @@ func TestReactionsCreateForPullRequestReviewCommentReq_EncodeDecode(t *testing.T
 	var typ2 ReactionsCreateForPullRequestReviewCommentReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReactionsCreateForPullRequestReviewCommentReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"content\": \"heart\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReactionsCreateForPullRequestReviewCommentReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReactionsCreateForPullRequestReviewCommentReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReactionsCreateForPullRequestReviewCommentReqContent_EncodeDecode(t *testing.T) {
 	var typ ReactionsCreateForPullRequestReviewCommentReqContent
 	typ.SetFake()
@@ -17309,6 +19350,36 @@ func TestReactionsCreateForReleaseReq_EncodeDecode(t *testing.T) {
 	var typ2 ReactionsCreateForReleaseReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReactionsCreateForReleaseReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"content\": \"heart\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReactionsCreateForReleaseReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReactionsCreateForReleaseReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReactionsCreateForReleaseReqContent_EncodeDecode(t *testing.T) {
 	var typ ReactionsCreateForReleaseReqContent
 	typ.SetFake()
@@ -17357,6 +19428,36 @@ func TestReactionsCreateForTeamDiscussionCommentInOrgReq_EncodeDecode(t *testing
 	var typ2 ReactionsCreateForTeamDiscussionCommentInOrgReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReactionsCreateForTeamDiscussionCommentInOrgReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"content\": \"heart\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReactionsCreateForTeamDiscussionCommentInOrgReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReactionsCreateForTeamDiscussionCommentInOrgReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReactionsCreateForTeamDiscussionCommentInOrgReqContent_EncodeDecode(t *testing.T) {
 	var typ ReactionsCreateForTeamDiscussionCommentInOrgReqContent
 	typ.SetFake()
@@ -17381,6 +19482,36 @@ func TestReactionsCreateForTeamDiscussionCommentLegacyReq_EncodeDecode(t *testin
 	var typ2 ReactionsCreateForTeamDiscussionCommentLegacyReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReactionsCreateForTeamDiscussionCommentLegacyReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"content\": \"heart\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReactionsCreateForTeamDiscussionCommentLegacyReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReactionsCreateForTeamDiscussionCommentLegacyReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReactionsCreateForTeamDiscussionCommentLegacyReqContent_EncodeDecode(t *testing.T) {
 	var typ ReactionsCreateForTeamDiscussionCommentLegacyReqContent
 	typ.SetFake()
@@ -17429,6 +19560,36 @@ func TestReactionsCreateForTeamDiscussionInOrgReq_EncodeDecode(t *testing.T) {
 	var typ2 ReactionsCreateForTeamDiscussionInOrgReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReactionsCreateForTeamDiscussionInOrgReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"content\": \"heart\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReactionsCreateForTeamDiscussionInOrgReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReactionsCreateForTeamDiscussionInOrgReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReactionsCreateForTeamDiscussionInOrgReqContent_EncodeDecode(t *testing.T) {
 	var typ ReactionsCreateForTeamDiscussionInOrgReqContent
 	typ.SetFake()
@@ -17453,6 +19614,36 @@ func TestReactionsCreateForTeamDiscussionLegacyReq_EncodeDecode(t *testing.T) {
 	var typ2 ReactionsCreateForTeamDiscussionLegacyReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReactionsCreateForTeamDiscussionLegacyReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"content\": \"heart\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReactionsCreateForTeamDiscussionLegacyReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReactionsCreateForTeamDiscussionLegacyReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReactionsCreateForTeamDiscussionLegacyReqContent_EncodeDecode(t *testing.T) {
 	var typ ReactionsCreateForTeamDiscussionLegacyReqContent
 	typ.SetFake()
@@ -18089,6 +20280,36 @@ func TestReposCreateAutolinkReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposCreateAutolinkReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposCreateAutolinkReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"key_prefix\": \"TICKET-\",\n                \"url_template\": \"https://example.com/TICKET?query=<num>\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposCreateAutolinkReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposCreateAutolinkReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposCreateCommitCommentReq_EncodeDecode(t *testing.T) {
 	var typ ReposCreateCommitCommentReq
 	typ.SetFake()
@@ -18101,6 +20322,36 @@ func TestReposCreateCommitCommentReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposCreateCommitCommentReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposCreateCommitCommentReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"body\": \"Great stuff\",\n                \"path\": \"file1.txt\",\n                \"position\": 4,\n                \"line\": 1\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposCreateCommitCommentReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposCreateCommitCommentReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposCreateCommitStatusReq_EncodeDecode(t *testing.T) {
 	var typ ReposCreateCommitStatusReq
 	typ.SetFake()
@@ -18110,8 +20361,38 @@ func TestReposCreateCommitStatusReq_EncodeDecode(t *testing.T) {
 	data := e.Bytes()
 	require.True(t, std.Valid(data), "Encoded: %s", data)
 
-	var typ2 ReposCreateCommitStatusReq
-	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
+	var typ2 ReposCreateCommitStatusReq
+	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
+}
+
+func TestReposCreateCommitStatusReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"state\": \"success\",\n                \"target_url\": \"https://example.com/build/status\",\n                \"description\": \"The build succeeded!\",\n                \"context\": \"continuous-integration/jenkins\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposCreateCommitStatusReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposCreateCommitStatusReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
 }
 func TestReposCreateCommitStatusReqState_EncodeDecode(t *testing.T) {
 	var typ ReposCreateCommitStatusReqState
@@ -18137,6 +20418,36 @@ func TestReposCreateDeployKeyReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposCreateDeployKeyReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposCreateDeployKeyReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"title\": \"octocat@octomac\",\n                \"key\": \"ssh-rsa AAA...\",\n                \"read_only\": true\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposCreateDeployKeyReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposCreateDeployKeyReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposCreateDeploymentAccepted_EncodeDecode(t *testing.T) {
 	var typ ReposCreateDeploymentAccepted
 	typ.SetFake()
@@ -18191,6 +20502,37 @@ func TestReposCreateDeploymentReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposCreateDeploymentReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposCreateDeploymentReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                    \"ref\": \"topic-branch\",\n                    \"auto_merge\": false,\n                    \"payload\": \"{ \\\"deploy\\\": \\\"migrate\\\" }\",\n                    \"description\": \"Deploy request from hubot\",\n                    \"required_contexts\": [\n                      \"ci/janky\",\n                      \"security/brakeman\"\n                    ]\n                  }"},
+		{Input: "{\n                    \"ref\": \"topic-branch\",\n                    \"payload\": \"{ \\\"deploy\\\": \\\"migrate\\\" }\",\n                    \"description\": \"Deploy request from hubot\"\n                  }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposCreateDeploymentReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposCreateDeploymentReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposCreateDeploymentReqPayload_EncodeDecode(t *testing.T) {
 	var typ ReposCreateDeploymentReqPayload
 	typ.SetFake()
@@ -18229,6 +20571,36 @@ func TestReposCreateDeploymentStatusReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposCreateDeploymentStatusReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposCreateDeploymentStatusReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"environment\": \"production\",\n                \"state\": \"success\",\n                \"log_url\": \"https://example.com/deployment/42/output\",\n                \"description\": \"Deployment finished successfully.\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposCreateDeploymentStatusReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposCreateDeploymentStatusReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposCreateDeploymentStatusReqEnvironment_EncodeDecode(t *testing.T) {
 	var typ ReposCreateDeploymentStatusReqEnvironment
 	typ.SetFake()
@@ -18265,6 +20637,36 @@ func TestReposCreateDispatchEventReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposCreateDispatchEventReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposCreateDispatchEventReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"event_type\": \"on-demand-test\",\n                \"client_payload\": {\n                  \"unit\": false,\n                  \"integration\": true\n                }\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposCreateDispatchEventReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposCreateDispatchEventReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposCreateDispatchEventReqClientPayload_EncodeDecode(t *testing.T) {
 	var typ ReposCreateDispatchEventReqClientPayload
 	typ = make(ReposCreateDispatchEventReqClientPayload)
@@ -18399,6 +20801,36 @@ func TestReposCreateInOrgReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposCreateInOrgReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposCreateInOrgReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"name\": \"Hello-World\",\n                \"description\": \"This is your first repository\",\n                \"homepage\": \"https://github.com\",\n                \"private\": false,\n                \"has_issues\": true,\n                \"has_projects\": true,\n                \"has_wiki\": true\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposCreateInOrgReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposCreateInOrgReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposCreateInOrgReqVisibility_EncodeDecode(t *testing.T) {
 	var typ ReposCreateInOrgReqVisibility
 	typ.SetFake()
@@ -18471,6 +20903,37 @@ func TestReposCreateOrUpdateFileContentsReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposCreateOrUpdateFileContentsReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposCreateOrUpdateFileContentsReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                    \"message\": \"a new commit message\",\n                    \"committer\": {\n                      \"name\": \"Monalisa Octocat\",\n                      \"email\": \"octocat@github.com\"\n                    },\n                    \"content\": \"bXkgdXBkYXRlZCBmaWxlIGNvbnRlbnRz\",\n                    \"sha\": \"95b966ae1c166bd92f8ae7d1c313e738c731dfc3\"\n                  }"},
+		{Input: "{\n                    \"message\": \"my commit message\",\n                    \"committer\": {\n                      \"name\": \"Monalisa Octocat\",\n                      \"email\": \"octocat@github.com\"\n                    },\n                    \"content\": \"bXkgbmV3IGZpbGUgY29udGVudHM=\"\n                  }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposCreateOrUpdateFileContentsReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposCreateOrUpdateFileContentsReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposCreateOrUpdateFileContentsReqAuthor_EncodeDecode(t *testing.T) {
 	var typ ReposCreateOrUpdateFileContentsReqAuthor
 	typ.SetFake()
@@ -18507,6 +20970,36 @@ func TestReposCreatePagesSiteReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposCreatePagesSiteReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposCreatePagesSiteReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"source\": {\n                  \"branch\": \"main\",\n                  \"path\": \"/docs\"\n                }\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposCreatePagesSiteReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposCreatePagesSiteReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposCreatePagesSiteReqSource_EncodeDecode(t *testing.T) {
 	var typ ReposCreatePagesSiteReqSource
 	typ.SetFake()
@@ -18543,6 +21036,36 @@ func TestReposCreateReleaseReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposCreateReleaseReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposCreateReleaseReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"tag_name\": \"v1.0.0\",\n                \"target_commitish\": \"master\",\n                \"name\": \"v1.0.0\",\n                \"body\": \"Description of the release\",\n                \"draft\": false,\n                \"prerelease\": false\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposCreateReleaseReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposCreateReleaseReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposCreateUsingTemplateReq_EncodeDecode(t *testing.T) {
 	var typ ReposCreateUsingTemplateReq
 	typ.SetFake()
@@ -18555,6 +21078,36 @@ func TestReposCreateUsingTemplateReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposCreateUsingTemplateReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposCreateUsingTemplateReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"owner\": \"octocat\",\n                \"name\": \"Hello-World\",\n                \"description\": \"This is your first repository\",\n                \"include_all_branches\": false,\n                \"private\": false\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposCreateUsingTemplateReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposCreateUsingTemplateReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposCreateWebhookApplicationJSONForbidden_EncodeDecode(t *testing.T) {
 	var typ ReposCreateWebhookApplicationJSONForbidden
 	typ.SetFake()
@@ -18583,13 +21136,43 @@ func TestReposCreateWebhookReq_EncodeDecode(t *testing.T) {
 	var typ ReposCreateWebhookReq
 	typ.SetFake()
 
-	e := jx.Encoder{}
-	typ.Encode(&e)
-	data := e.Bytes()
-	require.True(t, std.Valid(data), "Encoded: %s", data)
+	e := jx.Encoder{}
+	typ.Encode(&e)
+	data := e.Bytes()
+	require.True(t, std.Valid(data), "Encoded: %s", data)
+
+	var typ2 ReposCreateWebhookReq
+	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
+}
+
+func TestReposCreateWebhookReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"name\": \"web\",\n                \"active\": true,\n                \"events\": [\n                  \"push\",\n                  \"pull_request\"\n                ],\n                \"config\": {\n                  \"url\": \"https://example.com/webhook\",\n                  \"content_type\": \"json\",\n                  \"insecure_ssl\": \"0\"\n                }\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposCreateWebhookReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
 
-	var typ2 ReposCreateWebhookReq
-	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposCreateWebhookReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
 }
 func TestReposCreateWebhookReqConfig_EncodeDecode(t *testing.T) {
 	var typ ReposCreateWebhookReqConfig
@@ -18699,6 +21282,36 @@ func TestReposDeleteFileReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposDeleteFileReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposDeleteFileReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"message\": \"my commit message\",\n                \"committer\": {\n                  \"name\": \"Monalisa Octocat\",\n                  \"email\": \"octocat@github.com\"\n                },\n                \"sha\": \"329688480d39049927147c162b9d2deaf885005f\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposDeleteFileReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposDeleteFileReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposDeleteFileReqAuthor_EncodeDecode(t *testing.T) {
 	var typ ReposDeleteFileReqAuthor
 	typ.SetFake()
@@ -19281,6 +21894,36 @@ func TestReposMergeReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposMergeReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposMergeReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"base\": \"master\",\n                \"head\": \"cool_feature\",\n                \"commit_message\": \"Shipped cool_feature!\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposMergeReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposMergeReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposMergeUpstreamReq_EncodeDecode(t *testing.T) {
 	var typ ReposMergeUpstreamReq
 	typ.SetFake()
@@ -19293,6 +21936,36 @@ func TestReposMergeUpstreamReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposMergeUpstreamReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposMergeUpstreamReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"branch\": \"main\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposMergeUpstreamReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposMergeUpstreamReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposRemoveAppAccessRestrictionsOKApplicationJSON_EncodeDecode(t *testing.T) {
 	var typ ReposRemoveAppAccessRestrictionsOKApplicationJSON
 	typ.SetFake()
@@ -19593,6 +22266,36 @@ func TestReposRenameBranchReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposRenameBranchReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposRenameBranchReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"new_name\": \"my_renamed_branch\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposRenameBranchReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposRenameBranchReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposReplaceAllTopicsReq_EncodeDecode(t *testing.T) {
 	var typ ReposReplaceAllTopicsReq
 	typ.SetFake()
@@ -19605,6 +22308,36 @@ func TestReposReplaceAllTopicsReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposReplaceAllTopicsReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposReplaceAllTopicsReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"names\": [\n                  \"octocat\",\n                  \"atom\",\n                  \"electron\",\n                  \"api\"\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposReplaceAllTopicsReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposReplaceAllTopicsReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposSetAppAccessRestrictionsOKApplicationJSON_EncodeDecode(t *testing.T) {
 	var typ ReposSetAppAccessRestrictionsOKApplicationJSON
 	typ.SetFake()
@@ -19881,6 +22614,36 @@ func TestReposTransferReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposTransferReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposTransferReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"new_owner\": \"github\",\n                \"team_ids\": [\n                  12,\n                  345\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposTransferReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposTransferReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposUpdateApplicationJSONForbidden_EncodeDecode(t *testing.T) {
 	var typ ReposUpdateApplicationJSONForbidden
 	typ.SetFake()
@@ -19953,6 +22716,36 @@ func TestReposUpdateBranchProtectionReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposUpdateBranchProtectionReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposUpdateBranchProtectionReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"required_status_checks\": {\n                  \"strict\": true,\n                  \"contexts\": [\n                    \"continuous-integration/travis-ci\"\n                  ]\n                },\n                \"enforce_admins\": true,\n                \"required_pull_request_reviews\": {\n                  \"dismissal_restrictions\": {\n                    \"users\": [\n                      \"octocat\"\n                    ],\n                    \"teams\": [\n                      \"justice-league\"\n                    ]\n                  },\n                  \"dismiss_stale_reviews\": true,\n                  \"require_code_owner_reviews\": true,\n                  \"required_approving_review_count\": 2\n                },\n                \"restrictions\": {\n                  \"users\": [\n                    \"octocat\"\n                  ],\n                  \"teams\": [\n                    \"justice-league\"\n                  ],\n                  \"apps\": [\n                    \"super-ci\"\n                  ]\n                },\n                \"required_linear_history\": true,\n                \"allow_force_pushes\": true,\n                \"allow_deletions\": true,\n                \"required_conversation_resolution\": true\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposUpdateBranchProtectionReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposUpdateBranchProtectionReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposUpdateBranchProtectionReqRequiredPullRequestReviews_EncodeDecode(t *testing.T) {
 	var typ ReposUpdateBranchProtectionReqRequiredPullRequestReviews
 	typ.SetFake()
@@ -20013,6 +22806,36 @@ func TestReposUpdateCommitCommentReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposUpdateCommitCommentReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposUpdateCommitCommentReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"body\": \"Nice change\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposUpdateCommitCommentReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposUpdateCommitCommentReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposUpdateInvitationReq_EncodeDecode(t *testing.T) {
 	var typ ReposUpdateInvitationReq
 	typ.SetFake()
@@ -20046,8 +22869,38 @@ func TestReposUpdatePullRequestReviewProtectionReq_EncodeDecode(t *testing.T) {
 	data := e.Bytes()
 	require.True(t, std.Valid(data), "Encoded: %s", data)
 
-	var typ2 ReposUpdatePullRequestReviewProtectionReq
-	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
+	var typ2 ReposUpdatePullRequestReviewProtectionReq
+	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
+}
+
+func TestReposUpdatePullRequestReviewProtectionReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"dismissal_restrictions\": {\n                  \"users\": [\n                    \"octocat\"\n                  ],\n                  \"teams\": [\n                    \"justice-league\"\n                  ]\n                },\n                \"dismiss_stale_reviews\": true,\n                \"require_code_owner_reviews\": true,\n                \"required_approving_review_count\": 2\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposUpdatePullRequestReviewProtectionReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposUpdatePullRequestReviewProtectionReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
 }
 func TestReposUpdatePullRequestReviewProtectionReqDismissalRestrictions_EncodeDecode(t *testing.T) {
 	var typ ReposUpdatePullRequestReviewProtectionReqDismissalRestrictions
@@ -20073,6 +22926,36 @@ func TestReposUpdateReleaseAssetReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposUpdateReleaseAssetReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposUpdateReleaseAssetReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"name\": \"foo-1.0.0-osx.zip\",\n                \"label\": \"Mac binary\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposUpdateReleaseAssetReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposUpdateReleaseAssetReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposUpdateReleaseReq_EncodeDecode(t *testing.T) {
 	var typ ReposUpdateReleaseReq
 	typ.SetFake()
@@ -20085,6 +22968,36 @@ func TestReposUpdateReleaseReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposUpdateReleaseReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposUpdateReleaseReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"tag_name\": \"v1.0.0\",\n                \"target_commitish\": \"master\",\n                \"name\": \"v1.0.0\",\n                \"body\": \"Description of the release\",\n                \"draft\": false,\n                \"prerelease\": false\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposUpdateReleaseReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposUpdateReleaseReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposUpdateReq_EncodeDecode(t *testing.T) {
 	var typ ReposUpdateReq
 	typ.SetFake()
@@ -20097,6 +23010,36 @@ func TestReposUpdateReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposUpdateReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposUpdateReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"name\": \"Hello-World\",\n                \"description\": \"This is your first repository\",\n                \"homepage\": \"https://github.com\",\n                \"private\": true,\n                \"has_issues\": true,\n                \"has_projects\": true,\n                \"has_wiki\": true\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposUpdateReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposUpdateReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposUpdateReqSecurityAndAnalysis_EncodeDecode(t *testing.T) {
 	var typ ReposUpdateReqSecurityAndAnalysis
 	typ.SetFake()
@@ -20157,6 +23100,36 @@ func TestReposUpdateStatusCheckProtectionReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposUpdateStatusCheckProtectionReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposUpdateStatusCheckProtectionReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"strict\": true,\n                \"contexts\": [\n                  \"continuous-integration/travis-ci\"\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposUpdateStatusCheckProtectionReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposUpdateStatusCheckProtectionReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposUpdateWebhookConfigForRepoReq_EncodeDecode(t *testing.T) {
 	var typ ReposUpdateWebhookConfigForRepoReq
 	typ.SetFake()
@@ -20211,6 +23184,36 @@ func TestReposUpdateWebhookReq_EncodeDecode(t *testing.T) {
 	var typ2 ReposUpdateWebhookReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestReposUpdateWebhookReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"active\": true,\n                \"add_events\": [\n                  \"pull_request\"\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ ReposUpdateWebhookReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 ReposUpdateWebhookReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestReposUpdateWebhookReqConfig_EncodeDecode(t *testing.T) {
 	var typ ReposUpdateWebhookReqConfig
 	typ.SetFake()
@@ -21526,6 +24529,36 @@ func TestSecretScanningUpdateAlertReq_EncodeDecode(t *testing.T) {
 	var typ2 SecretScanningUpdateAlertReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestSecretScanningUpdateAlertReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"state\": \"resolved\",\n                \"resolution\": \"false_positive\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ SecretScanningUpdateAlertReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 SecretScanningUpdateAlertReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestSelectedActions_EncodeDecode(t *testing.T) {
 	var typ SelectedActions
 	typ.SetFake()
@@ -22477,6 +25510,36 @@ func TestTeamsCreateDiscussionCommentInOrgReq_EncodeDecode(t *testing.T) {
 	var typ2 TeamsCreateDiscussionCommentInOrgReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestTeamsCreateDiscussionCommentInOrgReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"body\": \"Do you like apples?\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ TeamsCreateDiscussionCommentInOrgReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 TeamsCreateDiscussionCommentInOrgReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestTeamsCreateDiscussionCommentLegacyReq_EncodeDecode(t *testing.T) {
 	var typ TeamsCreateDiscussionCommentLegacyReq
 	typ.SetFake()
@@ -22489,6 +25552,36 @@ func TestTeamsCreateDiscussionCommentLegacyReq_EncodeDecode(t *testing.T) {
 	var typ2 TeamsCreateDiscussionCommentLegacyReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestTeamsCreateDiscussionCommentLegacyReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"body\": \"Do you like apples?\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ TeamsCreateDiscussionCommentLegacyReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 TeamsCreateDiscussionCommentLegacyReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestTeamsCreateDiscussionInOrgReq_EncodeDecode(t *testing.T) {
 	var typ TeamsCreateDiscussionInOrgReq
 	typ.SetFake()
@@ -22501,17 +25594,77 @@ func TestTeamsCreateDiscussionInOrgReq_EncodeDecode(t *testing.T) {
 	var typ2 TeamsCreateDiscussionInOrgReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestTeamsCreateDiscussionInOrgReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"title\": \"Our first team post\",\n                \"body\": \"Hi! This is an area for us to collaborate as a team.\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ TeamsCreateDiscussionInOrgReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 TeamsCreateDiscussionInOrgReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestTeamsCreateDiscussionLegacyReq_EncodeDecode(t *testing.T) {
 	var typ TeamsCreateDiscussionLegacyReq
 	typ.SetFake()
 
-	e := jx.Encoder{}
-	typ.Encode(&e)
-	data := e.Bytes()
-	require.True(t, std.Valid(data), "Encoded: %s", data)
+	e := jx.Encoder{}
+	typ.Encode(&e)
+	data := e.Bytes()
+	require.True(t, std.Valid(data), "Encoded: %s", data)
+
+	var typ2 TeamsCreateDiscussionLegacyReq
+	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
+}
+
+func TestTeamsCreateDiscussionLegacyReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"title\": \"Our first team post\",\n                \"body\": \"Hi! This is an area for us to collaborate as a team.\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ TeamsCreateDiscussionLegacyReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
 
-	var typ2 TeamsCreateDiscussionLegacyReq
-	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 TeamsCreateDiscussionLegacyReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
 }
 func TestTeamsCreateOrUpdateIdpGroupConnectionsInOrgReq_EncodeDecode(t *testing.T) {
 	var typ TeamsCreateOrUpdateIdpGroupConnectionsInOrgReq
@@ -22525,6 +25678,36 @@ func TestTeamsCreateOrUpdateIdpGroupConnectionsInOrgReq_EncodeDecode(t *testing.
 	var typ2 TeamsCreateOrUpdateIdpGroupConnectionsInOrgReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestTeamsCreateOrUpdateIdpGroupConnectionsInOrgReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"groups\": [\n                  {\n                    \"group_id\": \"123\",\n                    \"group_name\": \"Octocat admins\",\n                    \"group_description\": \"string\"\n                  }\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ TeamsCreateOrUpdateIdpGroupConnectionsInOrgReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 TeamsCreateOrUpdateIdpGroupConnectionsInOrgReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestTeamsCreateOrUpdateIdpGroupConnectionsInOrgReqGroupsItem_EncodeDecode(t *testing.T) {
 	var typ TeamsCreateOrUpdateIdpGroupConnectionsInOrgReqGroupsItem
 	typ.SetFake()
@@ -22549,6 +25732,36 @@ func TestTeamsCreateOrUpdateIdpGroupConnectionsLegacyReq_EncodeDecode(t *testing
 	var typ2 TeamsCreateOrUpdateIdpGroupConnectionsLegacyReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestTeamsCreateOrUpdateIdpGroupConnectionsLegacyReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"groups\": [\n                  {\n                    \"group_id\": \"123\",\n                    \"group_name\": \"Octocat admins\",\n                    \"description\": \"The people who configure your octoworld.\",\n                    \"group_description\": \"string\"\n                  }\n                ]\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ TeamsCreateOrUpdateIdpGroupConnectionsLegacyReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 TeamsCreateOrUpdateIdpGroupConnectionsLegacyReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestTeamsCreateOrUpdateIdpGroupConnectionsLegacyReqGroupsItem_EncodeDecode(t *testing.T) {
 	var typ TeamsCreateOrUpdateIdpGroupConnectionsLegacyReqGroupsItem
 	typ.SetFake()
@@ -22573,6 +25786,36 @@ func TestTeamsCreateReq_EncodeDecode(t *testing.T) {
 	var typ2 TeamsCreateReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestTeamsCreateReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"name\": \"Justice League\",\n                \"description\": \"A great team\",\n                \"permission\": \"admin\",\n                \"privacy\": \"closed\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ TeamsCreateReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 TeamsCreateReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestTeamsCreateReqPermission_EncodeDecode(t *testing.T) {
 	var typ TeamsCreateReqPermission
 	typ.SetFake()
@@ -22753,6 +25996,36 @@ func TestTeamsUpdateDiscussionCommentInOrgReq_EncodeDecode(t *testing.T) {
 	var typ2 TeamsUpdateDiscussionCommentInOrgReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestTeamsUpdateDiscussionCommentInOrgReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"body\": \"Do you like pineapples?\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ TeamsUpdateDiscussionCommentInOrgReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 TeamsUpdateDiscussionCommentInOrgReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestTeamsUpdateDiscussionCommentLegacyReq_EncodeDecode(t *testing.T) {
 	var typ TeamsUpdateDiscussionCommentLegacyReq
 	typ.SetFake()
@@ -22765,6 +26038,36 @@ func TestTeamsUpdateDiscussionCommentLegacyReq_EncodeDecode(t *testing.T) {
 	var typ2 TeamsUpdateDiscussionCommentLegacyReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestTeamsUpdateDiscussionCommentLegacyReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"body\": \"Do you like pineapples?\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ TeamsUpdateDiscussionCommentLegacyReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 TeamsUpdateDiscussionCommentLegacyReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestTeamsUpdateDiscussionInOrgReq_EncodeDecode(t *testing.T) {
 	var typ TeamsUpdateDiscussionInOrgReq
 	typ.SetFake()
@@ -22777,6 +26080,36 @@ func TestTeamsUpdateDiscussionInOrgReq_EncodeDecode(t *testing.T) {
 	var typ2 TeamsUpdateDiscussionInOrgReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestTeamsUpdateDiscussionInOrgReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"title\": \"Welcome to our first team post\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ TeamsUpdateDiscussionInOrgReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 TeamsUpdateDiscussionInOrgReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestTeamsUpdateDiscussionLegacyReq_EncodeDecode(t *testing.T) {
 	var typ TeamsUpdateDiscussionLegacyReq
 	typ.SetFake()
@@ -22789,6 +26122,36 @@ func TestTeamsUpdateDiscussionLegacyReq_EncodeDecode(t *testing.T) {
 	var typ2 TeamsUpdateDiscussionLegacyReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestTeamsUpdateDiscussionLegacyReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"title\": \"Welcome to our first team post\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ TeamsUpdateDiscussionLegacyReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 TeamsUpdateDiscussionLegacyReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestTeamsUpdateInOrgReq_EncodeDecode(t *testing.T) {
 	var typ TeamsUpdateInOrgReq
 	typ.SetFake()
@@ -22801,6 +26164,36 @@ func TestTeamsUpdateInOrgReq_EncodeDecode(t *testing.T) {
 	var typ2 TeamsUpdateInOrgReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestTeamsUpdateInOrgReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"name\": \"new team name\",\n                \"description\": \"new team description\",\n                \"privacy\": \"closed\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ TeamsUpdateInOrgReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 TeamsUpdateInOrgReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestTeamsUpdateInOrgReqPermission_EncodeDecode(t *testing.T) {
 	var typ TeamsUpdateInOrgReqPermission
 	typ.SetFake()
@@ -22885,6 +26278,36 @@ func TestTeamsUpdateLegacyReq_EncodeDecode(t *testing.T) {
 	var typ2 TeamsUpdateLegacyReq
 	require.NoError(t, typ2.Decode(jx.DecodeBytes(data)))
 }
+
+func TestTeamsUpdateLegacyReq_Examples(t *testing.T) {
+
+	for i, tc := range []struct {
+		Input string
+	}{
+		{Input: "{\n                \"name\": \"new team name\",\n                \"description\": \"new team description\",\n                \"privacy\": \"closed\"\n              }"},
+	} {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
+			var typ TeamsUpdateLegacyReq
+
+			if err := typ.Decode(jx.DecodeStr(tc.Input)); err != nil {
+				var validateErr *validate.Error
+				if errors.As(err, &validateErr) {
+					t.Skipf("Validation error: %v", validateErr)
+					return
+				}
+				require.NoErrorf(t, err, "Input: %s", tc.Input)
+			}
+
+			e := jx.Encoder{}
+			typ.Encode(&e)
+			require.True(t, std.Valid(e.Bytes()), "Encoded: %s", e.Bytes())
+
+			var typ2 TeamsUpdateLegacyReq
+			require.NoError(t, typ2.Decode(jx.DecodeBytes(e.Bytes())))
+		})
+	}
+}
 func TestTeamsUpdateLegacyReqPermission_EncodeDecode(t *testing.T) {
 	var typ TeamsUpdateLegacyReqPermission
 	typ.SetFake()
diff --git a/gen/gen_contents_test.go b/gen/gen_contents_test.go
index c498ad5f..cc58e97a 100644
--- a/gen/gen_contents_test.go
+++ b/gen/gen_contents_test.go
@@ -6,13 +6,13 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"github.com/ogen-go/ogen/jsonschema"
+	"github.com/ogen-go/ogen/openapi"
 )
 
 func Test_filterMostSpecific(t *testing.T) {
-	sch := new(jsonschema.Schema)
-	list := func(input ...string) (r map[string]*jsonschema.Schema) {
-		r = map[string]*jsonschema.Schema{}
+	sch := new(openapi.MediaType)
+	list := func(input ...string) (r map[string]*openapi.MediaType) {
+		r = map[string]*openapi.MediaType{}
 		for _, value := range input {
 			r[value] = sch
 		}
@@ -20,8 +20,8 @@ func Test_filterMostSpecific(t *testing.T) {
 	}
 
 	tests := []struct {
-		contents map[string]*jsonschema.Schema
-		expected map[string]*jsonschema.Schema
+		contents map[string]*openapi.MediaType
+		expected map[string]*openapi.MediaType
 		wantErr  bool
 	}{
 		{list("text/html", "text/*"), list("text/html"), false},
@@ -38,7 +38,7 @@ func Test_filterMostSpecific(t *testing.T) {
 	for i, tt := range tests {
 		tt := tt
 		t.Run(fmt.Sprintf("Test%d", i+1), func(t *testing.T) {
-			contents := map[string]*jsonschema.Schema{}
+			contents := map[string]*openapi.MediaType{}
 			for k, v := range tt.contents {
 				contents[k] = v
 			}