{
  "description": "Tenant is the Schema for the tenants API",
  "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": "TenantSpec defines the desired state of Tenant",
      "properties": {
        "argocd": {
          "description": "ArgoCD defines configurations for the tenant",
          "properties": {
            "appProject": {
              "description": "AppProject contains details about argocd AppProjects",
              "properties": {
                "clusterResourceWhitelist": {
                  "description": "ClusterResourceWhitelist contains list of whitelisted cluster level resources",
                  "items": {
                    "description": "GroupKind specifies a Group and a Kind, but does not force a version.  This is useful for identifying concepts during lookup stages without having partially valid types",
                    "properties": {
                      "group": {
                        "type": "string"
                      },
                      "kind": {
                        "type": "string"
                      }
                    },
                    "required": [
                      "group",
                      "kind"
                    ],
                    "type": "object",
                    "additionalProperties": false
                  },
                  "type": "array"
                },
                "namespaceResourceBlacklist": {
                  "description": "NamespaceResourceBlacklist contains list of blacklisted namespace level resources",
                  "items": {
                    "description": "GroupKind specifies a Group and a Kind, but does not force a version.  This is useful for identifying concepts during lookup stages without having partially valid types",
                    "properties": {
                      "group": {
                        "type": "string"
                      },
                      "kind": {
                        "type": "string"
                      }
                    },
                    "required": [
                      "group",
                      "kind"
                    ],
                    "type": "object",
                    "additionalProperties": false
                  },
                  "type": "array"
                }
              },
              "type": "object",
              "additionalProperties": false
            },
            "sourceRepos": {
              "description": "SourceRepos contains list of repository URLs which can be used for deployment",
              "items": {
                "type": "string"
              },
              "type": "array"
            }
          },
          "required": [
            "sourceRepos"
          ],
          "type": "object",
          "additionalProperties": false
        },
        "commonMetadata": {
          "description": "CommonMetadata is used to apply given labels and annotations across all tenant's namespaces",
          "properties": {
            "annotations": {
              "additionalProperties": {
                "type": "string"
              },
              "description": "Annotations to be added to all tenant's namespaces",
              "type": "object"
            },
            "labels": {
              "additionalProperties": {
                "type": "string"
              },
              "description": "Labels to be added to all tenant's namespaces",
              "type": "object"
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "desc": {
          "description": "Desc can contains description about the tenant",
          "type": "string"
        },
        "editors": {
          "description": "Editors defines the list of editors",
          "properties": {
            "groups": {
              "description": "Groups defines the list of linked Openshift Groups",
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            "users": {
              "description": "Users defines the list of linked Openshift Users",
              "items": {
                "type": "string"
              },
              "type": "array"
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "hibernation": {
          "description": "Hibernation contains the schedule during which the tenant will be sleeping",
          "properties": {
            "sleepSchedule": {
              "description": "SleepSchedule contains the schedule during which the resources within the tenant's namespaces will be put to sleep",
              "type": "string"
            },
            "wakeSchedule": {
              "description": "WakeSchedule contains the schedule during which the resources within the tenant's namespaces will be awoken",
              "type": "string"
            }
          },
          "required": [
            "sleepSchedule",
            "wakeSchedule"
          ],
          "type": "object",
          "additionalProperties": false
        },
        "namespaces": {
          "description": "Namespaces field create new namespaces which are mentioned in it",
          "properties": {
            "withTenantPrefix": {
              "description": "WithTenantPrefix will create new namespaces mentioned in it and add a prefix of the tenant name to them",
              "items": {
                "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])$",
                "type": "string"
              },
              "type": "array"
            },
            "withoutTenantPrefix": {
              "description": "WithoutTenantPrefix will create new namespaces mentioned in it",
              "items": {
                "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])$",
                "type": "string"
              },
              "type": "array"
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "onDelete": {
          "default": {
            "cleanAppProject": true,
            "cleanNamespaces": false
          },
          "description": "OnDelete cleans resources when a tenant is deleted",
          "properties": {
            "cleanAppProject": {
              "default": true,
              "description": "CleanAppProject deletes ArgoCD AppProject when a tenant is deleted and the value is set to `true`",
              "type": "boolean"
            },
            "cleanNamespaces": {
              "default": false,
              "description": "CleanNamespaces deletes namespaces when a tenant is deleted and the value is set to `true`",
              "type": "boolean"
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "owners": {
          "description": "Owners defines the list of admins",
          "properties": {
            "groups": {
              "description": "Groups defines the list of linked Openshift Groups",
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            "users": {
              "description": "Users defines the list of linked Openshift Users",
              "items": {
                "type": "string"
              },
              "type": "array"
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "quota": {
          "description": "Quota field is used to link relevant Tenant Operator Quota CR",
          "type": "string"
        },
        "sandboxConfig": {
          "description": "SandboxConfig configures the sandbox environments for all mentioned users in tenant spec",
          "properties": {
            "enabled": {
              "description": "Enabled allows a tenant owner to select whether they want to enable the creation of sandbox namespaces for their tenant members",
              "type": "boolean"
            },
            "private": {
              "description": "Private will set the created sandbox namespace to be visible to only the specific user who it belongs to",
              "type": "boolean"
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "specificMetadata": {
          "description": "SpecificMetadata is used to apply given labels and annotation across tenant's specific namespaces",
          "items": {
            "properties": {
              "annotations": {
                "additionalProperties": {
                  "type": "string"
                },
                "description": "Annotations to be added to the specified namespaces",
                "type": "object"
              },
              "labels": {
                "additionalProperties": {
                  "type": "string"
                },
                "description": "Labels to be added to the specified namespaces",
                "type": "object"
              },
              "namespaces": {
                "description": "Namespaces names on which labels and annotations will be applied",
                "items": {
                  "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])$",
                  "type": "string"
                },
                "type": "array"
              }
            },
            "required": [
              "namespaces"
            ],
            "type": "object",
            "additionalProperties": false
          },
          "type": "array"
        },
        "templateInstances": {
          "description": "TemplateInstances are templates that will be added in matching namespaces",
          "items": {
            "description": "TenantTemplateInstance defines a template instance",
            "properties": {
              "metadata": {
                "description": "The metadata of the template instance to create",
                "type": "object"
              },
              "selector": {
                "description": "The labeSelector to filter namespaces that templates should be created by default in. If it is omitted, templates are created in all namespaces.",
                "properties": {
                  "matchExpressions": {
                    "description": "matchExpressions is a list of label selector requirements. The requirements are ANDed.",
                    "items": {
                      "description": "A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.",
                      "properties": {
                        "key": {
                          "description": "key is the label key that the selector applies to.",
                          "type": "string"
                        },
                        "operator": {
                          "description": "operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.",
                          "type": "string"
                        },
                        "values": {
                          "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.",
                          "items": {
                            "type": "string"
                          },
                          "type": "array"
                        }
                      },
                      "required": [
                        "key",
                        "operator"
                      ],
                      "type": "object",
                      "additionalProperties": false
                    },
                    "type": "array"
                  },
                  "matchLabels": {
                    "additionalProperties": {
                      "type": "string"
                    },
                    "description": "matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is \"key\", the operator is \"In\", and the values array contains only \"value\". The requirements are ANDed.",
                    "type": "object"
                  }
                },
                "type": "object",
                "x-kubernetes-map-type": "atomic",
                "additionalProperties": false
              },
              "spec": {
                "description": "The spec of the template instance",
                "properties": {
                  "parameters": {
                    "description": "Parameters hold the values of the defined parameters in the template",
                    "items": {
                      "properties": {
                        "name": {
                          "description": "Name is the name of the parameter to set",
                          "type": "string"
                        },
                        "value": {
                          "description": "Value is the value of the parameter to set",
                          "type": "string"
                        }
                      },
                      "type": "object",
                      "additionalProperties": false
                    },
                    "type": "array"
                  },
                  "sync": {
                    "description": "If true the template instance will keep the deployed resources in sync with the template.",
                    "type": "boolean"
                  },
                  "template": {
                    "description": "The template to instantiate. This is an immutable field",
                    "type": "string"
                  }
                },
                "required": [
                  "template"
                ],
                "type": "object",
                "additionalProperties": false
              }
            },
            "type": "object",
            "additionalProperties": false
          },
          "type": "array"
        },
        "viewers": {
          "description": "Viewers defines the list of viewers",
          "properties": {
            "groups": {
              "description": "Groups defines the list of linked Openshift Groups",
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            "users": {
              "description": "Users defines the list of linked Openshift Users",
              "items": {
                "type": "string"
              },
              "type": "array"
            }
          },
          "type": "object",
          "additionalProperties": false
        }
      },
      "required": [
        "quota"
      ],
      "type": "object",
      "additionalProperties": false
    },
    "status": {
      "description": "TenantStatus defines the observed state of Tenant",
      "properties": {
        "argocd": {
          "description": "ArgoCD contains details about ArgoCD deployment in case the feature is enabled",
          "properties": {
            "appProject": {
              "description": "AppProjectCreated will be true while the AppProject exists",
              "type": "boolean"
            },
            "argoNamespace": {
              "description": "ArgoNamespace saves the namespace of the created ArgoCD AppProject",
              "type": "string"
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "commonMetadata": {
          "description": "CommonMetadata stores the previous state of labels and annotation applied across all tenant namespaces, if mentioned in spec",
          "properties": {
            "annotations": {
              "additionalProperties": {
                "type": "string"
              },
              "description": "Annotations to be added to all tenant's namespaces",
              "type": "object"
            },
            "labels": {
              "additionalProperties": {
                "type": "string"
              },
              "description": "Labels to be added to all tenant's namespaces",
              "type": "object"
            }
          },
          "type": "object",
          "additionalProperties": false
        },
        "conditions": {
          "description": "Status conditions for tenant",
          "items": {
            "description": "Condition contains details for one aspect of the current state of this API Resource. --- This struct is intended for direct use as an array at the field path .status.conditions.  For example, type FooStatus struct{ // Represents the observations of a foo's current state. // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge // +listType=map // +listMapKey=type Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }",
            "properties": {
              "lastTransitionTime": {
                "description": "lastTransitionTime is the last time the condition transitioned from one status to another. This should be when the underlying condition changed.  If that is not known, then using the time when the API field changed is acceptable.",
                "format": "date-time",
                "type": "string"
              },
              "message": {
                "description": "message is a human readable message indicating details about the transition. This may be an empty string.",
                "maxLength": 32768,
                "type": "string"
              },
              "observedGeneration": {
                "description": "observedGeneration represents the .metadata.generation that the condition was set based upon. For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date with respect to the current state of the instance.",
                "format": "int64",
                "minimum": 0,
                "type": "integer"
              },
              "reason": {
                "description": "reason contains a programmatic identifier indicating the reason for the condition's last transition. Producers of specific condition types may define expected values and meanings for this field, and whether the values are considered a guaranteed API. The value should be a CamelCase string. This field may not be empty.",
                "maxLength": 1024,
                "minLength": 1,
                "pattern": "^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$",
                "type": "string"
              },
              "status": {
                "description": "status of the condition, one of True, False, Unknown.",
                "enum": [
                  "True",
                  "False",
                  "Unknown"
                ],
                "type": "string"
              },
              "type": {
                "description": "type of condition in CamelCase or in foo.example.com/CamelCase. --- Many .condition.type values are consistent across resources like Available, but because arbitrary conditions can be useful (see .node.status.conditions), the ability to deconflict is important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)",
                "maxLength": 316,
                "pattern": "^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$",
                "type": "string"
              }
            },
            "required": [
              "lastTransitionTime",
              "message",
              "reason",
              "status",
              "type"
            ],
            "type": "object",
            "additionalProperties": false
          },
          "type": "array"
        },
        "deployedNamespaces": {
          "description": "DeployedNamespaces has the string for created namespaces so they can be synced with spec",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "deployedSandboxes": {
          "additionalProperties": {
            "type": "string"
          },
          "description": "DeployedSandboxes has the map for created sandbox environments so they can be synced with spec",
          "type": "object"
        },
        "sandboxState": {
          "description": "SandboxState stores the previous state of sandbox field, if mentioned in spec",
          "type": "boolean"
        },
        "specificMetadata": {
          "description": "SpecificMetadata stores the previous state of labels and annotations applied across specific tenant namespaces, if mentioned in spec",
          "items": {
            "properties": {
              "annotations": {
                "additionalProperties": {
                  "type": "string"
                },
                "description": "Annotations to be added to the specified namespaces",
                "type": "object"
              },
              "labels": {
                "additionalProperties": {
                  "type": "string"
                },
                "description": "Labels to be added to the specified namespaces",
                "type": "object"
              },
              "namespaces": {
                "description": "Namespaces names on which labels and annotations will be applied",
                "items": {
                  "pattern": "^[a-z0-9]([-a-z0-9]*[a-z0-9])$",
                  "type": "string"
                },
                "type": "array"
              }
            },
            "required": [
              "namespaces"
            ],
            "type": "object",
            "additionalProperties": false
          },
          "type": "array"
        }
      },
      "type": "object",
      "additionalProperties": false
    }
  },
  "type": "object"
}