// apply.
func CertificateSigningRequestStatus() *CertificateSigningRequestStatusApplyConfiguration {
	return &CertificateSigningRequestStatusApplyConfiguration{}
}

// WithConditions adds the given value to the Conditions field in the declarative configuration
// and returns the receiver, so that objects can be build by chaining "With" function invocations.

// apply.
func NodeSelectorTerm() *NodeSelectorTermApplyConfiguration {
	return &NodeSelectorTermApplyConfiguration{}
}

// WithMatchExpressions adds the given value to the MatchExpressions field in the declarative configuration
// and returns the receiver, so that objects can be build by chaining "With" function invocations.

	}
	return t.ext
}

// unixSec returns the time's seconds since Jan 1 1970 (Unix time).
func (t *Time) unixSec() int64 { return t.sec() + internalToUnix }

// addSec adds d seconds to the time.
func (t *Time) addSec(d int64) {
	if t.wall&hasMonotonic != 0 {
		sec := int64(t.wall << 1 >> (nsecShift + 1))
		dsec := sec + d
		if 0 <= dsec && dsec <= 1<<33-1 {

  @CanIgnoreReturnValue
  N removeOutEdge(E edge);

  /**
   * Add {@code edge} to the set of incoming edges. Implicitly adds {@code node} as a predecessor.
   */
  void addInEdge(E edge, N node, boolean isSelfLoop);

  /** Add {@code edge} to the set of outgoing edges. Implicitly adds {@code node} as a successor. */
  void addOutEdge(E edge, N node);

            model {
                baseBinary(BinarySpec) {
                }
            }
        }

        then:
        realize("baseBinary") instanceof BinarySpec
    }

    def "adds a 'binaries' container to the project model"() {
        when:
        dsl {
            apply plugin: BinaryBasePlugin
        }

        then:
        realizeBinaries() != null
    }

    /**
     * Adds an {@code Action} to be executed when a plugin is added to this collection.
     *
     * @param action The action to be executed
     * @return the supplied action
     */
    @SuppressWarnings("UnusedDeclaration")
    Action<? super T> whenPluginAdded(Action<? super T> action);

    /**

// apply.
func CustomResourceDefinitionStatus() *CustomResourceDefinitionStatusApplyConfiguration {
	return &CustomResourceDefinitionStatusApplyConfiguration{}
}

// WithConditions adds the given value to the Conditions field in the declarative configuration
// and returns the receiver, so that objects can be build by chaining "With" function invocations.

     */
    void setSystemProperties(Map<String, ?> properties);

    /**
     * Adds some system properties to use for the process.
     *
     * @param properties The system properties. Must not be null.
     * @return this
     */
    JavaForkOptions systemProperties(Map<String, ?> properties);

    /**
     * Adds a system property to use for the process.
     *
     * @param name The name of the property

			d, ok := data.(myPhaseData)
			if !ok {
				return errors.New("invalid RunData type")
			}

			// implement your phase logic...
			fmt.Printf("%v\n", d.Data())
			return nil
		},
	}

	// Adds the new phases to the workflow
	// Phases will be executed the same order they are added to the workflow
	myWorkflowRunner.AppendPhase(myPhase1)
	myWorkflowRunner.AppendPhase(myPhase2)
}

func ExampleRunner_Run() {

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package event

// RulesMap - map of rules for every event name.
type RulesMap map[Name]Rules

// add - adds event names, prefixes, suffixes and target ID to rules map.
func (rulesMap RulesMap) add(eventNames []Name, pattern string, targetID TargetID) {
	rules := make(Rules)
	rules.Add(pattern, targetID)