apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  annotations:
    controller-gen.kubebuilder.io/version: v0.13.0
  name: compositions.apiextensions.crossplane.io
spec:
  group: apiextensions.crossplane.io
  names:
    categories:
    - crossplane
    kind: Composition
    listKind: CompositionList
    plural: compositions
    shortNames:
    - comp
    singular: composition
  scope: Cluster
  versions:
  - additionalPrinterColumns:
    - jsonPath: .spec.compositeTypeRef.kind
      name: XR-KIND
      type: string
    - jsonPath: .spec.compositeTypeRef.apiVersion
      name: XR-APIVERSION
      type: string
    - jsonPath: .metadata.creationTimestamp
      name: AGE
      type: date
    name: v1
    schema:
      openAPIV3Schema:
        description: A Composition specifies how a composite resource should be composed.
        properties:
          apiVersion:
            description: 'APIVersion defines the versioned schema of this representation
              of an object. Servers should convert recognized schemas to the latest
              internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources'
            type: string
          kind:
            description: 'Kind is a string value representing the REST resource this
              object represents. Servers may infer this from the endpoint the client
              submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
            type: string
          metadata:
            type: object
          spec:
            description: CompositionSpec specifies desired state of a composition.
            properties:
              compositeTypeRef:
                description: CompositeTypeRef specifies the type of composite resource
                  that this composition is compatible with.
                properties:
                  apiVersion:
                    description: APIVersion of the type.
                    type: string
                  kind:
                    description: Kind of the type.
                    type: string
                required:
                - apiVersion
                - kind
                type: object
              environment:
                description: "Environment configures the environment in which resources
                  are rendered. \n THIS IS AN ALPHA FIELD. Do not use it in production.
                  It is not honored unless the relevant Crossplane feature flag is
                  enabled, and may be changed or removed without notice."
                properties:
                  defaultData:
                    additionalProperties:
                      x-kubernetes-preserve-unknown-fields: true
                    description: DefaultData statically defines the initial state
                      of the environment. It has the same schema-less structure as
                      the data field in environment configs. It is overwritten by
                      the selected environment configs.
                    type: object
                  environmentConfigs:
                    description: "EnvironmentConfigs selects a list of `EnvironmentConfig`s.
                      The resolved resources are stored in the composite resource
                      at `spec.environmentConfigRefs` and is only updated if it is
                      null. \n The list of references is used to compute an in-memory
                      environment at compose time. The data of all object is merged
                      in the order they are listed, meaning the values of EnvironmentConfigs
                      with a larger index take priority over ones with smaller indices.
                      \n The computed environment can be accessed in a composition
                      using `FromEnvironmentFieldPath` and `CombineFromEnvironment`
                      patches."
                    items:
                      description: EnvironmentSource selects a EnvironmentConfig resource.
                      properties:
                        ref:
                          description: Ref is a named reference to a single EnvironmentConfig.
                            Either Ref or Selector is required.
                          properties:
                            name:
                              description: The name of the object.
                              type: string
                          required:
                          - name
                          type: object
                        selector:
                          description: Selector selects EnvironmentConfig(s) via labels.
                          properties:
                            matchLabels:
                              description: MatchLabels ensures an object with matching
                                labels is selected.
                              items:
                                description: An EnvironmentSourceSelectorLabelMatcher
                                  acts like a k8s label selector but can draw the
                                  label value from a different path.
                                properties:
                                  fromFieldPathPolicy:
                                    default: Required
                                    description: FromFieldPathPolicy specifies the
                                      policy for the valueFromFieldPath. The default
                                      is Required, meaning that an error will be returned
                                      if the field is not found in the composite resource.
                                      Optional means that if the field is not found
                                      in the composite resource, that label pair will
                                      just be skipped. N.B. other specified label
                                      matchers will still be used to retrieve the
                                      desired environment config, if any.
                                    enum:
                                    - Optional
                                    - Required
                                    type: string
                                  key:
                                    description: Key of the label to match.
                                    type: string
                                  type:
                                    default: FromCompositeFieldPath
                                    description: Type specifies where the value for
                                      a label comes from.
                                    enum:
                                    - FromCompositeFieldPath
                                    - Value
                                    type: string
                                  value:
                                    description: Value specifies a literal label value.
                                    type: string
                                  valueFromFieldPath:
                                    description: ValueFromFieldPath specifies the
                                      field path to look for the label value.
                                    type: string
                                required:
                                - key
                                type: object
                              type: array
                            maxMatch:
                              description: MaxMatch specifies the number of extracted
                                EnvironmentConfigs in Multiple mode, extracts all
                                if nil.
                              format: int64
                              type: integer
                            minMatch:
                              description: MinMatch specifies the required minimum
                                of extracted EnvironmentConfigs in Multiple mode.
                              format: int64
                              type: integer
                            mode:
                              default: Single
                              description: 'Mode specifies retrieval strategy: "Single"
                                or "Multiple".'
                              enum:
                              - Single
                              - Multiple
                              type: string
                            sortByFieldPath:
                              default: metadata.name
                              description: SortByFieldPath is the path to the field
                                based on which list of EnvironmentConfigs is alphabetically
                                sorted.
                              type: string
                          type: object
                        type:
                          default: Reference
                          description: Type specifies the way the EnvironmentConfig
                            is selected. Default is `Reference`
                          enum:
                          - Reference
                          - Selector
                          type: string
                      type: object
                    type: array
                  patches:
                    description: Patches is a list of environment patches that are
                      executed before a composition's resources are composed.
                    items:
                      description: EnvironmentPatch is a patch for a Composition environment.
                      properties:
                        combine:
                          description: Combine is the patch configuration for a CombineFromComposite
                            or CombineToComposite patch.
                          properties:
                            strategy:
                              description: Strategy defines the strategy to use to
                                combine the input variable values. Currently only
                                string is supported.
                              enum:
                              - string
                              type: string
                            string:
                              description: String declares that input variables should
                                be combined into a single string, using the relevant
                                settings for formatting purposes.
                              properties:
                                fmt:
                                  description: Format the input using a Go format
                                    string. See https://golang.org/pkg/fmt/ for details.
                                  type: string
                              required:
                              - fmt
                              type: object
                            variables:
                              description: Variables are the list of variables whose
                                values will be retrieved and combined.
                              items:
                                description: A CombineVariable defines the source
                                  of a value that is combined with others to form
                                  and patch an output value. Currently, this only
                                  supports retrieving values from a field path.
                                properties:
                                  fromFieldPath:
                                    description: FromFieldPath is the path of the
                                      field on the source whose value is to be used
                                      as input.
                                    type: string
                                required:
                                - fromFieldPath
                                type: object
                              minItems: 1
                              type: array
                          required:
                          - strategy
                          - variables
                          type: object
                        fromFieldPath:
                          description: FromFieldPath is the path of the field on the
                            resource whose value is to be used as input. Required
                            when type is FromCompositeFieldPath or ToCompositeFieldPath.
                          type: string
                        policy:
                          description: Policy configures the specifics of patching
                            behaviour.
                          properties:
                            fromFieldPath:
                              description: FromFieldPath specifies how to patch from
                                a field path. The default is 'Optional', which means
                                the patch will be a no-op if the specified fromFieldPath
                                does not exist. Use 'Required' if the patch should
                                fail if the specified path does not exist.
                              enum:
                              - Optional
                              - Required
                              type: string
                            mergeOptions:
                              description: MergeOptions Specifies merge options on
                                a field path
                              properties:
                                appendSlice:
                                  description: Specifies that already existing elements
                                    in a merged slice should be preserved
                                  type: boolean
                                keepMapValues:
                                  description: Specifies that already existing values
                                    in a merged map should be preserved
                                  type: boolean
                              type: object
                          type: object
                        toFieldPath:
                          description: ToFieldPath is the path of the field on the
                            resource whose value will be changed with the result of
                            transforms. Leave empty if you'd like to propagate to
                            the same path as fromFieldPath.
                          type: string
                        transforms:
                          description: Transforms are the list of functions that are
                            used as a FIFO pipe for the input to be transformed.
                          items:
                            description: Transform is a unit of process whose input
                              is transformed into an output with the supplied configuration.
                            properties:
                              convert:
                                description: Convert is used to cast the input into
                                  the given output type.
                                properties:
                                  format:
                                    description: "The expected input format. \n *
                                      `quantity` - parses the input as a K8s [`resource.Quantity`](https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity).
                                      Only used during `string -> float64` conversions.
                                      * `json` - parses the input as a JSON string.
                                      Only used during `string -> object` or `string
                                      -> list` conversions. \n If this property is
                                      null, the default conversion is applied."
                                    enum:
                                    - none
                                    - quantity
                                    - json
                                    type: string
                                  toType:
                                    description: ToType is the type of the output
                                      of this transform.
                                    enum:
                                    - string
                                    - int
                                    - int64
                                    - bool
                                    - float64
                                    - object
                                    - array
                                    type: string
                                required:
                                - toType
                                type: object
                              map:
                                additionalProperties:
                                  x-kubernetes-preserve-unknown-fields: true
                                description: Map uses the input as a key in the given
                                  map and returns the value.
                                type: object
                              match:
                                description: Match is a more complex version of Map
                                  that matches a list of patterns.
                                properties:
                                  fallbackTo:
                                    default: Value
                                    description: Determines to what value the transform
                                      should fallback if no pattern matches.
                                    enum:
                                    - Value
                                    - Input
                                    type: string
                                  fallbackValue:
                                    description: The fallback value that should be
                                      returned by the transform if now pattern matches.
                                    x-kubernetes-preserve-unknown-fields: true
                                  patterns:
                                    description: The patterns that should be tested
                                      against the input string. Patterns are tested
                                      in order. The value of the first match is used
                                      as result of this transform.
                                    items:
                                      description: MatchTransformPattern is a transform
                                        that returns the value that matches a pattern.
                                      properties:
                                        literal:
                                          description: Literal exactly matches the
                                            input string (case sensitive). Is required
                                            if `type` is `literal`.
                                          type: string
                                        regexp:
                                          description: Regexp to match against the
                                            input string. Is required if `type` is
                                            `regexp`.
                                          type: string
                                        result:
                                          description: The value that is used as result
                                            of the transform if the pattern matches.
                                          x-kubernetes-preserve-unknown-fields: true
                                        type:
                                          default: literal
                                          description: "Type specifies how the pattern
                                            matches the input. \n * `literal` - the
                                            pattern value has to exactly match (case
                                            sensitive) the input string. This is the
                                            default. \n * `regexp` - the pattern treated
                                            as a regular expression against which
                                            the input string is tested. Crossplane
                                            will throw an error if the key is not
                                            a valid regexp."
                                          enum:
                                          - literal
                                          - regexp
                                          type: string
                                      required:
                                      - result
                                      - type
                                      type: object
                                    type: array
                                type: object
                              math:
                                description: Math is used to transform the input via
                                  mathematical operations such as multiplication.
                                properties:
                                  clampMax:
                                    description: ClampMax makes sure that the value
                                      is not bigger than the given value.
                                    format: int64
                                    type: integer
                                  clampMin:
                                    description: ClampMin makes sure that the value
                                      is not smaller than the given value.
                                    format: int64
                                    type: integer
                                  multiply:
                                    description: Multiply the value.
                                    format: int64
                                    type: integer
                                  type:
                                    default: Multiply
                                    description: Type of the math transform to be
                                      run.
                                    enum:
                                    - Multiply
                                    - ClampMin
                                    - ClampMax
                                    type: string
                                type: object
                              string:
                                description: String is used to transform the input
                                  into a string or a different kind of string. Note
                                  that the input does not necessarily need to be a
                                  string.
                                properties:
                                  convert:
                                    description: Optional conversion method to be
                                      specified. `ToUpper` and `ToLower` change the
                                      letter case of the input string. `ToBase64`
                                      and `FromBase64` perform a base64 conversion
                                      based on the input string. `ToJson` converts
                                      any input value into its raw JSON representation.
                                      `ToSha1`, `ToSha256` and `ToSha512` generate
                                      a hash value based on the input converted to
                                      JSON.
                                    enum:
                                    - ToUpper
                                    - ToLower
                                    - ToBase64
                                    - FromBase64
                                    - ToJson
                                    - ToSha1
                                    - ToSha256
                                    - ToSha512
                                    type: string
                                  fmt:
                                    description: Format the input using a Go format
                                      string. See https://golang.org/pkg/fmt/ for
                                      details.
                                    type: string
                                  regexp:
                                    description: Extract a match from the input using
                                      a regular expression.
                                    properties:
                                      group:
                                        description: Group number to match. 0 (the
                                          default) matches the entire expression.
                                        type: integer
                                      match:
                                        description: Match string. May optionally
                                          include submatches, aka capture groups.
                                          See https://pkg.go.dev/regexp/ for details.
                                        type: string
                                    required:
                                    - match
                                    type: object
                                  trim:
                                    description: Trim the prefix or suffix from the
                                      input
                                    type: string
                                  type:
                                    default: Format
                                    description: Type of the string transform to be
                                      run.
                                    enum:
                                    - Format
                                    - Convert
                                    - TrimPrefix
                                    - TrimSuffix
                                    - Regexp
                                    type: string
                                type: object
                              type:
                                description: Type of the transform to be run.
                                enum:
                                - map
                                - match
                                - math
                                - string
                                - convert
                                type: string
                            required:
                            - type
                            type: object
                          type: array
                        type:
                          default: FromCompositeFieldPath
                          description: Type sets the patching behaviour to be used.
                            Each patch type may require its own fields to be set on
                            the Patch object.
                          enum:
                          - FromCompositeFieldPath
                          - ToCompositeFieldPath
                          - CombineFromComposite
                          - CombineToComposite
                          type: string
                      type: object
                    type: array
                  policy:
                    description: Policy represents the Resolve and Resolution policies
                      which apply to all EnvironmentSourceReferences in EnvironmentConfigs
                      list.
                    properties:
                      resolution:
                        default: Required
                        description: Resolution specifies whether resolution of this
                          reference is required. The default is 'Required', which
                          means the reconcile will fail if the reference cannot be
                          resolved. 'Optional' means this reference will be a no-op
                          if it cannot be resolved.
                        enum:
                        - Required
                        - Optional
                        type: string
                      resolve:
                        description: Resolve specifies when this reference should
                          be resolved. The default is 'IfNotPresent', which will attempt
                          to resolve the reference only when the corresponding field
                          is not present. Use 'Always' to resolve the reference on
                          every reconcile.
                        enum:
                        - Always
                        - IfNotPresent
                        type: string
                    type: object
                type: object
              mode:
                default: Resources
                description: "Mode controls what type or \"mode\" of Composition will
                  be used. \n \"Resources\" (the default) indicates that a Composition
                  uses what is commonly referred to as \"Patch & Transform\" or P&T
                  composition. This mode of Composition uses an array of resources,
                  each a template for a composed resource. \n \"Pipeline\" indicates
                  that a Composition specifies a pipeline of Composition Functions,
                  each of which is responsible for producing composed resources that
                  Crossplane should create or update. THE PIPELINE MODE IS A BETA
                  FEATURE. It is not honored if the relevant Crossplane feature flag
                  is disabled."
                enum:
                - Resources
                - Pipeline
                type: string
              patchSets:
                description: "PatchSets define a named set of patches that may be
                  included by any resource in this Composition. PatchSets cannot themselves
                  refer to other PatchSets. \n PatchSets are only used by the \"Resources\"
                  mode of Composition. They are ignored by other modes."
                items:
                  description: A PatchSet is a set of patches that can be reused from
                    all resources within a Composition.
                  properties:
                    name:
                      description: Name of this PatchSet.
                      type: string
                    patches:
                      description: Patches will be applied as an overlay to the base
                        resource.
                      items:
                        description: Patch objects are applied between composite and
                          composed resources. Their behaviour depends on the Type
                          selected. The default Type, FromCompositeFieldPath, copies
                          a value from the composite resource to the composed resource,
                          applying any defined transformers.
                        properties:
                          combine:
                            description: Combine is the patch configuration for a
                              CombineFromComposite, CombineFromEnvironment, CombineToComposite
                              or CombineToEnvironment patch.
                            properties:
                              strategy:
                                description: Strategy defines the strategy to use
                                  to combine the input variable values. Currently
                                  only string is supported.
                                enum:
                                - string
                                type: string
                              string:
                                description: String declares that input variables
                                  should be combined into a single string, using the
                                  relevant settings for formatting purposes.
                                properties:
                                  fmt:
                                    description: Format the input using a Go format
                                      string. See https://golang.org/pkg/fmt/ for
                                      details.
                                    type: string
                                required:
                                - fmt
                                type: object
                              variables:
                                description: Variables are the list of variables whose
                                  values will be retrieved and combined.
                                items:
                                  description: A CombineVariable defines the source
                                    of a value that is combined with others to form
                                    and patch an output value. Currently, this only
                                    supports retrieving values from a field path.
                                  properties:
                                    fromFieldPath:
                                      description: FromFieldPath is the path of the
                                        field on the source whose value is to be used
                                        as input.
                                      type: string
                                  required:
                                  - fromFieldPath
                                  type: object
                                minItems: 1
                                type: array
                            required:
                            - strategy
                            - variables
                            type: object
                          fromFieldPath:
                            description: FromFieldPath is the path of the field on
                              the resource whose value is to be used as input. Required
                              when type is FromCompositeFieldPath, FromEnvironmentFieldPath,
                              ToCompositeFieldPath, ToEnvironmentFieldPath.
                            type: string
                          patchSetName:
                            description: PatchSetName to include patches from. Required
                              when type is PatchSet.
                            type: string
                          policy:
                            description: Policy configures the specifics of patching
                              behaviour.
                            properties:
                              fromFieldPath:
                                description: FromFieldPath specifies how to patch
                                  from a field path. The default is 'Optional', which
                                  means the patch will be a no-op if the specified
                                  fromFieldPath does not exist. Use 'Required' if
                                  the patch should fail if the specified path does
                                  not exist.
                                enum:
                                - Optional
                                - Required
                                type: string
                              mergeOptions:
                                description: MergeOptions Specifies merge options
                                  on a field path
                                properties:
                                  appendSlice:
                                    description: Specifies that already existing elements
                                      in a merged slice should be preserved
                                    type: boolean
                                  keepMapValues:
                                    description: Specifies that already existing values
                                      in a merged map should be preserved
                                    type: boolean
                                type: object
                            type: object
                          toFieldPath:
                            description: ToFieldPath is the path of the field on the
                              resource whose value will be changed with the result
                              of transforms. Leave empty if you'd like to propagate
                              to the same path as fromFieldPath.
                            type: string
                          transforms:
                            description: Transforms are the list of functions that
                              are used as a FIFO pipe for the input to be transformed.
                            items:
                              description: Transform is a unit of process whose input
                                is transformed into an output with the supplied configuration.
                              properties:
                                convert:
                                  description: Convert is used to cast the input into
                                    the given output type.
                                  properties:
                                    format:
                                      description: "The expected input format. \n
                                        * `quantity` - parses the input as a K8s [`resource.Quantity`](https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity).
                                        Only used during `string -> float64` conversions.
                                        * `json` - parses the input as a JSON string.
                                        Only used during `string -> object` or `string
                                        -> list` conversions. \n If this property
                                        is null, the default conversion is applied."
                                      enum:
                                      - none
                                      - quantity
                                      - json
                                      type: string
                                    toType:
                                      description: ToType is the type of the output
                                        of this transform.
                                      enum:
                                      - string
                                      - int
                                      - int64
                                      - bool
                                      - float64
                                      - object
                                      - array
                                      type: string
                                  required:
                                  - toType
                                  type: object
                                map:
                                  additionalProperties:
                                    x-kubernetes-preserve-unknown-fields: true
                                  description: Map uses the input as a key in the
                                    given map and returns the value.
                                  type: object
                                match:
                                  description: Match is a more complex version of
                                    Map that matches a list of patterns.
                                  properties:
                                    fallbackTo:
                                      default: Value
                                      description: Determines to what value the transform
                                        should fallback if no pattern matches.
                                      enum:
                                      - Value
                                      - Input
                                      type: string
                                    fallbackValue:
                                      description: The fallback value that should
                                        be returned by the transform if now pattern
                                        matches.
                                      x-kubernetes-preserve-unknown-fields: true
                                    patterns:
                                      description: The patterns that should be tested
                                        against the input string. Patterns are tested
                                        in order. The value of the first match is
                                        used as result of this transform.
                                      items:
                                        description: MatchTransformPattern is a transform
                                          that returns the value that matches a pattern.
                                        properties:
                                          literal:
                                            description: Literal exactly matches the
                                              input string (case sensitive). Is required
                                              if `type` is `literal`.
                                            type: string
                                          regexp:
                                            description: Regexp to match against the
                                              input string. Is required if `type`
                                              is `regexp`.
                                            type: string
                                          result:
                                            description: The value that is used as
                                              result of the transform if the pattern
                                              matches.
                                            x-kubernetes-preserve-unknown-fields: true
                                          type:
                                            default: literal
                                            description: "Type specifies how the pattern
                                              matches the input. \n * `literal` -
                                              the pattern value has to exactly match
                                              (case sensitive) the input string. This
                                              is the default. \n * `regexp` - the
                                              pattern treated as a regular expression
                                              against which the input string is tested.
                                              Crossplane will throw an error if the
                                              key is not a valid regexp."
                                            enum:
                                            - literal
                                            - regexp
                                            type: string
                                        required:
                                        - result
                                        - type
                                        type: object
                                      type: array
                                  type: object
                                math:
                                  description: Math is used to transform the input
                                    via mathematical operations such as multiplication.
                                  properties:
                                    clampMax:
                                      description: ClampMax makes sure that the value
                                        is not bigger than the given value.
                                      format: int64
                                      type: integer
                                    clampMin:
                                      description: ClampMin makes sure that the value
                                        is not smaller than the given value.
                                      format: int64
                                      type: integer
                                    multiply:
                                      description: Multiply the value.
                                      format: int64
                                      type: integer
                                    type:
                                      default: Multiply
                                      description: Type of the math transform to be
                                        run.
                                      enum:
                                      - Multiply
                                      - ClampMin
                                      - ClampMax
                                      type: string
                                  type: object
                                string:
                                  description: String is used to transform the input
                                    into a string or a different kind of string. Note
                                    that the input does not necessarily need to be
                                    a string.
                                  properties:
                                    convert:
                                      description: Optional conversion method to be
                                        specified. `ToUpper` and `ToLower` change
                                        the letter case of the input string. `ToBase64`
                                        and `FromBase64` perform a base64 conversion
                                        based on the input string. `ToJson` converts
                                        any input value into its raw JSON representation.
                                        `ToSha1`, `ToSha256` and `ToSha512` generate
                                        a hash value based on the input converted
                                        to JSON.
                                      enum:
                                      - ToUpper
                                      - ToLower
                                      - ToBase64
                                      - FromBase64
                                      - ToJson
                                      - ToSha1
                                      - ToSha256
                                      - ToSha512
                                      type: string
                                    fmt:
                                      description: Format the input using a Go format
                                        string. See https://golang.org/pkg/fmt/ for
                                        details.
                                      type: string
                                    regexp:
                                      description: Extract a match from the input
                                        using a regular expression.
                                      properties:
                                        group:
                                          description: Group number to match. 0 (the
                                            default) matches the entire expression.
                                          type: integer
                                        match:
                                          description: Match string. May optionally
                                            include submatches, aka capture groups.
                                            See https://pkg.go.dev/regexp/ for details.
                                          type: string
                                      required:
                                      - match
                                      type: object
                                    trim:
                                      description: Trim the prefix or suffix from
                                        the input
                                      type: string
                                    type:
                                      default: Format
                                      description: Type of the string transform to
                                        be run.
                                      enum:
                                      - Format
                                      - Convert
                                      - TrimPrefix
                                      - TrimSuffix
                                      - Regexp
                                      type: string
                                  type: object
                                type:
                                  description: Type of the transform to be run.
                                  enum:
                                  - map
                                  - match
                                  - math
                                  - string
                                  - convert
                                  type: string
                              required:
                              - type
                              type: object
                            type: array
                          type:
                            default: FromCompositeFieldPath
                            description: Type sets the patching behaviour to be used.
                              Each patch type may require its own fields to be set
                              on the Patch object.
                            enum:
                            - FromCompositeFieldPath
                            - FromEnvironmentFieldPath
                            - PatchSet
                            - ToCompositeFieldPath
                            - ToEnvironmentFieldPath
                            - CombineFromEnvironment
                            - CombineFromComposite
                            - CombineToComposite
                            - CombineToEnvironment
                            type: string
                        type: object
                      type: array
                  required:
                  - name
                  - patches
                  type: object
                type: array
              pipeline:
                description: "Pipeline is a list of composition function steps that
                  will be used when a composite resource referring to this composition
                  is created. One of resources and pipeline must be specified - you
                  cannot specify both. \n The Pipeline is only used by the \"Pipeline\"
                  mode of Composition. It is ignored by other modes. \n THIS IS A
                  BETA FIELD. It is not honored if the relevant Crossplane feature
                  flag is disabled."
                items:
                  description: A PipelineStep in a Composition Function pipeline.
                  properties:
                    functionRef:
                      description: FunctionRef is a reference to the Composition Function
                        this step should execute.
                      properties:
                        name:
                          description: Name of the referenced Function.
                          type: string
                      required:
                      - name
                      type: object
                    input:
                      description: Input is an optional, arbitrary Kubernetes resource
                        (i.e. a resource with an apiVersion and kind) that will be
                        passed to the Composition Function as the 'input' of its RunFunctionRequest.
                      type: object
                      x-kubernetes-embedded-resource: true
                      x-kubernetes-preserve-unknown-fields: true
                    step:
                      description: Step name. Must be unique within its Pipeline.
                      type: string
                  required:
                  - functionRef
                  - step
                  type: object
                type: array
              publishConnectionDetailsWithStoreConfigRef:
                default:
                  name: default
                description: "PublishConnectionDetailsWithStoreConfig specifies the
                  secret store config with which the connection details of composite
                  resources dynamically provisioned using this composition will be
                  published. \n THIS IS AN ALPHA FIELD. Do not use it in production.
                  It is not honored unless the relevant Crossplane feature flag is
                  enabled, and may be changed or removed without notice."
                properties:
                  name:
                    description: Name of the referenced StoreConfig.
                    type: string
                required:
                - name
                type: object
              resources:
                description: "Resources is a list of resource templates that will
                  be used when a composite resource referring to this composition
                  is created. \n Resources are only used by the \"Resources\" mode
                  of Composition. They are ignored by other modes."
                items:
                  description: ComposedTemplate is used to provide information about
                    how the composed resource should be processed.
                  properties:
                    base:
                      description: Base is the target resource that the patches will
                        be applied on.
                      type: object
                      x-kubernetes-embedded-resource: true
                      x-kubernetes-preserve-unknown-fields: true
                    connectionDetails:
                      description: ConnectionDetails lists the propagation secret
                        keys from this target resource to the composition instance
                        connection secret.
                      items:
                        description: ConnectionDetail includes the information about
                          the propagation of the connection information from one secret
                          to another.
                        properties:
                          fromConnectionSecretKey:
                            description: FromConnectionSecretKey is the key that will
                              be used to fetch the value from the composed resource's
                              connection secret.
                            type: string
                          fromFieldPath:
                            description: FromFieldPath is the path of the field on
                              the composed resource whose value to be used as input.
                              Name must be specified if the type is FromFieldPath.
                            type: string
                          name:
                            description: Name of the connection secret key that will
                              be propagated to the connection secret of the composition
                              instance. Leave empty if you'd like to use the same
                              key name.
                            type: string
                          type:
                            description: 'Type sets the connection detail fetching
                              behaviour to be used. Each connection detail type may
                              require its own fields to be set on the ConnectionDetail
                              object. If the type is omitted Crossplane will attempt
                              to infer it based on which other fields were specified.
                              If multiple fields are specified the order of precedence
                              is: 1. FromValue 2. FromConnectionSecretKey 3. FromFieldPath'
                            enum:
                            - FromConnectionSecretKey
                            - FromFieldPath
                            - FromValue
                            type: string
                          value:
                            description: Value that will be propagated to the connection
                              secret of the composite resource. May be set to inject
                              a fixed, non-sensitive connection secret value, for
                              example a well-known port.
                            type: string
                        type: object
                      type: array
                    name:
                      description: A Name uniquely identifies this entry within its
                        Composition's resources array. Names are optional but *strongly*
                        recommended. When all entries in the resources array are named
                        entries may added, deleted, and reordered as long as their
                        names do not change. When entries are not named the length
                        and order of the resources array should be treated as immutable.
                        Either all or no entries must be named.
                      type: string
                    patches:
                      description: Patches will be applied as overlay to the base
                        resource.
                      items:
                        description: Patch objects are applied between composite and
                          composed resources. Their behaviour depends on the Type
                          selected. The default Type, FromCompositeFieldPath, copies
                          a value from the composite resource to the composed resource,
                          applying any defined transformers.
                        properties:
                          combine:
                            description: Combine is the patch configuration for a
                              CombineFromComposite, CombineFromEnvironment, CombineToComposite
                              or CombineToEnvironment patch.
                            properties:
                              strategy:
                                description: Strategy defines the strategy to use
                                  to combine the input variable values. Currently
                                  only string is supported.
                                enum:
                                - string
                                type: string
                              string:
                                description: String declares that input variables
                                  should be combined into a single string, using the
                                  relevant settings for formatting purposes.
                                properties:
                                  fmt:
                                    description: Format the input using a Go format
                                      string. See https://golang.org/pkg/fmt/ for
                                      details.
                                    type: string
                                required:
                                - fmt
                                type: object
                              variables:
                                description: Variables are the list of variables whose
                                  values will be retrieved and combined.
                                items:
                                  description: A CombineVariable defines the source
                                    of a value that is combined with others to form
                                    and patch an output value. Currently, this only
                                    supports retrieving values from a field path.
                                  properties:
                                    fromFieldPath:
                                      description: FromFieldPath is the path of the
                                        field on the source whose value is to be used
                                        as input.
                                      type: string
                                  required:
                                  - fromFieldPath
                                  type: object
                                minItems: 1
                                type: array
                            required:
                            - strategy
                            - variables
                            type: object
                          fromFieldPath:
                            description: FromFieldPath is the path of the field on
                              the resource whose value is to be used as input. Required
                              when type is FromCompositeFieldPath, FromEnvironmentFieldPath,
                              ToCompositeFieldPath, ToEnvironmentFieldPath.
                            type: string
                          patchSetName:
                            description: PatchSetName to include patches from. Required
                              when type is PatchSet.
                            type: string
                          policy:
                            description: Policy configures the specifics of patching
                              behaviour.
                            properties:
                              fromFieldPath:
                                description: FromFieldPath specifies how to patch
                                  from a field path. The default is 'Optional', which
                                  means the patch will be a no-op if the specified
                                  fromFieldPath does not exist. Use 'Required' if
                                  the patch should fail if the specified path does
                                  not exist.
                                enum:
                                - Optional
                                - Required
                                type: string
                              mergeOptions:
                                description: MergeOptions Specifies merge options
                                  on a field path
                                properties:
                                  appendSlice:
                                    description: Specifies that already existing elements
                                      in a merged slice should be preserved
                                    type: boolean
                                  keepMapValues:
                                    description: Specifies that already existing values
                                      in a merged map should be preserved
                                    type: boolean
                                type: object
                            type: object
                          toFieldPath:
                            description: ToFieldPath is the path of the field on the
                              resource whose value will be changed with the result
                              of transforms. Leave empty if you'd like to propagate
                              to the same path as fromFieldPath.
                            type: string
                          transforms:
                            description: Transforms are the list of functions that
                              are used as a FIFO pipe for the input to be transformed.
                            items:
                              description: Transform is a unit of process whose input
                                is transformed into an output with the supplied configuration.
                              properties:
                                convert:
                                  description: Convert is used to cast the input into
                                    the given output type.
                                  properties:
                                    format:
                                      description: "The expected input format. \n
                                        * `quantity` - parses the input as a K8s [`resource.Quantity`](https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity).
                                        Only used during `string -> float64` conversions.
                                        * `json` - parses the input as a JSON string.
                                        Only used during `string -> object` or `string
                                        -> list` conversions. \n If this property
                                        is null, the default conversion is applied."
                                      enum:
                                      - none
                                      - quantity
                                      - json
                                      type: string
                                    toType:
                                      description: ToType is the type of the output
                                        of this transform.
                                      enum:
                                      - string
                                      - int
                                      - int64
                                      - bool
                                      - float64
                                      - object
                                      - array
                                      type: string
                                  required:
                                  - toType
                                  type: object
                                map:
                                  additionalProperties:
                                    x-kubernetes-preserve-unknown-fields: true
                                  description: Map uses the input as a key in the
                                    given map and returns the value.
                                  type: object
                                match:
                                  description: Match is a more complex version of
                                    Map that matches a list of patterns.
                                  properties:
                                    fallbackTo:
                                      default: Value
                                      description: Determines to what value the transform
                                        should fallback if no pattern matches.
                                      enum:
                                      - Value
                                      - Input
                                      type: string
                                    fallbackValue:
                                      description: The fallback value that should
                                        be returned by the transform if now pattern
                                        matches.
                                      x-kubernetes-preserve-unknown-fields: true
                                    patterns:
                                      description: The patterns that should be tested
                                        against the input string. Patterns are tested
                                        in order. The value of the first match is
                                        used as result of this transform.
                                      items:
                                        description: MatchTransformPattern is a transform
                                          that returns the value that matches a pattern.
                                        properties:
                                          literal:
                                            description: Literal exactly matches the
                                              input string (case sensitive). Is required
                                              if `type` is `literal`.
                                            type: string
                                          regexp:
                                            description: Regexp to match against the
                                              input string. Is required if `type`
                                              is `regexp`.
                                            type: string
                                          result:
                                            description: The value that is used as
                                              result of the transform if the pattern
                                              matches.
                                            x-kubernetes-preserve-unknown-fields: true
                                          type:
                                            default: literal
                                            description: "Type specifies how the pattern
                                              matches the input. \n * `literal` -
                                              the pattern value has to exactly match
                                              (case sensitive) the input string. This
                                              is the default. \n * `regexp` - the
                                              pattern treated as a regular expression
                                              against which the input string is tested.
                                              Crossplane will throw an error if the
                                              key is not a valid regexp."
                                            enum:
                                            - literal
                                            - regexp
                                            type: string
                                        required:
                                        - result
                                        - type
                                        type: object
                                      type: array
                                  type: object
                                math:
                                  description: Math is used to transform the input
                                    via mathematical operations such as multiplication.
                                  properties:
                                    clampMax:
                                      description: ClampMax makes sure that the value
                                        is not bigger than the given value.
                                      format: int64
                                      type: integer
                                    clampMin:
                                      description: ClampMin makes sure that the value
                                        is not smaller than the given value.
                                      format: int64
                                      type: integer
                                    multiply:
                                      description: Multiply the value.
                                      format: int64
                                      type: integer
                                    type:
                                      default: Multiply
                                      description: Type of the math transform to be
                                        run.
                                      enum:
                                      - Multiply
                                      - ClampMin
                                      - ClampMax
                                      type: string
                                  type: object
                                string:
                                  description: String is used to transform the input
                                    into a string or a different kind of string. Note
                                    that the input does not necessarily need to be
                                    a string.
                                  properties:
                                    convert:
                                      description: Optional conversion method to be
                                        specified. `ToUpper` and `ToLower` change
                                        the letter case of the input string. `ToBase64`
                                        and `FromBase64` perform a base64 conversion
                                        based on the input string. `ToJson` converts
                                        any input value into its raw JSON representation.
                                        `ToSha1`, `ToSha256` and `ToSha512` generate
                                        a hash value based on the input converted
                                        to JSON.
                                      enum:
                                      - ToUpper
                                      - ToLower
                                      - ToBase64
                                      - FromBase64
                                      - ToJson
                                      - ToSha1
                                      - ToSha256
                                      - ToSha512
                                      type: string
                                    fmt:
                                      description: Format the input using a Go format
                                        string. See https://golang.org/pkg/fmt/ for
                                        details.
                                      type: string
                                    regexp:
                                      description: Extract a match from the input
                                        using a regular expression.
                                      properties:
                                        group:
                                          description: Group number to match. 0 (the
                                            default) matches the entire expression.
                                          type: integer
                                        match:
                                          description: Match string. May optionally
                                            include submatches, aka capture groups.
                                            See https://pkg.go.dev/regexp/ for details.
                                          type: string
                                      required:
                                      - match
                                      type: object
                                    trim:
                                      description: Trim the prefix or suffix from
                                        the input
                                      type: string
                                    type:
                                      default: Format
                                      description: Type of the string transform to
                                        be run.
                                      enum:
                                      - Format
                                      - Convert
                                      - TrimPrefix
                                      - TrimSuffix
                                      - Regexp
                                      type: string
                                  type: object
                                type:
                                  description: Type of the transform to be run.
                                  enum:
                                  - map
                                  - match
                                  - math
                                  - string
                                  - convert
                                  type: string
                              required:
                              - type
                              type: object
                            type: array
                          type:
                            default: FromCompositeFieldPath
                            description: Type sets the patching behaviour to be used.
                              Each patch type may require its own fields to be set
                              on the Patch object.
                            enum:
                            - FromCompositeFieldPath
                            - FromEnvironmentFieldPath
                            - PatchSet
                            - ToCompositeFieldPath
                            - ToEnvironmentFieldPath
                            - CombineFromEnvironment
                            - CombineFromComposite
                            - CombineToComposite
                            - CombineToEnvironment
                            type: string
                        type: object
                      type: array
                    readinessChecks:
                      default:
                      - matchCondition:
                          status: "True"
                          type: Ready
                        type: MatchCondition
                      description: ReadinessChecks allows users to define custom readiness
                        checks. All checks have to return true in order for resource
                        to be considered ready. The default readiness check is to
                        have the "Ready" condition to be "True".
                      items:
                        description: ReadinessCheck is used to indicate how to tell
                          whether a resource is ready for consumption
                        properties:
                          fieldPath:
                            description: FieldPath shows the path of the field whose
                              value will be used.
                            type: string
                          matchCondition:
                            description: MatchCondition specifies the condition you'd
                              like to match if you're using "MatchCondition" type.
                            properties:
                              status:
                                default: "True"
                                description: Status is the status of the condition
                                  you'd like to match.
                                type: string
                              type:
                                default: Ready
                                description: Type indicates the type of condition
                                  you'd like to use.
                                type: string
                            required:
                            - status
                            - type
                            type: object
                          matchInteger:
                            description: MatchInt is the value you'd like to match
                              if you're using "MatchInt" type.
                            format: int64
                            type: integer
                          matchString:
                            description: MatchString is the value you'd like to match
                              if you're using "MatchString" type.
                            type: string
                          type:
                            description: Type indicates the type of probe you'd like
                              to use.
                            enum:
                            - MatchString
                            - MatchInteger
                            - NonEmpty
                            - MatchCondition
                            - MatchTrue
                            - MatchFalse
                            - None
                            type: string
                        required:
                        - type
                        type: object
                      type: array
                  required:
                  - base
                  type: object
                type: array
              writeConnectionSecretsToNamespace:
                description: WriteConnectionSecretsToNamespace specifies the namespace
                  in which the connection secrets of composite resource dynamically
                  provisioned using this composition will be created. This field is
                  planned to be replaced in a future release in favor of PublishConnectionDetailsWithStoreConfigRef.
                  Currently, both could be set independently and connection details
                  would be published to both without affecting each other as long
                  as related fields at MR level specified.
                type: string
            required:
            - compositeTypeRef
            type: object
        type: object
    served: true
    storage: true
    subresources: {}
