import { ApiObject, ApiObjectMetadata, GroupVersionKind } from "cdk8s";
import { Construct } from "constructs";
/**
 * Challenge is a type to represent a Challenge request with an ACME server
 *
 * @schema Challenge
 */
export declare class Challenge extends ApiObject {
    /** Returns the apiVersion and kind for "Challenge" */
    static readonly GVK: GroupVersionKind;
    /**
     * Renders a Kubernetes manifest for "Challenge".
     *
     * This can be used to inline resource manifests inside other objects (e.g. as templates).
     *
     * @param props Initialization props
     */
    static manifest(props: ChallengeProps): any;
    /**
     * Defines a "Challenge" API object
     *
     * @param scope The scope in which to define this object
     * @param id A scope-local name for the object
     * @param props Initialization props
     */
    constructor(scope: Construct, id: string, props: ChallengeProps);
    /** Renders the object to Kubernetes JSON. */
    toJson(): any;
}
/**
 * Challenge is a type to represent a Challenge request with an ACME server
 *
 * @schema Challenge
 */
export interface ChallengeProps {
    /** @schema Challenge#metadata */
    readonly metadata: ApiObjectMetadata;
    /** @schema Challenge#spec */
    readonly spec: ChallengeSpec;
}
/** Converts an object of type 'ChallengeProps' to JSON representation. */
export declare function toJson_ChallengeProps(obj: ChallengeProps | undefined): Record<string, any> | undefined;
/** @schema ChallengeSpec */
export interface ChallengeSpec {
    /**
     * The URL to the ACME Authorization resource that this challenge is a part of.
     *
     * @schema ChallengeSpec#authorizationURL
     */
    readonly authorizationUrl: string;
    /**
     * DnsName is the identifier that this challenge is for, e.g. example.com. If the requested
     * DNSName is a 'wildcard', this field MUST be set to the non-wildcard domain, e.g. for
     * `*.example.com`, it must be `example.com`.
     *
     * @schema ChallengeSpec#dnsName
     */
    readonly dnsName: string;
    /**
     * References a properly configured ACME-type Issuer which should be used to create this
     * Challenge. If the Issuer does not exist, processing will be retried. If the Issuer is not an
     * 'ACME' Issuer, an error will be returned and the Challenge will be marked as failed.
     *
     * @schema ChallengeSpec#issuerRef
     */
    readonly issuerRef: ChallengeSpecIssuerRef;
    /**
     * The ACME challenge key for this challenge For HTTP01 challenges, this is the value that must
     * be responded with to complete the HTTP01 challenge in the format: `<private key JWK
     * thumbprint>.<key from acme server for challenge>`. For DNS01 challenges, this is the base64
     * encoded SHA256 sum of the `<private key JWK thumbprint>.<key from acme server for challenge>`
     * text that must be set as the TXT record content.
     *
     * @schema ChallengeSpec#key
     */
    readonly key: string;
    /**
     * Contains the domain solving configuration that should be used to solve this challenge
     * resource.
     *
     * @schema ChallengeSpec#solver
     */
    readonly solver: ChallengeSpecSolver;
    /**
     * The ACME challenge token for this challenge. This is the raw value returned from the ACME
     * server.
     *
     * @schema ChallengeSpec#token
     */
    readonly token: string;
    /**
     * The type of ACME challenge this resource represents. One of "HTTP-01" or "DNS-01".
     *
     * @schema ChallengeSpec#type
     */
    readonly type: ChallengeSpecType;
    /**
     * The URL of the ACME Challenge resource for this challenge. This can be used to lookup details
     * about the status of this challenge.
     *
     * @schema ChallengeSpec#url
     */
    readonly url: string;
    /**
     * Wildcard will be true if this challenge is for a wildcard identifier, for example
     * '*.example.com'.
     *
     * @schema ChallengeSpec#wildcard
     */
    readonly wildcard?: boolean;
}
/** Converts an object of type 'ChallengeSpec' to JSON representation. */
export declare function toJson_ChallengeSpec(obj: ChallengeSpec | undefined): Record<string, any> | undefined;
/**
 * References a properly configured ACME-type Issuer which should be used to create this Challenge.
 * If the Issuer does not exist, processing will be retried. If the Issuer is not an 'ACME' Issuer,
 * an error will be returned and the Challenge will be marked as failed.
 *
 * @schema ChallengeSpecIssuerRef
 */
export interface ChallengeSpecIssuerRef {
    /**
     * Group of the resource being referred to.
     *
     * @schema ChallengeSpecIssuerRef#group
     */
    readonly group?: string;
    /**
     * Kind of the resource being referred to.
     *
     * @schema ChallengeSpecIssuerRef#kind
     */
    readonly kind?: string;
    /**
     * Name of the resource being referred to.
     *
     * @schema ChallengeSpecIssuerRef#name
     */
    readonly name: string;
}
/** Converts an object of type 'ChallengeSpecIssuerRef' to JSON representation. */
export declare function toJson_ChallengeSpecIssuerRef(obj: ChallengeSpecIssuerRef | undefined): Record<string, any> | undefined;
/**
 * Contains the domain solving configuration that should be used to solve this challenge resource.
 *
 * @schema ChallengeSpecSolver
 */
export interface ChallengeSpecSolver {
    /**
     * Configures cert-manager to attempt to complete authorizations by performing the DNS01
     * challenge flow.
     *
     * @schema ChallengeSpecSolver#dns01
     */
    readonly dns01?: ChallengeSpecSolverDns01;
    /**
     * Configures cert-manager to attempt to complete authorizations by performing the HTTP01
     * challenge flow. It is not possible to obtain certificates for wildcard domain names (e.g.
     * `*.example.com`) using the HTTP01 challenge mechanism.
     *
     * @schema ChallengeSpecSolver#http01
     */
    readonly http01?: ChallengeSpecSolverHttp01;
    /**
     * Selector selects a set of DNSNames on the Certificate resource that should be solved using
     * this challenge solver. If not specified, the solver will be treated as the 'default' solver
     * with the lowest priority, i.e. if any other solver has a more specific match, it will be used
     * instead.
     *
     * @schema ChallengeSpecSolver#selector
     */
    readonly selector?: ChallengeSpecSolverSelector;
}
/** Converts an object of type 'ChallengeSpecSolver' to JSON representation. */
export declare function toJson_ChallengeSpecSolver(obj: ChallengeSpecSolver | undefined): Record<string, any> | undefined;
/**
 * The type of ACME challenge this resource represents. One of "HTTP-01" or "DNS-01".
 *
 * @schema ChallengeSpecType
 */
export declare enum ChallengeSpecType {
    /** HTTP-01 */
    HTTP_HYPHEN_01 = "HTTP-01",
    /** DNS-01 */
    DNS_HYPHEN_01 = "DNS-01"
}
/**
 * Configures cert-manager to attempt to complete authorizations by performing the DNS01 challenge
 * flow.
 *
 * @schema ChallengeSpecSolverDns01
 */
export interface ChallengeSpecSolverDns01 {
    /**
     * Use the 'ACME DNS' (https://github.com/joohoi/acme-dns) API to manage DNS01 challenge
     * records.
     *
     * @schema ChallengeSpecSolverDns01#acmeDNS
     */
    readonly acmeDns?: ChallengeSpecSolverDns01AcmeDns;
    /**
     * Use the Akamai DNS zone management API to manage DNS01 challenge records.
     *
     * @schema ChallengeSpecSolverDns01#akamai
     */
    readonly akamai?: ChallengeSpecSolverDns01Akamai;
    /**
     * Use the Microsoft Azure DNS API to manage DNS01 challenge records.
     *
     * @schema ChallengeSpecSolverDns01#azureDNS
     */
    readonly azureDns?: ChallengeSpecSolverDns01AzureDns;
    /**
     * Use the Google Cloud DNS API to manage DNS01 challenge records.
     *
     * @schema ChallengeSpecSolverDns01#cloudDNS
     */
    readonly cloudDns?: ChallengeSpecSolverDns01CloudDns;
    /**
     * Use the Cloudflare API to manage DNS01 challenge records.
     *
     * @schema ChallengeSpecSolverDns01#cloudflare
     */
    readonly cloudflare?: ChallengeSpecSolverDns01Cloudflare;
    /**
     * CNAMEStrategy configures how the DNS01 provider should handle CNAME records when found in DNS
     * zones.
     *
     * @schema ChallengeSpecSolverDns01#cnameStrategy
     */
    readonly cnameStrategy?: ChallengeSpecSolverDns01CnameStrategy;
    /**
     * Use the DigitalOcean DNS API to manage DNS01 challenge records.
     *
     * @schema ChallengeSpecSolverDns01#digitalocean
     */
    readonly digitalocean?: ChallengeSpecSolverDns01Digitalocean;
    /**
     * Use RFC2136 ("Dynamic Updates in the Domain Name System")
     * (https://datatracker.ietf.org/doc/rfc2136/) to manage DNS01 challenge records.
     *
     * @schema ChallengeSpecSolverDns01#rfc2136
     */
    readonly rfc2136?: ChallengeSpecSolverDns01Rfc2136;
    /**
     * Use the AWS Route53 API to manage DNS01 challenge records.
     *
     * @schema ChallengeSpecSolverDns01#route53
     */
    readonly route53?: ChallengeSpecSolverDns01Route53;
    /**
     * Configure an external webhook based DNS01 challenge solver to manage DNS01 challenge records.
     *
     * @schema ChallengeSpecSolverDns01#webhook
     */
    readonly webhook?: ChallengeSpecSolverDns01Webhook;
}
/** Converts an object of type 'ChallengeSpecSolverDns01' to JSON representation. */
export declare function toJson_ChallengeSpecSolverDns01(obj: ChallengeSpecSolverDns01 | undefined): Record<string, any> | undefined;
/**
 * Configures cert-manager to attempt to complete authorizations by performing the HTTP01 challenge
 * flow. It is not possible to obtain certificates for wildcard domain names (e.g. `*.example.com`)
 * using the HTTP01 challenge mechanism.
 *
 * @schema ChallengeSpecSolverHttp01
 */
export interface ChallengeSpecSolverHttp01 {
    /**
     * The Gateway API is a sig-network community API that models service networking in Kubernetes
     * (https://gateway-api.sigs.k8s.io/). The Gateway solver will create HTTPRoutes with the
     * specified labels in the same namespace as the challenge. This solver is experimental, and
     * fields / behaviour may change in the future.
     *
     * @schema ChallengeSpecSolverHttp01#gatewayHTTPRoute
     */
    readonly gatewayHttpRoute?: ChallengeSpecSolverHttp01GatewayHttpRoute;
    /**
     * The ingress based HTTP01 challenge solver will solve challenges by creating or modifying
     * Ingress resources in order to route requests for '/.well-known/acme-challenge/XYZ' to
     * 'challenge solver' pods that are provisioned by cert-manager for each Challenge to be
     * completed.
     *
     * @schema ChallengeSpecSolverHttp01#ingress
     */
    readonly ingress?: ChallengeSpecSolverHttp01Ingress;
}
/** Converts an object of type 'ChallengeSpecSolverHttp01' to JSON representation. */
export declare function toJson_ChallengeSpecSolverHttp01(obj: ChallengeSpecSolverHttp01 | undefined): Record<string, any> | undefined;
/**
 * Selector selects a set of DNSNames on the Certificate resource that should be solved using this
 * challenge solver. If not specified, the solver will be treated as the 'default' solver with the
 * lowest priority, i.e. if any other solver has a more specific match, it will be used instead.
 *
 * @schema ChallengeSpecSolverSelector
 */
export interface ChallengeSpecSolverSelector {
    /**
     * List of DNSNames that this solver will be used to solve. If specified and a match is found, a
     * dnsNames selector will take precedence over a dnsZones selector. If multiple solvers match
     * with the same dnsNames value, the solver with the most matching labels in matchLabels will be
     * selected. If neither has more matches, the solver defined earlier in the list will be
     * selected.
     *
     * @schema ChallengeSpecSolverSelector#dnsNames
     */
    readonly dnsNames?: string[];
    /**
     * List of DNSZones that this solver will be used to solve. The most specific DNS zone match
     * specified here will take precedence over other DNS zone matches, so a solver specifying
     * sys.example.com will be selected over one specifying example.com for the domain
     * www.sys.example.com. If multiple solvers match with the same dnsZones value, the solver with
     * the most matching labels in matchLabels will be selected. If neither has more matches, the
     * solver defined earlier in the list will be selected.
     *
     * @schema ChallengeSpecSolverSelector#dnsZones
     */
    readonly dnsZones?: string[];
    /**
     * A label selector that is used to refine the set of certificate's that this challenge solver
     * will apply to.
     *
     * @schema ChallengeSpecSolverSelector#matchLabels
     */
    readonly matchLabels?: {
        [key: string]: string;
    };
}
/** Converts an object of type 'ChallengeSpecSolverSelector' to JSON representation. */
export declare function toJson_ChallengeSpecSolverSelector(obj: ChallengeSpecSolverSelector | undefined): Record<string, any> | undefined;
/**
 * Use the 'ACME DNS' (https://github.com/joohoi/acme-dns) API to manage DNS01 challenge records.
 *
 * @schema ChallengeSpecSolverDns01AcmeDns
 */
export interface ChallengeSpecSolverDns01AcmeDns {
    /**
     * A reference to a specific 'key' within a Secret resource. In some instances, `key` is a
     * required field.
     *
     * @schema ChallengeSpecSolverDns01AcmeDns#accountSecretRef
     */
    readonly accountSecretRef: ChallengeSpecSolverDns01AcmeDnsAccountSecretRef;
    /** @schema ChallengeSpecSolverDns01AcmeDns#host */
    readonly host: string;
}
/** Converts an object of type 'ChallengeSpecSolverDns01AcmeDns' to JSON representation. */
export declare function toJson_ChallengeSpecSolverDns01AcmeDns(obj: ChallengeSpecSolverDns01AcmeDns | undefined): Record<string, any> | undefined;
/**
 * Use the Akamai DNS zone management API to manage DNS01 challenge records.
 *
 * @schema ChallengeSpecSolverDns01Akamai
 */
export interface ChallengeSpecSolverDns01Akamai {
    /**
     * A reference to a specific 'key' within a Secret resource. In some instances, `key` is a
     * required field.
     *
     * @schema ChallengeSpecSolverDns01Akamai#accessTokenSecretRef
     */
    readonly accessTokenSecretRef: ChallengeSpecSolverDns01AkamaiAccessTokenSecretRef;
    /**
     * A reference to a specific 'key' within a Secret resource. In some instances, `key` is a
     * required field.
     *
     * @schema ChallengeSpecSolverDns01Akamai#clientSecretSecretRef
     */
    readonly clientSecretSecretRef: ChallengeSpecSolverDns01AkamaiClientSecretSecretRef;
    /**
     * A reference to a specific 'key' within a Secret resource. In some instances, `key` is a
     * required field.
     *
     * @schema ChallengeSpecSolverDns01Akamai#clientTokenSecretRef
     */
    readonly clientTokenSecretRef: ChallengeSpecSolverDns01AkamaiClientTokenSecretRef;
    /** @schema ChallengeSpecSolverDns01Akamai#serviceConsumerDomain */
    readonly serviceConsumerDomain: string;
}
/** Converts an object of type 'ChallengeSpecSolverDns01Akamai' to JSON representation. */
export declare function toJson_ChallengeSpecSolverDns01Akamai(obj: ChallengeSpecSolverDns01Akamai | undefined): Record<string, any> | undefined;
/**
 * Use the Microsoft Azure DNS API to manage DNS01 challenge records.
 *
 * @schema ChallengeSpecSolverDns01AzureDns
 */
export interface ChallengeSpecSolverDns01AzureDns {
    /**
     * Auth: Azure Service Principal: The ClientID of the Azure Service Principal used to
     * authenticate with Azure DNS. If set, ClientSecret and TenantID must also be set.
     *
     * @schema ChallengeSpecSolverDns01AzureDns#clientID
     */
    readonly clientId?: string;
    /**
     * Auth: Azure Service Principal: A reference to a Secret containing the password associated
     * with the Service Principal. If set, ClientID and TenantID must also be set.
     *
     * @schema ChallengeSpecSolverDns01AzureDns#clientSecretSecretRef
     */
    readonly clientSecretSecretRef?: ChallengeSpecSolverDns01AzureDnsClientSecretSecretRef;
    /**
     * Name of the Azure environment (default AzurePublicCloud)
     *
     * @schema ChallengeSpecSolverDns01AzureDns#environment
     */
    readonly environment?: ChallengeSpecSolverDns01AzureDnsEnvironment;
    /**
     * Name of the DNS zone that should be used
     *
     * @schema ChallengeSpecSolverDns01AzureDns#hostedZoneName
     */
    readonly hostedZoneName?: string;
    /**
     * Auth: Azure Workload Identity or Azure Managed Service Identity: Settings to enable Azure
     * Workload Identity or Azure Managed Service Identity If set, ClientID, ClientSecret and
     * TenantID must not be set.
     *
     * @schema ChallengeSpecSolverDns01AzureDns#managedIdentity
     */
    readonly managedIdentity?: ChallengeSpecSolverDns01AzureDnsManagedIdentity;
    /**
     * Resource group the DNS zone is located in
     *
     * @schema ChallengeSpecSolverDns01AzureDns#resourceGroupName
     */
    readonly resourceGroupName: string;
    /**
     * ID of the Azure subscription
     *
     * @schema ChallengeSpecSolverDns01AzureDns#subscriptionID
     */
    readonly subscriptionId: string;
    /**
     * Auth: Azure Service Principal: The TenantID of the Azure Service Principal used to
     * authenticate with Azure DNS. If set, ClientID and ClientSecret must also be set.
     *
     * @schema ChallengeSpecSolverDns01AzureDns#tenantID
     */
    readonly tenantId?: string;
}
/** Converts an object of type 'ChallengeSpecSolverDns01AzureDns' to JSON representation. */
export declare function toJson_ChallengeSpecSolverDns01AzureDns(obj: ChallengeSpecSolverDns01AzureDns | undefined): Record<string, any> | undefined;
/**
 * Use the Google Cloud DNS API to manage DNS01 challenge records.
 *
 * @schema ChallengeSpecSolverDns01CloudDns
 */
export interface ChallengeSpecSolverDns01CloudDns {
    /**
     * HostedZoneName is an optional field that tells cert-manager in which Cloud DNS zone the
     * challenge record has to be created. If left empty cert-manager will automatically choose a
     * zone.
     *
     * @schema ChallengeSpecSolverDns01CloudDns#hostedZoneName
     */
    readonly hostedZoneName?: string;
    /** @schema ChallengeSpecSolverDns01CloudDns#project */
    readonly project: string;
    /**
     * A reference to a specific 'key' within a Secret resource. In some instances, `key` is a
     * required field.
     *
     * @schema ChallengeSpecSolverDns01CloudDns#serviceAccountSecretRef
     */
    readonly serviceAccountSecretRef?: ChallengeSpecSolverDns01CloudDnsServiceAccountSecretRef;
}
/** Converts an object of type 'ChallengeSpecSolverDns01CloudDns' to JSON representation. */
export declare function toJson_ChallengeSpecSolverDns01CloudDns(obj: ChallengeSpecSolverDns01CloudDns | undefined): Record<string, any> | undefined;
/**
 * Use the Cloudflare API to manage DNS01 challenge records.
 *
 * @schema ChallengeSpecSolverDns01Cloudflare
 */
export interface ChallengeSpecSolverDns01Cloudflare {
    /**
     * API key to use to authenticate with Cloudflare. Note: using an API token to authenticate is
     * now the recommended method as it allows greater control of permissions.
     *
     * @schema ChallengeSpecSolverDns01Cloudflare#apiKeySecretRef
     */
    readonly apiKeySecretRef?: ChallengeSpecSolverDns01CloudflareApiKeySecretRef;
    /**
     * API token used to authenticate with Cloudflare.
     *
     * @schema ChallengeSpecSolverDns01Cloudflare#apiTokenSecretRef
     */
    readonly apiTokenSecretRef?: ChallengeSpecSolverDns01CloudflareApiTokenSecretRef;
    /**
     * Email of the account, only required when using API key based authentication.
     *
     * @schema ChallengeSpecSolverDns01Cloudflare#email
     */
    readonly email?: string;
}
/** Converts an object of type 'ChallengeSpecSolverDns01Cloudflare' to JSON representation. */
export declare function toJson_ChallengeSpecSolverDns01Cloudflare(obj: ChallengeSpecSolverDns01Cloudflare | undefined): Record<string, any> | undefined;
/**
 * CNAMEStrategy configures how the DNS01 provider should handle CNAME records when found in DNS
 * zones.
 *
 * @schema ChallengeSpecSolverDns01CnameStrategy
 */
export declare enum ChallengeSpecSolverDns01CnameStrategy {
    /** None */
    NONE = "None",
    /** Follow */
    FOLLOW = "Follow"
}
/**
 * Use the DigitalOcean DNS API to manage DNS01 challenge records.
 *
 * @schema ChallengeSpecSolverDns01Digitalocean
 */
export interface ChallengeSpecSolverDns01Digitalocean {
    /**
     * A reference to a specific 'key' within a Secret resource. In some instances, `key` is a
     * required field.
     *
     * @schema ChallengeSpecSolverDns01Digitalocean#tokenSecretRef
     */
    readonly tokenSecretRef: ChallengeSpecSolverDns01DigitaloceanTokenSecretRef;
}
/** Converts an object of type 'ChallengeSpecSolverDns01Digitalocean' to JSON representation. */
export declare function toJson_ChallengeSpecSolverDns01Digitalocean(obj: ChallengeSpecSolverDns01Digitalocean | undefined): Record<string, any> | undefined;
/**
 * Use RFC2136 ("Dynamic Updates in the Domain Name System")
 * (https://datatracker.ietf.org/doc/rfc2136/) to manage DNS01 challenge records.
 *
 * @schema ChallengeSpecSolverDns01Rfc2136
 */
export interface ChallengeSpecSolverDns01Rfc2136 {
    /**
     * The IP address or hostname of an authoritative DNS server supporting RFC2136 in the form
     * host:port. If the host is an IPv6 address it must be enclosed in square brackets (e.g
     * [2001:db8::1]) ; port is optional. This field is required.
     *
     * @schema ChallengeSpecSolverDns01Rfc2136#nameserver
     */
    readonly nameserver: string;
    /**
     * The TSIG Algorithm configured in the DNS supporting RFC2136. Used only when
     * `tsigSecretSecretRef` and `tsigKeyName` are defined. Supported values are (case-insensitive):
     * `HMACMD5` (default), `HMACSHA1`, `HMACSHA256` or `HMACSHA512`.
     *
     * @schema ChallengeSpecSolverDns01Rfc2136#tsigAlgorithm
     */
    readonly tsigAlgorithm?: string;
    /**
     * The TSIG Key name configured in the DNS. If `tsigSecretSecretRef` is defined, this field is
     * required.
     *
     * @schema ChallengeSpecSolverDns01Rfc2136#tsigKeyName
     */
    readonly tsigKeyName?: string;
    /**
     * The name of the secret containing the TSIG value. If `tsigKeyName` is defined, this field is
     * required.
     *
     * @schema ChallengeSpecSolverDns01Rfc2136#tsigSecretSecretRef
     */
    readonly tsigSecretSecretRef?: ChallengeSpecSolverDns01Rfc2136TsigSecretSecretRef;
}
/** Converts an object of type 'ChallengeSpecSolverDns01Rfc2136' to JSON representation. */
export declare function toJson_ChallengeSpecSolverDns01Rfc2136(obj: ChallengeSpecSolverDns01Rfc2136 | undefined): Record<string, any> | undefined;
/**
 * Use the AWS Route53 API to manage DNS01 challenge records.
 *
 * @schema ChallengeSpecSolverDns01Route53
 */
export interface ChallengeSpecSolverDns01Route53 {
    /**
     * The AccessKeyID is used for authentication. Cannot be set when SecretAccessKeyID is set. If
     * neither the Access Key nor Key ID are set, we fall-back to using env vars, shared credentials
     * file or AWS Instance metadata, see:
     * https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html#specifying-credentials
     *
     * @schema ChallengeSpecSolverDns01Route53#accessKeyID
     */
    readonly accessKeyId?: string;
    /**
     * The SecretAccessKey is used for authentication. If set, pull the AWS access key ID from a key
     * within a Kubernetes Secret. Cannot be set when AccessKeyID is set. If neither the Access Key
     * nor Key ID are set, we fall-back to using env vars, shared credentials file or AWS Instance
     * metadata, see:
     * https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html#specifying-credentials
     *
     * @schema ChallengeSpecSolverDns01Route53#accessKeyIDSecretRef
     */
    readonly accessKeyIdSecretRef?: ChallengeSpecSolverDns01Route53AccessKeyIdSecretRef;
    /**
     * Auth configures how cert-manager authenticates.
     *
     * @schema ChallengeSpecSolverDns01Route53#auth
     */
    readonly auth?: ChallengeSpecSolverDns01Route53Auth;
    /**
     * If set, the provider will manage only this zone in Route53 and will not do a lookup using the
     * route53:ListHostedZonesByName api call.
     *
     * @schema ChallengeSpecSolverDns01Route53#hostedZoneID
     */
    readonly hostedZoneId?: string;
    /**
     * Override the AWS region.
     *
     * Route53 is a global service and does not have regional endpoints but the region specified
     * here (or via environment variables) is used as a hint to help compute the correct AWS
     * credential scope and partition when it connects to Route53. See:
     *
     * - [Amazon Route 53 endpoints and
     *   quotas](https://docs.aws.amazon.com/general/latest/gr/r53.html)
     * - [Global
     *   services](https://docs.aws.amazon.com/whitepapers/latest/aws-fault-isolation-boundaries/global-services.html)
     *
     * If you omit this region field, cert-manager will use the region from AWS_REGION and
     * AWS_DEFAULT_REGION environment variables, if they are set in the cert-manager controller
     * Pod.
     *
     * The `region` field is not needed if you use [IAM Roles for Service Accounts
     * (IRSA)](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html).
     * Instead an AWS_REGION environment variable is added to the cert-manager controller Pod by:
     * [Amazon EKS Pod Identity Webhook](https://github.com/aws/amazon-eks-pod-identity-webhook). In
     * this case this `region` field value is ignored.
     *
     * The `region` field is not needed if you use [EKS Pod
     * Identities](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html). Instead an
     * AWS_REGION environment variable is added to the cert-manager controller Pod by: [Amazon EKS
     * Pod Identity Agent](https://github.com/aws/eks-pod-identity-agent), In this case this
     * `region` field value is ignored.
     *
     * @schema ChallengeSpecSolverDns01Route53#region
     */
    readonly region?: string;
    /**
     * Role is a Role ARN which the Route53 provider will assume using either the explicit
     * credentials AccessKeyID/SecretAccessKey or the inferred credentials from environment
     * variables, shared credentials file or AWS Instance metadata
     *
     * @schema ChallengeSpecSolverDns01Route53#role
     */
    readonly role?: string;
    /**
     * The SecretAccessKey is used for authentication. If neither the Access Key nor Key ID are set,
     * we fall-back to using env vars, shared credentials file or AWS Instance metadata, see:
     * https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html#specifying-credentials
     *
     * @schema ChallengeSpecSolverDns01Route53#secretAccessKeySecretRef
     */
    readonly secretAccessKeySecretRef?: ChallengeSpecSolverDns01Route53SecretAccessKeySecretRef;
}
/** Converts an object of type 'ChallengeSpecSolverDns01Route53' to JSON representation. */
export declare function toJson_ChallengeSpecSolverDns01Route53(obj: ChallengeSpecSolverDns01Route53 | undefined): Record<string, any> | undefined;
/**
 * Configure an external webhook based DNS01 challenge solver to manage DNS01 challenge records.
 *
 * @schema ChallengeSpecSolverDns01Webhook
 */
export interface ChallengeSpecSolverDns01Webhook {
    /**
     * Additional configuration that should be passed to the webhook apiserver when challenges are
     * processed. This can contain arbitrary JSON data. Secret values should not be specified in
     * this stanza. If secret values are needed (e.g. credentials for a DNS service), you should use
     * a SecretKeySelector to reference a Secret resource. For details on the schema of this field,
     * consult the webhook provider implementation's documentation.
     *
     * @schema ChallengeSpecSolverDns01Webhook#config
     */
    readonly config?: any;
    /**
     * The API group name that should be used when POSTing ChallengePayload resources to the webhook
     * apiserver. This should be the same as the GroupName specified in the webhook provider
     * implementation.
     *
     * @schema ChallengeSpecSolverDns01Webhook#groupName
     */
    readonly groupName: string;
    /**
     * The name of the solver to use, as defined in the webhook provider implementation. This will
     * typically be the name of the provider, e.g. 'cloudflare'.
     *
     * @schema ChallengeSpecSolverDns01Webhook#solverName
     */
    readonly solverName: string;
}
/** Converts an object of type 'ChallengeSpecSolverDns01Webhook' to JSON representation. */
export declare function toJson_ChallengeSpecSolverDns01Webhook(obj: ChallengeSpecSolverDns01Webhook | undefined): Record<string, any> | undefined;
/**
 * The Gateway API is a sig-network community API that models service networking in Kubernetes
 * (https://gateway-api.sigs.k8s.io/). The Gateway solver will create HTTPRoutes with the specified
 * labels in the same namespace as the challenge. This solver is experimental, and fields /
 * behaviour may change in the future.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoute
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoute {
    /**
     * Custom labels that will be applied to HTTPRoutes created by cert-manager while solving
     * HTTP-01 challenges.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoute#labels
     */
    readonly labels?: {
        [key: string]: string;
    };
    /**
     * When solving an HTTP-01 challenge, cert-manager creates an HTTPRoute. cert-manager needs to
     * know which parentRefs should be used when creating the HTTPRoute. Usually, the parentRef
     * references a Gateway. See:
     * https://gateway-api.sigs.k8s.io/api-types/httproute/#attaching-to-gateways
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoute#parentRefs
     */
    readonly parentRefs?: ChallengeSpecSolverHttp01GatewayHttpRouteParentRefs[];
    /**
     * Optional pod template used to configure the ACME challenge solver pods used for HTTP01
     * challenges.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoute#podTemplate
     */
    readonly podTemplate?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplate;
    /**
     * Optional service type for Kubernetes solver service. Supported values are NodePort or
     * ClusterIP. If unset, defaults to NodePort.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoute#serviceType
     */
    readonly serviceType?: string;
}
/** Converts an object of type 'ChallengeSpecSolverHttp01GatewayHttpRoute' to JSON representation. */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoute(obj: ChallengeSpecSolverHttp01GatewayHttpRoute | undefined): Record<string, any> | undefined;
/**
 * The ingress based HTTP01 challenge solver will solve challenges by creating or modifying Ingress
 * resources in order to route requests for '/.well-known/acme-challenge/XYZ' to 'challenge solver'
 * pods that are provisioned by cert-manager for each Challenge to be completed.
 *
 * @schema ChallengeSpecSolverHttp01Ingress
 */
export interface ChallengeSpecSolverHttp01Ingress {
    /**
     * This field configures the annotation `kubernetes.io/ingress.class` when creating Ingress
     * resources to solve ACME challenges that use this challenge solver. Only one of `class`,
     * `name` or `ingressClassName` may be specified.
     *
     * @schema ChallengeSpecSolverHttp01Ingress#class
     */
    readonly class?: string;
    /**
     * This field configures the field `ingressClassName` on the created Ingress resources used to
     * solve ACME challenges that use this challenge solver. This is the recommended way of
     * configuring the ingress class. Only one of `class`, `name` or `ingressClassName` may be
     * specified.
     *
     * @schema ChallengeSpecSolverHttp01Ingress#ingressClassName
     */
    readonly ingressClassName?: string;
    /**
     * Optional ingress template used to configure the ACME challenge solver ingress used for HTTP01
     * challenges.
     *
     * @schema ChallengeSpecSolverHttp01Ingress#ingressTemplate
     */
    readonly ingressTemplate?: ChallengeSpecSolverHttp01IngressIngressTemplate;
    /**
     * The name of the ingress resource that should have ACME challenge solving routes inserted into
     * it in order to solve HTTP01 challenges. This is typically used in conjunction with ingress
     * controllers like ingress-gce, which maintains a 1:1 mapping between external IPs and ingress
     * resources. Only one of `class`, `name` or `ingressClassName` may be specified.
     *
     * @schema ChallengeSpecSolverHttp01Ingress#name
     */
    readonly name?: string;
    /**
     * Optional pod template used to configure the ACME challenge solver pods used for HTTP01
     * challenges.
     *
     * @schema ChallengeSpecSolverHttp01Ingress#podTemplate
     */
    readonly podTemplate?: ChallengeSpecSolverHttp01IngressPodTemplate;
    /**
     * Optional service type for Kubernetes solver service. Supported values are NodePort or
     * ClusterIP. If unset, defaults to NodePort.
     *
     * @schema ChallengeSpecSolverHttp01Ingress#serviceType
     */
    readonly serviceType?: string;
}
/** Converts an object of type 'ChallengeSpecSolverHttp01Ingress' to JSON representation. */
export declare function toJson_ChallengeSpecSolverHttp01Ingress(obj: ChallengeSpecSolverHttp01Ingress | undefined): Record<string, any> | undefined;
/**
 * A reference to a specific 'key' within a Secret resource. In some instances, `key` is a required
 * field.
 *
 * @schema ChallengeSpecSolverDns01AcmeDnsAccountSecretRef
 */
export interface ChallengeSpecSolverDns01AcmeDnsAccountSecretRef {
    /**
     * The key of the entry in the Secret resource's `data` field to be used. Some instances of this
     * field may be defaulted, in others it may be required.
     *
     * @schema ChallengeSpecSolverDns01AcmeDnsAccountSecretRef#key
     */
    readonly key?: string;
    /**
     * Name of the resource being referred to. More info:
     * https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
     *
     * @schema ChallengeSpecSolverDns01AcmeDnsAccountSecretRef#name
     */
    readonly name: string;
}
/**
 * Converts an object of type 'ChallengeSpecSolverDns01AcmeDnsAccountSecretRef' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverDns01AcmeDnsAccountSecretRef(obj: ChallengeSpecSolverDns01AcmeDnsAccountSecretRef | undefined): Record<string, any> | undefined;
/**
 * A reference to a specific 'key' within a Secret resource. In some instances, `key` is a required
 * field.
 *
 * @schema ChallengeSpecSolverDns01AkamaiAccessTokenSecretRef
 */
export interface ChallengeSpecSolverDns01AkamaiAccessTokenSecretRef {
    /**
     * The key of the entry in the Secret resource's `data` field to be used. Some instances of this
     * field may be defaulted, in others it may be required.
     *
     * @schema ChallengeSpecSolverDns01AkamaiAccessTokenSecretRef#key
     */
    readonly key?: string;
    /**
     * Name of the resource being referred to. More info:
     * https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
     *
     * @schema ChallengeSpecSolverDns01AkamaiAccessTokenSecretRef#name
     */
    readonly name: string;
}
/**
 * Converts an object of type 'ChallengeSpecSolverDns01AkamaiAccessTokenSecretRef' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverDns01AkamaiAccessTokenSecretRef(obj: ChallengeSpecSolverDns01AkamaiAccessTokenSecretRef | undefined): Record<string, any> | undefined;
/**
 * A reference to a specific 'key' within a Secret resource. In some instances, `key` is a required
 * field.
 *
 * @schema ChallengeSpecSolverDns01AkamaiClientSecretSecretRef
 */
export interface ChallengeSpecSolverDns01AkamaiClientSecretSecretRef {
    /**
     * The key of the entry in the Secret resource's `data` field to be used. Some instances of this
     * field may be defaulted, in others it may be required.
     *
     * @schema ChallengeSpecSolverDns01AkamaiClientSecretSecretRef#key
     */
    readonly key?: string;
    /**
     * Name of the resource being referred to. More info:
     * https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
     *
     * @schema ChallengeSpecSolverDns01AkamaiClientSecretSecretRef#name
     */
    readonly name: string;
}
/**
 * Converts an object of type 'ChallengeSpecSolverDns01AkamaiClientSecretSecretRef' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverDns01AkamaiClientSecretSecretRef(obj: ChallengeSpecSolverDns01AkamaiClientSecretSecretRef | undefined): Record<string, any> | undefined;
/**
 * A reference to a specific 'key' within a Secret resource. In some instances, `key` is a required
 * field.
 *
 * @schema ChallengeSpecSolverDns01AkamaiClientTokenSecretRef
 */
export interface ChallengeSpecSolverDns01AkamaiClientTokenSecretRef {
    /**
     * The key of the entry in the Secret resource's `data` field to be used. Some instances of this
     * field may be defaulted, in others it may be required.
     *
     * @schema ChallengeSpecSolverDns01AkamaiClientTokenSecretRef#key
     */
    readonly key?: string;
    /**
     * Name of the resource being referred to. More info:
     * https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
     *
     * @schema ChallengeSpecSolverDns01AkamaiClientTokenSecretRef#name
     */
    readonly name: string;
}
/**
 * Converts an object of type 'ChallengeSpecSolverDns01AkamaiClientTokenSecretRef' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverDns01AkamaiClientTokenSecretRef(obj: ChallengeSpecSolverDns01AkamaiClientTokenSecretRef | undefined): Record<string, any> | undefined;
/**
 * Auth: Azure Service Principal: A reference to a Secret containing the password associated with
 * the Service Principal. If set, ClientID and TenantID must also be set.
 *
 * @schema ChallengeSpecSolverDns01AzureDnsClientSecretSecretRef
 */
export interface ChallengeSpecSolverDns01AzureDnsClientSecretSecretRef {
    /**
     * The key of the entry in the Secret resource's `data` field to be used. Some instances of this
     * field may be defaulted, in others it may be required.
     *
     * @schema ChallengeSpecSolverDns01AzureDnsClientSecretSecretRef#key
     */
    readonly key?: string;
    /**
     * Name of the resource being referred to. More info:
     * https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
     *
     * @schema ChallengeSpecSolverDns01AzureDnsClientSecretSecretRef#name
     */
    readonly name: string;
}
/**
 * Converts an object of type 'ChallengeSpecSolverDns01AzureDnsClientSecretSecretRef' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverDns01AzureDnsClientSecretSecretRef(obj: ChallengeSpecSolverDns01AzureDnsClientSecretSecretRef | undefined): Record<string, any> | undefined;
/**
 * Name of the Azure environment (default AzurePublicCloud)
 *
 * @schema ChallengeSpecSolverDns01AzureDnsEnvironment
 */
export declare enum ChallengeSpecSolverDns01AzureDnsEnvironment {
    /** AzurePublicCloud */
    AZURE_PUBLIC_CLOUD = "AzurePublicCloud",
    /** AzureChinaCloud */
    AZURE_CHINA_CLOUD = "AzureChinaCloud",
    /** AzureGermanCloud */
    AZURE_GERMAN_CLOUD = "AzureGermanCloud",
    /** AzureUSGovernmentCloud */
    AZURE_US_GOVERNMENT_CLOUD = "AzureUSGovernmentCloud"
}
/**
 * Auth: Azure Workload Identity or Azure Managed Service Identity: Settings to enable Azure
 * Workload Identity or Azure Managed Service Identity If set, ClientID, ClientSecret and TenantID
 * must not be set.
 *
 * @schema ChallengeSpecSolverDns01AzureDnsManagedIdentity
 */
export interface ChallengeSpecSolverDns01AzureDnsManagedIdentity {
    /**
     * Client ID of the managed identity, can not be used at the same time as resourceID
     *
     * @schema ChallengeSpecSolverDns01AzureDnsManagedIdentity#clientID
     */
    readonly clientId?: string;
    /**
     * Resource ID of the managed identity, can not be used at the same time as clientID Cannot be
     * used for Azure Managed Service Identity
     *
     * @schema ChallengeSpecSolverDns01AzureDnsManagedIdentity#resourceID
     */
    readonly resourceId?: string;
}
/**
 * Converts an object of type 'ChallengeSpecSolverDns01AzureDnsManagedIdentity' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverDns01AzureDnsManagedIdentity(obj: ChallengeSpecSolverDns01AzureDnsManagedIdentity | undefined): Record<string, any> | undefined;
/**
 * A reference to a specific 'key' within a Secret resource. In some instances, `key` is a required
 * field.
 *
 * @schema ChallengeSpecSolverDns01CloudDnsServiceAccountSecretRef
 */
export interface ChallengeSpecSolverDns01CloudDnsServiceAccountSecretRef {
    /**
     * The key of the entry in the Secret resource's `data` field to be used. Some instances of this
     * field may be defaulted, in others it may be required.
     *
     * @schema ChallengeSpecSolverDns01CloudDnsServiceAccountSecretRef#key
     */
    readonly key?: string;
    /**
     * Name of the resource being referred to. More info:
     * https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
     *
     * @schema ChallengeSpecSolverDns01CloudDnsServiceAccountSecretRef#name
     */
    readonly name: string;
}
/**
 * Converts an object of type 'ChallengeSpecSolverDns01CloudDnsServiceAccountSecretRef' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverDns01CloudDnsServiceAccountSecretRef(obj: ChallengeSpecSolverDns01CloudDnsServiceAccountSecretRef | undefined): Record<string, any> | undefined;
/**
 * API key to use to authenticate with Cloudflare. Note: using an API token to authenticate is now
 * the recommended method as it allows greater control of permissions.
 *
 * @schema ChallengeSpecSolverDns01CloudflareApiKeySecretRef
 */
export interface ChallengeSpecSolverDns01CloudflareApiKeySecretRef {
    /**
     * The key of the entry in the Secret resource's `data` field to be used. Some instances of this
     * field may be defaulted, in others it may be required.
     *
     * @schema ChallengeSpecSolverDns01CloudflareApiKeySecretRef#key
     */
    readonly key?: string;
    /**
     * Name of the resource being referred to. More info:
     * https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
     *
     * @schema ChallengeSpecSolverDns01CloudflareApiKeySecretRef#name
     */
    readonly name: string;
}
/**
 * Converts an object of type 'ChallengeSpecSolverDns01CloudflareApiKeySecretRef' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverDns01CloudflareApiKeySecretRef(obj: ChallengeSpecSolverDns01CloudflareApiKeySecretRef | undefined): Record<string, any> | undefined;
/**
 * API token used to authenticate with Cloudflare.
 *
 * @schema ChallengeSpecSolverDns01CloudflareApiTokenSecretRef
 */
export interface ChallengeSpecSolverDns01CloudflareApiTokenSecretRef {
    /**
     * The key of the entry in the Secret resource's `data` field to be used. Some instances of this
     * field may be defaulted, in others it may be required.
     *
     * @schema ChallengeSpecSolverDns01CloudflareApiTokenSecretRef#key
     */
    readonly key?: string;
    /**
     * Name of the resource being referred to. More info:
     * https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
     *
     * @schema ChallengeSpecSolverDns01CloudflareApiTokenSecretRef#name
     */
    readonly name: string;
}
/**
 * Converts an object of type 'ChallengeSpecSolverDns01CloudflareApiTokenSecretRef' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverDns01CloudflareApiTokenSecretRef(obj: ChallengeSpecSolverDns01CloudflareApiTokenSecretRef | undefined): Record<string, any> | undefined;
/**
 * A reference to a specific 'key' within a Secret resource. In some instances, `key` is a required
 * field.
 *
 * @schema ChallengeSpecSolverDns01DigitaloceanTokenSecretRef
 */
export interface ChallengeSpecSolverDns01DigitaloceanTokenSecretRef {
    /**
     * The key of the entry in the Secret resource's `data` field to be used. Some instances of this
     * field may be defaulted, in others it may be required.
     *
     * @schema ChallengeSpecSolverDns01DigitaloceanTokenSecretRef#key
     */
    readonly key?: string;
    /**
     * Name of the resource being referred to. More info:
     * https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
     *
     * @schema ChallengeSpecSolverDns01DigitaloceanTokenSecretRef#name
     */
    readonly name: string;
}
/**
 * Converts an object of type 'ChallengeSpecSolverDns01DigitaloceanTokenSecretRef' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverDns01DigitaloceanTokenSecretRef(obj: ChallengeSpecSolverDns01DigitaloceanTokenSecretRef | undefined): Record<string, any> | undefined;
/**
 * The name of the secret containing the TSIG value. If `tsigKeyName` is defined, this field is
 * required.
 *
 * @schema ChallengeSpecSolverDns01Rfc2136TsigSecretSecretRef
 */
export interface ChallengeSpecSolverDns01Rfc2136TsigSecretSecretRef {
    /**
     * The key of the entry in the Secret resource's `data` field to be used. Some instances of this
     * field may be defaulted, in others it may be required.
     *
     * @schema ChallengeSpecSolverDns01Rfc2136TsigSecretSecretRef#key
     */
    readonly key?: string;
    /**
     * Name of the resource being referred to. More info:
     * https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
     *
     * @schema ChallengeSpecSolverDns01Rfc2136TsigSecretSecretRef#name
     */
    readonly name: string;
}
/**
 * Converts an object of type 'ChallengeSpecSolverDns01Rfc2136TsigSecretSecretRef' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverDns01Rfc2136TsigSecretSecretRef(obj: ChallengeSpecSolverDns01Rfc2136TsigSecretSecretRef | undefined): Record<string, any> | undefined;
/**
 * The SecretAccessKey is used for authentication. If set, pull the AWS access key ID from a key
 * within a Kubernetes Secret. Cannot be set when AccessKeyID is set. If neither the Access Key nor
 * Key ID are set, we fall-back to using env vars, shared credentials file or AWS Instance metadata,
 * see:
 * https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html#specifying-credentials
 *
 * @schema ChallengeSpecSolverDns01Route53AccessKeyIdSecretRef
 */
export interface ChallengeSpecSolverDns01Route53AccessKeyIdSecretRef {
    /**
     * The key of the entry in the Secret resource's `data` field to be used. Some instances of this
     * field may be defaulted, in others it may be required.
     *
     * @schema ChallengeSpecSolverDns01Route53AccessKeyIdSecretRef#key
     */
    readonly key?: string;
    /**
     * Name of the resource being referred to. More info:
     * https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
     *
     * @schema ChallengeSpecSolverDns01Route53AccessKeyIdSecretRef#name
     */
    readonly name: string;
}
/**
 * Converts an object of type 'ChallengeSpecSolverDns01Route53AccessKeyIdSecretRef' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverDns01Route53AccessKeyIdSecretRef(obj: ChallengeSpecSolverDns01Route53AccessKeyIdSecretRef | undefined): Record<string, any> | undefined;
/**
 * Auth configures how cert-manager authenticates.
 *
 * @schema ChallengeSpecSolverDns01Route53Auth
 */
export interface ChallengeSpecSolverDns01Route53Auth {
    /**
     * Kubernetes authenticates with Route53 using AssumeRoleWithWebIdentity by passing a bound
     * ServiceAccount token.
     *
     * @schema ChallengeSpecSolverDns01Route53Auth#kubernetes
     */
    readonly kubernetes: ChallengeSpecSolverDns01Route53AuthKubernetes;
}
/** Converts an object of type 'ChallengeSpecSolverDns01Route53Auth' to JSON representation. */
export declare function toJson_ChallengeSpecSolverDns01Route53Auth(obj: ChallengeSpecSolverDns01Route53Auth | undefined): Record<string, any> | undefined;
/**
 * The SecretAccessKey is used for authentication. If neither the Access Key nor Key ID are set, we
 * fall-back to using env vars, shared credentials file or AWS Instance metadata, see:
 * https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html#specifying-credentials
 *
 * @schema ChallengeSpecSolverDns01Route53SecretAccessKeySecretRef
 */
export interface ChallengeSpecSolverDns01Route53SecretAccessKeySecretRef {
    /**
     * The key of the entry in the Secret resource's `data` field to be used. Some instances of this
     * field may be defaulted, in others it may be required.
     *
     * @schema ChallengeSpecSolverDns01Route53SecretAccessKeySecretRef#key
     */
    readonly key?: string;
    /**
     * Name of the resource being referred to. More info:
     * https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
     *
     * @schema ChallengeSpecSolverDns01Route53SecretAccessKeySecretRef#name
     */
    readonly name: string;
}
/**
 * Converts an object of type 'ChallengeSpecSolverDns01Route53SecretAccessKeySecretRef' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverDns01Route53SecretAccessKeySecretRef(obj: ChallengeSpecSolverDns01Route53SecretAccessKeySecretRef | undefined): Record<string, any> | undefined;
/**
 * ParentReference identifies an API object (usually a Gateway) that can be considered a parent of
 * this resource (usually a route). There are two kinds of parent resources with "Core" support:
 *
 * - Gateway (Gateway conformance profile)
 * - Service (Mesh conformance profile, ClusterIP Services only)
 *
 * This API may be extended in the future to support additional kinds of parent resources.
 *
 * The API object must be valid in the cluster; the Group and Kind must be registered in the cluster
 * for this reference to be valid.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRouteParentRefs
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRouteParentRefs {
    /**
     * Group is the group of the referent. When unspecified, "gateway.networking.k8s.io" is
     * inferred. To set the core API group (such as for a "Service" kind referent), Group must be
     * explicitly set to "" (empty string).
     *
     * Support: Core
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRouteParentRefs#group
     */
    readonly group?: string;
    /**
     * Kind is kind of the referent.
     *
     * There are two kinds of parent resources with "Core" support:
     *
     * - Gateway (Gateway conformance profile)
     * - Service (Mesh conformance profile, ClusterIP Services only)
     *
     * Support for other resources is Implementation-Specific.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRouteParentRefs#kind
     */
    readonly kind?: string;
    /**
     * Name is the name of the referent.
     *
     * Support: Core
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRouteParentRefs#name
     */
    readonly name: string;
    /**
     * Namespace is the namespace of the referent. When unspecified, this refers to the local
     * namespace of the Route.
     *
     * Note that there are specific rules for ParentRefs which cross namespace boundaries.
     * Cross-namespace references are only valid if they are explicitly allowed by something in the
     * namespace they are referring to. For example: Gateway has the AllowedRoutes field, and
     * ReferenceGrant provides a generic way to enable any other kind of cross-namespace reference.
     *
     * [gateway:experimental:description](gateway:experimental:description) ParentRefs from a Route
     * to a Service in the same namespace are "producer" routes, which apply default routing rules
     * to inbound connections from any namespace to the Service.
     *
     * ParentRefs from a Route to a Service in a different namespace are "consumer" routes, and
     * these routing rules are only applied to outbound connections originating from the same
     * namespace as the Route, for which the intended destination of the connections are a Service
     * targeted as a ParentRef of the Route. </gateway:experimental:description>
     *
     * Support: Core
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRouteParentRefs#namespace
     */
    readonly namespace?: string;
    /**
     * Port is the network port this Route targets. It can be interpreted differently based on the
     * type of parent resource.
     *
     * When the parent resource is a Gateway, this targets all listeners listening on the specified
     * port that also support this kind of Route(and select this Route). It's not recommended to set
     * `Port` unless the networking behaviors specified in a Route must apply to a specific port as
     * opposed to a listener(s) whose port(s) may be changed. When both Port and SectionName are
     * specified, the name and port of the selected listener must match both specified values.
     *
     * [gateway:experimental:description](gateway:experimental:description) When the parent resource
     * is a Service, this targets a specific port in the Service spec. When both Port (experimental)
     * and SectionName are specified, the name and port of the selected port must match both
     * specified values. </gateway:experimental:description>
     *
     * Implementations MAY choose to support other parent resources. Implementations supporting
     * other types of parent resources MUST clearly document how/if Port is interpreted.
     *
     * For the purpose of status, an attachment is considered successful as long as the parent
     * resource accepts it partially. For example, Gateway listeners can restrict which Routes can
     * attach to them by Route kind, namespace, or hostname. If 1 of 2 Gateway listeners accept
     * attachment from the referencing Route, the Route MUST be considered successfully attached. If
     * no Gateway listeners accept attachment from this Route, the Route MUST be considered detached
     * from the Gateway.
     *
     * Support: Extended
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRouteParentRefs#port
     */
    readonly port?: number;
    /**
     * SectionName is the name of a section within the target resource. In the following resources,
     * SectionName is interpreted as the following:
     *
     * - Gateway: Listener name. When both Port (experimental) and SectionName are specified, the name
     *   and port of the selected listener must match both specified values.
     * - Service: Port name. When both Port (experimental) and SectionName are specified, the name and
     *   port of the selected listener must match both specified values.
     *
     * Implementations MAY choose to support attaching Routes to other resources. If that is the
     * case, they MUST clearly document how SectionName is interpreted.
     *
     * When unspecified (empty string), this will reference the entire resource. For the purpose of
     * status, an attachment is considered successful if at least one section in the parent resource
     * accepts it. For example, Gateway listeners can restrict which Routes can attach to them by
     * Route kind, namespace, or hostname. If 1 of 2 Gateway listeners accept attachment from the
     * referencing Route, the Route MUST be considered successfully attached. If no Gateway
     * listeners accept attachment from this Route, the Route MUST be considered detached from the
     * Gateway.
     *
     * Support: Core
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRouteParentRefs#sectionName
     */
    readonly sectionName?: string;
}
/**
 * Converts an object of type 'ChallengeSpecSolverHttp01GatewayHttpRouteParentRefs' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRouteParentRefs(obj: ChallengeSpecSolverHttp01GatewayHttpRouteParentRefs | undefined): Record<string, any> | undefined;
/**
 * Optional pod template used to configure the ACME challenge solver pods used for HTTP01
 * challenges.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplate
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplate {
    /**
     * ObjectMeta overrides for the pod used to solve HTTP01 challenges. Only the 'labels' and
     * 'annotations' fields may be set. If labels or annotations overlap with in-built values, the
     * values here will override the in-built values.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplate#metadata
     */
    readonly metadata?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateMetadata;
    /**
     * PodSpec defines overrides for the HTTP01 challenge solver pod. Check
     * ACMEChallengeSolverHTTP01IngressPodSpec to find out currently supported fields. All other
     * fields will be ignored.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplate#spec
     */
    readonly spec?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpec;
}
/**
 * Converts an object of type 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplate' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplate(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplate | undefined): Record<string, any> | undefined;
/**
 * Optional ingress template used to configure the ACME challenge solver ingress used for HTTP01
 * challenges.
 *
 * @schema ChallengeSpecSolverHttp01IngressIngressTemplate
 */
export interface ChallengeSpecSolverHttp01IngressIngressTemplate {
    /**
     * ObjectMeta overrides for the ingress used to solve HTTP01 challenges. Only the 'labels' and
     * 'annotations' fields may be set. If labels or annotations overlap with in-built values, the
     * values here will override the in-built values.
     *
     * @schema ChallengeSpecSolverHttp01IngressIngressTemplate#metadata
     */
    readonly metadata?: ChallengeSpecSolverHttp01IngressIngressTemplateMetadata;
}
/**
 * Converts an object of type 'ChallengeSpecSolverHttp01IngressIngressTemplate' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressIngressTemplate(obj: ChallengeSpecSolverHttp01IngressIngressTemplate | undefined): Record<string, any> | undefined;
/**
 * Optional pod template used to configure the ACME challenge solver pods used for HTTP01
 * challenges.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplate
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplate {
    /**
     * ObjectMeta overrides for the pod used to solve HTTP01 challenges. Only the 'labels' and
     * 'annotations' fields may be set. If labels or annotations overlap with in-built values, the
     * values here will override the in-built values.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplate#metadata
     */
    readonly metadata?: ChallengeSpecSolverHttp01IngressPodTemplateMetadata;
    /**
     * PodSpec defines overrides for the HTTP01 challenge solver pod. Check
     * ACMEChallengeSolverHTTP01IngressPodSpec to find out currently supported fields. All other
     * fields will be ignored.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplate#spec
     */
    readonly spec?: ChallengeSpecSolverHttp01IngressPodTemplateSpec;
}
/** Converts an object of type 'ChallengeSpecSolverHttp01IngressPodTemplate' to JSON representation. */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplate(obj: ChallengeSpecSolverHttp01IngressPodTemplate | undefined): Record<string, any> | undefined;
/**
 * Kubernetes authenticates with Route53 using AssumeRoleWithWebIdentity by passing a bound
 * ServiceAccount token.
 *
 * @schema ChallengeSpecSolverDns01Route53AuthKubernetes
 */
export interface ChallengeSpecSolverDns01Route53AuthKubernetes {
    /**
     * A reference to a service account that will be used to request a bound token (also known as
     * "projected token"). To use this field, you must configure an RBAC rule to let cert-manager
     * request a token.
     *
     * @schema ChallengeSpecSolverDns01Route53AuthKubernetes#serviceAccountRef
     */
    readonly serviceAccountRef: ChallengeSpecSolverDns01Route53AuthKubernetesServiceAccountRef;
}
/**
 * Converts an object of type 'ChallengeSpecSolverDns01Route53AuthKubernetes' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverDns01Route53AuthKubernetes(obj: ChallengeSpecSolverDns01Route53AuthKubernetes | undefined): Record<string, any> | undefined;
/**
 * ObjectMeta overrides for the pod used to solve HTTP01 challenges. Only the 'labels' and
 * 'annotations' fields may be set. If labels or annotations overlap with in-built values, the
 * values here will override the in-built values.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateMetadata
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateMetadata {
    /**
     * Annotations that should be added to the created ACME HTTP01 solver pods.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateMetadata#annotations
     */
    readonly annotations?: {
        [key: string]: string;
    };
    /**
     * Labels that should be added to the created ACME HTTP01 solver pods.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateMetadata#labels
     */
    readonly labels?: {
        [key: string]: string;
    };
}
/**
 * Converts an object of type 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateMetadata' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateMetadata(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateMetadata | undefined): Record<string, any> | undefined;
/**
 * PodSpec defines overrides for the HTTP01 challenge solver pod. Check
 * ACMEChallengeSolverHTTP01IngressPodSpec to find out currently supported fields. All other fields
 * will be ignored.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpec
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpec {
    /**
     * If specified, the pod's scheduling constraints
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpec#affinity
     */
    readonly affinity?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinity;
    /**
     * If specified, the pod's imagePullSecrets
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpec#imagePullSecrets
     */
    readonly imagePullSecrets?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecImagePullSecrets[];
    /**
     * 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/
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpec#nodeSelector
     */
    readonly nodeSelector?: {
        [key: string]: string;
    };
    /**
     * If specified, the pod's priorityClassName.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpec#priorityClassName
     */
    readonly priorityClassName?: string;
    /**
     * If specified, the pod's security context
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpec#securityContext
     */
    readonly securityContext?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContext;
    /**
     * If specified, the pod's service account
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpec#serviceAccountName
     */
    readonly serviceAccountName?: string;
    /**
     * If specified, the pod's tolerations.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpec#tolerations
     */
    readonly tolerations?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecTolerations[];
}
/**
 * Converts an object of type 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpec' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpec(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpec | undefined): Record<string, any> | undefined;
/**
 * ObjectMeta overrides for the ingress used to solve HTTP01 challenges. Only the 'labels' and
 * 'annotations' fields may be set. If labels or annotations overlap with in-built values, the
 * values here will override the in-built values.
 *
 * @schema ChallengeSpecSolverHttp01IngressIngressTemplateMetadata
 */
export interface ChallengeSpecSolverHttp01IngressIngressTemplateMetadata {
    /**
     * Annotations that should be added to the created ACME HTTP01 solver ingress.
     *
     * @schema ChallengeSpecSolverHttp01IngressIngressTemplateMetadata#annotations
     */
    readonly annotations?: {
        [key: string]: string;
    };
    /**
     * Labels that should be added to the created ACME HTTP01 solver ingress.
     *
     * @schema ChallengeSpecSolverHttp01IngressIngressTemplateMetadata#labels
     */
    readonly labels?: {
        [key: string]: string;
    };
}
/**
 * Converts an object of type 'ChallengeSpecSolverHttp01IngressIngressTemplateMetadata' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressIngressTemplateMetadata(obj: ChallengeSpecSolverHttp01IngressIngressTemplateMetadata | undefined): Record<string, any> | undefined;
/**
 * ObjectMeta overrides for the pod used to solve HTTP01 challenges. Only the 'labels' and
 * 'annotations' fields may be set. If labels or annotations overlap with in-built values, the
 * values here will override the in-built values.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateMetadata
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateMetadata {
    /**
     * Annotations that should be added to the created ACME HTTP01 solver pods.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateMetadata#annotations
     */
    readonly annotations?: {
        [key: string]: string;
    };
    /**
     * Labels that should be added to the created ACME HTTP01 solver pods.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateMetadata#labels
     */
    readonly labels?: {
        [key: string]: string;
    };
}
/**
 * Converts an object of type 'ChallengeSpecSolverHttp01IngressPodTemplateMetadata' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateMetadata(obj: ChallengeSpecSolverHttp01IngressPodTemplateMetadata | undefined): Record<string, any> | undefined;
/**
 * PodSpec defines overrides for the HTTP01 challenge solver pod. Check
 * ACMEChallengeSolverHTTP01IngressPodSpec to find out currently supported fields. All other fields
 * will be ignored.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpec
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpec {
    /**
     * If specified, the pod's scheduling constraints
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpec#affinity
     */
    readonly affinity?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinity;
    /**
     * If specified, the pod's imagePullSecrets
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpec#imagePullSecrets
     */
    readonly imagePullSecrets?: ChallengeSpecSolverHttp01IngressPodTemplateSpecImagePullSecrets[];
    /**
     * 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/
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpec#nodeSelector
     */
    readonly nodeSelector?: {
        [key: string]: string;
    };
    /**
     * If specified, the pod's priorityClassName.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpec#priorityClassName
     */
    readonly priorityClassName?: string;
    /**
     * If specified, the pod's security context
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpec#securityContext
     */
    readonly securityContext?: ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContext;
    /**
     * If specified, the pod's service account
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpec#serviceAccountName
     */
    readonly serviceAccountName?: string;
    /**
     * If specified, the pod's tolerations.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpec#tolerations
     */
    readonly tolerations?: ChallengeSpecSolverHttp01IngressPodTemplateSpecTolerations[];
}
/**
 * Converts an object of type 'ChallengeSpecSolverHttp01IngressPodTemplateSpec' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpec(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpec | undefined): Record<string, any> | undefined;
/**
 * A reference to a service account that will be used to request a bound token (also known as
 * "projected token"). To use this field, you must configure an RBAC rule to let cert-manager
 * request a token.
 *
 * @schema ChallengeSpecSolverDns01Route53AuthKubernetesServiceAccountRef
 */
export interface ChallengeSpecSolverDns01Route53AuthKubernetesServiceAccountRef {
    /**
     * TokenAudiences is an optional list of audiences to include in the token passed to AWS. The
     * default token consisting of the issuer's namespace and name is always included. If unset the
     * audience defaults to `sts.amazonaws.com`.
     *
     * @schema ChallengeSpecSolverDns01Route53AuthKubernetesServiceAccountRef#audiences
     */
    readonly audiences?: string[];
    /**
     * Name of the ServiceAccount used to request a token.
     *
     * @schema ChallengeSpecSolverDns01Route53AuthKubernetesServiceAccountRef#name
     */
    readonly name: string;
}
/**
 * Converts an object of type 'ChallengeSpecSolverDns01Route53AuthKubernetesServiceAccountRef' to
 * JSON representation.
 */
export declare function toJson_ChallengeSpecSolverDns01Route53AuthKubernetesServiceAccountRef(obj: ChallengeSpecSolverDns01Route53AuthKubernetesServiceAccountRef | undefined): Record<string, any> | undefined;
/**
 * If specified, the pod's scheduling constraints
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinity
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinity {
    /**
     * Describes node affinity scheduling rules for the pod.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinity#nodeAffinity
     */
    readonly nodeAffinity?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinity;
    /**
     * Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc.
     * as some other pod(s)).
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinity#podAffinity
     */
    readonly podAffinity?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinity;
    /**
     * Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node,
     * zone, etc. as some other pod(s)).
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinity#podAntiAffinity
     */
    readonly podAntiAffinity?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinity;
}
/**
 * Converts an object of type 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinity' to
 * JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinity(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinity | undefined): Record<string, any> | undefined;
/**
 * LocalObjectReference contains enough information to let you locate the referenced object inside
 * the same namespace.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecImagePullSecrets
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecImagePullSecrets {
    /**
     * Name of the referent. This field is effectively required, but due to backwards compatibility
     * is allowed to be empty. Instances of this type with an empty value here are almost certainly
     * wrong. More info:
     * https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecImagePullSecrets#name
     */
    readonly name?: string;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecImagePullSecrets' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecImagePullSecrets(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecImagePullSecrets | undefined): Record<string, any> | undefined;
/**
 * If specified, the pod's security context
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContext
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContext {
    /**
     * A special supplemental group that applies to all containers in a pod. Some volume types allow
     * the Kubelet to change the ownership of that volume to be owned by the pod:
     *
     * 1. The owning GID will be the FSGroup
     * 2. The setgid bit is set (new files created in the volume will be owned by FSGroup)
     * 3. The permission bits are OR'd with rw-rw----
     *
     * If unset, the Kubelet will not modify the ownership and permissions of any volume. Note that
     * this field cannot be set when spec.os.name is windows.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContext#fsGroup
     */
    readonly fsGroup?: number;
    /**
     * FsGroupChangePolicy defines behavior of changing ownership and permission of the volume
     * before being exposed inside Pod. This field will only apply to volume types which support
     * fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types
     * such as: secret, configmaps and emptydir. Valid values are "OnRootMismatch" and "Always". If
     * not specified, "Always" is used. Note that this field cannot be set when spec.os.name is
     * windows.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContext#fsGroupChangePolicy
     */
    readonly fsGroupChangePolicy?: string;
    /**
     * The GID to run the entrypoint of the container process. Uses runtime default if unset. May
     * also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the
     * value specified in SecurityContext takes precedence for that container. Note that this field
     * cannot be set when spec.os.name is windows.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContext#runAsGroup
     */
    readonly runAsGroup?: number;
    /**
     * Indicates that the container must run as a non-root user. If true, the Kubelet will validate
     * the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the
     * container if it does. If unset or false, no such validation will be performed. May also be
     * set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value
     * specified in SecurityContext takes precedence.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContext#runAsNonRoot
     */
    readonly runAsNonRoot?: boolean;
    /**
     * The UID to run the entrypoint of the container process. Defaults to user specified in image
     * metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext
     * and PodSecurityContext, the value specified in SecurityContext takes precedence for that
     * container. Note that this field cannot be set when spec.os.name is windows.
     *
     * @default user specified in image metadata if unspecified.
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContext#runAsUser
     */
    readonly runAsUser?: number;
    /**
     * The SELinux context to be applied to all containers. If unspecified, the container runtime
     * will allocate a random SELinux context for each container. May also be set in
     * SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified
     * in SecurityContext takes precedence for that container. Note that this field cannot be set
     * when spec.os.name is windows.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContext#seLinuxOptions
     */
    readonly seLinuxOptions?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSeLinuxOptions;
    /**
     * The seccomp options to use by the containers in this pod. Note that this field cannot be set
     * when spec.os.name is windows.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContext#seccompProfile
     */
    readonly seccompProfile?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSeccompProfile;
    /**
     * A list of groups applied to the first process run in each container, in addition to the
     * container's primary GID, the fsGroup (if specified), and group memberships defined in the
     * container image for the uid of the container process. If unspecified, no additional groups
     * are added to any container. Note that group memberships defined in the container image for
     * the uid of the container process are still effective, even if they are not included in this
     * list. Note that this field cannot be set when spec.os.name is windows.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContext#supplementalGroups
     */
    readonly supplementalGroups?: number[];
    /**
     * Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by
     * the container runtime) might fail to launch. Note that this field cannot be set when
     * spec.os.name is windows.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContext#sysctls
     */
    readonly sysctls?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSysctls[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContext' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContext(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContext | undefined): Record<string, any> | undefined;
/**
 * The pod this Toleration is attached to tolerates any taint that matches the triple
 * <key,value,effect> using the matching operator <operator>.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecTolerations
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecTolerations {
    /**
     * Effect indicates the taint effect to match. Empty means match all taint effects. When
     * specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecTolerations#effect
     */
    readonly effect?: string;
    /**
     * Key is the taint key that the toleration applies to. Empty means match all taint keys. If the
     * key is empty, operator must be Exists; this combination means to match all values and all
     * keys.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecTolerations#key
     */
    readonly key?: string;
    /**
     * Operator represents a key's relationship to the value. Valid operators are Exists and Equal.
     * Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all
     * taints of a particular category.
     *
     * @default Equal.
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecTolerations#operator
     */
    readonly operator?: string;
    /**
     * TolerationSeconds represents the period of time the toleration (which must be of effect
     * NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set,
     * which means tolerate the taint forever (do not evict). Zero and negative values will be
     * treated as 0 (evict immediately) by the system.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecTolerations#tolerationSeconds
     */
    readonly tolerationSeconds?: number;
    /**
     * Value is the taint value the toleration matches to. If the operator is Exists, the value
     * should be empty, otherwise just a regular string.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecTolerations#value
     */
    readonly value?: string;
}
/**
 * Converts an object of type 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecTolerations'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecTolerations(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecTolerations | undefined): Record<string, any> | undefined;
/**
 * If specified, the pod's scheduling constraints
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinity
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinity {
    /**
     * Describes node affinity scheduling rules for the pod.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinity#nodeAffinity
     */
    readonly nodeAffinity?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinity;
    /**
     * Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc.
     * as some other pod(s)).
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinity#podAffinity
     */
    readonly podAffinity?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinity;
    /**
     * Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node,
     * zone, etc. as some other pod(s)).
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinity#podAntiAffinity
     */
    readonly podAntiAffinity?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinity;
}
/**
 * Converts an object of type 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinity' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinity(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinity | undefined): Record<string, any> | undefined;
/**
 * LocalObjectReference contains enough information to let you locate the referenced object inside
 * the same namespace.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecImagePullSecrets
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecImagePullSecrets {
    /**
     * Name of the referent. This field is effectively required, but due to backwards compatibility
     * is allowed to be empty. Instances of this type with an empty value here are almost certainly
     * wrong. More info:
     * https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecImagePullSecrets#name
     */
    readonly name?: string;
}
/**
 * Converts an object of type 'ChallengeSpecSolverHttp01IngressPodTemplateSpecImagePullSecrets' to
 * JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecImagePullSecrets(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecImagePullSecrets | undefined): Record<string, any> | undefined;
/**
 * If specified, the pod's security context
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContext
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContext {
    /**
     * A special supplemental group that applies to all containers in a pod. Some volume types allow
     * the Kubelet to change the ownership of that volume to be owned by the pod:
     *
     * 1. The owning GID will be the FSGroup
     * 2. The setgid bit is set (new files created in the volume will be owned by FSGroup)
     * 3. The permission bits are OR'd with rw-rw----
     *
     * If unset, the Kubelet will not modify the ownership and permissions of any volume. Note that
     * this field cannot be set when spec.os.name is windows.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContext#fsGroup
     */
    readonly fsGroup?: number;
    /**
     * FsGroupChangePolicy defines behavior of changing ownership and permission of the volume
     * before being exposed inside Pod. This field will only apply to volume types which support
     * fsGroup based ownership(and permissions). It will have no effect on ephemeral volume types
     * such as: secret, configmaps and emptydir. Valid values are "OnRootMismatch" and "Always". If
     * not specified, "Always" is used. Note that this field cannot be set when spec.os.name is
     * windows.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContext#fsGroupChangePolicy
     */
    readonly fsGroupChangePolicy?: string;
    /**
     * The GID to run the entrypoint of the container process. Uses runtime default if unset. May
     * also be set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the
     * value specified in SecurityContext takes precedence for that container. Note that this field
     * cannot be set when spec.os.name is windows.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContext#runAsGroup
     */
    readonly runAsGroup?: number;
    /**
     * Indicates that the container must run as a non-root user. If true, the Kubelet will validate
     * the image at runtime to ensure that it does not run as UID 0 (root) and fail to start the
     * container if it does. If unset or false, no such validation will be performed. May also be
     * set in SecurityContext. If set in both SecurityContext and PodSecurityContext, the value
     * specified in SecurityContext takes precedence.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContext#runAsNonRoot
     */
    readonly runAsNonRoot?: boolean;
    /**
     * The UID to run the entrypoint of the container process. Defaults to user specified in image
     * metadata if unspecified. May also be set in SecurityContext. If set in both SecurityContext
     * and PodSecurityContext, the value specified in SecurityContext takes precedence for that
     * container. Note that this field cannot be set when spec.os.name is windows.
     *
     * @default user specified in image metadata if unspecified.
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContext#runAsUser
     */
    readonly runAsUser?: number;
    /**
     * The SELinux context to be applied to all containers. If unspecified, the container runtime
     * will allocate a random SELinux context for each container. May also be set in
     * SecurityContext. If set in both SecurityContext and PodSecurityContext, the value specified
     * in SecurityContext takes precedence for that container. Note that this field cannot be set
     * when spec.os.name is windows.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContext#seLinuxOptions
     */
    readonly seLinuxOptions?: ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSeLinuxOptions;
    /**
     * The seccomp options to use by the containers in this pod. Note that this field cannot be set
     * when spec.os.name is windows.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContext#seccompProfile
     */
    readonly seccompProfile?: ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSeccompProfile;
    /**
     * A list of groups applied to the first process run in each container, in addition to the
     * container's primary GID, the fsGroup (if specified), and group memberships defined in the
     * container image for the uid of the container process. If unspecified, no additional groups
     * are added to any container. Note that group memberships defined in the container image for
     * the uid of the container process are still effective, even if they are not included in this
     * list. Note that this field cannot be set when spec.os.name is windows.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContext#supplementalGroups
     */
    readonly supplementalGroups?: number[];
    /**
     * Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by
     * the container runtime) might fail to launch. Note that this field cannot be set when
     * spec.os.name is windows.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContext#sysctls
     */
    readonly sysctls?: ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSysctls[];
}
/**
 * Converts an object of type 'ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContext' to
 * JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContext(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContext | undefined): Record<string, any> | undefined;
/**
 * The pod this Toleration is attached to tolerates any taint that matches the triple
 * <key,value,effect> using the matching operator <operator>.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecTolerations
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecTolerations {
    /**
     * Effect indicates the taint effect to match. Empty means match all taint effects. When
     * specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecTolerations#effect
     */
    readonly effect?: string;
    /**
     * Key is the taint key that the toleration applies to. Empty means match all taint keys. If the
     * key is empty, operator must be Exists; this combination means to match all values and all
     * keys.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecTolerations#key
     */
    readonly key?: string;
    /**
     * Operator represents a key's relationship to the value. Valid operators are Exists and Equal.
     * Defaults to Equal. Exists is equivalent to wildcard for value, so that a pod can tolerate all
     * taints of a particular category.
     *
     * @default Equal.
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecTolerations#operator
     */
    readonly operator?: string;
    /**
     * TolerationSeconds represents the period of time the toleration (which must be of effect
     * NoExecute, otherwise this field is ignored) tolerates the taint. By default, it is not set,
     * which means tolerate the taint forever (do not evict). Zero and negative values will be
     * treated as 0 (evict immediately) by the system.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecTolerations#tolerationSeconds
     */
    readonly tolerationSeconds?: number;
    /**
     * Value is the taint value the toleration matches to. If the operator is Exists, the value
     * should be empty, otherwise just a regular string.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecTolerations#value
     */
    readonly value?: string;
}
/**
 * Converts an object of type 'ChallengeSpecSolverHttp01IngressPodTemplateSpecTolerations' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecTolerations(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecTolerations | undefined): Record<string, any> | undefined;
/**
 * Describes node affinity scheduling rules for the pod.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinity
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinity {
    /**
     * The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions
     * specified by this field, but it may choose a node that violates one or more of the
     * expressions. The node that is most preferred is the one with the greatest sum of weights,
     * i.e. for each node that meets all of the scheduling requirements (resource request,
     * requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the
     * elements of this field and adding "weight" to the sum if the node matches the corresponding
     * matchExpressions; the node(s) with the highest sum are the most preferred.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinity#preferredDuringSchedulingIgnoredDuringExecution
     */
    readonly preferredDuringSchedulingIgnoredDuringExecution?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution[];
    /**
     * If the affinity requirements specified by this field are not met at scheduling time, the pod
     * will not be scheduled onto the node. If the affinity requirements specified by this field
     * cease to be met at some point during pod execution (e.g. due to an update), the system may or
     * may not try to eventually evict the pod from its node.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinity#requiredDuringSchedulingIgnoredDuringExecution
     */
    readonly requiredDuringSchedulingIgnoredDuringExecution?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinity' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinity(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinity | undefined): Record<string, any> | undefined;
/**
 * Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as
 * some other pod(s)).
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinity
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinity {
    /**
     * The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions
     * specified by this field, but it may choose a node that violates one or more of the
     * expressions. The node that is most preferred is the one with the greatest sum of weights,
     * i.e. for each node that meets all of the scheduling requirements (resource request,
     * requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the
     * elements of this field and adding "weight" to the sum if the node has pods which matches the
     * corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinity#preferredDuringSchedulingIgnoredDuringExecution
     */
    readonly preferredDuringSchedulingIgnoredDuringExecution?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution[];
    /**
     * If the affinity requirements specified by this field are not met at scheduling time, the pod
     * will not be scheduled onto the node. If the affinity requirements specified by this field
     * cease to be met at some point during pod execution (e.g. due to a pod label update), the
     * system may or may not try to eventually evict the pod from its node. When there are multiple
     * elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all
     * terms must be satisfied.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinity#requiredDuringSchedulingIgnoredDuringExecution
     */
    readonly requiredDuringSchedulingIgnoredDuringExecution?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinity' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinity(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinity | undefined): Record<string, any> | undefined;
/**
 * Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone,
 * etc. as some other pod(s)).
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinity
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinity {
    /**
     * The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity
     * expressions specified by this field, but it may choose a node that violates one or more of
     * the expressions. The node that is most preferred is the one with the greatest sum of weights,
     * i.e. for each node that meets all of the scheduling requirements (resource request,
     * requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through
     * the elements of this field and adding "weight" to the sum if the node has pods which matches
     * the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinity#preferredDuringSchedulingIgnoredDuringExecution
     */
    readonly preferredDuringSchedulingIgnoredDuringExecution?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution[];
    /**
     * If the anti-affinity requirements specified by this field are not met at scheduling time, the
     * pod will not be scheduled onto the node. If the anti-affinity requirements specified by this
     * field cease to be met at some point during pod execution (e.g. due to a pod label update),
     * the system may or may not try to eventually evict the pod from its node. When there are
     * multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected,
     * i.e. all terms must be satisfied.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinity#requiredDuringSchedulingIgnoredDuringExecution
     */
    readonly requiredDuringSchedulingIgnoredDuringExecution?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinity' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinity(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinity | undefined): Record<string, any> | undefined;
/**
 * The SELinux context to be applied to all containers. If unspecified, the container runtime will
 * allocate a random SELinux context for each container. May also be set in SecurityContext. If set
 * in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes
 * precedence for that container. Note that this field cannot be set when spec.os.name is windows.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSeLinuxOptions
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSeLinuxOptions {
    /**
     * Level is SELinux level label that applies to the container.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSeLinuxOptions#level
     */
    readonly level?: string;
    /**
     * Role is a SELinux role label that applies to the container.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSeLinuxOptions#role
     */
    readonly role?: string;
    /**
     * Type is a SELinux type label that applies to the container.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSeLinuxOptions#type
     */
    readonly type?: string;
    /**
     * User is a SELinux user label that applies to the container.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSeLinuxOptions#user
     */
    readonly user?: string;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSeLinuxOptions' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSeLinuxOptions(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSeLinuxOptions | undefined): Record<string, any> | undefined;
/**
 * The seccomp options to use by the containers in this pod. Note that this field cannot be set when
 * spec.os.name is windows.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSeccompProfile
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSeccompProfile {
    /**
     * LocalhostProfile indicates a profile defined in a file on the node should be used. The
     * profile must be preconfigured on the node to work. Must be a descending path, relative to the
     * kubelet's configured seccomp profile location. Must be set if type is "Localhost". Must NOT
     * be set for any other type.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSeccompProfile#localhostProfile
     */
    readonly localhostProfile?: string;
    /**
     * Type indicates which kind of seccomp profile will be applied. Valid options are:
     *
     * Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the
     * container runtime default profile should be used. Unconfined - no profile should be applied.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSeccompProfile#type
     */
    readonly type: string;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSeccompProfile' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSeccompProfile(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSeccompProfile | undefined): Record<string, any> | undefined;
/**
 * Sysctl defines a kernel parameter to be set
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSysctls
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSysctls {
    /**
     * Name of a property to set
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSysctls#name
     */
    readonly name: string;
    /**
     * Value of a property to set
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSysctls#value
     */
    readonly value: string;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSysctls' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSysctls(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecSecurityContextSysctls | undefined): Record<string, any> | undefined;
/**
 * Describes node affinity scheduling rules for the pod.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinity
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinity {
    /**
     * The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions
     * specified by this field, but it may choose a node that violates one or more of the
     * expressions. The node that is most preferred is the one with the greatest sum of weights,
     * i.e. for each node that meets all of the scheduling requirements (resource request,
     * requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the
     * elements of this field and adding "weight" to the sum if the node matches the corresponding
     * matchExpressions; the node(s) with the highest sum are the most preferred.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinity#preferredDuringSchedulingIgnoredDuringExecution
     */
    readonly preferredDuringSchedulingIgnoredDuringExecution?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution[];
    /**
     * If the affinity requirements specified by this field are not met at scheduling time, the pod
     * will not be scheduled onto the node. If the affinity requirements specified by this field
     * cease to be met at some point during pod execution (e.g. due to an update), the system may or
     * may not try to eventually evict the pod from its node.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinity#requiredDuringSchedulingIgnoredDuringExecution
     */
    readonly requiredDuringSchedulingIgnoredDuringExecution?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution;
}
/**
 * Converts an object of type 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinity'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinity(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinity | undefined): Record<string, any> | undefined;
/**
 * Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as
 * some other pod(s)).
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinity
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinity {
    /**
     * The scheduler will prefer to schedule pods to nodes that satisfy the affinity expressions
     * specified by this field, but it may choose a node that violates one or more of the
     * expressions. The node that is most preferred is the one with the greatest sum of weights,
     * i.e. for each node that meets all of the scheduling requirements (resource request,
     * requiredDuringScheduling affinity expressions, etc.), compute a sum by iterating through the
     * elements of this field and adding "weight" to the sum if the node has pods which matches the
     * corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinity#preferredDuringSchedulingIgnoredDuringExecution
     */
    readonly preferredDuringSchedulingIgnoredDuringExecution?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution[];
    /**
     * If the affinity requirements specified by this field are not met at scheduling time, the pod
     * will not be scheduled onto the node. If the affinity requirements specified by this field
     * cease to be met at some point during pod execution (e.g. due to a pod label update), the
     * system may or may not try to eventually evict the pod from its node. When there are multiple
     * elements, the lists of nodes corresponding to each podAffinityTerm are intersected, i.e. all
     * terms must be satisfied.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinity#requiredDuringSchedulingIgnoredDuringExecution
     */
    readonly requiredDuringSchedulingIgnoredDuringExecution?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution[];
}
/**
 * Converts an object of type 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinity'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinity(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinity | undefined): Record<string, any> | undefined;
/**
 * Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone,
 * etc. as some other pod(s)).
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinity
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinity {
    /**
     * The scheduler will prefer to schedule pods to nodes that satisfy the anti-affinity
     * expressions specified by this field, but it may choose a node that violates one or more of
     * the expressions. The node that is most preferred is the one with the greatest sum of weights,
     * i.e. for each node that meets all of the scheduling requirements (resource request,
     * requiredDuringScheduling anti-affinity expressions, etc.), compute a sum by iterating through
     * the elements of this field and adding "weight" to the sum if the node has pods which matches
     * the corresponding podAffinityTerm; the node(s) with the highest sum are the most preferred.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinity#preferredDuringSchedulingIgnoredDuringExecution
     */
    readonly preferredDuringSchedulingIgnoredDuringExecution?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution[];
    /**
     * If the anti-affinity requirements specified by this field are not met at scheduling time, the
     * pod will not be scheduled onto the node. If the anti-affinity requirements specified by this
     * field cease to be met at some point during pod execution (e.g. due to a pod label update),
     * the system may or may not try to eventually evict the pod from its node. When there are
     * multiple elements, the lists of nodes corresponding to each podAffinityTerm are intersected,
     * i.e. all terms must be satisfied.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinity#requiredDuringSchedulingIgnoredDuringExecution
     */
    readonly requiredDuringSchedulingIgnoredDuringExecution?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinity' to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinity(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinity | undefined): Record<string, any> | undefined;
/**
 * The SELinux context to be applied to all containers. If unspecified, the container runtime will
 * allocate a random SELinux context for each container. May also be set in SecurityContext. If set
 * in both SecurityContext and PodSecurityContext, the value specified in SecurityContext takes
 * precedence for that container. Note that this field cannot be set when spec.os.name is windows.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSeLinuxOptions
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSeLinuxOptions {
    /**
     * Level is SELinux level label that applies to the container.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSeLinuxOptions#level
     */
    readonly level?: string;
    /**
     * Role is a SELinux role label that applies to the container.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSeLinuxOptions#role
     */
    readonly role?: string;
    /**
     * Type is a SELinux type label that applies to the container.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSeLinuxOptions#type
     */
    readonly type?: string;
    /**
     * User is a SELinux user label that applies to the container.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSeLinuxOptions#user
     */
    readonly user?: string;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSeLinuxOptions' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSeLinuxOptions(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSeLinuxOptions | undefined): Record<string, any> | undefined;
/**
 * The seccomp options to use by the containers in this pod. Note that this field cannot be set when
 * spec.os.name is windows.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSeccompProfile
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSeccompProfile {
    /**
     * LocalhostProfile indicates a profile defined in a file on the node should be used. The
     * profile must be preconfigured on the node to work. Must be a descending path, relative to the
     * kubelet's configured seccomp profile location. Must be set if type is "Localhost". Must NOT
     * be set for any other type.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSeccompProfile#localhostProfile
     */
    readonly localhostProfile?: string;
    /**
     * Type indicates which kind of seccomp profile will be applied. Valid options are:
     *
     * Localhost - a profile defined in a file on the node should be used. RuntimeDefault - the
     * container runtime default profile should be used. Unconfined - no profile should be applied.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSeccompProfile#type
     */
    readonly type: string;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSeccompProfile' to JSON
 * representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSeccompProfile(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSeccompProfile | undefined): Record<string, any> | undefined;
/**
 * Sysctl defines a kernel parameter to be set
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSysctls
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSysctls {
    /**
     * Name of a property to set
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSysctls#name
     */
    readonly name: string;
    /**
     * Value of a property to set
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSysctls#value
     */
    readonly value: string;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSysctls' to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSysctls(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecSecurityContextSysctls | undefined): Record<string, any> | undefined;
/**
 * An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a
 * no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution {
    /**
     * A node selector term, associated with the corresponding weight.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution#preference
     */
    readonly preference: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference;
    /**
     * Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution#weight
     */
    readonly weight: number;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution | undefined): Record<string, any> | undefined;
/**
 * If the affinity requirements specified by this field are not met at scheduling time, the pod will
 * not be scheduled onto the node. If the affinity requirements specified by this field cease to be
 * met at some point during pod execution (e.g. due to an update), the system may or may not try to
 * eventually evict the pod from its node.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution {
    /**
     * Required. A list of node selector terms. The terms are ORed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution#nodeSelectorTerms
     */
    readonly nodeSelectorTerms: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution | undefined): Record<string, any> | undefined;
/**
 * The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the
 * most preferred node(s)
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution {
    /**
     * Required. A pod affinity term, associated with the corresponding weight.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution#podAffinityTerm
     */
    readonly podAffinityTerm: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm;
    /**
     * Weight associated with matching the corresponding podAffinityTerm, in the range 1-100.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution#weight
     */
    readonly weight: number;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution | undefined): Record<string, any> | undefined;
/**
 * Defines a set of pods (namely those matching the labelSelector relative to the given
 * namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity)
 * with, where co-located is defined as running on a node whose value of the label with key
 * <topologyKey> matches that of any node on which a pod of the set of pods is running
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution {
    /**
     * A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm
     * matches with no Pods.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution#labelSelector
     */
    readonly labelSelector?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector;
    /**
     * MatchLabelKeys is a set of pod label keys to select which pods will be taken into
     * consideration. The keys are used to lookup values from the incoming pod labels, those
     * key-value labels are merged with `labelSelector` as `key in (value)` to select the group of
     * existing pods which pods will be taken into consideration for the incoming pod's pod (anti)
     * affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value
     * is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also,
     * matchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires
     * enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution#matchLabelKeys
     */
    readonly matchLabelKeys?: string[];
    /**
     * MismatchLabelKeys is a set of pod label keys to select which pods will be taken into
     * consideration. The keys are used to lookup values from the incoming pod labels, those
     * key-value labels are merged with `labelSelector` as `key notin (value)` to select the group
     * of existing pods which pods will be taken into consideration for the incoming pod's pod
     * (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The
     * default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and
     * labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set. This is a
     * beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by
     * default).
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution#mismatchLabelKeys
     */
    readonly mismatchLabelKeys?: string[];
    /**
     * A label query over the set of namespaces that the term applies to. The term is applied to the
     * union of the namespaces selected by this field and the ones listed in the namespaces field.
     * null selector and null or empty namespaces list means "this pod's namespace". An empty
     * selector ({}) matches all namespaces.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution#namespaceSelector
     */
    readonly namespaceSelector?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector;
    /**
     * Namespaces specifies a static list of namespace names that the term applies to. The term is
     * applied to the union of the namespaces listed in this field and the ones selected by
     * namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's
     * namespace".
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution#namespaces
     */
    readonly namespaces?: string[];
    /**
     * This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods
     * matching the labelSelector in the specified namespaces, where co-located is defined as
     * running on a node whose value of the label with key topologyKey matches that of any node on
     * which any of the selected pods is running. Empty topologyKey is not allowed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution#topologyKey
     */
    readonly topologyKey: string;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution | undefined): Record<string, any> | undefined;
/**
 * The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the
 * most preferred node(s)
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution {
    /**
     * Required. A pod affinity term, associated with the corresponding weight.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution#podAffinityTerm
     */
    readonly podAffinityTerm: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm;
    /**
     * Weight associated with matching the corresponding podAffinityTerm, in the range 1-100.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution#weight
     */
    readonly weight: number;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution | undefined): Record<string, any> | undefined;
/**
 * Defines a set of pods (namely those matching the labelSelector relative to the given
 * namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity)
 * with, where co-located is defined as running on a node whose value of the label with key
 * <topologyKey> matches that of any node on which a pod of the set of pods is running
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution {
    /**
     * A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm
     * matches with no Pods.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution#labelSelector
     */
    readonly labelSelector?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector;
    /**
     * MatchLabelKeys is a set of pod label keys to select which pods will be taken into
     * consideration. The keys are used to lookup values from the incoming pod labels, those
     * key-value labels are merged with `labelSelector` as `key in (value)` to select the group of
     * existing pods which pods will be taken into consideration for the incoming pod's pod (anti)
     * affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value
     * is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also,
     * matchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires
     * enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution#matchLabelKeys
     */
    readonly matchLabelKeys?: string[];
    /**
     * MismatchLabelKeys is a set of pod label keys to select which pods will be taken into
     * consideration. The keys are used to lookup values from the incoming pod labels, those
     * key-value labels are merged with `labelSelector` as `key notin (value)` to select the group
     * of existing pods which pods will be taken into consideration for the incoming pod's pod
     * (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The
     * default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and
     * labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set. This is a
     * beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by
     * default).
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution#mismatchLabelKeys
     */
    readonly mismatchLabelKeys?: string[];
    /**
     * A label query over the set of namespaces that the term applies to. The term is applied to the
     * union of the namespaces selected by this field and the ones listed in the namespaces field.
     * null selector and null or empty namespaces list means "this pod's namespace". An empty
     * selector ({}) matches all namespaces.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution#namespaceSelector
     */
    readonly namespaceSelector?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector;
    /**
     * Namespaces specifies a static list of namespace names that the term applies to. The term is
     * applied to the union of the namespaces listed in this field and the ones selected by
     * namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's
     * namespace".
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution#namespaces
     */
    readonly namespaces?: string[];
    /**
     * This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods
     * matching the labelSelector in the specified namespaces, where co-located is defined as
     * running on a node whose value of the label with key topologyKey matches that of any node on
     * which any of the selected pods is running. Empty topologyKey is not allowed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution#topologyKey
     */
    readonly topologyKey: string;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution | undefined): Record<string, any> | undefined;
/**
 * An empty preferred scheduling term matches all objects with implicit weight 0 (i.e. it's a
 * no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution {
    /**
     * A node selector term, associated with the corresponding weight.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution#preference
     */
    readonly preference: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference;
    /**
     * Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution#weight
     */
    readonly weight: number;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution | undefined): Record<string, any> | undefined;
/**
 * If the affinity requirements specified by this field are not met at scheduling time, the pod will
 * not be scheduled onto the node. If the affinity requirements specified by this field cease to be
 * met at some point during pod execution (e.g. due to an update), the system may or may not try to
 * eventually evict the pod from its node.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution {
    /**
     * Required. A list of node selector terms. The terms are ORed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution#nodeSelectorTerms
     */
    readonly nodeSelectorTerms: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution | undefined): Record<string, any> | undefined;
/**
 * The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the
 * most preferred node(s)
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution {
    /**
     * Required. A pod affinity term, associated with the corresponding weight.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution#podAffinityTerm
     */
    readonly podAffinityTerm: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm;
    /**
     * Weight associated with matching the corresponding podAffinityTerm, in the range 1-100.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution#weight
     */
    readonly weight: number;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution | undefined): Record<string, any> | undefined;
/**
 * Defines a set of pods (namely those matching the labelSelector relative to the given
 * namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity)
 * with, where co-located is defined as running on a node whose value of the label with key
 * <topologyKey> matches that of any node on which a pod of the set of pods is running
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution {
    /**
     * A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm
     * matches with no Pods.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution#labelSelector
     */
    readonly labelSelector?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector;
    /**
     * MatchLabelKeys is a set of pod label keys to select which pods will be taken into
     * consideration. The keys are used to lookup values from the incoming pod labels, those
     * key-value labels are merged with `labelSelector` as `key in (value)` to select the group of
     * existing pods which pods will be taken into consideration for the incoming pod's pod (anti)
     * affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value
     * is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also,
     * matchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires
     * enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution#matchLabelKeys
     */
    readonly matchLabelKeys?: string[];
    /**
     * MismatchLabelKeys is a set of pod label keys to select which pods will be taken into
     * consideration. The keys are used to lookup values from the incoming pod labels, those
     * key-value labels are merged with `labelSelector` as `key notin (value)` to select the group
     * of existing pods which pods will be taken into consideration for the incoming pod's pod
     * (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The
     * default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and
     * labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set. This is a
     * beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by
     * default).
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution#mismatchLabelKeys
     */
    readonly mismatchLabelKeys?: string[];
    /**
     * A label query over the set of namespaces that the term applies to. The term is applied to the
     * union of the namespaces selected by this field and the ones listed in the namespaces field.
     * null selector and null or empty namespaces list means "this pod's namespace". An empty
     * selector ({}) matches all namespaces.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution#namespaceSelector
     */
    readonly namespaceSelector?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector;
    /**
     * Namespaces specifies a static list of namespace names that the term applies to. The term is
     * applied to the union of the namespaces listed in this field and the ones selected by
     * namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's
     * namespace".
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution#namespaces
     */
    readonly namespaces?: string[];
    /**
     * This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods
     * matching the labelSelector in the specified namespaces, where co-located is defined as
     * running on a node whose value of the label with key topologyKey matches that of any node on
     * which any of the selected pods is running. Empty topologyKey is not allowed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution#topologyKey
     */
    readonly topologyKey: string;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution | undefined): Record<string, any> | undefined;
/**
 * The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the
 * most preferred node(s)
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution {
    /**
     * Required. A pod affinity term, associated with the corresponding weight.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution#podAffinityTerm
     */
    readonly podAffinityTerm: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm;
    /**
     * Weight associated with matching the corresponding podAffinityTerm, in the range 1-100.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution#weight
     */
    readonly weight: number;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution | undefined): Record<string, any> | undefined;
/**
 * Defines a set of pods (namely those matching the labelSelector relative to the given
 * namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity)
 * with, where co-located is defined as running on a node whose value of the label with key
 * <topologyKey> matches that of any node on which a pod of the set of pods is running
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution {
    /**
     * A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm
     * matches with no Pods.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution#labelSelector
     */
    readonly labelSelector?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector;
    /**
     * MatchLabelKeys is a set of pod label keys to select which pods will be taken into
     * consideration. The keys are used to lookup values from the incoming pod labels, those
     * key-value labels are merged with `labelSelector` as `key in (value)` to select the group of
     * existing pods which pods will be taken into consideration for the incoming pod's pod (anti)
     * affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value
     * is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also,
     * matchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires
     * enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution#matchLabelKeys
     */
    readonly matchLabelKeys?: string[];
    /**
     * MismatchLabelKeys is a set of pod label keys to select which pods will be taken into
     * consideration. The keys are used to lookup values from the incoming pod labels, those
     * key-value labels are merged with `labelSelector` as `key notin (value)` to select the group
     * of existing pods which pods will be taken into consideration for the incoming pod's pod
     * (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The
     * default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and
     * labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set. This is a
     * beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by
     * default).
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution#mismatchLabelKeys
     */
    readonly mismatchLabelKeys?: string[];
    /**
     * A label query over the set of namespaces that the term applies to. The term is applied to the
     * union of the namespaces selected by this field and the ones listed in the namespaces field.
     * null selector and null or empty namespaces list means "this pod's namespace". An empty
     * selector ({}) matches all namespaces.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution#namespaceSelector
     */
    readonly namespaceSelector?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector;
    /**
     * Namespaces specifies a static list of namespace names that the term applies to. The term is
     * applied to the union of the namespaces listed in this field and the ones selected by
     * namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's
     * namespace".
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution#namespaces
     */
    readonly namespaces?: string[];
    /**
     * This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods
     * matching the labelSelector in the specified namespaces, where co-located is defined as
     * running on a node whose value of the label with key topologyKey matches that of any node on
     * which any of the selected pods is running. Empty topologyKey is not allowed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution#topologyKey
     */
    readonly topologyKey: string;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution | undefined): Record<string, any> | undefined;
/**
 * A node selector term, associated with the corresponding weight.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference {
    /**
     * A list of node selector requirements by node's labels.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions[];
    /**
     * A list of node selector requirements by node's fields.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference#matchFields
     */
    readonly matchFields?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference | undefined): Record<string, any> | undefined;
/**
 * A null or empty node selector term matches no objects. The requirements of them are ANDed. The
 * TopologySelectorTerm type implements a subset of the NodeSelectorTerm.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms {
    /**
     * A list of node selector requirements by node's labels.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions[];
    /**
     * A list of node selector requirements by node's fields.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms#matchFields
     */
    readonly matchFields?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms | undefined): Record<string, any> | undefined;
/**
 * Required. A pod affinity term, associated with the corresponding weight.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm {
    /**
     * A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm
     * matches with no Pods.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#labelSelector
     */
    readonly labelSelector?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector;
    /**
     * MatchLabelKeys is a set of pod label keys to select which pods will be taken into
     * consideration. The keys are used to lookup values from the incoming pod labels, those
     * key-value labels are merged with `labelSelector` as `key in (value)` to select the group of
     * existing pods which pods will be taken into consideration for the incoming pod's pod (anti)
     * affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value
     * is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also,
     * matchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires
     * enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#matchLabelKeys
     */
    readonly matchLabelKeys?: string[];
    /**
     * MismatchLabelKeys is a set of pod label keys to select which pods will be taken into
     * consideration. The keys are used to lookup values from the incoming pod labels, those
     * key-value labels are merged with `labelSelector` as `key notin (value)` to select the group
     * of existing pods which pods will be taken into consideration for the incoming pod's pod
     * (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The
     * default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and
     * labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set. This is a
     * beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by
     * default).
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#mismatchLabelKeys
     */
    readonly mismatchLabelKeys?: string[];
    /**
     * A label query over the set of namespaces that the term applies to. The term is applied to the
     * union of the namespaces selected by this field and the ones listed in the namespaces field.
     * null selector and null or empty namespaces list means "this pod's namespace". An empty
     * selector ({}) matches all namespaces.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#namespaceSelector
     */
    readonly namespaceSelector?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector;
    /**
     * Namespaces specifies a static list of namespace names that the term applies to. The term is
     * applied to the union of the namespaces listed in this field and the ones selected by
     * namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's
     * namespace".
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#namespaces
     */
    readonly namespaces?: string[];
    /**
     * This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods
     * matching the labelSelector in the specified namespaces, where co-located is defined as
     * running on a node whose value of the label with key topologyKey matches that of any node on
     * which any of the selected pods is running. Empty topologyKey is not allowed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#topologyKey
     */
    readonly topologyKey: string;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm | undefined): Record<string, any> | undefined;
/**
 * A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm
 * matches with no Pods.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector {
    /**
     * MatchExpressions is a list of label selector requirements. The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions[];
    /**
     * MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is
     * equivalent to an element of matchExpressions, whose key field is "key", the operator is "In",
     * and the values array contains only "value". The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector#matchLabels
     */
    readonly matchLabels?: {
        [key: string]: string;
    };
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector | undefined): Record<string, any> | undefined;
/**
 * A label query over the set of namespaces that the term applies to. The term is applied to the
 * union of the namespaces selected by this field and the ones listed in the namespaces field. null
 * selector and null or empty namespaces list means "this pod's namespace". An empty selector ({})
 * matches all namespaces.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector {
    /**
     * MatchExpressions is a list of label selector requirements. The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions[];
    /**
     * MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is
     * equivalent to an element of matchExpressions, whose key field is "key", the operator is "In",
     * and the values array contains only "value". The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector#matchLabels
     */
    readonly matchLabels?: {
        [key: string]: string;
    };
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector | undefined): Record<string, any> | undefined;
/**
 * Required. A pod affinity term, associated with the corresponding weight.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm {
    /**
     * A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm
     * matches with no Pods.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#labelSelector
     */
    readonly labelSelector?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector;
    /**
     * MatchLabelKeys is a set of pod label keys to select which pods will be taken into
     * consideration. The keys are used to lookup values from the incoming pod labels, those
     * key-value labels are merged with `labelSelector` as `key in (value)` to select the group of
     * existing pods which pods will be taken into consideration for the incoming pod's pod (anti)
     * affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value
     * is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also,
     * matchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires
     * enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#matchLabelKeys
     */
    readonly matchLabelKeys?: string[];
    /**
     * MismatchLabelKeys is a set of pod label keys to select which pods will be taken into
     * consideration. The keys are used to lookup values from the incoming pod labels, those
     * key-value labels are merged with `labelSelector` as `key notin (value)` to select the group
     * of existing pods which pods will be taken into consideration for the incoming pod's pod
     * (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The
     * default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and
     * labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set. This is a
     * beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by
     * default).
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#mismatchLabelKeys
     */
    readonly mismatchLabelKeys?: string[];
    /**
     * A label query over the set of namespaces that the term applies to. The term is applied to the
     * union of the namespaces selected by this field and the ones listed in the namespaces field.
     * null selector and null or empty namespaces list means "this pod's namespace". An empty
     * selector ({}) matches all namespaces.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#namespaceSelector
     */
    readonly namespaceSelector?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector;
    /**
     * Namespaces specifies a static list of namespace names that the term applies to. The term is
     * applied to the union of the namespaces listed in this field and the ones selected by
     * namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's
     * namespace".
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#namespaces
     */
    readonly namespaces?: string[];
    /**
     * This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods
     * matching the labelSelector in the specified namespaces, where co-located is defined as
     * running on a node whose value of the label with key topologyKey matches that of any node on
     * which any of the selected pods is running. Empty topologyKey is not allowed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#topologyKey
     */
    readonly topologyKey: string;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm | undefined): Record<string, any> | undefined;
/**
 * A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm
 * matches with no Pods.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector {
    /**
     * MatchExpressions is a list of label selector requirements. The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions[];
    /**
     * MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is
     * equivalent to an element of matchExpressions, whose key field is "key", the operator is "In",
     * and the values array contains only "value". The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector#matchLabels
     */
    readonly matchLabels?: {
        [key: string]: string;
    };
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector | undefined): Record<string, any> | undefined;
/**
 * A label query over the set of namespaces that the term applies to. The term is applied to the
 * union of the namespaces selected by this field and the ones listed in the namespaces field. null
 * selector and null or empty namespaces list means "this pod's namespace". An empty selector ({})
 * matches all namespaces.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector {
    /**
     * MatchExpressions is a list of label selector requirements. The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions[];
    /**
     * MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is
     * equivalent to an element of matchExpressions, whose key field is "key", the operator is "In",
     * and the values array contains only "value". The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector#matchLabels
     */
    readonly matchLabels?: {
        [key: string]: string;
    };
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector | undefined): Record<string, any> | undefined;
/**
 * A node selector term, associated with the corresponding weight.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference {
    /**
     * A list of node selector requirements by node's labels.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions[];
    /**
     * A list of node selector requirements by node's fields.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference#matchFields
     */
    readonly matchFields?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference | undefined): Record<string, any> | undefined;
/**
 * A null or empty node selector term matches no objects. The requirements of them are ANDed. The
 * TopologySelectorTerm type implements a subset of the NodeSelectorTerm.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms {
    /**
     * A list of node selector requirements by node's labels.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions[];
    /**
     * A list of node selector requirements by node's fields.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms#matchFields
     */
    readonly matchFields?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms | undefined): Record<string, any> | undefined;
/**
 * Required. A pod affinity term, associated with the corresponding weight.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm {
    /**
     * A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm
     * matches with no Pods.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#labelSelector
     */
    readonly labelSelector?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector;
    /**
     * MatchLabelKeys is a set of pod label keys to select which pods will be taken into
     * consideration. The keys are used to lookup values from the incoming pod labels, those
     * key-value labels are merged with `labelSelector` as `key in (value)` to select the group of
     * existing pods which pods will be taken into consideration for the incoming pod's pod (anti)
     * affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value
     * is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also,
     * matchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires
     * enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#matchLabelKeys
     */
    readonly matchLabelKeys?: string[];
    /**
     * MismatchLabelKeys is a set of pod label keys to select which pods will be taken into
     * consideration. The keys are used to lookup values from the incoming pod labels, those
     * key-value labels are merged with `labelSelector` as `key notin (value)` to select the group
     * of existing pods which pods will be taken into consideration for the incoming pod's pod
     * (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The
     * default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and
     * labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set. This is a
     * beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by
     * default).
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#mismatchLabelKeys
     */
    readonly mismatchLabelKeys?: string[];
    /**
     * A label query over the set of namespaces that the term applies to. The term is applied to the
     * union of the namespaces selected by this field and the ones listed in the namespaces field.
     * null selector and null or empty namespaces list means "this pod's namespace". An empty
     * selector ({}) matches all namespaces.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#namespaceSelector
     */
    readonly namespaceSelector?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector;
    /**
     * Namespaces specifies a static list of namespace names that the term applies to. The term is
     * applied to the union of the namespaces listed in this field and the ones selected by
     * namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's
     * namespace".
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#namespaces
     */
    readonly namespaces?: string[];
    /**
     * This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods
     * matching the labelSelector in the specified namespaces, where co-located is defined as
     * running on a node whose value of the label with key topologyKey matches that of any node on
     * which any of the selected pods is running. Empty topologyKey is not allowed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#topologyKey
     */
    readonly topologyKey: string;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm | undefined): Record<string, any> | undefined;
/**
 * A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm
 * matches with no Pods.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector {
    /**
     * MatchExpressions is a list of label selector requirements. The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions[];
    /**
     * MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is
     * equivalent to an element of matchExpressions, whose key field is "key", the operator is "In",
     * and the values array contains only "value". The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector#matchLabels
     */
    readonly matchLabels?: {
        [key: string]: string;
    };
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector | undefined): Record<string, any> | undefined;
/**
 * A label query over the set of namespaces that the term applies to. The term is applied to the
 * union of the namespaces selected by this field and the ones listed in the namespaces field. null
 * selector and null or empty namespaces list means "this pod's namespace". An empty selector ({})
 * matches all namespaces.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector {
    /**
     * MatchExpressions is a list of label selector requirements. The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions[];
    /**
     * MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is
     * equivalent to an element of matchExpressions, whose key field is "key", the operator is "In",
     * and the values array contains only "value". The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector#matchLabels
     */
    readonly matchLabels?: {
        [key: string]: string;
    };
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector | undefined): Record<string, any> | undefined;
/**
 * Required. A pod affinity term, associated with the corresponding weight.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm {
    /**
     * A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm
     * matches with no Pods.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#labelSelector
     */
    readonly labelSelector?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector;
    /**
     * MatchLabelKeys is a set of pod label keys to select which pods will be taken into
     * consideration. The keys are used to lookup values from the incoming pod labels, those
     * key-value labels are merged with `labelSelector` as `key in (value)` to select the group of
     * existing pods which pods will be taken into consideration for the incoming pod's pod (anti)
     * affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value
     * is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also,
     * matchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires
     * enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#matchLabelKeys
     */
    readonly matchLabelKeys?: string[];
    /**
     * MismatchLabelKeys is a set of pod label keys to select which pods will be taken into
     * consideration. The keys are used to lookup values from the incoming pod labels, those
     * key-value labels are merged with `labelSelector` as `key notin (value)` to select the group
     * of existing pods which pods will be taken into consideration for the incoming pod's pod
     * (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The
     * default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and
     * labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set. This is a
     * beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by
     * default).
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#mismatchLabelKeys
     */
    readonly mismatchLabelKeys?: string[];
    /**
     * A label query over the set of namespaces that the term applies to. The term is applied to the
     * union of the namespaces selected by this field and the ones listed in the namespaces field.
     * null selector and null or empty namespaces list means "this pod's namespace". An empty
     * selector ({}) matches all namespaces.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#namespaceSelector
     */
    readonly namespaceSelector?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector;
    /**
     * Namespaces specifies a static list of namespace names that the term applies to. The term is
     * applied to the union of the namespaces listed in this field and the ones selected by
     * namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's
     * namespace".
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#namespaces
     */
    readonly namespaces?: string[];
    /**
     * This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods
     * matching the labelSelector in the specified namespaces, where co-located is defined as
     * running on a node whose value of the label with key topologyKey matches that of any node on
     * which any of the selected pods is running. Empty topologyKey is not allowed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#topologyKey
     */
    readonly topologyKey: string;
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm | undefined): Record<string, any> | undefined;
/**
 * A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm
 * matches with no Pods.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector {
    /**
     * MatchExpressions is a list of label selector requirements. The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions[];
    /**
     * MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is
     * equivalent to an element of matchExpressions, whose key field is "key", the operator is "In",
     * and the values array contains only "value". The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector#matchLabels
     */
    readonly matchLabels?: {
        [key: string]: string;
    };
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector | undefined): Record<string, any> | undefined;
/**
 * A label query over the set of namespaces that the term applies to. The term is applied to the
 * union of the namespaces selected by this field and the ones listed in the namespaces field. null
 * selector and null or empty namespaces list means "this pod's namespace". An empty selector ({})
 * matches all namespaces.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector {
    /**
     * MatchExpressions is a list of label selector requirements. The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions[];
    /**
     * MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is
     * equivalent to an element of matchExpressions, whose key field is "key", the operator is "In",
     * and the values array contains only "value". The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector#matchLabels
     */
    readonly matchLabels?: {
        [key: string]: string;
    };
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector | undefined): Record<string, any> | undefined;
/**
 * A node selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions {
    /**
     * The label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions#key
     */
    readonly key: string;
    /**
     * Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists,
     * DoesNotExist. Gt, and Lt.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * An array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the
     * operator is Gt or Lt, the values array must have a single element, which will be interpreted
     * as an integer. This array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * A node selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields {
    /**
     * The label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields#key
     */
    readonly key: string;
    /**
     * Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists,
     * DoesNotExist. Gt, and Lt.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields#operator
     */
    readonly operator: string;
    /**
     * An array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the
     * operator is Gt or Lt, the values array must have a single element, which will be interpreted
     * as an integer. This array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields | undefined): Record<string, any> | undefined;
/**
 * A node selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions {
    /**
     * The label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions#key
     */
    readonly key: string;
    /**
     * Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists,
     * DoesNotExist. Gt, and Lt.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * An array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the
     * operator is Gt or Lt, the values array must have a single element, which will be interpreted
     * as an integer. This array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * A node selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields {
    /**
     * The label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields#key
     */
    readonly key: string;
    /**
     * Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists,
     * DoesNotExist. Gt, and Lt.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields#operator
     */
    readonly operator: string;
    /**
     * An array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the
     * operator is Gt or Lt, the values array must have a single element, which will be interpreted
     * as an integer. This array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields | undefined): Record<string, any> | undefined;
/**
 * A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm
 * matches with no Pods.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector {
    /**
     * MatchExpressions is a list of label selector requirements. The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions[];
    /**
     * MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is
     * equivalent to an element of matchExpressions, whose key field is "key", the operator is "In",
     * and the values array contains only "value". The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector#matchLabels
     */
    readonly matchLabels?: {
        [key: string]: string;
    };
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector | undefined): Record<string, any> | undefined;
/**
 * A label query over the set of namespaces that the term applies to. The term is applied to the
 * union of the namespaces selected by this field and the ones listed in the namespaces field. null
 * selector and null or empty namespaces list means "this pod's namespace". An empty selector ({})
 * matches all namespaces.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector {
    /**
     * MatchExpressions is a list of label selector requirements. The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions[];
    /**
     * MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is
     * equivalent to an element of matchExpressions, whose key field is "key", the operator is "In",
     * and the values array contains only "value". The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector#matchLabels
     */
    readonly matchLabels?: {
        [key: string]: string;
    };
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector | undefined): Record<string, any> | undefined;
/**
 * A label selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions {
    /**
     * Key is the label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions#key
     */
    readonly key: string;
    /**
     * Operator represents a key's relationship to a set of values. Valid operators are In, NotIn,
     * Exists and DoesNotExist.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * Values is an array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This
     * array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * A label selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions {
    /**
     * Key is the label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions#key
     */
    readonly key: string;
    /**
     * Operator represents a key's relationship to a set of values. Valid operators are In, NotIn,
     * Exists and DoesNotExist.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * Values is an array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This
     * array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm
 * matches with no Pods.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector {
    /**
     * MatchExpressions is a list of label selector requirements. The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions[];
    /**
     * MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is
     * equivalent to an element of matchExpressions, whose key field is "key", the operator is "In",
     * and the values array contains only "value". The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector#matchLabels
     */
    readonly matchLabels?: {
        [key: string]: string;
    };
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector | undefined): Record<string, any> | undefined;
/**
 * A label query over the set of namespaces that the term applies to. The term is applied to the
 * union of the namespaces selected by this field and the ones listed in the namespaces field. null
 * selector and null or empty namespaces list means "this pod's namespace". An empty selector ({})
 * matches all namespaces.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector {
    /**
     * MatchExpressions is a list of label selector requirements. The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions[];
    /**
     * MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is
     * equivalent to an element of matchExpressions, whose key field is "key", the operator is "In",
     * and the values array contains only "value". The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector#matchLabels
     */
    readonly matchLabels?: {
        [key: string]: string;
    };
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector | undefined): Record<string, any> | undefined;
/**
 * A label selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions {
    /**
     * Key is the label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions#key
     */
    readonly key: string;
    /**
     * Operator represents a key's relationship to a set of values. Valid operators are In, NotIn,
     * Exists and DoesNotExist.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * Values is an array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This
     * array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * A label selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions {
    /**
     * Key is the label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions#key
     */
    readonly key: string;
    /**
     * Operator represents a key's relationship to a set of values. Valid operators are In, NotIn,
     * Exists and DoesNotExist.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * Values is an array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This
     * array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * A node selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions {
    /**
     * The label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions#key
     */
    readonly key: string;
    /**
     * Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists,
     * DoesNotExist. Gt, and Lt.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * An array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the
     * operator is Gt or Lt, the values array must have a single element, which will be interpreted
     * as an integer. This array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * A node selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields {
    /**
     * The label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields#key
     */
    readonly key: string;
    /**
     * Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists,
     * DoesNotExist. Gt, and Lt.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields#operator
     */
    readonly operator: string;
    /**
     * An array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the
     * operator is Gt or Lt, the values array must have a single element, which will be interpreted
     * as an integer. This array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields | undefined): Record<string, any> | undefined;
/**
 * A node selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions {
    /**
     * The label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions#key
     */
    readonly key: string;
    /**
     * Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists,
     * DoesNotExist. Gt, and Lt.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * An array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the
     * operator is Gt or Lt, the values array must have a single element, which will be interpreted
     * as an integer. This array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * A node selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields {
    /**
     * The label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields#key
     */
    readonly key: string;
    /**
     * Represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists,
     * DoesNotExist. Gt, and Lt.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields#operator
     */
    readonly operator: string;
    /**
     * An array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. If the
     * operator is Gt or Lt, the values array must have a single element, which will be interpreted
     * as an integer. This array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields | undefined): Record<string, any> | undefined;
/**
 * A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm
 * matches with no Pods.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector {
    /**
     * MatchExpressions is a list of label selector requirements. The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions[];
    /**
     * MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is
     * equivalent to an element of matchExpressions, whose key field is "key", the operator is "In",
     * and the values array contains only "value". The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector#matchLabels
     */
    readonly matchLabels?: {
        [key: string]: string;
    };
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector | undefined): Record<string, any> | undefined;
/**
 * A label query over the set of namespaces that the term applies to. The term is applied to the
 * union of the namespaces selected by this field and the ones listed in the namespaces field. null
 * selector and null or empty namespaces list means "this pod's namespace". An empty selector ({})
 * matches all namespaces.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector {
    /**
     * MatchExpressions is a list of label selector requirements. The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions[];
    /**
     * MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is
     * equivalent to an element of matchExpressions, whose key field is "key", the operator is "In",
     * and the values array contains only "value". The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector#matchLabels
     */
    readonly matchLabels?: {
        [key: string]: string;
    };
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector | undefined): Record<string, any> | undefined;
/**
 * A label selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions {
    /**
     * Key is the label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions#key
     */
    readonly key: string;
    /**
     * Operator represents a key's relationship to a set of values. Valid operators are In, NotIn,
     * Exists and DoesNotExist.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * Values is an array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This
     * array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * A label selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions {
    /**
     * Key is the label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions#key
     */
    readonly key: string;
    /**
     * Operator represents a key's relationship to a set of values. Valid operators are In, NotIn,
     * Exists and DoesNotExist.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * Values is an array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This
     * array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm
 * matches with no Pods.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector {
    /**
     * MatchExpressions is a list of label selector requirements. The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions[];
    /**
     * MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is
     * equivalent to an element of matchExpressions, whose key field is "key", the operator is "In",
     * and the values array contains only "value". The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector#matchLabels
     */
    readonly matchLabels?: {
        [key: string]: string;
    };
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector | undefined): Record<string, any> | undefined;
/**
 * A label query over the set of namespaces that the term applies to. The term is applied to the
 * union of the namespaces selected by this field and the ones listed in the namespaces field. null
 * selector and null or empty namespaces list means "this pod's namespace". An empty selector ({})
 * matches all namespaces.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector {
    /**
     * MatchExpressions is a list of label selector requirements. The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector#matchExpressions
     */
    readonly matchExpressions?: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions[];
    /**
     * MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is
     * equivalent to an element of matchExpressions, whose key field is "key", the operator is "In",
     * and the values array contains only "value". The requirements are ANDed.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector#matchLabels
     */
    readonly matchLabels?: {
        [key: string]: string;
    };
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector | undefined): Record<string, any> | undefined;
/**
 * A label selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions {
    /**
     * Key is the label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions#key
     */
    readonly key: string;
    /**
     * Operator represents a key's relationship to a set of values. Valid operators are In, NotIn,
     * Exists and DoesNotExist.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * Values is an array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This
     * array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * A label selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions {
    /**
     * Key is the label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions#key
     */
    readonly key: string;
    /**
     * Operator represents a key's relationship to a set of values. Valid operators are In, NotIn,
     * Exists and DoesNotExist.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * Values is an array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This
     * array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * A label selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions {
    /**
     * Key is the label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions#key
     */
    readonly key: string;
    /**
     * Operator represents a key's relationship to a set of values. Valid operators are In, NotIn,
     * Exists and DoesNotExist.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * Values is an array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This
     * array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * A label selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions {
    /**
     * Key is the label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions#key
     */
    readonly key: string;
    /**
     * Operator represents a key's relationship to a set of values. Valid operators are In, NotIn,
     * Exists and DoesNotExist.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * Values is an array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This
     * array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * A label selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions {
    /**
     * Key is the label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions#key
     */
    readonly key: string;
    /**
     * Operator represents a key's relationship to a set of values. Valid operators are In, NotIn,
     * Exists and DoesNotExist.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * Values is an array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This
     * array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * A label selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions
 */
export interface ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions {
    /**
     * Key is the label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions#key
     */
    readonly key: string;
    /**
     * Operator represents a key's relationship to a set of values. Valid operators are In, NotIn,
     * Exists and DoesNotExist.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * Values is an array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This
     * array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions(obj: ChallengeSpecSolverHttp01GatewayHttpRoutePodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * A label selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions {
    /**
     * Key is the label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions#key
     */
    readonly key: string;
    /**
     * Operator represents a key's relationship to a set of values. Valid operators are In, NotIn,
     * Exists and DoesNotExist.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * Values is an array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This
     * array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * A label selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions {
    /**
     * Key is the label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions#key
     */
    readonly key: string;
    /**
     * Operator represents a key's relationship to a set of values. Valid operators are In, NotIn,
     * Exists and DoesNotExist.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * Values is an array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This
     * array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * A label selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions {
    /**
     * Key is the label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions#key
     */
    readonly key: string;
    /**
     * Operator represents a key's relationship to a set of values. Valid operators are In, NotIn,
     * Exists and DoesNotExist.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * Values is an array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This
     * array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * A label selector requirement is a selector that contains values, a key, and an operator that
 * relates the key and values.
 *
 * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions
 */
export interface ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions {
    /**
     * Key is the label key that the selector applies to.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions#key
     */
    readonly key: string;
    /**
     * Operator represents a key's relationship to a set of values. Valid operators are In, NotIn,
     * Exists and DoesNotExist.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions#operator
     */
    readonly operator: string;
    /**
     * Values is an array of string values. If the operator is In or NotIn, the values array must be
     * non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This
     * array is replaced during a strategic merge patch.
     *
     * @schema ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions#values
     */
    readonly values?: string[];
}
/**
 * Converts an object of type
 * 'ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions'
 * to JSON representation.
 */
export declare function toJson_ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions(obj: ChallengeSpecSolverHttp01IngressPodTemplateSpecAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions | undefined): Record<string, any> | undefined;
/**
 * Order is a type to represent an Order with an ACME server
 *
 * @schema Order
 */
export declare class Order extends ApiObject {
    /** Returns the apiVersion and kind for "Order" */
    static readonly GVK: GroupVersionKind;
    /**
     * Renders a Kubernetes manifest for "Order".
     *
     * This can be used to inline resource manifests inside other objects (e.g. as templates).
     *
     * @param props Initialization props
     */
    static manifest(props: OrderProps): any;
    /**
     * Defines a "Order" API object
     *
     * @param scope The scope in which to define this object
     * @param id A scope-local name for the object
     * @param props Initialization props
     */
    constructor(scope: Construct, id: string, props: OrderProps);
    /** Renders the object to Kubernetes JSON. */
    toJson(): any;
}
/**
 * Order is a type to represent an Order with an ACME server
 *
 * @schema Order
 */
export interface OrderProps {
    /** @schema Order#metadata */
    readonly metadata: ApiObjectMetadata;
    /** @schema Order#spec */
    readonly spec: OrderSpec;
}
/** Converts an object of type 'OrderProps' to JSON representation. */
export declare function toJson_OrderProps(obj: OrderProps | undefined): Record<string, any> | undefined;
/** @schema OrderSpec */
export interface OrderSpec {
    /**
     * CommonName is the common name as specified on the DER encoded CSR. If specified, this value
     * must also be present in `dnsNames` or `ipAddresses`. This field must match the corresponding
     * field on the DER encoded CSR.
     *
     * @schema OrderSpec#commonName
     */
    readonly commonName?: string;
    /**
     * DNSNames is a list of DNS names that should be included as part of the Order validation
     * process. This field must match the corresponding field on the DER encoded CSR.
     *
     * @schema OrderSpec#dnsNames
     */
    readonly dnsNames?: string[];
    /**
     * Duration is the duration for the not after date for the requested certificate. this is set on
     * order creation as pe the ACME spec.
     *
     * @schema OrderSpec#duration
     */
    readonly duration?: string;
    /**
     * IPAddresses is a list of IP addresses that should be included as part of the Order validation
     * process. This field must match the corresponding field on the DER encoded CSR.
     *
     * @schema OrderSpec#ipAddresses
     */
    readonly ipAddresses?: string[];
    /**
     * IssuerRef references a properly configured ACME-type Issuer which should be used to create
     * this Order. If the Issuer does not exist, processing will be retried. If the Issuer is not an
     * 'ACME' Issuer, an error will be returned and the Order will be marked as failed.
     *
     * @schema OrderSpec#issuerRef
     */
    readonly issuerRef: OrderSpecIssuerRef;
    /**
     * Certificate signing request bytes in DER encoding. This will be used when finalizing the
     * order. This field must be set on the order.
     *
     * @schema OrderSpec#request
     */
    readonly request: string;
}
/** Converts an object of type 'OrderSpec' to JSON representation. */
export declare function toJson_OrderSpec(obj: OrderSpec | undefined): Record<string, any> | undefined;
/**
 * IssuerRef references a properly configured ACME-type Issuer which should be used to create this
 * Order. If the Issuer does not exist, processing will be retried. If the Issuer is not an 'ACME'
 * Issuer, an error will be returned and the Order will be marked as failed.
 *
 * @schema OrderSpecIssuerRef
 */
export interface OrderSpecIssuerRef {
    /**
     * Group of the resource being referred to.
     *
     * @schema OrderSpecIssuerRef#group
     */
    readonly group?: string;
    /**
     * Kind of the resource being referred to.
     *
     * @schema OrderSpecIssuerRef#kind
     */
    readonly kind?: string;
    /**
     * Name of the resource being referred to.
     *
     * @schema OrderSpecIssuerRef#name
     */
    readonly name: string;
}
/** Converts an object of type 'OrderSpecIssuerRef' to JSON representation. */
export declare function toJson_OrderSpecIssuerRef(obj: OrderSpecIssuerRef | undefined): Record<string, any> | undefined;
//# sourceMappingURL=acme.cert-manager.io.d.ts.map