id(stageTriggerId(model, stage, os))
    uuid = stageTriggerUuid(model, stage, os)
    name = stage.stageName.stageName + " (Trigger)" + (os?.asName()?.toCapitalized()?.let { "($it)" } ?: "")
    type = Type.COMPOSITE

    applyDefaultSettings()

    features {
        publishBuildStatusToGithub(model)
    }

    if (generateTriggers) {
        val enableTriggers = model.branch.enableVcsTriggers

		VersionID string
		ModTime   time.Time
		Signature string
		Type      uint8
		Flags     uint8
		EcM, EcN  uint8 // Note that these will be 0/0 for non-v2 objects and older xl.meta
	}{
		VersionID: hex.EncodeToString(z.VersionID[:]),
		ModTime:   time.Unix(0, z.ModTime),
		Signature: hex.EncodeToString(z.Signature[:]),
		Type:      z.Type,
		Flags:     z.Flags,
		EcM:       z.EcM,
		EcN:       z.EcN,
	}

    {{- end }}
  {{- if .Values.additionalAnnotations }}
  annotations: {{- toYaml .Values.additionalAnnotations | nindent 4 }}
  {{- end }}
spec:
  strategy:
    type: {{ .Values.deploymentUpdate.type }}
    {{- if eq .Values.deploymentUpdate.type "RollingUpdate" }}
    rollingUpdate:
      maxSurge: {{ .Values.deploymentUpdate.maxSurge }}
      maxUnavailable: {{ .Values.deploymentUpdate.maxUnavailable }}
    {{- end }}

import (
	"errors"
	"fmt"
)

// Error is the generic type for any error happening during decrypting
// an object. It indicates that the object itself or its metadata was
// modified accidentally or maliciously.
type Error struct {
	msg   string
	cause error
}

// Errorf - formats according to a format specifier and returns
// the string as a value that satisfies error of type crypto.Error

		t.Run(tt.want, func(t *testing.T) {
			if got := tt.arn.String(); got != tt.want {
				t.Errorf("ARN.String() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestNewIAMRoleARN(t *testing.T) {
	type args struct {
		resourceID   string
		serverRegion string
	}
	tests := []struct {
		name    string
		args    args
		want    ARN
		wantErr bool
	}{
		{
			name: "valid resource ID must succeed",

 *         }
 *         public void failure(Service service) {
 *           // Something failed, at this point we could log it, notify a load balancer, or take
 *           // some other action.  For now we will just exit.
 *           System.exit(1);
 *         }
 *       },
 *       MoreExecutors.directExecutor());
 *

   * "nhs.uk"}.
   *
   * <p>If a {@code desiredType} is specified, this method only finds suffixes of the given type.
   * Otherwise, it finds the first suffix of any type.
   */
  private int findSuffixOfType(Optional<PublicSuffixType> desiredType) {
    int partsSize = parts.size();

    for (int i = 0; i < partsSize; i++) {

 *         }
 *         public void failure(Service service) {
 *           // Something failed, at this point we could log it, notify a load balancer, or take
 *           // some other action.  For now we will just exit.
 *           System.exit(1);
 *         }
 *       },
 *       MoreExecutors.directExecutor());
 *

// Copyright 2012 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p2

type Twoer interface {
	// Deprecated: No good.
	PackageTwoMeth()
}

// Deprecated: No good.
func F() string {}

func G() Twoer {}

type onlyReader struct {
	io.Reader
}

// An onlyWriter only implements io.Writer, no matter what other methods the underlying implementation may have.
type onlyWriter struct {
	io.Writer
}

// A scriptedReader is an io.Reader that executes its steps sequentially.
type scriptedReader []func(p []byte) (n int, err error)