text:
//go:build !ignore_autogenerated
// +build !ignore_autogenerated

// Code generated by openapi-gen. DO NOT EDIT.

// This file was autogenerated by openapi-gen. Do not edit it manually!

package v1

import (
	common "k8s.io/kube-openapi/pkg/common"
	spec "k8s.io/kube-openapi/pkg/validation/spec"
)

func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenAPIDefinition {
	return map[string]common.OpenAPIDefinition{
		"kmodules.xyz/offshoot-api/api/v1.ContainerRuntimeSettings": schema_kmodulesxyz_offshoot_api_api_v1_ContainerRuntimeSettings(ref),
		"kmodules.xyz/offshoot-api/api/v1.IONiceSettings":           schema_kmodulesxyz_offshoot_api_api_v1_IONiceSettings(ref),
		"kmodules.xyz/offshoot-api/api/v1.NiceSettings":             schema_kmodulesxyz_offshoot_api_api_v1_NiceSettings(ref),
		"kmodules.xyz/offshoot-api/api/v1.ObjectMeta":               schema_kmodulesxyz_offshoot_api_api_v1_ObjectMeta(ref),
		"kmodules.xyz/offshoot-api/api/v1.PartialObjectMeta":        schema_kmodulesxyz_offshoot_api_api_v1_PartialObjectMeta(ref),
		"kmodules.xyz/offshoot-api/api/v1.PersistentVolumeClaim":    schema_kmodulesxyz_offshoot_api_api_v1_PersistentVolumeClaim(ref),
		"kmodules.xyz/offshoot-api/api/v1.PodRuntimeSettings":       schema_kmodulesxyz_offshoot_api_api_v1_PodRuntimeSettings(ref),
		"kmodules.xyz/offshoot-api/api/v1.PodSpec":                  schema_kmodulesxyz_offshoot_api_api_v1_PodSpec(ref),
		"kmodules.xyz/offshoot-api/api/v1.PodTemplateSpec":          schema_kmodulesxyz_offshoot_api_api_v1_PodTemplateSpec(ref),
		"kmodules.xyz/offshoot-api/api/v1.RuntimeSettings":          schema_kmodulesxyz_offshoot_api_api_v1_RuntimeSettings(ref),
		"kmodules.xyz/offshoot-api/api/v1.ServicePort":              schema_kmodulesxyz_offshoot_api_api_v1_ServicePort(ref),
		"kmodules.xyz/offshoot-api/api/v1.ServiceSpec":              schema_kmodulesxyz_offshoot_api_api_v1_ServiceSpec(ref),
		"kmodules.xyz/offshoot-api/api/v1.ServiceTemplateSpec":      schema_kmodulesxyz_offshoot_api_api_v1_ServiceTemplateSpec(ref),
	}
}

func schema_kmodulesxyz_offshoot_api_api_v1_ContainerRuntimeSettings(ref common.ReferenceCallback) common.OpenAPIDefinition {
	return common.OpenAPIDefinition{
		Schema: spec.Schema{
			SchemaProps: spec.SchemaProps{
				Type: []string{"object"},
				Properties: map[string]spec.Schema{
					"resources": {
						SchemaProps: spec.SchemaProps{
							Description: "Compute Resources required by container. Cannot be updated. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/",
							Default:     map[string]interface{}{},
							Ref:         ref("k8s.io/api/core/v1.ResourceRequirements"),
						},
					},
					"livenessProbe": {
						SchemaProps: spec.SchemaProps{
							Description: "Periodic probe of container liveness. Container will be restarted if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes",
							Ref:         ref("k8s.io/api/core/v1.Probe"),
						},
					},
					"readinessProbe": {
						SchemaProps: spec.SchemaProps{
							Description: "Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes",
							Ref:         ref("k8s.io/api/core/v1.Probe"),
						},
					},
					"lifecycle": {
						SchemaProps: spec.SchemaProps{
							Description: "Actions that the management system should take in response to container lifecycle events. Cannot be updated.",
							Ref:         ref("k8s.io/api/core/v1.Lifecycle"),
						},
					},
					"securityContext": {
						SchemaProps: spec.SchemaProps{
							Description: "Security options the pod should run with. More info: https://kubernetes.io/docs/concepts/policy/security-context/ More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/",
							Ref:         ref("k8s.io/api/core/v1.SecurityContext"),
						},
					},
					"nice": {
						SchemaProps: spec.SchemaProps{
							Description: "Settings to configure `nice` to throttle the load on cpu. More info: http://kennystechtalk.blogspot.com/2015/04/throttling-cpu-usage-with-linux-cgroups.html More info: https://oakbytes.wordpress.com/2012/06/06/linux-scheduler-cfs-and-nice/",
							Ref:         ref("kmodules.xyz/offshoot-api/api/v1.NiceSettings"),
						},
					},
					"ionice": {
						SchemaProps: spec.SchemaProps{
							Description: "Settings to configure `ionice` to throttle the load on disk. More info: http://kennystechtalk.blogspot.com/2015/04/throttling-cpu-usage-with-linux-cgroups.html More info: https://oakbytes.wordpress.com/2012/06/06/linux-scheduler-cfs-and-nice/",
							Ref:         ref("kmodules.xyz/offshoot-api/api/v1.IONiceSettings"),
						},
					},
					"envFrom": {
						SchemaProps: spec.SchemaProps{
							Description: "List of sources to populate environment variables in the container. The keys defined within a source must be a C_IDENTIFIER. All invalid keys will be reported as an event when the container is starting. When a key exists in multiple sources, the value associated with the last source will take precedence. Values defined by an Env with a duplicate key will take precedence. Cannot be updated.",
							Type:        []string{"array"},
							Items: &spec.SchemaOrArray{
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: map[string]interface{}{},
										Ref:     ref("k8s.io/api/core/v1.EnvFromSource"),
									},
								},
							},
						},
					},
					"env": {
						VendorExtensible: spec.VendorExtensible{
							Extensions: spec.Extensions{
								"x-kubernetes-patch-merge-key": "name",
								"x-kubernetes-patch-strategy":  "merge",
							},
						},
						SchemaProps: spec.SchemaProps{
							Description: "List of environment variables to set in the container. Cannot be updated.",
							Type:        []string{"array"},
							Items: &spec.SchemaOrArray{
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: map[string]interface{}{},
										Ref:     ref("k8s.io/api/core/v1.EnvVar"),
									},
								},
							},
						},
					},
				},
			},
		},
		Dependencies: []string{
			"k8s.io/api/core/v1.EnvFromSource", "k8s.io/api/core/v1.EnvVar", "k8s.io/api/core/v1.Lifecycle", "k8s.io/api/core/v1.Probe", "k8s.io/api/core/v1.ResourceRequirements", "k8s.io/api/core/v1.SecurityContext", "kmodules.xyz/offshoot-api/api/v1.IONiceSettings", "kmodules.xyz/offshoot-api/api/v1.NiceSettings"},
	}
}

func schema_kmodulesxyz_offshoot_api_api_v1_IONiceSettings(ref common.ReferenceCallback) common.OpenAPIDefinition {
	return common.OpenAPIDefinition{
		Schema: spec.Schema{
			SchemaProps: spec.SchemaProps{
				Description: "https://linux.die.net/man/1/ionice",
				Type:        []string{"object"},
				Properties: map[string]spec.Schema{
					"class": {
						SchemaProps: spec.SchemaProps{
							Type:   []string{"integer"},
							Format: "int32",
						},
					},
					"classData": {
						SchemaProps: spec.SchemaProps{
							Type:   []string{"integer"},
							Format: "int32",
						},
					},
				},
			},
		},
	}
}

func schema_kmodulesxyz_offshoot_api_api_v1_NiceSettings(ref common.ReferenceCallback) common.OpenAPIDefinition {
	return common.OpenAPIDefinition{
		Schema: spec.Schema{
			SchemaProps: spec.SchemaProps{
				Description: "https://linux.die.net/man/1/nice",
				Type:        []string{"object"},
				Properties: map[string]spec.Schema{
					"adjustment": {
						SchemaProps: spec.SchemaProps{
							Type:   []string{"integer"},
							Format: "int32",
						},
					},
				},
			},
		},
	}
}

func schema_kmodulesxyz_offshoot_api_api_v1_ObjectMeta(ref common.ReferenceCallback) common.OpenAPIDefinition {
	return common.OpenAPIDefinition{
		Schema: spec.Schema{
			SchemaProps: spec.SchemaProps{
				Description: "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.",
				Type:        []string{"object"},
				Properties: map[string]spec.Schema{
					"labels": {
						SchemaProps: spec.SchemaProps{
							Description: "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels",
							Type:        []string{"object"},
							AdditionalProperties: &spec.SchemaOrBool{
								Allows: true,
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: "",
										Type:    []string{"string"},
										Format:  "",
									},
								},
							},
						},
					},
					"annotations": {
						SchemaProps: spec.SchemaProps{
							Description: "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations",
							Type:        []string{"object"},
							AdditionalProperties: &spec.SchemaOrBool{
								Allows: true,
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: "",
										Type:    []string{"string"},
										Format:  "",
									},
								},
							},
						},
					},
				},
			},
		},
	}
}

func schema_kmodulesxyz_offshoot_api_api_v1_PartialObjectMeta(ref common.ReferenceCallback) common.OpenAPIDefinition {
	return common.OpenAPIDefinition{
		Schema: spec.Schema{
			SchemaProps: spec.SchemaProps{
				Description: "ObjectMeta is metadata that all persisted resources must have, which includes all objects users must create.",
				Type:        []string{"object"},
				Properties: map[string]spec.Schema{
					"name": {
						SchemaProps: spec.SchemaProps{
							Description: "Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names",
							Type:        []string{"string"},
							Format:      "",
						},
					},
					"generateName": {
						SchemaProps: spec.SchemaProps{
							Description: "GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.\n\nIf this field is specified and the generated name exists, the server will NOT return a 409 - instead, it will either return 201 Created or 500 with Reason ServerTimeout indicating a unique name could not be found in the time allotted, and the client should retry (optionally after the time indicated in the Retry-After header).\n\nApplied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency",
							Type:        []string{"string"},
							Format:      "",
						},
					},
					"namespace": {
						SchemaProps: spec.SchemaProps{
							Description: "Namespace defines the space within each name must be unique. An empty namespace is equivalent to the \"default\" namespace, but \"default\" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.\n\nMust be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces",
							Type:        []string{"string"},
							Format:      "",
						},
					},
					"labels": {
						SchemaProps: spec.SchemaProps{
							Description: "Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels",
							Type:        []string{"object"},
							AdditionalProperties: &spec.SchemaOrBool{
								Allows: true,
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: "",
										Type:    []string{"string"},
										Format:  "",
									},
								},
							},
						},
					},
					"annotations": {
						SchemaProps: spec.SchemaProps{
							Description: "Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations",
							Type:        []string{"object"},
							AdditionalProperties: &spec.SchemaOrBool{
								Allows: true,
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: "",
										Type:    []string{"string"},
										Format:  "",
									},
								},
							},
						},
					},
					"ownerReferences": {
						VendorExtensible: spec.VendorExtensible{
							Extensions: spec.Extensions{
								"x-kubernetes-patch-merge-key": "uid",
								"x-kubernetes-patch-strategy":  "merge",
							},
						},
						SchemaProps: spec.SchemaProps{
							Description: "List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller.",
							Type:        []string{"array"},
							Items: &spec.SchemaOrArray{
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: map[string]interface{}{},
										Ref:     ref("k8s.io/apimachinery/pkg/apis/meta/v1.OwnerReference"),
									},
								},
							},
						},
					},
				},
			},
		},
		Dependencies: []string{
			"k8s.io/apimachinery/pkg/apis/meta/v1.OwnerReference"},
	}
}

func schema_kmodulesxyz_offshoot_api_api_v1_PersistentVolumeClaim(ref common.ReferenceCallback) common.OpenAPIDefinition {
	return common.OpenAPIDefinition{
		Schema: spec.Schema{
			SchemaProps: spec.SchemaProps{
				Description: "PersistentVolumeClaim is a user's request for and claim to a persistent volume",
				Type:        []string{"object"},
				Properties: map[string]spec.Schema{
					"kind": {
						SchemaProps: spec.SchemaProps{
							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{"string"},
							Format:      "",
						},
					},
					"apiVersion": {
						SchemaProps: spec.SchemaProps{
							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{"string"},
							Format:      "",
						},
					},
					"metadata": {
						SchemaProps: spec.SchemaProps{
							Description: "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata",
							Default:     map[string]interface{}{},
							Ref:         ref("kmodules.xyz/offshoot-api/api/v1.PartialObjectMeta"),
						},
					},
					"spec": {
						SchemaProps: spec.SchemaProps{
							Description: "Spec defines the desired characteristics of a volume requested by a pod author. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims",
							Default:     map[string]interface{}{},
							Ref:         ref("k8s.io/api/core/v1.PersistentVolumeClaimSpec"),
						},
					},
					"status": {
						SchemaProps: spec.SchemaProps{
							Description: "Status represents the current information/status of a persistent volume claim. Read-only. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims",
							Default:     map[string]interface{}{},
							Ref:         ref("k8s.io/api/core/v1.PersistentVolumeClaimStatus"),
						},
					},
				},
			},
		},
		Dependencies: []string{
			"k8s.io/api/core/v1.PersistentVolumeClaimSpec", "k8s.io/api/core/v1.PersistentVolumeClaimStatus", "kmodules.xyz/offshoot-api/api/v1.PartialObjectMeta"},
	}
}

func schema_kmodulesxyz_offshoot_api_api_v1_PodRuntimeSettings(ref common.ReferenceCallback) common.OpenAPIDefinition {
	return common.OpenAPIDefinition{
		Schema: spec.Schema{
			SchemaProps: spec.SchemaProps{
				Type: []string{"object"},
				Properties: map[string]spec.Schema{
					"podAnnotations": {
						SchemaProps: spec.SchemaProps{
							Description: "PodAnnotations are the annotations that will be attached with the respective Pod",
							Type:        []string{"object"},
							AdditionalProperties: &spec.SchemaOrBool{
								Allows: true,
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: "",
										Type:    []string{"string"},
										Format:  "",
									},
								},
							},
						},
					},
					"nodeSelector": {
						SchemaProps: spec.SchemaProps{
							Description: "NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node's labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/",
							Type:        []string{"object"},
							AdditionalProperties: &spec.SchemaOrBool{
								Allows: true,
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: "",
										Type:    []string{"string"},
										Format:  "",
									},
								},
							},
						},
					},
					"serviceAccountName": {
						SchemaProps: spec.SchemaProps{
							Description: "ServiceAccountName is the name of the ServiceAccount to use to run this pod. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/",
							Type:        []string{"string"},
							Format:      "",
						},
					},
					"serviceAccountAnnotations": {
						SchemaProps: spec.SchemaProps{
							Description: "ServiceAccountAnnotations are the annotations that will be attached with the respective ServiceAccount",
							Type:        []string{"object"},
							AdditionalProperties: &spec.SchemaOrBool{
								Allows: true,
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: "",
										Type:    []string{"string"},
										Format:  "",
									},
								},
							},
						},
					},
					"automountServiceAccountToken": {
						SchemaProps: spec.SchemaProps{
							Description: "AutomountServiceAccountToken indicates whether a service account token should be automatically mounted.",
							Type:        []string{"boolean"},
							Format:      "",
						},
					},
					"nodeName": {
						SchemaProps: spec.SchemaProps{
							Description: "NodeName is a request to schedule this pod onto a specific node. If it is non-empty, the scheduler simply schedules this pod onto that node, assuming that it fits resource requirements.",
							Type:        []string{"string"},
							Format:      "",
						},
					},
					"securityContext": {
						SchemaProps: spec.SchemaProps{
							Description: "Security options the pod should run with. More info: https://kubernetes.io/docs/concepts/policy/security-context/ More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/",
							Ref:         ref("k8s.io/api/core/v1.PodSecurityContext"),
						},
					},
					"imagePullSecrets": {
						SchemaProps: spec.SchemaProps{
							Description: "ImagePullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images used by this PodRuntimeSettings. If specified, these secrets will be passed to individual puller implementations for them to use. For example, in the case of docker, only DockerConfig type secrets are honored. More info: https://kubernetes.io/docs/concepts/containers/images#specifying-imagepullsecrets-on-a-pod",
							Type:        []string{"array"},
							Items: &spec.SchemaOrArray{
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: map[string]interface{}{},
										Ref:     ref("k8s.io/api/core/v1.LocalObjectReference"),
									},
								},
							},
						},
					},
					"affinity": {
						SchemaProps: spec.SchemaProps{
							Description: "If specified, the pod's scheduling constraints",
							Ref:         ref("k8s.io/api/core/v1.Affinity"),
						},
					},
					"schedulerName": {
						SchemaProps: spec.SchemaProps{
							Description: "If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler.",
							Type:        []string{"string"},
							Format:      "",
						},
					},
					"tolerations": {
						SchemaProps: spec.SchemaProps{
							Description: "If specified, the pod's tolerations.",
							Type:        []string{"array"},
							Items: &spec.SchemaOrArray{
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: map[string]interface{}{},
										Ref:     ref("k8s.io/api/core/v1.Toleration"),
									},
								},
							},
						},
					},
					"priorityClassName": {
						SchemaProps: spec.SchemaProps{
							Description: "If specified, indicates the pod's priority. \"system-node-critical\" and \"system-cluster-critical\" are two special keywords which indicate the highest priorities with the former being the highest priority. Any other name must be defined by creating a PriorityClass object with that name. If not specified, the pod priority will be default or zero if there is no default.",
							Type:        []string{"string"},
							Format:      "",
						},
					},
					"priority": {
						SchemaProps: spec.SchemaProps{
							Description: "The priority value. Various system components use this field to find the priority of the pod. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority.",
							Type:        []string{"integer"},
							Format:      "int32",
						},
					},
					"readinessGates": {
						SchemaProps: spec.SchemaProps{
							Description: "If specified, all readiness gates will be evaluated for pod readiness. A pod is ready when all its containers are ready AND all conditions specified in the readiness gates have status equal to \"True\" More info: https://git.k8s.io/enhancements/keps/sig-network/0007-pod-ready%2B%2B.md",
							Type:        []string{"array"},
							Items: &spec.SchemaOrArray{
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: map[string]interface{}{},
										Ref:     ref("k8s.io/api/core/v1.PodReadinessGate"),
									},
								},
							},
						},
					},
					"runtimeClassName": {
						SchemaProps: spec.SchemaProps{
							Description: "RuntimeClassName refers to a RuntimeClass object in the node.k8s.io group, which should be used to run this pod.  If no RuntimeClass resource matches the named class, the pod will not be run. If unset or empty, the \"legacy\" RuntimeClass will be used, which is an implicit class with an empty definition that uses the default runtime handler. More info: https://git.k8s.io/enhancements/keps/sig-node/runtime-class.md This is an alpha feature and may change in the future.",
							Type:        []string{"string"},
							Format:      "",
						},
					},
					"enableServiceLinks": {
						SchemaProps: spec.SchemaProps{
							Description: "EnableServiceLinks indicates whether information about services should be injected into pod's environment variables, matching the syntax of Docker links. Optional: Defaults to true.",
							Type:        []string{"boolean"},
							Format:      "",
						},
					},
					"topologySpreadConstraints": {
						VendorExtensible: spec.VendorExtensible{
							Extensions: spec.Extensions{
								"x-kubernetes-list-map-keys": []interface{}{
									"topologyKey",
									"whenUnsatisfiable",
								},
								"x-kubernetes-list-type":       "map",
								"x-kubernetes-patch-merge-key": "topologyKey",
								"x-kubernetes-patch-strategy":  "merge",
							},
						},
						SchemaProps: spec.SchemaProps{
							Description: "TopologySpreadConstraints describes how a group of pods ought to spread across topology domains. Scheduler will schedule pods in a way which abides by the constraints. All topologySpreadConstraints are ANDed.",
							Type:        []string{"array"},
							Items: &spec.SchemaOrArray{
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: map[string]interface{}{},
										Ref:     ref("k8s.io/api/core/v1.TopologySpreadConstraint"),
									},
								},
							},
						},
					},
				},
			},
		},
		Dependencies: []string{
			"k8s.io/api/core/v1.Affinity", "k8s.io/api/core/v1.LocalObjectReference", "k8s.io/api/core/v1.PodReadinessGate", "k8s.io/api/core/v1.PodSecurityContext", "k8s.io/api/core/v1.Toleration", "k8s.io/api/core/v1.TopologySpreadConstraint"},
	}
}

func schema_kmodulesxyz_offshoot_api_api_v1_PodSpec(ref common.ReferenceCallback) common.OpenAPIDefinition {
	return common.OpenAPIDefinition{
		Schema: spec.Schema{
			SchemaProps: spec.SchemaProps{
				Type: []string{"object"},
				Properties: map[string]spec.Schema{
					"serviceAccountName": {
						SchemaProps: spec.SchemaProps{
							Description: "ServiceAccountName is the name of the ServiceAccount to use to run this pod. More info: https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/",
							Type:        []string{"string"},
							Format:      "",
						},
					},
					"nodeSelector": {
						SchemaProps: spec.SchemaProps{
							Description: "NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node's labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/",
							Type:        []string{"object"},
							AdditionalProperties: &spec.SchemaOrBool{
								Allows: true,
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: "",
										Type:    []string{"string"},
										Format:  "",
									},
								},
							},
						},
					},
					"affinity": {
						SchemaProps: spec.SchemaProps{
							Description: "If specified, the pod's scheduling constraints",
							Ref:         ref("k8s.io/api/core/v1.Affinity"),
						},
					},
					"schedulerName": {
						SchemaProps: spec.SchemaProps{
							Description: "If specified, the pod will be dispatched by specified scheduler. If not specified, the pod will be dispatched by default scheduler.",
							Type:        []string{"string"},
							Format:      "",
						},
					},
					"tolerations": {
						SchemaProps: spec.SchemaProps{
							Description: "If specified, the pod's tolerations.",
							Type:        []string{"array"},
							Items: &spec.SchemaOrArray{
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: map[string]interface{}{},
										Ref:     ref("k8s.io/api/core/v1.Toleration"),
									},
								},
							},
						},
					},
					"imagePullSecrets": {
						SchemaProps: spec.SchemaProps{
							Description: "ImagePullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images used by this PodSpec. If specified, these secrets will be passed to individual puller implementations for them to use.",
							Type:        []string{"array"},
							Items: &spec.SchemaOrArray{
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: map[string]interface{}{},
										Ref:     ref("k8s.io/api/core/v1.LocalObjectReference"),
									},
								},
							},
						},
					},
					"priorityClassName": {
						SchemaProps: spec.SchemaProps{
							Description: "If specified, indicates the pod's priority. \"system-node-critical\" and \"system-cluster-critical\" are two special keywords which indicate the highest priorities with the former being the highest priority. Any other name must be defined by creating a PriorityClass object with that name. If not specified, the pod priority will be default or zero if there is no default.",
							Type:        []string{"string"},
							Format:      "",
						},
					},
					"priority": {
						SchemaProps: spec.SchemaProps{
							Description: "The priority value. Various system components use this field to find the priority of the pod. When Priority Admission Controller is enabled, it prevents users from setting this field. The admission controller populates this field from PriorityClassName. The higher the value, the higher the priority.",
							Type:        []string{"integer"},
							Format:      "int32",
						},
					},
					"hostNetwork": {
						SchemaProps: spec.SchemaProps{
							Description: "Host networking requested for this pod. Use the host's network namespace. If this option is set, the ports that will be used must be specified. Default to false.",
							Type:        []string{"boolean"},
							Format:      "",
						},
					},
					"hostPID": {
						SchemaProps: spec.SchemaProps{
							Description: "Use the host's pid namespace. Optional: Default to false.",
							Type:        []string{"boolean"},
							Format:      "",
						},
					},
					"hostIPC": {
						SchemaProps: spec.SchemaProps{
							Description: "Use the host's ipc namespace. Optional: Default to false.",
							Type:        []string{"boolean"},
							Format:      "",
						},
					},
					"shareProcessNamespace": {
						SchemaProps: spec.SchemaProps{
							Description: "Share a single process namespace between all of the containers in a pod. When this is set containers will be able to view and signal processes from other containers in the same pod, and the first process in each container will not be assigned PID 1. HostPID and ShareProcessNamespace cannot both be set. Optional: Default to false.",
							Type:        []string{"boolean"},
							Format:      "",
						},
					},
					"securityContext": {
						SchemaProps: spec.SchemaProps{
							Description: "SecurityContext holds pod-level security attributes and common container settings. Optional: Defaults to empty.  See type description for default values of each field.",
							Ref:         ref("k8s.io/api/core/v1.PodSecurityContext"),
						},
					},
					"terminationGracePeriodSeconds": {
						SchemaProps: spec.SchemaProps{
							Description: "Optional duration in seconds the pod needs to terminate gracefully. May be decreased in delete request. Value must be non-negative integer. The value zero indicates stop immediately via the kill signal (no opportunity to shut down). If this value is nil, the default grace period will be used instead. The grace period is the duration in seconds after the processes running in the pod are sent a termination signal and the time when the processes are forcibly halted with a kill signal. Set this value longer than the expected cleanup time for your process. Defaults to 30 seconds.",
							Type:        []string{"integer"},
							Format:      "int64",
						},
					},
					"dnsPolicy": {
						SchemaProps: spec.SchemaProps{
							Description: "Set DNS policy for the pod. Defaults to \"ClusterFirst\". Valid values are 'ClusterFirstWithHostNet', 'ClusterFirst', 'Default' or 'None'. DNS parameters given in DNSConfig will be merged with the policy selected with DNSPolicy. To have DNS options set along with hostNetwork, you have to specify DNS policy explicitly to 'ClusterFirstWithHostNet'.",
							Type:        []string{"string"},
							Format:      "",
						},
					},
					"dnsConfig": {
						SchemaProps: spec.SchemaProps{
							Description: "Specifies the DNS parameters of a pod. Parameters specified here will be merged to the generated DNS configuration based on DNSPolicy.",
							Ref:         ref("k8s.io/api/core/v1.PodDNSConfig"),
						},
					},
					"topologySpreadConstraints": {
						VendorExtensible: spec.VendorExtensible{
							Extensions: spec.Extensions{
								"x-kubernetes-list-map-keys": []interface{}{
									"topologyKey",
									"whenUnsatisfiable",
								},
								"x-kubernetes-list-type":       "map",
								"x-kubernetes-patch-merge-key": "topologyKey",
								"x-kubernetes-patch-strategy":  "merge",
							},
						},
						SchemaProps: spec.SchemaProps{
							Description: "TopologySpreadConstraints describes how a group of pods ought to spread across topology domains. Scheduler will schedule pods in a way which abides by the constraints. All topologySpreadConstraints are ANDed.",
							Type:        []string{"array"},
							Items: &spec.SchemaOrArray{
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: map[string]interface{}{},
										Ref:     ref("k8s.io/api/core/v1.TopologySpreadConstraint"),
									},
								},
							},
						},
					},
					"volumes": {
						VendorExtensible: spec.VendorExtensible{
							Extensions: spec.Extensions{
								"x-kubernetes-patch-merge-key": "name",
								"x-kubernetes-patch-strategy":  "merge,retainKeys",
							},
						},
						SchemaProps: spec.SchemaProps{
							Description: "List of volumes that can be mounted by containers belonging to the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes",
							Type:        []string{"array"},
							Items: &spec.SchemaOrArray{
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: map[string]interface{}{},
										Ref:     ref("k8s.io/api/core/v1.Volume"),
									},
								},
							},
						},
					},
					"initContainers": {
						VendorExtensible: spec.VendorExtensible{
							Extensions: spec.Extensions{
								"x-kubernetes-patch-merge-key": "name",
								"x-kubernetes-patch-strategy":  "merge",
							},
						},
						SchemaProps: spec.SchemaProps{
							Description: "List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, or Liveness probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/",
							Type:        []string{"array"},
							Items: &spec.SchemaOrArray{
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: map[string]interface{}{},
										Ref:     ref("k8s.io/api/core/v1.Container"),
									},
								},
							},
						},
					},
					"args": {
						SchemaProps: spec.SchemaProps{
							Description: "Arguments to the entrypoint. The docker image's CMD is used if this is not provided. Variable references $(VAR_NAME) are expanded using the container's environment. If a variable cannot be resolved, the reference in the input string will be unchanged. The $(VAR_NAME) syntax can be escaped with a double $$, ie: $$(VAR_NAME). Escaped references will never be expanded, regardless of whether the variable exists or not. Cannot be updated. More info: https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell",
							Type:        []string{"array"},
							Items: &spec.SchemaOrArray{
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: "",
										Type:    []string{"string"},
										Format:  "",
									},
								},
							},
						},
					},
					"env": {
						SchemaProps: spec.SchemaProps{
							Description: "List of environment variables to set in the container. Cannot be updated.",
							Type:        []string{"array"},
							Items: &spec.SchemaOrArray{
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: map[string]interface{}{},
										Ref:     ref("k8s.io/api/core/v1.EnvVar"),
									},
								},
							},
						},
					},
					"resources": {
						SchemaProps: spec.SchemaProps{
							Description: "Compute Resources required by the sidecar container.",
							Default:     map[string]interface{}{},
							Ref:         ref("k8s.io/api/core/v1.ResourceRequirements"),
						},
					},
					"livenessProbe": {
						SchemaProps: spec.SchemaProps{
							Description: "Periodic probe of container liveness. Container will be restarted if the probe fails. Controllers may set default LivenessProbe if no liveness probe is provided. To ignore defaulting, set the value to empty LivenessProbe \"{}\". Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes",
							Ref:         ref("k8s.io/api/core/v1.Probe"),
						},
					},
					"readinessProbe": {
						SchemaProps: spec.SchemaProps{
							Description: "Periodic probe of container service readiness. Container will be removed from service endpoints if the probe fails. Cannot be updated. Controllers may set default ReadinessProbe if no readyness probe is provided. To ignore defaulting, set the value to empty ReadynessProbe \"{}\". More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes",
							Ref:         ref("k8s.io/api/core/v1.Probe"),
						},
					},
					"lifecycle": {
						SchemaProps: spec.SchemaProps{
							Description: "Actions that the management system should take in response to container lifecycle events. Cannot be updated.",
							Ref:         ref("k8s.io/api/core/v1.Lifecycle"),
						},
					},
					"containerSecurityContext": {
						SchemaProps: spec.SchemaProps{
							Description: "Security options the pod should run with. More info: https://kubernetes.io/docs/concepts/policy/security-context/ More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/",
							Ref:         ref("k8s.io/api/core/v1.SecurityContext"),
						},
					},
					"volumeMounts": {
						VendorExtensible: spec.VendorExtensible{
							Extensions: spec.Extensions{
								"x-kubernetes-patch-merge-key": "mountPath",
								"x-kubernetes-patch-strategy":  "merge",
							},
						},
						SchemaProps: spec.SchemaProps{
							Description: "Pod volumes to mount into the container's filesystem. Cannot be updated.",
							Type:        []string{"array"},
							Items: &spec.SchemaOrArray{
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: map[string]interface{}{},
										Ref:     ref("k8s.io/api/core/v1.VolumeMount"),
									},
								},
							},
						},
					},
				},
			},
		},
		Dependencies: []string{
			"k8s.io/api/core/v1.Affinity", "k8s.io/api/core/v1.Container", "k8s.io/api/core/v1.EnvVar", "k8s.io/api/core/v1.Lifecycle", "k8s.io/api/core/v1.LocalObjectReference", "k8s.io/api/core/v1.PodDNSConfig", "k8s.io/api/core/v1.PodSecurityContext", "k8s.io/api/core/v1.Probe", "k8s.io/api/core/v1.ResourceRequirements", "k8s.io/api/core/v1.SecurityContext", "k8s.io/api/core/v1.Toleration", "k8s.io/api/core/v1.TopologySpreadConstraint", "k8s.io/api/core/v1.Volume", "k8s.io/api/core/v1.VolumeMount"},
	}
}

func schema_kmodulesxyz_offshoot_api_api_v1_PodTemplateSpec(ref common.ReferenceCallback) common.OpenAPIDefinition {
	return common.OpenAPIDefinition{
		Schema: spec.Schema{
			SchemaProps: spec.SchemaProps{
				Description: "PodTemplateSpec describes the data a pod should have when created from a template",
				Type:        []string{"object"},
				Properties: map[string]spec.Schema{
					"metadata": {
						SchemaProps: spec.SchemaProps{
							Description: "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata",
							Default:     map[string]interface{}{},
							Ref:         ref("kmodules.xyz/offshoot-api/api/v1.ObjectMeta"),
						},
					},
					"controller": {
						SchemaProps: spec.SchemaProps{
							Description: "Workload controller's metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata",
							Default:     map[string]interface{}{},
							Ref:         ref("kmodules.xyz/offshoot-api/api/v1.ObjectMeta"),
						},
					},
					"spec": {
						SchemaProps: spec.SchemaProps{
							Description: "Specification of the desired behavior of the pod. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#spec-and-status",
							Default:     map[string]interface{}{},
							Ref:         ref("kmodules.xyz/offshoot-api/api/v1.PodSpec"),
						},
					},
				},
			},
		},
		Dependencies: []string{
			"kmodules.xyz/offshoot-api/api/v1.ObjectMeta", "kmodules.xyz/offshoot-api/api/v1.PodSpec"},
	}
}

func schema_kmodulesxyz_offshoot_api_api_v1_RuntimeSettings(ref common.ReferenceCallback) common.OpenAPIDefinition {
	return common.OpenAPIDefinition{
		Schema: spec.Schema{
			SchemaProps: spec.SchemaProps{
				Type: []string{"object"},
				Properties: map[string]spec.Schema{
					"pod": {
						SchemaProps: spec.SchemaProps{
							Ref: ref("kmodules.xyz/offshoot-api/api/v1.PodRuntimeSettings"),
						},
					},
					"container": {
						SchemaProps: spec.SchemaProps{
							Ref: ref("kmodules.xyz/offshoot-api/api/v1.ContainerRuntimeSettings"),
						},
					},
				},
			},
		},
		Dependencies: []string{
			"kmodules.xyz/offshoot-api/api/v1.ContainerRuntimeSettings", "kmodules.xyz/offshoot-api/api/v1.PodRuntimeSettings"},
	}
}

func schema_kmodulesxyz_offshoot_api_api_v1_ServicePort(ref common.ReferenceCallback) common.OpenAPIDefinition {
	return common.OpenAPIDefinition{
		Schema: spec.Schema{
			SchemaProps: spec.SchemaProps{
				Description: "ServicePort contains information on service's port.",
				Type:        []string{"object"},
				Properties: map[string]spec.Schema{
					"name": {
						SchemaProps: spec.SchemaProps{
							Description: "The name of this port within the service. This must be a DNS_LABEL. All ports within a ServiceSpec must have unique names. This maps to the 'Name' field in EndpointPort objects. Optional if only one ServicePort is defined on this service.",
							Type:        []string{"string"},
							Format:      "",
						},
					},
					"port": {
						SchemaProps: spec.SchemaProps{
							Description: "The port that will be exposed by this service.",
							Default:     0,
							Type:        []string{"integer"},
							Format:      "int32",
						},
					},
					"nodePort": {
						SchemaProps: spec.SchemaProps{
							Description: "The port on each node on which this service is exposed when type=NodePort or LoadBalancer. Usually assigned by the system. If specified, it will be allocated to the service if unused or else creation of the service will fail. Default is to auto-allocate a port if the ServiceType of this Service requires one. More info: https://kubernetes.io/docs/concepts/services-networking/service/#type-nodeport",
							Type:        []string{"integer"},
							Format:      "int32",
						},
					},
				},
				Required: []string{"port"},
			},
		},
	}
}

func schema_kmodulesxyz_offshoot_api_api_v1_ServiceSpec(ref common.ReferenceCallback) common.OpenAPIDefinition {
	return common.OpenAPIDefinition{
		Schema: spec.Schema{
			SchemaProps: spec.SchemaProps{
				Description: "ServiceSpec describes the attributes that a user creates on a service.",
				Type:        []string{"object"},
				Properties: map[string]spec.Schema{
					"ports": {
						VendorExtensible: spec.VendorExtensible{
							Extensions: spec.Extensions{
								"x-kubernetes-patch-merge-key": "port",
								"x-kubernetes-patch-strategy":  "merge",
							},
						},
						SchemaProps: spec.SchemaProps{
							Description: "The list of ports that are exposed by this service. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies",
							Type:        []string{"array"},
							Items: &spec.SchemaOrArray{
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: map[string]interface{}{},
										Ref:     ref("kmodules.xyz/offshoot-api/api/v1.ServicePort"),
									},
								},
							},
						},
					},
					"clusterIP": {
						SchemaProps: spec.SchemaProps{
							Description: "clusterIP is the IP address of the service and is usually assigned randomly by the master. If an address is specified manually and is not in use by others, it will be allocated to the service; otherwise, creation of the service will fail. This field can not be changed through updates. Valid values are \"None\", empty string (\"\"), or a valid IP address. \"None\" can be specified for headless services when proxying is not required. Only applies to types ClusterIP, NodePort, and LoadBalancer. Ignored if type is ExternalName. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies",
							Type:        []string{"string"},
							Format:      "",
						},
					},
					"type": {
						SchemaProps: spec.SchemaProps{
							Description: "type determines how the Service is exposed. Defaults to ClusterIP. Valid options are ExternalName, ClusterIP, NodePort, and LoadBalancer. \"ExternalName\" maps to the specified externalName. \"ClusterIP\" allocates a cluster-internal IP address for load-balancing to endpoints. Endpoints are determined by the selector or if that is not specified, by manual construction of an Endpoints object. If clusterIP is \"None\", no virtual IP is allocated and the endpoints are published as a set of endpoints rather than a stable IP. \"NodePort\" builds on ClusterIP and allocates a port on every node which routes to the clusterIP. \"LoadBalancer\" builds on NodePort and creates an external load-balancer (if supported in the current cloud) which routes to the clusterIP. More info: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services---service-types",
							Type:        []string{"string"},
							Format:      "",
						},
					},
					"externalIPs": {
						SchemaProps: spec.SchemaProps{
							Description: "externalIPs is a list of IP addresses for which nodes in the cluster will also accept traffic for this service.  These IPs are not managed by Kubernetes.  The user is responsible for ensuring that traffic arrives at a node with this IP.  A common example is external load-balancers that are not part of the Kubernetes system.",
							Type:        []string{"array"},
							Items: &spec.SchemaOrArray{
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: "",
										Type:    []string{"string"},
										Format:  "",
									},
								},
							},
						},
					},
					"loadBalancerIP": {
						SchemaProps: spec.SchemaProps{
							Description: "Only applies to Service Type: LoadBalancer LoadBalancer will get created with the IP specified in this field. This feature depends on whether the underlying cloud-provider supports specifying the loadBalancerIP when a load balancer is created. This field will be ignored if the cloud-provider does not support the feature.",
							Type:        []string{"string"},
							Format:      "",
						},
					},
					"loadBalancerSourceRanges": {
						SchemaProps: spec.SchemaProps{
							Description: "If specified and supported by the platform, this will restrict traffic through the cloud-provider load-balancer will be restricted to the specified client IPs. This field will be ignored if the cloud-provider does not support the feature.\" More info: https://kubernetes.io/docs/tasks/access-application-cluster/configure-cloud-provider-firewall/",
							Type:        []string{"array"},
							Items: &spec.SchemaOrArray{
								Schema: &spec.Schema{
									SchemaProps: spec.SchemaProps{
										Default: "",
										Type:    []string{"string"},
										Format:  "",
									},
								},
							},
						},
					},
					"externalTrafficPolicy": {
						SchemaProps: spec.SchemaProps{
							Description: "externalTrafficPolicy denotes if this Service desires to route external traffic to node-local or cluster-wide endpoints. \"Local\" preserves the client source IP and avoids a second hop for LoadBalancer and Nodeport type services, but risks potentially imbalanced traffic spreading. \"Cluster\" obscures the client source IP and may cause a second hop to another node, but should have good overall load-spreading.",
							Type:        []string{"string"},
							Format:      "",
						},
					},
					"healthCheckNodePort": {
						SchemaProps: spec.SchemaProps{
							Description: "healthCheckNodePort specifies the healthcheck nodePort for the service. If not specified, HealthCheckNodePort is created by the service api backend with the allocated nodePort. Will use user-specified nodePort value if specified by the client. Only effects when Type is set to LoadBalancer and ExternalTrafficPolicy is set to Local.",
							Type:        []string{"integer"},
							Format:      "int32",
						},
					},
					"sessionAffinityConfig": {
						SchemaProps: spec.SchemaProps{
							Description: "sessionAffinityConfig contains the configurations of session affinity.",
							Ref:         ref("k8s.io/api/core/v1.SessionAffinityConfig"),
						},
					},
				},
			},
		},
		Dependencies: []string{
			"k8s.io/api/core/v1.SessionAffinityConfig", "kmodules.xyz/offshoot-api/api/v1.ServicePort"},
	}
}

func schema_kmodulesxyz_offshoot_api_api_v1_ServiceTemplateSpec(ref common.ReferenceCallback) common.OpenAPIDefinition {
	return common.OpenAPIDefinition{
		Schema: spec.Schema{
			SchemaProps: spec.SchemaProps{
				Description: "ServiceTemplateSpec describes the data a service should have when created from a template",
				Type:        []string{"object"},
				Properties: map[string]spec.Schema{
					"metadata": {
						SchemaProps: spec.SchemaProps{
							Description: "Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata",
							Default:     map[string]interface{}{},
							Ref:         ref("kmodules.xyz/offshoot-api/api/v1.ObjectMeta"),
						},
					},
					"spec": {
						SchemaProps: spec.SchemaProps{
							Description: "Specification of the desired behavior of the service. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#spec-and-status",
							Default:     map[string]interface{}{},
							Ref:         ref("kmodules.xyz/offshoot-api/api/v1.ServiceSpec"),
						},
					},
				},
			},
		},
		Dependencies: []string{
			"kmodules.xyz/offshoot-api/api/v1.ObjectMeta", "kmodules.xyz/offshoot-api/api/v1.ServiceSpec"},
	}
}


text:
package org.mitre.mat.core;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.StringReader;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.codehaus.jackson.JsonFactory;
import org.codehaus.jackson.JsonParser;
import org.codehaus.jackson.JsonNode;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.node.ArrayNode;

/**
 * The object which handles the JSON serialization and deserialization
 * of MAT-compliant documents.
 *
 * @author sam
 * @author robyn
 */
public class MATJSONEncoding implements MATDocumentEncoding {

    /*
     * READING
     */
    public void fromFile(MATDocumentInterface doc, String fileName)
            throws MATDocumentException {
        try {
            StringBuffer buf = null;

            BufferedReader b = null;
            b = new BufferedReader(
                    new InputStreamReader(new FileInputStream(fileName),
                    "UTF-8"));

            // Read the contents of the file.
            buf = new StringBuffer();
            int READ_LEN = 2048;

            char[] cbuf = new char[READ_LEN];

            while (true) {
                int chars = b.read(cbuf, 0, READ_LEN);
                if (chars < 0) {
                    break;
                }
                buf.append(cbuf, 0, chars);
                if (chars < READ_LEN) {
                    break;
                }
            }
            b.close();
            this.fromEncodedString(doc, new String(buf));
        } catch (IOException ex) {
            throw new MATDocumentException(ex.toString());
        }

    }

    public void fromEncodedString(MATDocumentInterface doc, String jsonData)
            throws MATDocumentException {
        JsonFactory jsonFact = new JsonFactory();
        try {
            JsonParser parser = jsonFact.createJsonParser(new StringReader(jsonData));
            JsonNode jsonValues = new ObjectMapper().readTree(parser);
            this.fromJsonNode(doc, jsonValues);
        } catch (MATDocumentException ex) {
            throw ex;
        } catch (IOException ex) {
            throw new MATDocumentException(ex.toString());
        } catch (AnnotationException ex) {
            ex.printStackTrace();
            throw new MATDocumentException(ex.toString());
        }
    }

    // Additional method to manage decoding from the JSON-RPC protocol
    // and other JSON structures.
    public void fromJsonNode(MATDocumentInterface doc, JsonNode jsonValues)
            throws MATDocumentException, AnnotationException {
        // Right now, we're just going to check the decoding.
        JsonNode verNode = jsonValues.path("version");
        //  The default version is 1, if no version is specified.
        int version = 1;
        if (verNode != null) {
            version = verNode.getIntValue();
        }
        if (version > 2) {
            // I should be throwing something, I know.
            throw new MATDocumentException("MAT JSON version is later than 2");
        }
        doc.setSignal(jsonValues.path("signal").getTextValue());
        JsonNode atypeValues = jsonValues.path("asets");
        // Bookkeeping for the annotation-valued attributes.
        // I need to keep track of a mapping from IDs to annotations,
        // from atypes to their attrIndices and attrTypes, and
        // from annotations to their attribute iterators.
        HashMap<String, AnnotationCore> annotMap = new HashMap<String, AnnotationCore>();
        HashMap<Atype, List<AttributeType>> attrTypeHash = new HashMap<Atype, List<AttributeType>>();
        HashMap<Atype, List<Integer>> attrIndexHash = new HashMap<Atype, List<Integer>>();
        HashMap<AnnotationCore, List<JsonNode>> annotAttrHash = new HashMap<AnnotationCore, List<JsonNode>>();
        if (!atypeValues.isMissingNode()) {
            Iterator<JsonNode> atypeIterator = atypeValues.getElements();
            while (atypeIterator.hasNext()) {
                JsonNode thisAtype = atypeIterator.next();
                String newType = thisAtype.path("type").getTextValue();
                // Try to find out whether it's got an ID or a span.
                boolean hasSpan = true;
                boolean hasID = false;
                JsonNode hasSpanNode = thisAtype.path("hasSpan");
                if (!hasSpanNode.isMissingNode()) {
                    hasSpan = hasSpanNode.getBooleanValue();
                }
                JsonNode hasIDNode = thisAtype.path("hasID");
                if (!hasIDNode.isMissingNode()) {
                    hasID = hasIDNode.getBooleanValue();
                }
                Atype newAtype = doc.findOrAddAtype(newType, hasSpan);
                Iterator<JsonNode> attrListIterator = thisAtype.path("attrs").getElements();
                //List<AttributeType> attrTypes = null;
                List<AttributeType> annotAttrTypes = null;
                List<Integer> attrIndices = null;
                List<Integer> annotAttrIndices = null;
                // Collect the types and the indices, so we can use them
                // to create the annotation later. We have to postpone
                // adding the annotation attributes, because some of theam
                // may be annotations.
                if (attrListIterator.hasNext()) {
                    //attrTypes = new ArrayList<AttributeType>();
                    annotAttrTypes = new ArrayList<AttributeType>();
                    attrIndices = new ArrayList<Integer>();
                    annotAttrIndices = new ArrayList<Integer>();
                }
                while (attrListIterator.hasNext()) {
                    JsonNode elt = attrListIterator.next();
                    int i;
                    if (elt.isTextual()) {
                        i = newAtype.findOrAddAttribute(elt.getTextValue());
                    } else {
                        // It's a hash. The type is string, by default.
                        JsonNode tElt = elt.path("type");
                        String aType = Atype.STRING_ATTR_TYPE;
                        if (!tElt.isMissingNode()) {
                            aType = tElt.getTextValue();
                        }
                        // aggregation is NONE by default
                        int aggregation = AttributeType.NONE_AGGREGATION;
                        JsonNode aElt = elt.path("aggregation");
                        if (!aElt.isMissingNode() && !aElt.isNull()) {
                            aggregation = AttributeType.getAggregationFromString(aElt.getTextValue());
                        }
                        i = newAtype.findOrAddAttribute(elt.path("name").getTextValue(), aType, aggregation);
                    }
                    attrIndices.add(i);
                    AttributeType attrType = newAtype.getAttributeType(i);
                    //attrTypes.add(attrType);
                    if (attrType instanceof AnnotationAttributeType) {
                        annotAttrIndices.add(i);
                        annotAttrTypes.add(attrType);
                    }
                }
                boolean hasAnnotVals = (annotAttrTypes != null) && !annotAttrTypes.isEmpty();
                // Postpone adding the attributes, just in case there
                // are annotation-valued attributes.
                // Now, postpone ONLY the annotation-valued attributes. 7/5/13
                if (hasAnnotVals) {
                    attrTypeHash.put(newAtype, annotAttrTypes);
                    attrIndexHash.put(newAtype, annotAttrIndices);
                }

                Iterator<JsonNode> annotIterator = thisAtype.path("annots").getElements();

                while (annotIterator.hasNext()) {
                    JsonNode annot = annotIterator.next();
                    ArrayList<String> attrVals = new ArrayList<String>();
                    ArrayList<String> annotVals = null;
                    if (hasAnnotVals) {
                        annotVals = new ArrayList<String>();
                    }
                    Iterator<JsonNode> annotValIterator = annot.getElements();  // items in annotations' list
                    AnnotationCore ac;
                    if (hasSpan) {
                        // If there's a span, pick off the first two indices.
                        int startIndex = annotValIterator.next().getIntValue();
                        int endIndex = annotValIterator.next().getIntValue();
                        ac = doc.createAnnotation(newAtype, startIndex, endIndex);
                    } else {
                        ac = doc.createSpanlessAnnotation(newAtype);
                    }
                    if (hasID) {
                        JsonNode idNode = annotValIterator.next();
                        if (!idNode.isNull()) {
                            String id = idNode.getTextValue();
                            ac.setID(id);
                            annotMap.put(id, ac);
                        }
                    }
                    if (attrIndices != null) {
                        Iterator<Integer> it = attrIndices.iterator();
                        List<JsonNode> annotValues = new ArrayList<JsonNode>();
                        while (annotValIterator.hasNext()) {
                            JsonNode valNode = annotValIterator.next();
                            Integer i = it.next();
                            if (annotAttrIndices.contains(i)) {
                                // save it
                                annotValues.add(valNode);
                            } else {
                                setAttributeValueFromNode(valNode, i, ac, annotMap);
                            }
                        }
                        if (!annotValues.isEmpty()) {
                            annotAttrHash.put(ac, annotValues);
                        }
                    }
                }
            }
        } else {
            throw new MATDocumentException("Missing atypeValues");
        }
        // Now that we've created all the annotations, let's add the
        // postponed attributes.
        Iterator<Entry<AnnotationCore, List<JsonNode>>> it = annotAttrHash.entrySet().iterator();
        while (it.hasNext()) {
            Entry<AnnotationCore, List<JsonNode>> e = it.next();
            AnnotationCore ac = e.getKey();
            Iterator<JsonNode> attrIt = e.getValue().iterator();
            // Iterator<AttributeType> attrTypes = attrTypeHash.get(ac.parentAtype).iterator();
            Iterator<Integer> attrIndices = attrIndexHash.get(ac.parentAtype).iterator();
            while (attrIt.hasNext()) {
                JsonNode o = attrIt.next();
                int i = attrIndices.next();
                setAttributeValueFromNode(o, i, ac, annotMap);
            }

        }
        JsonNode newMetaData = jsonValues.path("metadata");
        doc.setMetaData(this.jsonNodeToHashMap(newMetaData));
    }

    private void setAttributeValueFromNode(JsonNode valNode, int i, AnnotationCore ac,
            HashMap<String, AnnotationCore> annotMap) throws AnnotationException, MATDocumentException {
        // if it's an array node, we have a collection
        AttributeType attribType = ac.getParentAtype().getAttributeType(i);
        if (valNode instanceof ArrayNode) {
            // convert the node to an ArrayList, mapping IDs to Annots if needed
            ArrayList valList;
            if (Atype.ANNOTATION_ATTR_TYPE.equals(attribType.getType())) {
                valList = mapAnnots((ArrayList) convertJsonNode(valNode), annotMap);
            } else if (Atype.BOOLEAN_ATTR_TYPE.equals(attribType.getType())) {
                valList = digestValues(attribType, (ArrayList) convertJsonNode(valNode));
            } else {
                valList = (ArrayList) convertJsonNode(valNode);
            }

            // create the correct type of collection for the aggregation type
            AttributeValueCollection coll = null;
            int aggregation = attribType.getAggregationType();
            if (aggregation == AttributeType.LIST_AGGREGATION) {
                coll = new AttributeValueList(valList);
            } else if (aggregation == AttributeType.SET_AGGREGATION) {
                coll = new AttributeValueSet(new HashSet(valList));
            } else {
                throw new AnnotationException("invalid aggregation type for ArrayNode");
            }
            // System.out.println("try to set attribute value type: " + attribType.getType()
            //        + " aggregation: " + aggregation);
            ac.setAttributeValue(i, coll);
            // System.out.println("\t...success");
        } else {
            // for a single value, we always want to pass in a String
            // which setAttributeValue will convert to the required type
            // using the AttributeType's digestFromString method
            String val = null;
            try {
                val = this.convertJsonNode(valNode).toString();
            } catch (NullPointerException x) {
                // leave val = null;
            }
            //System.out.println("try to set attribute value " + attribType.getName()
            //        + " type: " + attribType.getType() + " val " + val);
            if (Atype.ANNOTATION_ATTR_TYPE.equals(attribType.getType())) {
                ac.setAttributeValue(i, annotMap.get(val));
            } else {
                ac.setAttributeValue(i, val);
            }
            //System.out.println("\t...success");
        }
    }

    private ArrayList mapAnnots(ArrayList idList, HashMap<String, AnnotationCore> annotMap) {
        ArrayList annotList = new ArrayList(idList.size());
        for (Iterator i = idList.iterator(); i.hasNext();) {
            annotList.add(annotMap.get((String) i.next()));
        }
        return annotList;
    }

    private ArrayList digestValues(AttributeType attrType, ArrayList stringVals) throws AnnotationException {
        ArrayList valsList = new ArrayList(stringVals.size());
        for (Iterator i = stringVals.iterator(); i.hasNext();) {
            valsList.add(attrType.digestSingleValueFromString((String) i.next()));
        }
        return valsList;
    }

    // Ick.
    private HashMap<String, Object> jsonNodeToHashMap(JsonNode node) {
        HashMap<String, Object> hash = new HashMap<String, Object>();

        if (!node.isMissingNode()) {
            Iterator<String> fieldIterator = node.getFieldNames();
            while (fieldIterator.hasNext()) {
                String field = fieldIterator.next();
                JsonNode subNode = node.get(field);
                hash.put(field, this.convertJsonNode(subNode));
            }
        }
        return hash;
    }

    private Object convertJsonNode(JsonNode subNode) {
        if (subNode.isMissingNode()) {
            return null;
        } else if (subNode.isObject()) {
            return this.jsonNodeToHashMap(subNode);
        } else if (subNode.isArray()) {
            return this.jsonNodeToArrayList(subNode);
        } else if (subNode.isTextual()) {
            return subNode.getTextValue();
        } else if (subNode.isInt()) {
            return subNode.getIntValue();
        } else if (subNode.isDouble()) {
            return subNode.getDoubleValue();
        } else if (subNode.isNumber()) {
            return subNode.getNumberValue();
        } else if (subNode.isNull()) {
            return null;
        } else {
            return subNode.getValueAsText();
        }
    }

    private ArrayList<Object> jsonNodeToArrayList(JsonNode subNode) {
        ArrayList<Object> list = new ArrayList<Object>();
        Iterator<JsonNode> nodeIterator = subNode.getElements();
        while (nodeIterator.hasNext()) {
            list.add(this.convertJsonNode(nodeIterator.next()));
        }
        return list;
    }

    /*
     * WRITING
     */
    public String toEncodedString(MATDocumentInterface doc) {
        // guts moved into method below
        return this.toEncodedString(this.toJsonNode(doc));

    }

    // this is used directly by the unit test, but usually the above method
    // is the one that will be called
    // Map must be of the format returned by toJsonNode
    /**
     * A version of toEncodedString that directly takes a JSON Node.
     * Generally you should use the version that takes a MATDocument instead.
     * @param node a JSON Node describing the document
     * @return
     * @see #toEncodedString(org.mitre.mat.core.MATDocumentInterface)
     */
    protected String toEncodedString(Map node) {
        try {
            Writer exportWriter = null;

            ObjectMapper mapper = new ObjectMapper();
            ByteArrayOutputStream b = new ByteArrayOutputStream();
            exportWriter = new OutputStreamWriter(b, "UTF-8");

            exportWriter = new BufferedWriter(exportWriter);

            mapper.writeValue(exportWriter, node);

            exportWriter.close();
            return b.toString("UTF-8");
        } catch (IOException ex) {
            Logger.getLogger(MATJSONEncoding.class.getName()).log(Level.SEVERE, null, ex);
            return null;
        }
    }

    public void toFile(MATDocumentInterface doc, String fileName) {

        Writer exportWriter = null;
        try {
            ObjectMapper mapper = new ObjectMapper();
            exportWriter = new OutputStreamWriter(
                    new FileOutputStream(new File(fileName)),
                    "UTF-8");
            exportWriter = new BufferedWriter(exportWriter);

            mapper.writeValue(exportWriter, this.toJsonNode(doc));

            exportWriter.close();
        } catch (UnsupportedEncodingException ex) {
            Logger.getLogger(MATJSONEncoding.class.getName()).log(Level.SEVERE, null, ex);
        } catch (java.io.IOException ex) {
            Logger.getLogger(MATJSONEncoding.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            try {
                exportWriter.close();
            } catch (IOException ex) {
                Logger.getLogger(MATJSONEncoding.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
    // Not actually to a JSON node, but to a value that can
    // be mapped. Perhaps fix this later, when I talk to Ben.

    /**
     * Converts a MAT Document into a JSON-node-like value that can be mapped.
     * @param doc
     * @return
     */
    public Map toJsonNode(MATDocumentInterface doc) {
        Map jsonData = new LinkedHashMap();
        jsonData.put("signal", doc.getSignal());
        HashMap<String, Object> mdata = doc.getMetaData();
        if (mdata == null) {
            mdata = new HashMap<String, Object>();
        }
        jsonData.put("metadata", mdata);
        jsonData.put("asets", this.getAtypesAsMaps(doc));
        jsonData.put("version", 2);
        return jsonData;
    }

    // returns a List of the atypes in this AnnotationManager, as Maps
    private List getAtypesAsMaps(MATDocumentInterface doc) {
        HashMap<String, Atype> docAtypes = doc.getDocRepository();
        //System.err.println("AnnotMgr.getAtypesAsMaps: docAtypes=" +
        //        (docAtypes == null ? "null" : docAtypes.toString()));
        if (docAtypes == null) {
            return new ArrayList();
        } else {
            List atypes = new ArrayList();
            for (Iterator i = docAtypes.values().iterator(); i.hasNext();) {
                Atype atype = (Atype) i.next();
                Map mapForm = new LinkedHashMap();
                List<AnnotationCore> annotObjects = doc.getAnnotationsOfType(atype);
                // See if any of the annotations have IDs.
                boolean hasID = false;
                for (Iterator<AnnotationCore> ai = annotObjects.iterator(); ai.hasNext();) {
                    if (ai.next().getID(false) != null) {
                        hasID = true;
                        break;
                    }
                }
                mapForm.put("type", atype.getAtypeType());
                mapForm.put("hasSpan", atype.getHasSpan());
                mapForm.put("hasID", hasID);
                ArrayList attrListForm = new ArrayList();
                List<String> attrs = atype.getAttributeNames();
                for (int j = 0; j < attrs.size(); j++) {
                    String attrtype = atype.getAttributeTypeType(j);
                    AttributeType t = atype.getAttributeType(j);
                    Map attrForm = new LinkedHashMap();
                    attrForm.put("name", attrs.get(j));
                    attrForm.put("type", attrtype);
                    int aggregation = t.getAggregationType();
                    if (aggregation != AttributeType.NONE_AGGREGATION) {
                        attrForm.put("aggregation", AttributeType.aggregationString[aggregation]);
                    }
                    /*** I don't think I really need this -- only the python needs this to write out the task definitions
                    if (t.hasDefault()) {
                    if (t.defaultIsTextSpan) {
                    attrForm.put("default", t.getDefaultValue());
                    } else {
                    attrForm.put("default_is_text_span", true);
                    }
                    }
                     * ***/
                    attrListForm.add(attrForm);
                }
                mapForm.put("attrs", attrListForm);
                mapForm.put("annots", this.getAnnotationsAsArrays(annotObjects, atype.getHasSpan(), hasID));
                atypes.add(mapForm);
            }
            return atypes;
        }
    }

    /* actually returns them as an ArrayList of ArrayLists */
    private List getAnnotationsAsArrays(List<AnnotationCore> annotObjects, boolean hasSpan, boolean hasID) {
        List annotArrays = new ArrayList(annotObjects.size());
        for (Iterator<AnnotationCore> i = annotObjects.iterator(); i.hasNext();) {
            ArrayList listForm = new ArrayList();
            AnnotationCore ac;
            if (hasSpan) {
                Annotation annot = (Annotation) i.next();
                listForm.add(annot.getStartIndex());
                listForm.add(annot.getEndIndex());
                ac = annot;
            } else {
                ac = i.next();
            }
            if (hasID) {
                listForm.add(ac.getID(false));
            }
            Iterator it = ac.getAttributeValues().iterator();
            while (it.hasNext()) {
                Object o = it.next();
                if (o instanceof AnnotationCore) {
                    listForm.add(((AnnotationCore) o).getID(false));
                } else if (o instanceof AttributeValueCollection) {
                    AttributeValueCollection c = (AttributeValueCollection) o;
                    if (c.getType().equals(Atype.ANNOTATION_ATTR_TYPE)) {
                        listForm.add(annotsToIds(c.getCollection()));
                    } else {
                        listForm.add(((AttributeValueCollection) o).getCollection());
                    }
                } else {
                    listForm.add(o);
                }
            }
            annotArrays.add(listForm);
        }
        return annotArrays;
    }

    // takes a collection of annotations and returns a list of the ID of the annotations in the collection
    private List annotsToIds(Collection annotCollection) {
        List idList = new ArrayList(annotCollection.size());
        for (Iterator i = annotCollection.iterator(); i.hasNext();) {
            idList.add(((AnnotationCore) i.next()).getID(false));
        }
        return idList;
    }
}

redpajama_set_name: RedPajamaGithub


text:
FROM ehazlett/logstash

EXPOSE 5000
ENTRYPOINT ["/opt/logstash/bin/logstash", "-f", "/etc/logstash.conf.sample"]
ADD logstash.conf.sample /etc/logstash.conf.sample


text:
@interface ServerDetailsTableViewController : UITableViewController
@property (strong, nonatomic) IBOutlet UITableViewCell *ipTableViewCell;
@property (strong, nonatomic) IBOutlet UITableViewCell *statusTableViewCell;
@property (strong, nonatomic) IBOutlet UITableViewCell *locationTableViewCell;
@property (strong, nonatomic) Server* server;
@property (strong, nonatomic) IBOutlet UITableViewCell *osTableViewCell;
@property (strong, nonatomic) IBOutlet UITableViewCell *powerStatusTableViewCell;
@property (strong, nonatomic) IBOutlet UITableViewCell *labelTableViewCell;
@property (strong, nonatomic) IBOutlet UITableViewCell *ramTableViewCell;
@property (strong, nonatomic) IBOutlet UITableViewCell *diskTableViewCell;
@property (strong, nonatomic) IBOutlet UITableViewCell *createdDateTableViewCell;
@property (strong, nonatomic) IBOutlet UITableViewCell *bandWidthTableViewCell;
@property (strong, nonatomic) IBOutlet UITableViewCell *vcpuCountTableViewCell;

@end


text:
// Copyright 2009 the Sputnik authors.  All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.

/**
  * @name: S11.8.4_A3.1_T1.3;
  * @section: 11.8.4;
  * @assertion: If Type(Primitive(x)) is not String or Type(Primitive(y)) is not String, then operator x >= y returns ToNumber(x) >= ToNumber(y);
  * @description: Type(Primitive(x)) and Type(Primitive(y)) vary between Null and Undefined;
 */

//CHECK#1
if (null >= undefined !== false) {
  $ERROR('#1: null >= undefined === false');
}

//CHECK#2
if (undefined >= null !== false) {
  $ERROR('#2: undefined >= null === false');
}

//CHECK#3
if (undefined >= undefined !== false) {
  $ERROR('#3: undefined >= undefined === false');
}

//CHECK#4
if (null >= null !== true) {
  $ERROR('#4: null >= null === true');
}


text:
<?php

/* ProyectoPrincipalBundle:Users:acceso.html.twig */
class __TwigTemplate_11592569f3829f7e1debd677e387629c extends Twig_Template
{
    public function __construct(Twig_Environment $env)
    {
        parent::__construct($env);

        $this->parent = $this->env->loadTemplate("ProyectoPrincipalBundle:Helpers:base.html.twig");

        $this->blocks = array(
            'info' => array($this, 'block_info'),
            'error' => array($this, 'block_error'),
            'contenido' => array($this, 'block_contenido'),
        );
    }

    protected function doGetParent(array $context)
    {
        return "ProyectoPrincipalBundle:Helpers:base.html.twig";
    }

    protected function doDisplay(array $context, array $blocks = array())
    {
        $this->parent->display($context, array_merge($this->blocks, $blocks));
    }

    // line 2
    public function block_info($context, array $blocks = array())
    {
        // line 3
        echo "

\t
env, $this->env->getExtension('assets')->getAssetUrl("images/incrustacion.jpg"), "html", null, true);
        echo "\" width=\"300\"/>

";
        // line 6
        $this->env->loadTemplate("ProyectoPrincipalBundle:Helpers:info.html.twig")->display(array_merge($context, array("info" => $this->getContext($context, "info"))));
    }

    // line 8
    public function block_error($context, array $blocks = array())
    {
        // line 9
        if ($this->getContext($context, "error")) {
            // line 10
            echo "

\t<button type=\"button\" class=\"close\" data-dismiss=\"alert\">
\t\t
\t</button>
\t  Error
\tNo puede acceder al sistema, intente más tarde, o comuníquese con el administrador del sistema.
\t

";
        }
    }

    // line 21
    public function block_contenido($context, array $blocks = array())
    {
        // line 22
        echo "

\t

\t\t

\t\t\t
Formulario de acceso

\t\t

\t\t

\t\t\t
\t\t\t

\t\t\t\t<form class=\"form-inline\" action=\"";
        // line 31
        echo twig_escape_filter($this->env, $this->env->getExtension('routing')->getPath("login_check"), "html", null, true);
        echo "\" method=\"post\">
\t\t\t\t\t<input type=\"text\" class=\"span4\" placeholder=\"Usuario\" name=\"_username\"  value=\"";
        // line 32
        echo twig_escape_filter($this->env, $this->getContext($context, "ultimo_nombreusuario"), "html", null, true);
        echo "\">
\t\t\t\t\t<input type=\"password\" class=\"span4\" placeholder=\"Password\" name=\"_password\"  >
\t\t\t\t\t
\t\t\t\t\t\t<input type=\"checkbox\">
\t\t\t\t\t\t Recordar mis datos
\t\t\t\t\t<button onclick=\"\" class=\"btn btn-info btn-small\" type=\"submit\">
\t\t\t\t\t\t
\t\t\t\t\t\tIniciar sesión
\t\t\t\t\t</button>
\t\t\t\t\t
\t\t\t\t</form>
\t\t\t

\t\t

\t

";
    }

    public function getTemplateName()
    {
        return "ProyectoPrincipalBundle:Users:acceso.html.twig";
    }

    public function isTraitable()
    {
        return false;
    }

    public function getDebugInfo()
    {
        return array (  81 => 32,  77 => 31,  66 => 22,  63 => 21,  50 => 10,  48 => 9,  45 => 8,  41 => 6,  36 => 4,  33 => 3,  30 => 2,);
    }
}


text:
Running locally:

- Export the needed variables:
  ```
  export AWS_ACCESS_KEY_ID=<your aws access key id>
  export AWS_SECRET_ACCESS_KEY=<your aws secret access key>
  ```
  - Alternatively, add these to a file (say ~/keynote-demo-env-vars) and
    source it when needed.

- Create a private variables file (say ~/keynote-demo-private-vars.yml) with
  the following contents:
  ```
---
demo_route_53_zone: <my route53 delegated zone>

demo_additional_ssh_keys:
- <ssh pub key 1>
- <ssh pub key 2>

demo_github_clientid: <github client id>
demo_github_clientsecret: <github client secret>
demo_github_organizations:
- <github organization>

openshift_master_htpasswd_users:
  demo: <pre-hashed password>

demo_registry_s3_accesskey: <s3 access key for registry>
demo_registry_s3_secretkey: <s3 secret key for registry>
demo_registry_s3_bucket_prefix: <prefix to use for s3 bucket>
demo_registry_s3_bucket: <s3 bucket name>

openshift_additional_repos:
- id: ops_mirror
  name: Ops Mirror
  baseurl: <url to private mirror>
  enabled: 1
  gpgcheck: 0
  sslclientcert: /var/lib/yum/client-cert.pem
  sslclientkey: /var/lib/yum/client-key.pem
demo_repo_cert_contents: <contents of the client cert for above repo>
demo_repo_key_contents: <contents of the client key for above repo>
   ```

- Create the hosts:
```
ansible-playbook -i inventory/aws/ec2.py -e "@vars.common.yml" -e "@vars.demo.prod.yml" -e"@~/keynote-demo-private-vars.yml" provision.yml
```

- Configure the hosts:
```
ansible-playbook -i inventory/aws/ec2.py -e "@vars.common.yml" -e "@vars.demo.prod.yml" -e "@~/keynote-demo-private-vars.yml" configure.yml
```

- Teardown the environment:
```
ansible-playbook -i inventory/aws/ec2.py -e "@vars.common.yml" -e "@vars.demo.prod.yml" -e "@~/keynote-demo-private-vars.yml" teardown.yml
```


text: @pushd %userprofile%\dropbox


text:
/*
 * Do not modify this file. This file is generated from the storagegateway-2013-06-30.normal.json service model.
 */
using System;
using System.Collections.Generic;
using System.Xml.Serialization;
using System.Text;
using System.IO;

using Amazon.Runtime;
using Amazon.Runtime.Internal;

namespace Amazon.StorageGateway.Model
{
    /// <summary>
    /// ListVolumeInitiatorsOutput
    /// </summary>
    public partial class ListVolumeInitiatorsResponse : AmazonWebServiceResponse
    {
        private List<string> _initiators = new List<string>();

        /// <summary>
        /// Gets and sets the property Initiators.
        /// <para>
        /// The host names and port numbers of all iSCSI initiators that are connected to the
        /// gateway.
        /// </para>
        /// </summary>
        public List<string> Initiators
        {
            get { return this._initiators; }
            set { this._initiators = value; }
        }

        // Check to see if Initiators property is set
        internal bool IsSetInitiators()
        {
            return this._initiators != null && this._initiators.Count > 0;
        }

    }
}


text:
import os
from commands import getstatusoutput
from django import template
from django.conf import settings
from django.utils._os import safe_join

register = template.Library()

@register.simple_tag
def scss(file_path):
    """
    Convert an scss file into css and returns the output.
    """
    input_path = safe_join(settings.SMATIC_SCSS_PATH, file_path)
    if not os.path.exists(input_path):
        raise Exception('File does not exist: %s\n' % input_path)

    cmd = "%(bin)s --scss -t %(sass_style)s -C %(input)s" % {
        'bin': getattr(settings, 'SASS_BIN', 'sass'),
        'sass_style': 'compact',
        'input': input_path,
    }
    (status, output) = getstatusoutput(cmd)
    if not status == 0:
        raise Exception(output)

    return output

@register.simple_tag
def js(file_path):
    input_path = safe_join(settings.SMATIC_JS_PATH, file_path)
    if not os.path.exists(input_path):
        # TODO: check if enabled on
        raise Exception('File does not exist: %s\n' % input_path)

    return '<script type="text/javascript" src="%sjs/%s"></script>' % (
        settings.STATIC_URL, file_path
    )


text:
<?php
include __DIR__ . DIRECTORY_SEPARATOR . 'core.php';
include __DIR__ . DIRECTORY_SEPARATOR . 'io.php';
include __DIR__ . DIRECTORY_SEPARATOR . 'installer.php';


text:
namespace Zu.ChromeDevTools.Network
{
    using Newtonsoft.Json;

    /// <summary>
    /// Sets the requests to intercept that match the provided patterns and optionally resource types.
    /// Deprecated, please use Fetch.enable instead.
    /// </summary>
    public sealed class SetRequestInterceptionCommand : ICommand
    {
        private const string ChromeRemoteInterface_CommandName = "Network.setRequestInterception";

        [JsonIgnore]
        public string CommandName
        {
            get { return ChromeRemoteInterface_CommandName; }
        }

        /// <summary>
        /// Requests matching any of these patterns will be forwarded and wait for the corresponding
        /// continueInterceptedRequest call.
        /// </summary>
        [JsonProperty("patterns")]
        public RequestPattern[] Patterns
        {
            get;
            set;
        }
    }

    public sealed class SetRequestInterceptionCommandResponse : ICommandResponse<SetRequestInterceptionCommand>
    {
    }
}


text:
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Threading.Tasks;
using Azure.Core.TestFramework;
using FluentAssertions;
using NUnit.Framework;

namespace Azure.DigitalTwins.Core.Tests
{
    /// <summary>
    /// Tests for DigitalTwinServiceClient methods dealing with Digital Twin operations.
    /// </summary>
    public class ModelsTests : E2eTestBase
    {
        public ModelsTests(bool isAsync)
            : base(isAsync)
        {
        }

        [Test]
        public async Task Models_Lifecycle()
        {
            DigitalTwinsClient client = GetClient();

            string buildingModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.BuildingModelId).ConfigureAwait(false);
            string floorModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.FloorModelId).ConfigureAwait(false);
            string hvacModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.HvacModelId).ConfigureAwait(false);
            string wardModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.WardModelId).ConfigureAwait(false);

            try
            {
                string modelBuilding = TestAssetsHelper.GetBuildingModelPayload(buildingModelId, hvacModelId, floorModelId);
                string modelHvac = TestAssetsHelper.GetHvacModelPayload(hvacModelId, floorModelId);
                string modelWard = TestAssetsHelper.GetWardModelPayload(wardModelId);

                // CREATE models
                var modelsList = new List<string> { modelBuilding, modelHvac, modelWard };
                await client.CreateModelsAsync(modelsList).ConfigureAwait(false);

                // GET one created model
                Response<ModelData> buildingModel = await client.GetModelAsync(buildingModelId).ConfigureAwait(false);
                Console.WriteLine($"Got {buildingModelId} as {buildingModel.Value.Model}");

                // LIST all models
                AsyncPageable<ModelData> models = client.GetModelsAsync();
                await foreach (ModelData model in models)
                {
                    Console.WriteLine($"{model.Id}");
                }

                // DECOMMISSION a model
                await client.DecommissionModelAsync(buildingModelId).ConfigureAwait(false);
            }
            finally
            {
                // Test DELETE all models.
                try
                {
                    await client.DeleteModelAsync(buildingModelId).ConfigureAwait(false);
                    await client.DeleteModelAsync(hvacModelId).ConfigureAwait(false);
                    await client.DeleteModelAsync(wardModelId).ConfigureAwait(false);
                }
                catch (Exception ex)
                {
                    Assert.Fail($"Test clean up failed: {ex.Message}");
                }
            }
        }

        /// <summary>
        /// Swagger defines ModelData as an object, but expected to be "a language map that contains the localized" values.
        /// A model definition may specify a single string value, and the service will turn that into a dictionary.
        /// This test validates that potentially non-conforming data format (string) properly gets translated into a map
        /// on the service, and can be properly deserialized into a ModelData instance in the SDK.
        /// </summary>
        [Test]
        public async Task ModelData_DisplayNameAndDescription_Deserializes()
        {
            // arrange

            DigitalTwinsClient client = GetClient();

            string wardModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.WardModelId).ConfigureAwait(false);

            // add a model with a single value for displayName and for description, neither of which were defined as a map
            string modelWard = TestAssetsHelper.GetWardModelPayload(wardModelId);

            await client.CreateModelsAsync(new[] { modelWard }).ConfigureAwait(false);

            // act
            // should not throw on deserialization
            Response<ModelData> wardModel = await client.GetModelAsync(wardModelId).ConfigureAwait(false);

            // assert

            wardModel.Value.DisplayName.Count.Should().Be(1, "Should have 1 entry for display name");
            wardModel.Value.DisplayName.Keys.First().Should().Be("en");
        }

        [Test]
        public void Models_ModelNotExists_ThrowsNotFoundException()
        {
            // arrange
            DigitalTwinsClient client = GetClient();

            // act
            Func<Task> act = async () => await client.GetModelAsync("urn:doesnotexist:fakemodel:1000").ConfigureAwait(false);

            // assert
            act.Should().Throw<RequestFailedException>()
                .And.Status.Should().Be((int)HttpStatusCode.NotFound);
        }

        [Test]
        public void Models_MalformedModelId_ThrowsBadRequestException()
        {
            // arrange
            DigitalTwinsClient client = GetClient();

            // act
            Func<Task> act = async () => await client.GetModelAsync("thisIsNotAValidModelId").ConfigureAwait(false);

            // assert
            act.Should().Throw<RequestFailedException>()
                .And.Status.Should().Be((int)HttpStatusCode.BadRequest);
        }

        [Test]
        public async Task Models_ModelAlreadyExists_ThrowsConflictException()
        {
            // arrange

            DigitalTwinsClient client = GetClient();

            string wardModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.WardModelId).ConfigureAwait(false);

            string modelWard = TestAssetsHelper.GetWardModelPayload(wardModelId);

            var modelsList = new List<string> { modelWard };

            // Create model once
            await client.CreateModelsAsync(modelsList).ConfigureAwait(false);

            // act
            Func<Task> act = async () => await client.CreateModelsAsync(modelsList).ConfigureAwait(false);

            // assert
            act.Should().Throw<RequestFailedException>()
                .And.Status.Should().Be((int)HttpStatusCode.Conflict);
        }
    }
}


text:
function V = inverseFPCA(X, dampen)

% Inverse Fourier PCA algorithm where we compute two second derivative
% matrices and then invert one of them. This is a necessary intermediate
% step because I'm not sure of the conditioning of the matrices.

% This function carries inside it a Bernoulli generative model for the
% data. For release, should strip it out and make it general.

% This only works for n source variables and n signal variables.

% A: Original mixing matrix we're generating samples from (we're just
%       pretending we know it
% n: dimensionsality of the signal.
% m: number of samples

[m, n] = size(X);

% Hessian 1
u =  randn( [n,1]);
u = dampen * u / norm(u);

weights = exp( 1i * X * u);
reweighted = bsxfun(@times, X, weights);

zeroth = sum( weights )/m; % zeroth order
first = sum( reweighted ).'/m;
second = reweighted.' * X/m;

psi = second * zeroth - first * first.';

% Hessian 2
v =  randn( [n,1]);
v = dampen * v / norm(v);

weights = exp( 1i * X * v);
reweighted = bsxfun(@times, X, weights);

zeroth = sum( weights )/m; % zeroth order
first = sum( reweighted ).'/m;
second = reweighted.' * X/m;

phi = second * zeroth - first * first.';

M = psi / phi;

[V, ~] = eig(M);
end


text:
import { Component } from '@angular/core';
import { TestBed, async, ComponentFixture } from '@angular/core/testing';
import { By } from '@angular/platform-browser';
import { Ng42TestComponentModule } from './index';

describe('Ng42TestComponent', () => {

	let fixture: ComponentFixture<TestApp>;
	let testComponent: TestApp;
	let ng42TestComponentElement: HTMLElement;

	beforeEach(async(() => {
		TestBed.configureTestingModule({
			imports: [Ng42TestComponentModule],
			declarations: [TestApp],
		});

		TestBed.compileComponents();
	}));

	beforeEach(() => {
		fixture = TestBed.createComponent(TestApp);
		testComponent = fixture.debugElement.componentInstance;
		ng42TestComponentElement = fixture.debugElement.query(
			By.css('ng42-test-component')
		).nativeElement;
	});

	it('should set the test-component role on the host', () => {
		expect(ng42TestComponentElement.getAttribute('role')).toBe('test');
	});

});

@Component({ template: `<ng42-test-component>Test Component</ng42-test-component>` })
class TestApp { }


text:
#import "APCDataMonitor+Bridge.h"
#import "APCAppCore.h"

NSString *const kFirstTimeRefreshToday = @"FirstTimeRefreshToday";

@implementation APCDataMonitor (Bridge)

- (void) refreshFromBridgeOnCompletion: (APCDataMonitorResponseHandler) completionBlock
{
    if (self.dataSubstrate.currentUser.serverConsented)
    {
        __weak typeof(self) weakSelf = self;

        [[APCScheduler defaultScheduler] fetchTasksAndSchedulesFromServerAndThenUseThisQueue: [NSOperationQueue mainQueue]
                                                                            toDoThisWhenDone: ^(NSError *errorFromServerFetch)
         {
             if (errorFromServerFetch)
             {
                 [weakSelf finishRefreshCommandPassingError: errorFromServerFetch
                                          toCompletionBlock: completionBlock];
             }
             else
             {
                 [APCTask refreshSurveysOnCompletion: ^(NSError *errorFromRefreshingSurveys) {

                     [weakSelf finishRefreshCommandPassingError: errorFromRefreshingSurveys
                                              toCompletionBlock: completionBlock];

                 }];
             }
         }];
    }
}

- (void) finishRefreshCommandPassingError: (NSError *) error
                        toCompletionBlock: (APCDataMonitorResponseHandler) completionBlock
{
    [[NSOperationQueue mainQueue] addOperationWithBlock:^{

        if (completionBlock)
        {
            completionBlock (error);
        }

        [[NSNotificationCenter defaultCenter] postNotificationName: APCUpdateActivityNotification
                                                            object: self
                                                          userInfo: nil];
    }];
}

- (void) batchUploadDataToBridgeOnCompletion: (void (^)(NSError * error)) completionBlock
{
    if (self.dataSubstrate.currentUser.serverConsented && !self.batchUploadingInProgress) {
        self.batchUploadingInProgress = YES;
        NSManagedObjectContext * context = self.dataSubstrate.persistentContext;
        [context performBlock:^{
            NSFetchRequest * request = [APCResult request];
            request.predicate = [NSPredicate predicateWithFormat:@"uploaded == nil || uploaded == %@", @(NO)];
            NSError * error;
            NSArray * unUploadedResults = [context executeFetchRequest:request error:&error];
            for (APCResult * result in unUploadedResults) {
                [result uploadToBridgeOnCompletion:^(NSError *error) {
                    APCLogError2 (error);
                }];
            }
            dispatch_async(dispatch_get_main_queue(), ^{
                self.batchUploadingInProgress = NO;
                if (completionBlock) {
                    completionBlock(error);
                }
            });
        }];
    }
}

- (void) uploadZipFile:(NSString*) path onCompletion: (void (^)(NSError * error)) completionBlock
{
    NSParameterAssert(path);

    APCLogFilenameBeingUploaded (path);

    [SBBComponent(SBBUploadManager) uploadFileToBridge:[NSURL fileURLWithPath:path] contentType:@"application/zip" completion:^(NSError *error) {
        if (!error) {
            APCLogEventWithData(kNetworkEvent, (@{@"event_detail":[NSString stringWithFormat:@"Uploaded Passive Collector File: %@", path.lastPathComponent]}));
        }
        if (completionBlock) {
            completionBlock(error);
        }
    }];

}

@end


text:
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration debug="true" xmlns:log4j="http://jakarta.apache.org/log4j/">

  <appender name="PRIMARY" class="org.apache.log4j.FileAppender">
    <errorHandler class="org.apache.log4j.varia.FallbackErrorHandler">
      <root-ref/>
      <appender-ref ref="FALLBACK" />
    </errorHandler>

    <param name="File" value="/xyz/x.log" />
    <param name="Append" value="false" />

    <layout class="org.apache.log4j.PatternLayout">
      <param name="ConversionPattern" value="%-5p %c{2} - %m%n"/>
    </layout>
  </appender>

  <appender name="FALLBACK" class="org.apache.log4j.FileAppender">
    <param name="File" value="output/temp" />
    <param name="Append" value="false" />
    <layout class="org.apache.log4j.PatternLayout">
      <param name="ConversionPattern" value="FALLBACK - %c - %m%n"/>
    </layout>
  </appender>

  <root>
    <priority value ="debug" />
    <appender-ref ref="PRIMARY" />
  </root>

</log4j:configuration>