import { APIResource } from 'cloudflaredev/resource';
import * as AccessAPI from 'cloudflaredev/resources/zero-trust/access/access';
import * as BookmarksAPI from 'cloudflaredev/resources/zero-trust/access/bookmarks';
import * as CustomPagesAPI from 'cloudflaredev/resources/zero-trust/access/custom-pages';
import * as GroupsAPI from 'cloudflaredev/resources/zero-trust/access/groups';
import * as KeysAPI from 'cloudflaredev/resources/zero-trust/access/keys';
import * as ServiceTokensAPI from 'cloudflaredev/resources/zero-trust/access/service-tokens';
import * as TagsAPI from 'cloudflaredev/resources/zero-trust/access/tags';
import * as ApplicationsAPI from 'cloudflaredev/resources/zero-trust/access/applications/applications';
import * as CertificatesAPI from 'cloudflaredev/resources/zero-trust/access/certificates/certificates';
import * as LogsAPI from 'cloudflaredev/resources/zero-trust/access/logs/logs';
import * as UsersAPI from 'cloudflaredev/resources/zero-trust/access/users/users';
export declare class Access extends APIResource {
    applications: ApplicationsAPI.Applications;
    certificates: CertificatesAPI.Certificates;
    groups: GroupsAPI.Groups;
    serviceTokens: ServiceTokensAPI.ServiceTokens;
    bookmarks: BookmarksAPI.Bookmarks;
    keys: KeysAPI.Keys;
    logs: LogsAPI.Logs;
    users: UsersAPI.Users;
    customPages: CustomPagesAPI.CustomPages;
    tags: TagsAPI.Tags;
}
/**
 * Enforces a device posture rule has run successfully
 */
export interface AccessDevicePostureRule {
    device_posture: AccessDevicePostureRule.DevicePosture;
}
export declare namespace AccessDevicePostureRule {
    interface DevicePosture {
        /**
         * The ID of a device posture integration.
         */
        integration_uid: string;
    }
}
/**
 * Enforces a device posture rule has run successfully
 */
export interface AccessDevicePostureRuleParam {
    device_posture: AccessDevicePostureRuleParam.DevicePosture;
}
export declare namespace AccessDevicePostureRuleParam {
    interface DevicePosture {
        /**
         * The ID of a device posture integration.
         */
        integration_uid: string;
    }
}
/**
 * Matches a specific email.
 */
export type AccessRule = EmailRule | EmailListRule | DomainRule | EveryoneRule | IPRule | IPListRule | CertificateRule | GroupRule | AzureGroupRule | GitHubOrganizationRule | GSuiteGroupRule | OktaGroupRule | SAMLGroupRule | ServiceTokenRule | AnyValidServiceTokenRule | ExternalEvaluationRule | CountryRule | AuthenticationMethodRule | AccessDevicePostureRule;
/**
 * Matches a specific email.
 */
export type AccessRuleParam = EmailRuleParam | EmailListRuleParam | DomainRuleParam | EveryoneRuleParam | IPRuleParam | IPListRuleParam | CertificateRuleParam | GroupRuleParam | AzureGroupRuleParam | GitHubOrganizationRuleParam | GSuiteGroupRuleParam | OktaGroupRuleParam | SAMLGroupRuleParam | ServiceTokenRuleParam | AnyValidServiceTokenRuleParam | ExternalEvaluationRuleParam | CountryRuleParam | AuthenticationMethodRuleParam | AccessDevicePostureRuleParam;
/**
 * Matches any valid Access Service Token
 */
export interface AnyValidServiceTokenRule {
    /**
     * An empty object which matches on all service tokens.
     */
    any_valid_service_token: unknown;
}
/**
 * Matches any valid Access Service Token
 */
export interface AnyValidServiceTokenRuleParam {
    /**
     * An empty object which matches on all service tokens.
     */
    any_valid_service_token: unknown;
}
/**
 * Enforce different MFA options
 */
export interface AuthenticationMethodRule {
    auth_method: AuthenticationMethodRule.AuthMethod;
}
export declare namespace AuthenticationMethodRule {
    interface AuthMethod {
        /**
         * The type of authentication method https://datatracker.ietf.org/doc/html/rfc8176.
         */
        auth_method: string;
    }
}
/**
 * Enforce different MFA options
 */
export interface AuthenticationMethodRuleParam {
    auth_method: AuthenticationMethodRuleParam.AuthMethod;
}
export declare namespace AuthenticationMethodRuleParam {
    interface AuthMethod {
        /**
         * The type of authentication method https://datatracker.ietf.org/doc/html/rfc8176.
         */
        auth_method: string;
    }
}
/**
 * Matches an Azure group. Requires an Azure identity provider.
 */
export interface AzureGroupRule {
    azureAD: AzureGroupRule.AzureAD;
}
export declare namespace AzureGroupRule {
    interface AzureAD {
        /**
         * The ID of an Azure group.
         */
        id: string;
        /**
         * The ID of your Azure identity provider.
         */
        connection_id: string;
    }
}
/**
 * Matches an Azure group. Requires an Azure identity provider.
 */
export interface AzureGroupRuleParam {
    azureAD: AzureGroupRuleParam.AzureAD;
}
export declare namespace AzureGroupRuleParam {
    interface AzureAD {
        /**
         * The ID of an Azure group.
         */
        id: string;
        /**
         * The ID of your Azure identity provider.
         */
        connection_id: string;
    }
}
/**
 * Matches any valid client certificate.
 */
export interface CertificateRule {
    certificate: unknown;
}
/**
 * Matches any valid client certificate.
 */
export interface CertificateRuleParam {
    certificate: unknown;
}
/**
 * Matches a specific country
 */
export interface CountryRule {
    geo: CountryRule.Geo;
}
export declare namespace CountryRule {
    interface Geo {
        /**
         * The country code that should be matched.
         */
        country_code: string;
    }
}
/**
 * Matches a specific country
 */
export interface CountryRuleParam {
    geo: CountryRuleParam.Geo;
}
export declare namespace CountryRuleParam {
    interface Geo {
        /**
         * The country code that should be matched.
         */
        country_code: string;
    }
}
/**
 * Match an entire email domain.
 */
export interface DomainRule {
    email_domain: DomainRule.EmailDomain;
}
export declare namespace DomainRule {
    interface EmailDomain {
        /**
         * The email domain to match.
         */
        domain: string;
    }
}
/**
 * Match an entire email domain.
 */
export interface DomainRuleParam {
    email_domain: DomainRuleParam.EmailDomain;
}
export declare namespace DomainRuleParam {
    interface EmailDomain {
        /**
         * The email domain to match.
         */
        domain: string;
    }
}
/**
 * Matches an email address from a list.
 */
export interface EmailListRule {
    email_list: EmailListRule.EmailList;
}
export declare namespace EmailListRule {
    interface EmailList {
        /**
         * The ID of a previously created email list.
         */
        id: string;
    }
}
/**
 * Matches an email address from a list.
 */
export interface EmailListRuleParam {
    email_list: EmailListRuleParam.EmailList;
}
export declare namespace EmailListRuleParam {
    interface EmailList {
        /**
         * The ID of a previously created email list.
         */
        id: string;
    }
}
/**
 * Matches a specific email.
 */
export interface EmailRule {
    email: EmailRule.Email;
}
export declare namespace EmailRule {
    interface Email {
        /**
         * The email of the user.
         */
        email: string;
    }
}
/**
 * Matches a specific email.
 */
export interface EmailRuleParam {
    email: EmailRuleParam.Email;
}
export declare namespace EmailRuleParam {
    interface Email {
        /**
         * The email of the user.
         */
        email: string;
    }
}
/**
 * Matches everyone.
 */
export interface EveryoneRule {
    /**
     * An empty object which matches on all users.
     */
    everyone: unknown;
}
/**
 * Matches everyone.
 */
export interface EveryoneRuleParam {
    /**
     * An empty object which matches on all users.
     */
    everyone: unknown;
}
/**
 * Create Allow or Block policies which evaluate the user based on custom criteria.
 */
export interface ExternalEvaluationRule {
    external_evaluation: ExternalEvaluationRule.ExternalEvaluation;
}
export declare namespace ExternalEvaluationRule {
    interface ExternalEvaluation {
        /**
         * The API endpoint containing your business logic.
         */
        evaluate_url: string;
        /**
         * The API endpoint containing the key that Access uses to verify that the response
         * came from your API.
         */
        keys_url: string;
    }
}
/**
 * Create Allow or Block policies which evaluate the user based on custom criteria.
 */
export interface ExternalEvaluationRuleParam {
    external_evaluation: ExternalEvaluationRuleParam.ExternalEvaluation;
}
export declare namespace ExternalEvaluationRuleParam {
    interface ExternalEvaluation {
        /**
         * The API endpoint containing your business logic.
         */
        evaluate_url: string;
        /**
         * The API endpoint containing the key that Access uses to verify that the response
         * came from your API.
         */
        keys_url: string;
    }
}
/**
 * Matches a Github organization. Requires a Github identity provider.
 */
export interface GitHubOrganizationRule {
    'github-organization': GitHubOrganizationRule.GitHubOrganization;
}
export declare namespace GitHubOrganizationRule {
    interface GitHubOrganization {
        /**
         * The ID of your Github identity provider.
         */
        connection_id: string;
        /**
         * The name of the organization.
         */
        name: string;
    }
}
/**
 * Matches a Github organization. Requires a Github identity provider.
 */
export interface GitHubOrganizationRuleParam {
    'github-organization': GitHubOrganizationRuleParam.GitHubOrganization;
}
export declare namespace GitHubOrganizationRuleParam {
    interface GitHubOrganization {
        /**
         * The ID of your Github identity provider.
         */
        connection_id: string;
        /**
         * The name of the organization.
         */
        name: string;
    }
}
/**
 * Matches an Access group.
 */
export interface GroupRule {
    group: GroupRule.Group;
}
export declare namespace GroupRule {
    interface Group {
        /**
         * The ID of a previously created Access group.
         */
        id: string;
    }
}
/**
 * Matches an Access group.
 */
export interface GroupRuleParam {
    group: GroupRuleParam.Group;
}
export declare namespace GroupRuleParam {
    interface Group {
        /**
         * The ID of a previously created Access group.
         */
        id: string;
    }
}
/**
 * Matches a group in Google Workspace. Requires a Google Workspace identity
 * provider.
 */
export interface GSuiteGroupRule {
    gsuite: GSuiteGroupRule.GSuite;
}
export declare namespace GSuiteGroupRule {
    interface GSuite {
        /**
         * The ID of your Google Workspace identity provider.
         */
        connection_id: string;
        /**
         * The email of the Google Workspace group.
         */
        email: string;
    }
}
/**
 * Matches a group in Google Workspace. Requires a Google Workspace identity
 * provider.
 */
export interface GSuiteGroupRuleParam {
    gsuite: GSuiteGroupRuleParam.GSuite;
}
export declare namespace GSuiteGroupRuleParam {
    interface GSuite {
        /**
         * The ID of your Google Workspace identity provider.
         */
        connection_id: string;
        /**
         * The email of the Google Workspace group.
         */
        email: string;
    }
}
/**
 * Matches an IP address from a list.
 */
export interface IPListRule {
    ip_list: IPListRule.IPList;
}
export declare namespace IPListRule {
    interface IPList {
        /**
         * The ID of a previously created IP list.
         */
        id: string;
    }
}
/**
 * Matches an IP address from a list.
 */
export interface IPListRuleParam {
    ip_list: IPListRuleParam.IPList;
}
export declare namespace IPListRuleParam {
    interface IPList {
        /**
         * The ID of a previously created IP list.
         */
        id: string;
    }
}
/**
 * Matches an IP address block.
 */
export interface IPRule {
    ip: IPRule.IP;
}
export declare namespace IPRule {
    interface IP {
        /**
         * An IPv4 or IPv6 CIDR block.
         */
        ip: string;
    }
}
/**
 * Matches an IP address block.
 */
export interface IPRuleParam {
    ip: IPRuleParam.IP;
}
export declare namespace IPRuleParam {
    interface IP {
        /**
         * An IPv4 or IPv6 CIDR block.
         */
        ip: string;
    }
}
/**
 * Matches an Okta group. Requires an Okta identity provider.
 */
export interface OktaGroupRule {
    okta: OktaGroupRule.Okta;
}
export declare namespace OktaGroupRule {
    interface Okta {
        /**
         * The ID of your Okta identity provider.
         */
        connection_id: string;
        /**
         * The email of the Okta group.
         */
        email: string;
    }
}
/**
 * Matches an Okta group. Requires an Okta identity provider.
 */
export interface OktaGroupRuleParam {
    okta: OktaGroupRuleParam.Okta;
}
export declare namespace OktaGroupRuleParam {
    interface Okta {
        /**
         * The ID of your Okta identity provider.
         */
        connection_id: string;
        /**
         * The email of the Okta group.
         */
        email: string;
    }
}
/**
 * Matches a SAML group. Requires a SAML identity provider.
 */
export interface SAMLGroupRule {
    saml: SAMLGroupRule.SAML;
}
export declare namespace SAMLGroupRule {
    interface SAML {
        /**
         * The name of the SAML attribute.
         */
        attribute_name: string;
        /**
         * The SAML attribute value to look for.
         */
        attribute_value: string;
    }
}
/**
 * Matches a SAML group. Requires a SAML identity provider.
 */
export interface SAMLGroupRuleParam {
    saml: SAMLGroupRuleParam.SAML;
}
export declare namespace SAMLGroupRuleParam {
    interface SAML {
        /**
         * The name of the SAML attribute.
         */
        attribute_name: string;
        /**
         * The SAML attribute value to look for.
         */
        attribute_value: string;
    }
}
/**
 * Matches a specific Access Service Token
 */
export interface ServiceTokenRule {
    service_token: ServiceTokenRule.ServiceToken;
}
export declare namespace ServiceTokenRule {
    interface ServiceToken {
        /**
         * The ID of a Service Token.
         */
        token_id: string;
    }
}
/**
 * Matches a specific Access Service Token
 */
export interface ServiceTokenRuleParam {
    service_token: ServiceTokenRuleParam.ServiceToken;
}
export declare namespace ServiceTokenRuleParam {
    interface ServiceToken {
        /**
         * The ID of a Service Token.
         */
        token_id: string;
    }
}
export declare namespace Access {
    export import AccessDevicePostureRule = AccessAPI.AccessDevicePostureRule;
    export import AccessRule = AccessAPI.AccessRule;
    export import AnyValidServiceTokenRule = AccessAPI.AnyValidServiceTokenRule;
    export import AuthenticationMethodRule = AccessAPI.AuthenticationMethodRule;
    export import AzureGroupRule = AccessAPI.AzureGroupRule;
    export import CertificateRule = AccessAPI.CertificateRule;
    export import CountryRule = AccessAPI.CountryRule;
    export import DomainRule = AccessAPI.DomainRule;
    export import EmailListRule = AccessAPI.EmailListRule;
    export import EmailRule = AccessAPI.EmailRule;
    export import EveryoneRule = AccessAPI.EveryoneRule;
    export import ExternalEvaluationRule = AccessAPI.ExternalEvaluationRule;
    export import GitHubOrganizationRule = AccessAPI.GitHubOrganizationRule;
    export import GroupRule = AccessAPI.GroupRule;
    export import GSuiteGroupRule = AccessAPI.GSuiteGroupRule;
    export import IPListRule = AccessAPI.IPListRule;
    export import IPRule = AccessAPI.IPRule;
    export import OktaGroupRule = AccessAPI.OktaGroupRule;
    export import SAMLGroupRule = AccessAPI.SAMLGroupRule;
    export import ServiceTokenRule = AccessAPI.ServiceTokenRule;
    export import Applications = ApplicationsAPI.Applications;
    export import AllowedHeaders = ApplicationsAPI.AllowedHeaders;
    export import AllowedIdPs = ApplicationsAPI.AllowedIdPs;
    export import AllowedMethods = ApplicationsAPI.AllowedMethods;
    export import AllowedOrigins = ApplicationsAPI.AllowedOrigins;
    export import AppID = ApplicationsAPI.AppID;
    export import Application = ApplicationsAPI.Application;
    export import ApplicationType = ApplicationsAPI.ApplicationType;
    export import CORSHeaders = ApplicationsAPI.CORSHeaders;
    export import SaaSAppNameFormat = ApplicationsAPI.SaaSAppNameFormat;
    export import SaaSAppNameIDFormat = ApplicationsAPI.SaaSAppNameIDFormat;
    export import SaaSAppSource = ApplicationsAPI.SaaSAppSource;
    export import SAMLSaaSApp = ApplicationsAPI.SAMLSaaSApp;
    export import SelfHostedDomains = ApplicationsAPI.SelfHostedDomains;
    export import ApplicationDeleteResponse = ApplicationsAPI.ApplicationDeleteResponse;
    export import ApplicationRevokeTokensResponse = ApplicationsAPI.ApplicationRevokeTokensResponse;
    export import ApplicationsSinglePage = ApplicationsAPI.ApplicationsSinglePage;
    export import ApplicationCreateParams = ApplicationsAPI.ApplicationCreateParams;
    export import ApplicationUpdateParams = ApplicationsAPI.ApplicationUpdateParams;
    export import ApplicationListParams = ApplicationsAPI.ApplicationListParams;
    export import ApplicationDeleteParams = ApplicationsAPI.ApplicationDeleteParams;
    export import ApplicationGetParams = ApplicationsAPI.ApplicationGetParams;
    export import ApplicationRevokeTokensParams = ApplicationsAPI.ApplicationRevokeTokensParams;
    export import Certificates = CertificatesAPI.Certificates;
    export import AssociatedHostnames = CertificatesAPI.AssociatedHostnames;
    export import Certificate = CertificatesAPI.Certificate;
    export import CertificateDeleteResponse = CertificatesAPI.CertificateDeleteResponse;
    export import CertificatesSinglePage = CertificatesAPI.CertificatesSinglePage;
    export import CertificateCreateParams = CertificatesAPI.CertificateCreateParams;
    export import CertificateUpdateParams = CertificatesAPI.CertificateUpdateParams;
    export import CertificateListParams = CertificatesAPI.CertificateListParams;
    export import CertificateDeleteParams = CertificatesAPI.CertificateDeleteParams;
    export import CertificateGetParams = CertificatesAPI.CertificateGetParams;
    export import Groups = GroupsAPI.Groups;
    export import ZeroTrustGroup = GroupsAPI.ZeroTrustGroup;
    export import GroupDeleteResponse = GroupsAPI.GroupDeleteResponse;
    export import ZeroTrustGroupsSinglePage = GroupsAPI.ZeroTrustGroupsSinglePage;
    export import GroupCreateParams = GroupsAPI.GroupCreateParams;
    export import GroupUpdateParams = GroupsAPI.GroupUpdateParams;
    export import GroupListParams = GroupsAPI.GroupListParams;
    export import GroupDeleteParams = GroupsAPI.GroupDeleteParams;
    export import GroupGetParams = GroupsAPI.GroupGetParams;
    export import ServiceTokens = ServiceTokensAPI.ServiceTokens;
    export import ServiceToken = ServiceTokensAPI.ServiceToken;
    export import ServiceTokenCreateResponse = ServiceTokensAPI.ServiceTokenCreateResponse;
    export import ServiceTokenRotateResponse = ServiceTokensAPI.ServiceTokenRotateResponse;
    export import ServiceTokensSinglePage = ServiceTokensAPI.ServiceTokensSinglePage;
    export import ServiceTokenCreateParams = ServiceTokensAPI.ServiceTokenCreateParams;
    export import ServiceTokenUpdateParams = ServiceTokensAPI.ServiceTokenUpdateParams;
    export import ServiceTokenListParams = ServiceTokensAPI.ServiceTokenListParams;
    export import ServiceTokenDeleteParams = ServiceTokensAPI.ServiceTokenDeleteParams;
    export import Bookmarks = BookmarksAPI.Bookmarks;
    export import Bookmark = BookmarksAPI.Bookmark;
    export import BookmarkDeleteResponse = BookmarksAPI.BookmarkDeleteResponse;
    export import BookmarksSinglePage = BookmarksAPI.BookmarksSinglePage;
    export import BookmarkCreateParams = BookmarksAPI.BookmarkCreateParams;
    export import BookmarkUpdateParams = BookmarksAPI.BookmarkUpdateParams;
    export import Keys = KeysAPI.Keys;
    export import KeyUpdateResponse = KeysAPI.KeyUpdateResponse;
    export import KeyGetResponse = KeysAPI.KeyGetResponse;
    export import KeyRotateResponse = KeysAPI.KeyRotateResponse;
    export import KeyUpdateParams = KeysAPI.KeyUpdateParams;
    export import Logs = LogsAPI.Logs;
    export import Users = UsersAPI.Users;
    export import AccessUser = UsersAPI.AccessUser;
    export import AccessUsersSinglePage = UsersAPI.AccessUsersSinglePage;
    export import CustomPages = CustomPagesAPI.CustomPages;
    export import CustomPage = CustomPagesAPI.CustomPage;
    export import CustomPageWithoutHTML = CustomPagesAPI.CustomPageWithoutHTML;
    export import CustomPageDeleteResponse = CustomPagesAPI.CustomPageDeleteResponse;
    export import CustomPageWithoutHTMLsSinglePage = CustomPagesAPI.CustomPageWithoutHTMLsSinglePage;
    export import CustomPageCreateParams = CustomPagesAPI.CustomPageCreateParams;
    export import CustomPageUpdateParams = CustomPagesAPI.CustomPageUpdateParams;
    export import Tags = TagsAPI.Tags;
    export import Tag = TagsAPI.Tag;
    export import TagDeleteResponse = TagsAPI.TagDeleteResponse;
    export import TagsSinglePage = TagsAPI.TagsSinglePage;
    export import TagCreateParams = TagsAPI.TagCreateParams;
    export import TagUpdateParams = TagsAPI.TagUpdateParams;
}
//# sourceMappingURL=access.d.ts.map