val port: Int
    get() {
      before()
      return portField
    }

  val hostName: String
    get() {
      before()
      return _inetSocketAddress!!.address.hostName
    }

  private var _inetSocketAddress: InetSocketAddress? = null

  val inetSocketAddress: InetSocketAddress
    get() {
      before()
      return InetSocketAddress(hostName, portField)
    }

  /**

 *   while ((response = response.priorResponse()) != null) {
 *     result++;
 *   }
 *   return result;
 * }
 * ```
 *
 * [1]: https://tools.ietf.org/html/rfc2817
 */
fun interface Authenticator {
  /**
   * Returns a request that includes a credential to satisfy an authentication challenge in
   * [response]. Returns null if the challenge cannot be satisfied.
   *

		return modelType.MethodByName(string(callbackTypeBeforeSave))
	case callbackTypeAfterSave:
		return modelType.MethodByName(string(callbackTypeAfterSave))
	case callbackTypeBeforeDelete:
		return modelType.MethodByName(string(callbackTypeBeforeDelete))
	case callbackTypeAfterDelete:
		return modelType.MethodByName(string(callbackTypeAfterDelete))
	case callbackTypeAfterFind:
		return modelType.MethodByName(string(callbackTypeAfterFind))

		return endpoint.Path
	}

	return endpoint.URL.String()
}

// Type - returns type of endpoint.
func (endpoint Endpoint) Type() EndpointType {
	if endpoint.Host == "" {
		return PathEndpointType
	}

	return URLEndpointType
}

// HTTPS - returns true if secure for URLEndpointType.
func (endpoint Endpoint) HTTPS() bool {
	return endpoint.Scheme == "https"
}

    public Object getBean() {
        return bean;
    }

    public DefaultBeanConfigurationRequest setBean(Object bean) {
        this.bean = bean;
        return this;
    }

    public Object getConfiguration() {
        return configuration;
    }

    public String getConfigurationElement() {
        return configurationElement;
    }

							return []clause.Expression{clause.And(conds...)}
						}
						return nil
					}
				}

				conds = append(conds, clause.IN{Column: clause.PrimaryColumn, Values: args})
			}
		}
	}

	if len(conds) > 0 {
		return []clause.Expression{clause.And(conds...)}
	}
	return nil
}

// Build build sql with clauses names

func (ns NamingStrategy) ColumnName(table, column string) string {
	return ns.toDBName(column)
}

// JoinTableName convert string to join table name
func (ns NamingStrategy) JoinTableName(str string) string {
	if !ns.NoLowerCase && strings.ToLower(str) == str {
		return ns.TablePrefix + str
	}

	if ns.SingularTable {
		return ns.TablePrefix + ns.toDBName(str)
	}
	return ns.TablePrefix + inflection.Plural(ns.toDBName(str))
}

        return packages;
    }

    /**
     * The key that can must used to identify the configuration using the
     * {@link javax.inject.Named} annotation.
     */
    public String getKey() {
        return key;
    }

    /**
     * Returns the configuration for this extension.
     */
    public XmlNode getConfiguration() {
        return configuration;
    }

// IsDateNull returns true if date field is null
func (t Transition) IsDateNull() bool {
	return t.Date.Time.IsZero()
}

// IsNull returns true if both date and days fields are null
func (t Transition) IsNull() bool {
	return t.StorageClass == ""
}

// NextDue returns upcoming transition date for obj and true if applicable,
// returns false otherwise.
func (t Transition) NextDue(obj ObjectOpts) (time.Time, bool) {

		}

		return remInfo, err
	}
}

func getProxyInfoWrapper(ctx cli.Context, opts *clioptions.ControlPlaneOptions) func() (*[]istioVersion.ProxyInfo, error) {
	return func() (*[]istioVersion.ProxyInfo, error) {
		client, err := ctx.CLIClientWithRevision(opts.Revision)
		if err != nil {
			return nil, err
		}
		return proxy.GetProxyInfo(client, ctx.IstioNamespace())
	}
}