
// This file was autogenerated by go-to-protobuf. Do not edit it manually!

syntax = "proto2";

package github.com.openshift.api.image.v1;

import "k8s.io/api/core/v1/generated.proto";
import "k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto";
import "k8s.io/apimachinery/pkg/runtime/generated.proto";
import "k8s.io/apimachinery/pkg/runtime/schema/generated.proto";

// Package-wide variables from generator "generated".
option go_package = "github.com/openshift/api/image/v1";

// DockerImageReference points to a container image.
message DockerImageReference {
  // Registry is the registry that contains the container image
  optional string registry = 1;

  // Namespace is the namespace that contains the container image
  optional string namespace = 2;

  // Name is the name of the container image
  optional string name = 3;

  // Tag is which tag of the container image is being referenced
  optional string tag = 4;

  // ID is the identifier for the container image
  optional string iD = 5;
}

// Image is an immutable representation of a container image and metadata at a point in time.
// Images are named by taking a hash of their contents (metadata and content) and any change
// in format, content, or metadata results in a new name. The images resource is primarily
// for use by cluster administrators and integrations like the cluster image registry - end
// users instead access images via the imagestreamtags or imagestreamimages resources. While
// image metadata is stored in the API, any integration that implements the container image
// registry API must provide its own storage for the raw manifest data, image config, and
// layer contents.
//
// Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).
// +openshift:compatibility-gen:level=1
message Image {
  optional k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1;

  // DockerImageReference is the string that can be used to pull this image.
  optional string dockerImageReference = 2;

  // DockerImageMetadata contains metadata about this image
  // +patchStrategy=replace
  // +kubebuilder:pruning:PreserveUnknownFields
  optional k8s.io.apimachinery.pkg.runtime.RawExtension dockerImageMetadata = 3;

  // DockerImageMetadataVersion conveys the version of the object, which if empty defaults to "1.0"
  optional string dockerImageMetadataVersion = 4;

  // DockerImageManifest is the raw JSON of the manifest
  optional string dockerImageManifest = 5;

  // DockerImageLayers represents the layers in the image. May not be set if the image does not define that data.
  repeated ImageLayer dockerImageLayers = 6;

  // Signatures holds all signatures of the image.
  // +patchMergeKey=name
  // +patchStrategy=merge
  repeated ImageSignature signatures = 7;

  // DockerImageSignatures provides the signatures as opaque blobs. This is a part of manifest schema v1.
  repeated bytes dockerImageSignatures = 8;

  // DockerImageManifestMediaType specifies the mediaType of manifest. This is a part of manifest schema v2.
  optional string dockerImageManifestMediaType = 9;

  // DockerImageConfig is a JSON blob that the runtime uses to set up the container. This is a part of manifest schema v2.
  optional string dockerImageConfig = 10;
}

// ImageBlobReferences describes the blob references within an image.
message ImageBlobReferences {
  // imageMissing is true if the image is referenced by the image stream but the image
  // object has been deleted from the API by an administrator. When this field is set,
  // layers and config fields may be empty and callers that depend on the image metadata
  // should consider the image to be unavailable for download or viewing.
  // +optional
  optional bool imageMissing = 3;

  // layers is the list of blobs that compose this image, from base layer to top layer.
  // All layers referenced by this array will be defined in the blobs map. Some images
  // may have zero layers.
  // +optional
  repeated string layers = 1;

  // config, if set, is the blob that contains the image config. Some images do
  // not have separate config blobs and this field will be set to nil if so.
  // +optional
  optional string config = 2;
}

// ImageImportSpec describes a request to import a specific image.
message ImageImportSpec {
  // From is the source of an image to import; only kind DockerImage is allowed
  optional k8s.io.api.core.v1.ObjectReference from = 1;

  // To is a tag in the current image stream to assign the imported image to, if name is not specified the default tag from from.name will be used
  optional k8s.io.api.core.v1.LocalObjectReference to = 2;

  // ImportPolicy is the policy controlling how the image is imported
  optional TagImportPolicy importPolicy = 3;

  // ReferencePolicy defines how other components should consume the image
  optional TagReferencePolicy referencePolicy = 5;

  // IncludeManifest determines if the manifest for each image is returned in the response
  optional bool includeManifest = 4;
}

// ImageImportStatus describes the result of an image import.
message ImageImportStatus {
  // Status is the status of the image import, including errors encountered while retrieving the image
  optional k8s.io.apimachinery.pkg.apis.meta.v1.Status status = 1;

  // Image is the metadata of that image, if the image was located
  optional Image image = 2;

  // Tag is the tag this image was located under, if any
  optional string tag = 3;
}

// ImageLayer represents a single layer of the image. Some images may have multiple layers. Some may have none.
message ImageLayer {
  // Name of the layer as defined by the underlying store.
  optional string name = 1;

  // Size of the layer in bytes as defined by the underlying store.
  optional int64 size = 2;

  // MediaType of the referenced object.
  optional string mediaType = 3;
}

// ImageLayerData contains metadata about an image layer.
message ImageLayerData {
  // Size of the layer in bytes as defined by the underlying store. This field is
  // optional if the necessary information about size is not available.
  optional int64 size = 1;

  // MediaType of the referenced object.
  optional string mediaType = 2;
}

// ImageList is a list of Image objects.
//
// Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).
// +openshift:compatibility-gen:level=1
message ImageList {
  optional k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1;

  // Items is a list of images
  repeated Image items = 2;
}

// ImageLookupPolicy describes how an image stream can be used to override the image references
// used by pods, builds, and other resources in a namespace.
message ImageLookupPolicy {
  // local will change the docker short image references (like "mysql" or
  // "php:latest") on objects in this namespace to the image ID whenever they match
  // this image stream, instead of reaching out to a remote registry. The name will
  // be fully qualified to an image ID if found. The tag's referencePolicy is taken
  // into account on the replaced value. Only works within the current namespace.
  optional bool local = 3;
}

// ImageSignature holds a signature of an image. It allows to verify image identity and possibly other claims
// as long as the signature is trusted. Based on this information it is possible to restrict runnable images
// to those matching cluster-wide policy.
// Mandatory fields should be parsed by clients doing image verification. The others are parsed from
// signature's content by the server. They serve just an informative purpose.
//
// Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).
// +openshift:compatibility-gen:level=1
message ImageSignature {
  optional k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1;

  // Required: Describes a type of stored blob.
  optional string type = 2;

  // Required: An opaque binary string which is an image's signature.
  optional bytes content = 3;

  // Conditions represent the latest available observations of a signature's current state.
  // +patchMergeKey=type
  // +patchStrategy=merge
  repeated SignatureCondition conditions = 4;

  // A human readable string representing image's identity. It could be a product name and version, or an
  // image pull spec (e.g. "registry.access.redhat.com/rhel7/rhel:7.2").
  optional string imageIdentity = 5;

  // Contains claims from the signature.
  map<string, string> signedClaims = 6;

  // If specified, it is the time of signature's creation.
  optional k8s.io.apimachinery.pkg.apis.meta.v1.Time created = 7;

  // If specified, it holds information about an issuer of signing certificate or key (a person or entity
  // who signed the signing certificate or key).
  optional SignatureIssuer issuedBy = 8;

  // If specified, it holds information about a subject of signing certificate or key (a person or entity
  // who signed the image).
  optional SignatureSubject issuedTo = 9;
}

// An ImageStream stores a mapping of tags to images, metadata overrides that are applied
// when images are tagged in a stream, and an optional reference to a container image
// repository on a registry. Users typically update the spec.tags field to point to external
// images which are imported from container registries using credentials in your namespace
// with the pull secret type, or to existing image stream tags and images which are
// immediately accessible for tagging or pulling. The history of images applied to a tag
// is visible in the status.tags field and any user who can view an image stream is allowed
// to tag that image into their own image streams. Access to pull images from the integrated
// registry is granted by having the "get imagestreams/layers" permission on a given image
// stream. Users may remove a tag by deleting the imagestreamtag resource, which causes both
// spec and status for that tag to be removed. Image stream history is retained until an
// administrator runs the prune operation, which removes references that are no longer in
// use. To preserve a historical image, ensure there is a tag in spec pointing to that image
// by its digest.
//
// Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).
// +openshift:compatibility-gen:level=1
message ImageStream {
  optional k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1;

  // Spec describes the desired state of this stream
  // +optional
  optional ImageStreamSpec spec = 2;

  // Status describes the current state of this stream
  // +optional
  optional ImageStreamStatus status = 3;
}

// ImageStreamImage represents an Image that is retrieved by image name from an ImageStream.
// User interfaces and regular users can use this resource to access the metadata details of
// a tagged image in the image stream history for viewing, since Image resources are not
// directly accessible to end users. A not found error will be returned if no such image is
// referenced by a tag within the ImageStream. Images are created when spec tags are set on
// an image stream that represent an image in an external registry, when pushing to the
// integrated registry, or when tagging an existing image from one image stream to another.
// The name of an image stream image is in the form "<STREAM>@<DIGEST>", where the digest is
// the content addressible identifier for the image (sha256:xxxxx...). You can use
// ImageStreamImages as the from.kind of an image stream spec tag to reference an image
// exactly. The only operations supported on the imagestreamimage endpoint are retrieving
// the image.
//
// Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).
// +openshift:compatibility-gen:level=1
message ImageStreamImage {
  optional k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1;

  // Image associated with the ImageStream and image name.
  optional Image image = 2;
}

// The image stream import resource provides an easy way for a user to find and import container images
// from other container image registries into the server. Individual images or an entire image repository may
// be imported, and users may choose to see the results of the import prior to tagging the resulting
// images into the specified image stream.
//
// This API is intended for end-user tools that need to see the metadata of the image prior to import
// (for instance, to generate an application from it). Clients that know the desired image can continue
// to create spec.tags directly into their image streams.
//
// Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).
// +openshift:compatibility-gen:level=1
message ImageStreamImport {
  optional k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1;

  // Spec is a description of the images that the user wishes to import
  optional ImageStreamImportSpec spec = 2;

  // Status is the result of importing the image
  optional ImageStreamImportStatus status = 3;
}

// ImageStreamImportSpec defines what images should be imported.
message ImageStreamImportSpec {
  // Import indicates whether to perform an import - if so, the specified tags are set on the spec
  // and status of the image stream defined by the type meta.
  optional bool import = 1;

  // Repository is an optional import of an entire container image repository. A maximum limit on the
  // number of tags imported this way is imposed by the server.
  optional RepositoryImportSpec repository = 2;

  // Images are a list of individual images to import.
  repeated ImageImportSpec images = 3;
}

// ImageStreamImportStatus contains information about the status of an image stream import.
message ImageStreamImportStatus {
  // Import is the image stream that was successfully updated or created when 'to' was set.
  optional ImageStream import = 1;

  // Repository is set if spec.repository was set to the outcome of the import
  optional RepositoryImportStatus repository = 2;

  // Images is set with the result of importing spec.images
  repeated ImageImportStatus images = 3;
}

// ImageStreamLayers describes information about the layers referenced by images in this
// image stream.
//
// Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).
// +openshift:compatibility-gen:level=1
message ImageStreamLayers {
  optional k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1;

  // blobs is a map of blob name to metadata about the blob.
  map<string, ImageLayerData> blobs = 2;

  // images is a map between an image name and the names of the blobs and config that
  // comprise the image.
  map<string, ImageBlobReferences> images = 3;
}

// ImageStreamList is a list of ImageStream objects.
//
// Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).
// +openshift:compatibility-gen:level=1
message ImageStreamList {
  optional k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1;

  // Items is a list of imageStreams
  repeated ImageStream items = 2;
}

// ImageStreamMapping represents a mapping from a single image stream tag to a container
// image as well as the reference to the container image stream the image came from. This
// resource is used by privileged integrators to create an image resource and to associate
// it with an image stream in the status tags field. Creating an ImageStreamMapping will
// allow any user who can view the image stream to tag or pull that image, so only create
// mappings where the user has proven they have access to the image contents directly.
// The only operation supported for this resource is create and the metadata name and
// namespace should be set to the image stream containing the tag that should be updated.
//
// Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).
// +openshift:compatibility-gen:level=1
message ImageStreamMapping {
  optional k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1;

  // Image is a container image.
  optional Image image = 2;

  // Tag is a string value this image can be located with inside the stream.
  optional string tag = 3;
}

// ImageStreamSpec represents options for ImageStreams.
message ImageStreamSpec {
  // lookupPolicy controls how other resources reference images within this namespace.
  optional ImageLookupPolicy lookupPolicy = 3;

  // dockerImageRepository is optional, if specified this stream is backed by a container repository on this server
  // Deprecated: This field is deprecated as of v3.7 and will be removed in a future release.
  // Specify the source for the tags to be imported in each tag via the spec.tags.from reference instead.
  optional string dockerImageRepository = 1;

  // tags map arbitrary string values to specific image locators
  // +patchMergeKey=name
  // +patchStrategy=merge
  repeated TagReference tags = 2;
}

// ImageStreamStatus contains information about the state of this image stream.
message ImageStreamStatus {
  // DockerImageRepository represents the effective location this stream may be accessed at.
  // May be empty until the server determines where the repository is located
  optional string dockerImageRepository = 1;

  // PublicDockerImageRepository represents the public location from where the image can
  // be pulled outside the cluster. This field may be empty if the administrator
  // has not exposed the integrated registry externally.
  optional string publicDockerImageRepository = 3;

  // Tags are a historical record of images associated with each tag. The first entry in the
  // TagEvent array is the currently tagged image.
  // +patchMergeKey=tag
  // +patchStrategy=merge
  repeated NamedTagEventList tags = 2;
}

// ImageStreamTag represents an Image that is retrieved by tag name from an ImageStream.
// Use this resource to interact with the tags and images in an image stream by tag, or
// to see the image details for a particular tag. The image associated with this resource
// is the most recently successfully tagged, imported, or pushed image (as described in the
// image stream status.tags.items list for this tag). If an import is in progress or has
// failed the previous image will be shown. Deleting an image stream tag clears both the
// status and spec fields of an image stream. If no image can be retrieved for a given tag,
// a not found error will be returned.
//
// Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).
// +openshift:compatibility-gen:level=1
message ImageStreamTag {
  optional k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1;

  // tag is the spec tag associated with this image stream tag, and it may be null
  // if only pushes have occurred to this image stream.
  optional TagReference tag = 2;

  // generation is the current generation of the tagged image - if tag is provided
  // and this value is not equal to the tag generation, a user has requested an
  // import that has not completed, or conditions will be filled out indicating any
  // error.
  optional int64 generation = 3;

  // lookupPolicy indicates whether this tag will handle image references in this
  // namespace.
  optional ImageLookupPolicy lookupPolicy = 6;

  // conditions is an array of conditions that apply to the image stream tag.
  repeated TagEventCondition conditions = 4;

  // image associated with the ImageStream and tag.
  optional Image image = 5;
}

// ImageStreamTagList is a list of ImageStreamTag objects.
//
// Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).
// +openshift:compatibility-gen:level=1
message ImageStreamTagList {
  optional k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1;

  // Items is the list of image stream tags
  repeated ImageStreamTag items = 2;
}

// ImageTag represents a single tag within an image stream and includes the spec,
// the status history, and the currently referenced image (if any) of the provided
// tag. This type replaces the ImageStreamTag by providing a full view of the tag.
// ImageTags are returned for every spec or status tag present on the image stream.
// If no tag exists in either form a not found error will be returned by the API.
// A create operation will succeed if no spec tag has already been defined and the
// spec field is set. Delete will remove both spec and status elements from the
// image stream.
//
// Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).
// +openshift:compatibility-gen:level=1
message ImageTag {
  optional k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1;

  // spec is the spec tag associated with this image stream tag, and it may be null
  // if only pushes have occurred to this image stream.
  optional TagReference spec = 2;

  // status is the status tag details associated with this image stream tag, and it
  // may be null if no push or import has been performed.
  optional NamedTagEventList status = 3;

  // image is the details of the most recent image stream status tag, and it may be
  // null if import has not completed or an administrator has deleted the image
  // object. To verify this is the most recent image, you must verify the generation
  // of the most recent status.items entry matches the spec tag (if a spec tag is
  // set). This field will not be set when listing image tags.
  optional Image image = 4;
}

// ImageTagList is a list of ImageTag objects. When listing image tags, the image
// field is not populated. Tags are returned in alphabetical order by image stream
// and then tag.
//
// Compatibility level 1: Stable within a major release for a minimum of 12 months or 3 minor releases (whichever is longer).
// +openshift:compatibility-gen:level=1
message ImageTagList {
  optional k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1;

  // Items is the list of image stream tags
  repeated ImageTag items = 2;
}

// NamedTagEventList relates a tag to its image history.
message NamedTagEventList {
  // Tag is the tag for which the history is recorded
  optional string tag = 1;

  // Standard object's metadata.
  repeated TagEvent items = 2;

  // Conditions is an array of conditions that apply to the tag event list.
  repeated TagEventCondition conditions = 3;
}

// RepositoryImportSpec describes a request to import images from a container image repository.
message RepositoryImportSpec {
  // From is the source for the image repository to import; only kind DockerImage and a name of a container image repository is allowed
  optional k8s.io.api.core.v1.ObjectReference from = 1;

  // ImportPolicy is the policy controlling how the image is imported
  optional TagImportPolicy importPolicy = 2;

  // ReferencePolicy defines how other components should consume the image
  optional TagReferencePolicy referencePolicy = 4;

  // IncludeManifest determines if the manifest for each image is returned in the response
  optional bool includeManifest = 3;
}

// RepositoryImportStatus describes the result of an image repository import
message RepositoryImportStatus {
  // Status reflects whether any failure occurred during import
  optional k8s.io.apimachinery.pkg.apis.meta.v1.Status status = 1;

  // Images is a list of images successfully retrieved by the import of the repository.
  repeated ImageImportStatus images = 2;

  // AdditionalTags are tags that exist in the repository but were not imported because
  // a maximum limit of automatic imports was applied.
  repeated string additionalTags = 3;
}

// SecretList is a list of Secret.
// +openshift:compatibility-gen:level=1
message SecretList {
  // Standard list metadata.
  // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
  // +optional
  optional k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1;

  // Items is a list of secret objects.
  // More info: https://kubernetes.io/docs/concepts/configuration/secret
  repeated k8s.io.api.core.v1.Secret items = 2;
}

// SignatureCondition describes an image signature condition of particular kind at particular probe time.
message SignatureCondition {
  // Type of signature condition, Complete or Failed.
  optional string type = 1;

  // Status of the condition, one of True, False, Unknown.
  optional string status = 2;

  // Last time the condition was checked.
  optional k8s.io.apimachinery.pkg.apis.meta.v1.Time lastProbeTime = 3;

  // Last time the condition transit from one status to another.
  optional k8s.io.apimachinery.pkg.apis.meta.v1.Time lastTransitionTime = 4;

  // (brief) reason for the condition's last transition.
  optional string reason = 5;

  // Human readable message indicating details about last transition.
  optional string message = 6;
}

// SignatureGenericEntity holds a generic information about a person or entity who is an issuer or a subject
// of signing certificate or key.
message SignatureGenericEntity {
  // Organization name.
  optional string organization = 1;

  // Common name (e.g. openshift-signing-service).
  optional string commonName = 2;
}

// SignatureIssuer holds information about an issuer of signing certificate or key.
message SignatureIssuer {
  optional SignatureGenericEntity signatureGenericEntity = 1;
}

// SignatureSubject holds information about a person or entity who created the signature.
message SignatureSubject {
  optional SignatureGenericEntity signatureGenericEntity = 1;

  // If present, it is a human readable key id of public key belonging to the subject used to verify image
  // signature. It should contain at least 64 lowest bits of public key's fingerprint (e.g.
  // 0x685ebe62bf278440).
  optional string publicKeyID = 2;
}

// TagEvent is used by ImageStreamStatus to keep a historical record of images associated with a tag.
message TagEvent {
  // Created holds the time the TagEvent was created
  optional k8s.io.apimachinery.pkg.apis.meta.v1.Time created = 1;

  // DockerImageReference is the string that can be used to pull this image
  optional string dockerImageReference = 2;

  // Image is the image
  optional string image = 3;

  // Generation is the spec tag generation that resulted in this tag being updated
  optional int64 generation = 4;
}

// TagEventCondition contains condition information for a tag event.
message TagEventCondition {
  // Type of tag event condition, currently only ImportSuccess
  optional string type = 1;

  // Status of the condition, one of True, False, Unknown.
  optional string status = 2;

  // LastTransitionTIme is the time the condition transitioned from one status to another.
  optional k8s.io.apimachinery.pkg.apis.meta.v1.Time lastTransitionTime = 3;

  // Reason is a brief machine readable explanation for the condition's last transition.
  optional string reason = 4;

  // Message is a human readable description of the details about last transition, complementing reason.
  optional string message = 5;

  // Generation is the spec tag generation that this status corresponds to
  optional int64 generation = 6;
}

// TagImportPolicy controls how images related to this tag will be imported.
message TagImportPolicy {
  // Insecure is true if the server may bypass certificate verification or connect directly over HTTP during image import.
  optional bool insecure = 1;

  // Scheduled indicates to the server that this tag should be periodically checked to ensure it is up to date, and imported
  optional bool scheduled = 2;
}

// TagReference specifies optional annotations for images using this tag and an optional reference to an ImageStreamTag, ImageStreamImage, or DockerImage this tag should track.
message TagReference {
  // Name of the tag
  optional string name = 1;

  // Optional; if specified, annotations that are applied to images retrieved via ImageStreamTags.
  // +optional
  map<string, string> annotations = 2;

  // Optional; if specified, a reference to another image that this tag should point to. Valid values
  // are ImageStreamTag, ImageStreamImage, and DockerImage.  ImageStreamTag references
  // can only reference a tag within this same ImageStream.
  optional k8s.io.api.core.v1.ObjectReference from = 3;

  // Reference states if the tag will be imported. Default value is false, which means the tag will
  // be imported.
  optional bool reference = 4;

  // Generation is a counter that tracks mutations to the spec tag (user intent). When a tag reference
  // is changed the generation is set to match the current stream generation (which is incremented every
  // time spec is changed). Other processes in the system like the image importer observe that the
  // generation of spec tag is newer than the generation recorded in the status and use that as a trigger
  // to import the newest remote tag. To trigger a new import, clients may set this value to zero which
  // will reset the generation to the latest stream generation. Legacy clients will send this value as
  // nil which will be merged with the current tag generation.
  // +optional
  optional int64 generation = 5;

  // ImportPolicy is information that controls how images may be imported by the server.
  optional TagImportPolicy importPolicy = 6;

  // ReferencePolicy defines how other components should consume the image.
  optional TagReferencePolicy referencePolicy = 7;
}

// TagReferencePolicy describes how pull-specs for images in this image stream tag are generated when
// image change triggers in deployment configs or builds are resolved. This allows the image stream
// author to control how images are accessed.
message TagReferencePolicy {
  // Type determines how the image pull spec should be transformed when the image stream tag is used in
  // deployment config triggers or new builds. The default value is `Source`, indicating the original
  // location of the image should be used (if imported). The user may also specify `Local`, indicating
  // that the pull spec should point to the integrated container image registry and leverage the registry's
  // ability to proxy the pull to an upstream registry. `Local` allows the credentials used to pull this
  // image to be managed from the image stream's namespace, so others on the platform can access a remote
  // image but have no access to the remote secret. It also allows the image layers to be mirrored into
  // the local registry which the images can still be pulled even if the upstream registry is unavailable.
  optional string type = 1;
}

