/// <summary>
        /// Gets the hash code
        /// </summary>
        /// <returns>Hash code</returns>
        public override int GetHashCode()
        {
            unchecked // Overflow is fine, just wrap
            {
                var hashCode = 41;
                // Suitable nullity checks etc, of course :)
                if (Id != null)
                {
                    hashCode = hashCode * 59 + Id.GetHashCode();
                }
                if (ProgramId != null)
                {
                    hashCode = hashCode * 59 + ProgramId.GetHashCode();
                }
                if (PipelineId != null)
                {
                    hashCode = hashCode * 59 + PipelineId.GetHashCode();
                }
                if (ArtifactsVersion != null)
                {
                    hashCode = hashCode * 59 + ArtifactsVersion.GetHashCode();
                }
                if (User != null)
                {
                    hashCode = hashCode * 59 + User.GetHashCode();
                }

                hashCode = hashCode * 59 + Status.GetHashCode();

                hashCode = hashCode * 59 + Trigger.GetHashCode();
                if (CreatedAt != null)
                {
                    hashCode = hashCode * 59 + CreatedAt.GetHashCode();
                }
                if (UpdatedAt != null)
                {
                    hashCode = hashCode * 59 + UpdatedAt.GetHashCode();
                }
                if (FinishedAt != null)
                {
                    hashCode = hashCode * 59 + FinishedAt.GetHashCode();
                }
                if (Embedded != null)
                {
                    hashCode = hashCode * 59 + Embedded.GetHashCode();
                }
                if (Links != null)
                {
                    hashCode = hashCode * 59 + Links.GetHashCode();
                }
                return(hashCode);
            }
        }
        /// <summary>
        /// Returns true if PipelineExecution instances are equal
        /// </summary>
        /// <param name="other">Instance of PipelineExecution to be compared</param>
        /// <returns>Boolean</returns>
        public bool Equals(PipelineExecution other)
        {
            if (other is null)
            {
                return(false);
            }
            if (ReferenceEquals(this, other))
            {
                return(true);
            }

            return
                ((
                     Id == other.Id ||
                     Id != null &&
                     Id.Equals(other.Id)
                     ) &&
                 (
                     ProgramId == other.ProgramId ||
                     ProgramId != null &&
                     ProgramId.Equals(other.ProgramId)
                 ) &&
                 (
                     PipelineId == other.PipelineId ||
                     PipelineId != null &&
                     PipelineId.Equals(other.PipelineId)
                 ) &&
                 (
                     ArtifactsVersion == other.ArtifactsVersion ||
                     ArtifactsVersion != null &&
                     ArtifactsVersion.Equals(other.ArtifactsVersion)
                 ) &&
                 (
                     User == other.User ||
                     User != null &&
                     User.Equals(other.User)
                 ) &&
                 (
                     Status == other.Status ||

                     Status.Equals(other.Status)
                 ) &&
                 (
                     Trigger == other.Trigger ||

                     Trigger.Equals(other.Trigger)
                 ) &&
                 (
                     CreatedAt == other.CreatedAt ||
                     CreatedAt != null &&
                     CreatedAt.Equals(other.CreatedAt)
                 ) &&
                 (
                     UpdatedAt == other.UpdatedAt ||
                     UpdatedAt != null &&
                     UpdatedAt.Equals(other.UpdatedAt)
                 ) &&
                 (
                     FinishedAt == other.FinishedAt ||
                     FinishedAt != null &&
                     FinishedAt.Equals(other.FinishedAt)
                 ) &&
                 (
                     Embedded == other.Embedded ||
                     Embedded != null &&
                     Embedded.Equals(other.Embedded)
                 ) &&
                 (
                     Links == other.Links ||
                     Links != null &&
                     Links.Equals(other.Links)
                 ));
        }