/**
 * Cloudflare ACCOUNTS API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service accounts
 */
import * as Schema from "effect/Schema";
import type * as HttpClient from "effect/unstable/http/HttpClient";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import { type DefaultErrors } from "../errors.ts";
declare const AccountCreationForbidden_base: Schema.Class<AccountCreationForbidden, Schema.TaggedStruct<"AccountCreationForbidden", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class AccountCreationForbidden extends AccountCreationForbidden_base {
}
declare const AccountNameTooLong_base: Schema.Class<AccountNameTooLong, Schema.TaggedStruct<"AccountNameTooLong", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class AccountNameTooLong extends AccountNameTooLong_base {
}
declare const BadRequest_base: Schema.Class<BadRequest, Schema.TaggedStruct<"BadRequest", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class BadRequest extends BadRequest_base {
}
declare const EndpointNotFound_base: Schema.Class<EndpointNotFound, Schema.TaggedStruct<"EndpointNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class EndpointNotFound extends EndpointNotFound_base {
}
declare const InvalidAccountName_base: Schema.Class<InvalidAccountName, Schema.TaggedStruct<"InvalidAccountName", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidAccountName extends InvalidAccountName_base {
}
declare const InvalidRoute_base: Schema.Class<InvalidRoute, Schema.TaggedStruct<"InvalidRoute", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidRoute extends InvalidRoute_base {
}
declare const InvalidTokenName_base: Schema.Class<InvalidTokenName, Schema.TaggedStruct<"InvalidTokenName", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidTokenName extends InvalidTokenName_base {
}
declare const JsonDecodeFailure_base: Schema.Class<JsonDecodeFailure, Schema.TaggedStruct<"JsonDecodeFailure", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class JsonDecodeFailure extends JsonDecodeFailure_base {
}
declare const MemberNotFound_base: Schema.Class<MemberNotFound, Schema.TaggedStruct<"MemberNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class MemberNotFound extends MemberNotFound_base {
}
declare const MethodNotAllowed_base: Schema.Class<MethodNotAllowed, Schema.TaggedStruct<"MethodNotAllowed", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class MethodNotAllowed extends MethodNotAllowed_base {
}
declare const MissingAuthenticationToken_base: Schema.Class<MissingAuthenticationToken, Schema.TaggedStruct<"MissingAuthenticationToken", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class MissingAuthenticationToken extends MissingAuthenticationToken_base {
}
declare const MissingName_base: Schema.Class<MissingName, Schema.TaggedStruct<"MissingName", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class MissingName extends MissingName_base {
}
declare const PermissionGroupNotFound_base: Schema.Class<PermissionGroupNotFound, Schema.TaggedStruct<"PermissionGroupNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class PermissionGroupNotFound extends PermissionGroupNotFound_base {
}
declare const TokenNotFound_base: Schema.Class<TokenNotFound, Schema.TaggedStruct<"TokenNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class TokenNotFound extends TokenNotFound_base {
}
declare const UpdateAccountTypeNotSupported_base: Schema.Class<UpdateAccountTypeNotSupported, Schema.TaggedStruct<"UpdateAccountTypeNotSupported", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class UpdateAccountTypeNotSupported extends UpdateAccountTypeNotSupported_base {
}
declare const ValidationError_base: Schema.Class<ValidationError, Schema.TaggedStruct<"ValidationError", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class ValidationError extends ValidationError_base {
}
export interface GetAccountRequest {
    /** Account identifier tag. */
    accountId: string;
}
export declare const GetAccountRequest: Schema.Schema<GetAccountRequest>;
export interface GetAccountResponse {
    /** Identifier */
    id: string;
    /** Account name */
    name: string;
    type: "standard" | "enterprise";
    /** Timestamp for the creation of the account */
    createdOn?: string | null;
    /** Parent container details */
    managedBy?: {
        parentOrgId?: string | null;
        parentOrgName?: string | null;
    } | null;
    /** Account settings */
    settings?: {
        abuseContactEmail?: string | null;
        enforceTwofactor?: boolean | null;
    } | null;
}
export declare const GetAccountResponse: Schema.Schema<GetAccountResponse>;
export type GetAccountError = DefaultErrors | InvalidRoute;
export declare const getAccount: API.OperationMethod<GetAccountRequest, GetAccountResponse, GetAccountError, Credentials | HttpClient.HttpClient>;
export interface ListAccountsRequest {
}
export declare const ListAccountsRequest: Schema.Schema<ListAccountsRequest>;
export interface ListAccountsResponse {
    result: {
        id: string;
        name: string;
        type: "standard" | "enterprise";
        createdOn?: string | null;
        managedBy?: {
            parentOrgId?: string | null;
            parentOrgName?: string | null;
        } | null;
        settings?: {
            abuseContactEmail?: string | null;
            enforceTwofactor?: boolean | null;
        } | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListAccountsResponse: Schema.Schema<ListAccountsResponse>;
export type ListAccountsError = DefaultErrors;
export declare const listAccounts: API.PaginatedOperationMethod<ListAccountsRequest, ListAccountsResponse, ListAccountsError, Credentials | HttpClient.HttpClient>;
export interface CreateAccountRequest {
    /** Account name */
    name: string;
    type?: "standard" | "enterprise";
    /** information related to the tenant unit, and optionally, an id of the unit to create the account on. see https://developers.cloudflare.com/tenant/how-to/manage-accounts/ */
    unit?: {
        id?: string;
    };
}
export declare const CreateAccountRequest: Schema.Schema<CreateAccountRequest>;
export interface CreateAccountResponse {
    /** Identifier */
    id: string;
    /** Account name */
    name: string;
    type: "standard" | "enterprise";
    /** Timestamp for the creation of the account */
    createdOn?: string | null;
    /** Parent container details */
    managedBy?: {
        parentOrgId?: string | null;
        parentOrgName?: string | null;
    } | null;
    /** Account settings */
    settings?: {
        abuseContactEmail?: string | null;
        enforceTwofactor?: boolean | null;
    } | null;
}
export declare const CreateAccountResponse: Schema.Schema<CreateAccountResponse>;
export type CreateAccountError = DefaultErrors | AccountCreationForbidden | MissingName;
export declare const createAccount: API.OperationMethod<CreateAccountRequest, CreateAccountResponse, CreateAccountError, Credentials | HttpClient.HttpClient>;
export interface UpdateAccountRequest {
    /** Path param: Account identifier tag. */
    accountId: string;
    /** Body param: Identifier */
    id: string;
    /** Body param: Account name */
    name: string;
    /** Body param: */
    type?: "standard" | "enterprise";
    /** Body param: Parent container details */
    managedBy?: unknown;
    /** Body param: Account settings */
    settings?: {
        abuseContactEmail?: string;
        enforceTwofactor?: boolean;
    };
}
export declare const UpdateAccountRequest: Schema.Schema<UpdateAccountRequest>;
export interface UpdateAccountResponse {
    /** Identifier */
    id: string;
    /** Account name */
    name: string;
    type: "standard" | "enterprise";
    /** Timestamp for the creation of the account */
    createdOn?: string | null;
    /** Parent container details */
    managedBy?: {
        parentOrgId?: string | null;
        parentOrgName?: string | null;
    } | null;
    /** Account settings */
    settings?: {
        abuseContactEmail?: string | null;
        enforceTwofactor?: boolean | null;
    } | null;
}
export declare const UpdateAccountResponse: Schema.Schema<UpdateAccountResponse>;
export type UpdateAccountError = DefaultErrors | InvalidAccountName | AccountNameTooLong | UpdateAccountTypeNotSupported | InvalidRoute | MethodNotAllowed;
export declare const updateAccount: API.OperationMethod<UpdateAccountRequest, UpdateAccountResponse, UpdateAccountError, Credentials | HttpClient.HttpClient>;
export interface DeleteAccountRequest {
    /** The account ID of the account to be deleted */
    accountId: string;
}
export declare const DeleteAccountRequest: Schema.Schema<DeleteAccountRequest>;
export interface DeleteAccountResponse {
    /** Identifier */
    id: string;
}
export declare const DeleteAccountResponse: Schema.Schema<DeleteAccountResponse>;
export type DeleteAccountError = DefaultErrors | InvalidRoute | MethodNotAllowed;
export declare const deleteAccount: API.OperationMethod<DeleteAccountRequest, DeleteAccountResponse, DeleteAccountError, Credentials | HttpClient.HttpClient>;
export interface ListLogAuditsRequest {
    /** Path param: The unique id that identifies the account. */
    accountId: string;
    cursor?: string;
    /** Query param: Limits the returned results to logs older than the specified date. This can be a date string 2019-04-30 (interpreted in UTC) or an absolute timestamp that conforms to RFC3339. */
    before: string;
    /** Query param: Limits the returned results to logs newer than the specified date. This can be a date string 2019-04-30 (interpreted in UTC) or an absolute timestamp that conforms to RFC3339. */
    since: string;
    /** Query param: */
    id?: {
        not?: string[];
    };
    /** Query param: */
    accountName?: {
        not?: string[];
    };
    /** Query param: */
    actionResult?: {
        not?: ("success" | "failure")[];
    };
    /** Query param: */
    actionType?: {
        not?: ("create" | "delete" | "view" | "update")[];
    };
    /** Query param: */
    actorContext?: {
        not?: ("api_key" | "api_token" | "dash" | "oauth" | "origin_ca_key")[];
    };
    /** Query param: */
    actorEmail?: {
        not?: string[];
    };
    /** Query param: */
    actorId?: {
        not?: string[];
    };
    /** Query param: */
    actorIpAddress?: {
        not?: string[];
    };
    /** Query param: */
    actorTokenId?: {
        not?: string[];
    };
    /** Query param: */
    actorTokenName?: {
        not?: string[];
    };
    /** Query param: */
    actorType?: {
        not?: ("account" | "cloudflare_admin" | "system" | "user")[];
    };
    /** Query param: */
    auditLogId?: {
        not?: string[];
    };
    /** Query param: Sets sorting order. */
    direction?: "desc" | "asc";
    /** Query param: The number limits the objects to return. The cursor attribute may be used to iterate over the next batch of objects if there are more than the limit. */
    limit?: number;
    /** Query param: */
    rawCfRayId?: {
        not?: string[];
    };
    /** Query param: */
    rawMethod?: {
        not?: string[];
    };
    /** Query param: */
    rawStatusCode?: {
        not?: number[];
    };
    /** Query param: */
    rawUri?: {
        not?: string[];
    };
    /** Query param: */
    resourceId?: {
        not?: string[];
    };
    /** Query param: */
    resourceProduct?: {
        not?: string[];
    };
    /** Query param: */
    resourceScope?: {
        not?: ("accounts" | "user" | "zones")[];
    };
    /** Query param: */
    resourceType?: {
        not?: string[];
    };
    /** Query param: */
    zoneId?: {
        not?: string[];
    };
    /** Query param: */
    zoneName?: {
        not?: string[];
    };
}
export declare const ListLogAuditsRequest: Schema.Schema<ListLogAuditsRequest>;
export interface ListLogAuditsResponse {
    result: {
        id?: string | null;
        account?: {
            id?: string | null;
            name?: string | null;
        } | null;
        action?: {
            description?: string | null;
            result?: string | null;
            time?: string | null;
            type?: string | null;
        } | null;
        actor?: {
            id?: string | null;
            context?: "api_key" | "api_token" | "dash" | "oauth" | "origin_ca_key" | null;
            email?: string | null;
            ipAddress?: string | null;
            tokenId?: string | null;
            tokenName?: string | null;
            type?: "account" | "cloudflare_admin" | "system" | "user" | null;
        } | null;
        raw?: {
            cfRayId?: string | null;
            method?: string | null;
            statusCode?: number | null;
            uri?: string | null;
            userAgent?: string | null;
        } | null;
        resource?: {
            id?: string | null;
            product?: string | null;
            request?: unknown | null;
            response?: unknown | null;
            scope?: unknown | null;
            type?: string | null;
        } | null;
        zone?: {
            id?: string | null;
            name?: string | null;
        } | null;
    }[];
    resultInfo?: {
        cursors?: {
            after?: string | null;
        } | null;
    } | null;
}
export declare const ListLogAuditsResponse: Schema.Schema<ListLogAuditsResponse>;
export type ListLogAuditsError = DefaultErrors;
export declare const listLogAudits: API.PaginatedOperationMethod<ListLogAuditsRequest, ListLogAuditsResponse, ListLogAuditsError, Credentials | HttpClient.HttpClient>;
export interface GetMemberRequest {
    memberId: string;
    /** Account identifier tag. */
    accountId: string;
}
export declare const GetMemberRequest: Schema.Schema<GetMemberRequest>;
export interface GetMemberResponse {
    /** Membership identifier tag. */
    id?: string | null;
    /** The contact email address of the user. */
    email?: string | null;
    /** Access policy for the membership */
    policies?: {
        id?: string | null;
        access?: "allow" | "deny" | null;
        permissionGroups?: {
            id: string;
        }[] | null;
        resourceGroups?: {
            id: string;
        }[] | null;
    }[] | null;
    /** Roles assigned to this Member. */
    roles?: {
        id: string;
        description: string;
        name: string;
        permissions: {
            analytics?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            billing?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            cachePurge?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            dns?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            dnsRecords?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            lb?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            logs?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            organization?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            ssl?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            waf?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            zoneSettings?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            zones?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
        };
    }[] | null;
    /** A member's status in the account. */
    status?: "accepted" | "pending" | null;
    /** Details of the user associated to the membership. */
    user?: {
        email: string;
        id?: string | null;
        firstName?: string | null;
        lastName?: string | null;
        twoFactorAuthenticationEnabled?: boolean | null;
    } | null;
}
export declare const GetMemberResponse: Schema.Schema<GetMemberResponse>;
export type GetMemberError = DefaultErrors | MemberNotFound | InvalidRoute;
export declare const getMember: API.OperationMethod<GetMemberRequest, GetMemberResponse, GetMemberError, Credentials | HttpClient.HttpClient>;
export interface ListMembersRequest {
    /** Path param: Account identifier tag. */
    accountId: string;
    page?: number;
    perPage?: number;
    /** Query param: Direction to order results. */
    direction?: "asc" | "desc";
    /** Query param: Field to order results by. */
    order?: "user.first_name" | "user.last_name" | "user.email" | "status";
    /** Query param: A member's status in the account. */
    status?: "accepted" | "pending" | "rejected";
}
export declare const ListMembersRequest: Schema.Schema<ListMembersRequest>;
export interface ListMembersResponse {
    result: {
        id?: string | null;
        email?: string | null;
        policies?: {
            id?: string | null;
            access?: "allow" | "deny" | null;
            permissionGroups?: {
                id: string;
            }[] | null;
            resourceGroups?: {
                id: string;
            }[] | null;
        }[] | null;
        roles?: {
            id: string;
            description: string;
            name: string;
            permissions: {
                analytics?: {
                    read?: boolean | null;
                    write?: boolean | null;
                } | null;
                billing?: {
                    read?: boolean | null;
                    write?: boolean | null;
                } | null;
                cachePurge?: {
                    read?: boolean | null;
                    write?: boolean | null;
                } | null;
                dns?: {
                    read?: boolean | null;
                    write?: boolean | null;
                } | null;
                dnsRecords?: {
                    read?: boolean | null;
                    write?: boolean | null;
                } | null;
                lb?: {
                    read?: boolean | null;
                    write?: boolean | null;
                } | null;
                logs?: {
                    read?: boolean | null;
                    write?: boolean | null;
                } | null;
                organization?: {
                    read?: boolean | null;
                    write?: boolean | null;
                } | null;
                ssl?: {
                    read?: boolean | null;
                    write?: boolean | null;
                } | null;
                waf?: {
                    read?: boolean | null;
                    write?: boolean | null;
                } | null;
                zoneSettings?: {
                    read?: boolean | null;
                    write?: boolean | null;
                } | null;
                zones?: {
                    read?: boolean | null;
                    write?: boolean | null;
                } | null;
            };
        }[] | null;
        status?: "accepted" | "pending" | null;
        user?: {
            email: string;
            id?: string | null;
            firstName?: string | null;
            lastName?: string | null;
            twoFactorAuthenticationEnabled?: boolean | null;
        } | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListMembersResponse: Schema.Schema<ListMembersResponse>;
export type ListMembersError = DefaultErrors;
export declare const listMembers: API.PaginatedOperationMethod<ListMembersRequest, ListMembersResponse, ListMembersError, Credentials | HttpClient.HttpClient>;
export interface CreateMemberRequest {
    /** Path param: Account identifier tag. */
    accountId: string;
    /** Body param: The contact email address of the user. */
    email: string;
    /** Body param: Array of roles associated with this member. */
    roles: string[];
    /** Body param: */
    status?: "accepted" | "pending";
}
export declare const CreateMemberRequest: Schema.Schema<CreateMemberRequest>;
export interface CreateMemberResponse {
    /** Membership identifier tag. */
    id?: string | null;
    /** The contact email address of the user. */
    email?: string | null;
    /** Access policy for the membership */
    policies?: {
        id?: string | null;
        access?: "allow" | "deny" | null;
        permissionGroups?: {
            id: string;
        }[] | null;
        resourceGroups?: {
            id: string;
        }[] | null;
    }[] | null;
    /** Roles assigned to this Member. */
    roles?: {
        id: string;
        description: string;
        name: string;
        permissions: {
            analytics?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            billing?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            cachePurge?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            dns?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            dnsRecords?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            lb?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            logs?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            organization?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            ssl?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            waf?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            zoneSettings?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            zones?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
        };
    }[] | null;
    /** A member's status in the account. */
    status?: "accepted" | "pending" | null;
    /** Details of the user associated to the membership. */
    user?: {
        email: string;
        id?: string | null;
        firstName?: string | null;
        lastName?: string | null;
        twoFactorAuthenticationEnabled?: boolean | null;
    } | null;
}
export declare const CreateMemberResponse: Schema.Schema<CreateMemberResponse>;
export type CreateMemberError = DefaultErrors | InvalidRoute | ValidationError;
export declare const createMember: API.OperationMethod<CreateMemberRequest, CreateMemberResponse, CreateMemberError, Credentials | HttpClient.HttpClient>;
export interface UpdateMemberRequest {
    memberId: string;
    /** Path param: Account identifier tag. */
    accountId: string;
    /** Body param: Roles assigned to this member. */
    roles?: {
        id: string;
    }[];
}
export declare const UpdateMemberRequest: Schema.Schema<UpdateMemberRequest>;
export interface UpdateMemberResponse {
    /** Membership identifier tag. */
    id?: string | null;
    /** The contact email address of the user. */
    email?: string | null;
    /** Access policy for the membership */
    policies?: {
        id?: string | null;
        access?: "allow" | "deny" | null;
        permissionGroups?: {
            id: string;
        }[] | null;
        resourceGroups?: {
            id: string;
        }[] | null;
    }[] | null;
    /** Roles assigned to this Member. */
    roles?: {
        id: string;
        description: string;
        name: string;
        permissions: {
            analytics?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            billing?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            cachePurge?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            dns?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            dnsRecords?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            lb?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            logs?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            organization?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            ssl?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            waf?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            zoneSettings?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            zones?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
        };
    }[] | null;
    /** A member's status in the account. */
    status?: "accepted" | "pending" | null;
    /** Details of the user associated to the membership. */
    user?: {
        email: string;
        id?: string | null;
        firstName?: string | null;
        lastName?: string | null;
        twoFactorAuthenticationEnabled?: boolean | null;
    } | null;
}
export declare const UpdateMemberResponse: Schema.Schema<UpdateMemberResponse>;
export type UpdateMemberError = DefaultErrors | MemberNotFound | InvalidRoute | BadRequest | MethodNotAllowed;
export declare const updateMember: API.OperationMethod<UpdateMemberRequest, UpdateMemberResponse, UpdateMemberError, Credentials | HttpClient.HttpClient>;
export interface DeleteMemberRequest {
    memberId: string;
    /** Account identifier tag. */
    accountId: string;
}
export declare const DeleteMemberRequest: Schema.Schema<DeleteMemberRequest>;
export interface DeleteMemberResponse {
    /** Identifier */
    id: string;
}
export declare const DeleteMemberResponse: Schema.Schema<DeleteMemberResponse>;
export type DeleteMemberError = DefaultErrors | MemberNotFound | InvalidRoute;
export declare const deleteMember: API.OperationMethod<DeleteMemberRequest, DeleteMemberResponse, DeleteMemberError, Credentials | HttpClient.HttpClient>;
export interface GetRoleRequest {
    roleId: string;
    /** Account identifier tag. */
    accountId: string;
}
export declare const GetRoleRequest: Schema.Schema<GetRoleRequest>;
export interface GetRoleResponse {
    /** Role identifier tag. */
    id: string;
    /** Description of role's permissions. */
    description: string;
    /** Role name. */
    name: string;
    permissions: {
        analytics?: {
            read?: boolean | null;
            write?: boolean | null;
        } | null;
        billing?: {
            read?: boolean | null;
            write?: boolean | null;
        } | null;
        cachePurge?: {
            read?: boolean | null;
            write?: boolean | null;
        } | null;
        dns?: {
            read?: boolean | null;
            write?: boolean | null;
        } | null;
        dnsRecords?: {
            read?: boolean | null;
            write?: boolean | null;
        } | null;
        lb?: {
            read?: boolean | null;
            write?: boolean | null;
        } | null;
        logs?: {
            read?: boolean | null;
            write?: boolean | null;
        } | null;
        organization?: {
            read?: boolean | null;
            write?: boolean | null;
        } | null;
        ssl?: {
            read?: boolean | null;
            write?: boolean | null;
        } | null;
        waf?: {
            read?: boolean | null;
            write?: boolean | null;
        } | null;
        zoneSettings?: {
            read?: boolean | null;
            write?: boolean | null;
        } | null;
        zones?: {
            read?: boolean | null;
            write?: boolean | null;
        } | null;
    };
}
export declare const GetRoleResponse: Schema.Schema<GetRoleResponse>;
export type GetRoleError = DefaultErrors | InvalidRoute;
export declare const getRole: API.OperationMethod<GetRoleRequest, GetRoleResponse, GetRoleError, Credentials | HttpClient.HttpClient>;
export interface ListRolesRequest {
    /** Path param: Account identifier tag. */
    accountId: string;
    page?: number;
    perPage?: number;
}
export declare const ListRolesRequest: Schema.Schema<ListRolesRequest>;
export interface ListRolesResponse {
    result: {
        id: string;
        description: string;
        name: string;
        permissions: {
            analytics?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            billing?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            cachePurge?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            dns?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            dnsRecords?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            lb?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            logs?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            organization?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            ssl?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            waf?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            zoneSettings?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
            zones?: {
                read?: boolean | null;
                write?: boolean | null;
            } | null;
        };
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListRolesResponse: Schema.Schema<ListRolesResponse>;
export type ListRolesError = DefaultErrors;
export declare const listRoles: API.PaginatedOperationMethod<ListRolesRequest, ListRolesResponse, ListRolesError, Credentials | HttpClient.HttpClient>;
export interface GetSubscriptionRequest {
    /** Identifier */
    accountId: string;
}
export declare const GetSubscriptionRequest: Schema.Schema<GetSubscriptionRequest>;
export interface GetSubscriptionResponse {
    result: {
        id?: string | null;
        currency?: string | null;
        currentPeriodEnd?: string | null;
        currentPeriodStart?: string | null;
        frequency?: "weekly" | "monthly" | "quarterly" | "yearly" | null;
        price?: number | null;
        ratePlan?: {
            id?: "free" | "lite" | "pro" | "pro_plus" | "business" | "enterprise" | "partners_free" | "partners_pro" | "partners_business" | "partners_enterprise" | null;
            currency?: string | null;
            externallyManaged?: boolean | null;
            isContract?: boolean | null;
            publicName?: string | null;
            scope?: string | null;
            sets?: string[] | null;
        } | null;
        state?: "Trial" | "Provisioned" | "Paid" | "AwaitingPayment" | "Cancelled" | "Failed" | "Expired" | null;
    }[];
}
export declare const GetSubscriptionResponse: Schema.Schema<GetSubscriptionResponse>;
export type GetSubscriptionError = DefaultErrors;
export declare const getSubscription: API.PaginatedOperationMethod<GetSubscriptionRequest, GetSubscriptionResponse, GetSubscriptionError, Credentials | HttpClient.HttpClient>;
export interface CreateSubscriptionRequest {
    /** Path param: Identifier */
    accountId: string;
    /** Body param: How often the subscription is renewed automatically. */
    frequency?: "weekly" | "monthly" | "quarterly" | "yearly";
    /** Body param: The rate plan applied to the subscription. */
    ratePlan?: {
        id?: "free" | "lite" | "pro" | "pro_plus" | "business" | "enterprise" | "partners_free" | "partners_pro" | "partners_business" | "partners_enterprise";
        currency?: string;
        externallyManaged?: boolean;
        isContract?: boolean;
        publicName?: string;
        scope?: string;
        sets?: string[];
    };
}
export declare const CreateSubscriptionRequest: Schema.Schema<CreateSubscriptionRequest>;
export interface CreateSubscriptionResponse {
    /** Subscription identifier tag. */
    id?: string | null;
    /** The monetary unit in which pricing information is displayed. */
    currency?: string | null;
    /** The end of the current period and also when the next billing is due. */
    currentPeriodEnd?: string | null;
    /** When the current billing period started. May match initial_period_start if this is the first period. */
    currentPeriodStart?: string | null;
    /** How often the subscription is renewed automatically. */
    frequency?: "weekly" | "monthly" | "quarterly" | "yearly" | null;
    /** The price of the subscription that will be billed, in US dollars. */
    price?: number | null;
    /** The rate plan applied to the subscription. */
    ratePlan?: {
        id?: "free" | "lite" | "pro" | "pro_plus" | "business" | "enterprise" | "partners_free" | "partners_pro" | "partners_business" | "partners_enterprise" | null;
        currency?: string | null;
        externallyManaged?: boolean | null;
        isContract?: boolean | null;
        publicName?: string | null;
        scope?: string | null;
        sets?: string[] | null;
    } | null;
    /** The state that the subscription is in. */
    state?: "Trial" | "Provisioned" | "Paid" | "AwaitingPayment" | "Cancelled" | "Failed" | "Expired" | null;
}
export declare const CreateSubscriptionResponse: Schema.Schema<CreateSubscriptionResponse>;
export type CreateSubscriptionError = DefaultErrors | JsonDecodeFailure | InvalidRoute;
export declare const createSubscription: API.OperationMethod<CreateSubscriptionRequest, CreateSubscriptionResponse, CreateSubscriptionError, Credentials | HttpClient.HttpClient>;
export interface UpdateSubscriptionRequest {
    subscriptionIdentifier: string;
    /** Path param: Identifier */
    accountId: string;
    /** Body param: How often the subscription is renewed automatically. */
    frequency?: "weekly" | "monthly" | "quarterly" | "yearly";
    /** Body param: The rate plan applied to the subscription. */
    ratePlan?: {
        id?: "free" | "lite" | "pro" | "pro_plus" | "business" | "enterprise" | "partners_free" | "partners_pro" | "partners_business" | "partners_enterprise";
        currency?: string;
        externallyManaged?: boolean;
        isContract?: boolean;
        publicName?: string;
        scope?: string;
        sets?: string[];
    };
}
export declare const UpdateSubscriptionRequest: Schema.Schema<UpdateSubscriptionRequest>;
export interface UpdateSubscriptionResponse {
    /** Subscription identifier tag. */
    id?: string | null;
    /** The monetary unit in which pricing information is displayed. */
    currency?: string | null;
    /** The end of the current period and also when the next billing is due. */
    currentPeriodEnd?: string | null;
    /** When the current billing period started. May match initial_period_start if this is the first period. */
    currentPeriodStart?: string | null;
    /** How often the subscription is renewed automatically. */
    frequency?: "weekly" | "monthly" | "quarterly" | "yearly" | null;
    /** The price of the subscription that will be billed, in US dollars. */
    price?: number | null;
    /** The rate plan applied to the subscription. */
    ratePlan?: {
        id?: "free" | "lite" | "pro" | "pro_plus" | "business" | "enterprise" | "partners_free" | "partners_pro" | "partners_business" | "partners_enterprise" | null;
        currency?: string | null;
        externallyManaged?: boolean | null;
        isContract?: boolean | null;
        publicName?: string | null;
        scope?: string | null;
        sets?: string[] | null;
    } | null;
    /** The state that the subscription is in. */
    state?: "Trial" | "Provisioned" | "Paid" | "AwaitingPayment" | "Cancelled" | "Failed" | "Expired" | null;
}
export declare const UpdateSubscriptionResponse: Schema.Schema<UpdateSubscriptionResponse>;
export type UpdateSubscriptionError = DefaultErrors | JsonDecodeFailure | InvalidRoute | EndpointNotFound;
export declare const updateSubscription: API.OperationMethod<UpdateSubscriptionRequest, UpdateSubscriptionResponse, UpdateSubscriptionError, Credentials | HttpClient.HttpClient>;
export interface DeleteSubscriptionRequest {
    subscriptionIdentifier: string;
    /** Identifier */
    accountId: string;
}
export declare const DeleteSubscriptionRequest: Schema.Schema<DeleteSubscriptionRequest>;
export interface DeleteSubscriptionResponse {
    /** Subscription identifier tag. */
    subscriptionId?: string | null;
}
export declare const DeleteSubscriptionResponse: Schema.Schema<DeleteSubscriptionResponse>;
export type DeleteSubscriptionError = DefaultErrors | InvalidRoute | EndpointNotFound;
export declare const deleteSubscription: API.OperationMethod<DeleteSubscriptionRequest, DeleteSubscriptionResponse, DeleteSubscriptionError, Credentials | HttpClient.HttpClient>;
export interface GetTokenRequest {
    tokenId: string;
    /** Account identifier tag. */
    accountId: string;
}
export declare const GetTokenRequest: Schema.Schema<GetTokenRequest>;
export interface GetTokenResponse {
    /** Token identifier tag. */
    id?: string | null;
    condition?: {
        requestIp?: {
            in?: string[] | null;
            notIn?: string[] | null;
        } | null;
    } | null;
    /** The expiration time on or after which the JWT MUST NOT be accepted for processing. */
    expiresOn?: string | null;
    /** The time on which the token was created. */
    issuedOn?: string | null;
    /** Last time the token was used. */
    lastUsedOn?: string | null;
    /** Last time the token was modified. */
    modifiedOn?: string | null;
    /** Token name. */
    name?: string | null;
    /** The time before which the token MUST NOT be accepted for processing. */
    notBefore?: string | null;
    /** List of access policies assigned to the token. */
    policies?: {
        id: string;
        effect: "allow" | "deny";
        permissionGroups: {
            id: string;
            meta?: {
                key?: string | null;
                value?: string | null;
            } | null;
            name?: string | null;
        }[];
        resources: Record<string, unknown>;
    }[] | null;
    /** Status of the token. */
    status?: "active" | "disabled" | "expired" | null;
}
export declare const GetTokenResponse: Schema.Schema<GetTokenResponse>;
export type GetTokenError = DefaultErrors | InvalidRoute | TokenNotFound;
export declare const getToken: API.OperationMethod<GetTokenRequest, GetTokenResponse, GetTokenError, Credentials | HttpClient.HttpClient>;
export interface ListTokensRequest {
    /** Path param: Account identifier tag. */
    accountId: string;
    page?: number;
    perPage?: number;
    /** Query param: Direction to order results. */
    direction?: "asc" | "desc";
}
export declare const ListTokensRequest: Schema.Schema<ListTokensRequest>;
export interface ListTokensResponse {
    result: {
        id?: string | null;
        condition?: {
            requestIp?: {
                in?: string[] | null;
                notIn?: string[] | null;
            } | null;
        } | null;
        expiresOn?: string | null;
        issuedOn?: string | null;
        lastUsedOn?: string | null;
        modifiedOn?: string | null;
        name?: string | null;
        notBefore?: string | null;
        policies?: {
            id: string;
            effect: "allow" | "deny";
            permissionGroups: {
                id: string;
                meta?: {
                    key?: string | null;
                    value?: string | null;
                } | null;
                name?: string | null;
            }[];
            resources: Record<string, unknown>;
        }[] | null;
        status?: "active" | "disabled" | "expired" | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListTokensResponse: Schema.Schema<ListTokensResponse>;
export type ListTokensError = DefaultErrors;
export declare const listTokens: API.PaginatedOperationMethod<ListTokensRequest, ListTokensResponse, ListTokensError, Credentials | HttpClient.HttpClient>;
export interface CreateTokenRequest {
    /** Path param: Account identifier tag. */
    accountId: string;
    /** Body param: Token name. */
    name: string;
    /** Body param: List of access policies assigned to the token. */
    policies: {
        effect: "allow" | "deny";
        permissionGroups: {
            id: string;
            meta?: {
                key?: string;
                value?: string;
            };
        }[];
        resources: Record<string, unknown>;
    }[];
    /** Body param: */
    condition?: {
        requestIp?: {
            in?: string[];
            notIn?: string[];
        };
    };
    /** Body param: The expiration time on or after which the JWT MUST NOT be accepted for processing. */
    expiresOn?: string;
    /** Body param: The time before which the token MUST NOT be accepted for processing. */
    notBefore?: string;
}
export declare const CreateTokenRequest: Schema.Schema<CreateTokenRequest>;
export interface CreateTokenResponse {
    /** Token identifier tag. */
    id?: string | null;
    condition?: {
        requestIp?: {
            in?: string[] | null;
            notIn?: string[] | null;
        } | null;
    } | null;
    /** The expiration time on or after which the JWT MUST NOT be accepted for processing. */
    expiresOn?: string | null;
    /** The time on which the token was created. */
    issuedOn?: string | null;
    /** Last time the token was used. */
    lastUsedOn?: string | null;
    /** Last time the token was modified. */
    modifiedOn?: string | null;
    /** Token name. */
    name?: string | null;
    /** The time before which the token MUST NOT be accepted for processing. */
    notBefore?: string | null;
    /** List of access policies assigned to the token. */
    policies?: {
        id: string;
        effect: "allow" | "deny";
        permissionGroups: {
            id: string;
            meta?: {
                key?: string | null;
                value?: string | null;
            } | null;
            name?: string | null;
        }[];
        resources: Record<string, unknown>;
    }[] | null;
    /** Status of the token. */
    status?: "active" | "disabled" | "expired" | null;
    /** The token value. */
    value?: string | null;
}
export declare const CreateTokenResponse: Schema.Schema<CreateTokenResponse>;
export type CreateTokenError = DefaultErrors | InvalidRoute | InvalidTokenName | PermissionGroupNotFound;
export declare const createToken: API.OperationMethod<CreateTokenRequest, CreateTokenResponse, CreateTokenError, Credentials | HttpClient.HttpClient>;
export interface UpdateTokenRequest {
    tokenId: string;
    /** Path param: Account identifier tag. */
    accountId: string;
    /** Body param: Token name. */
    name: string;
    /** Body param: List of access policies assigned to the token. */
    policies: {
        effect: "allow" | "deny";
        permissionGroups: {
            id: string;
            meta?: {
                key?: string;
                value?: string;
            };
        }[];
        resources: Record<string, unknown>;
    }[];
    /** Body param: */
    condition?: {
        requestIp?: {
            in?: string[];
            notIn?: string[];
        };
    };
    /** Body param: The expiration time on or after which the JWT MUST NOT be accepted for processing. */
    expiresOn?: string;
    /** Body param: The time before which the token MUST NOT be accepted for processing. */
    notBefore?: string;
    /** Body param: Status of the token. */
    status?: "active" | "disabled" | "expired";
}
export declare const UpdateTokenRequest: Schema.Schema<UpdateTokenRequest>;
export interface UpdateTokenResponse {
    /** Token identifier tag. */
    id?: string | null;
    condition?: {
        requestIp?: {
            in?: string[] | null;
            notIn?: string[] | null;
        } | null;
    } | null;
    /** The expiration time on or after which the JWT MUST NOT be accepted for processing. */
    expiresOn?: string | null;
    /** The time on which the token was created. */
    issuedOn?: string | null;
    /** Last time the token was used. */
    lastUsedOn?: string | null;
    /** Last time the token was modified. */
    modifiedOn?: string | null;
    /** Token name. */
    name?: string | null;
    /** The time before which the token MUST NOT be accepted for processing. */
    notBefore?: string | null;
    /** List of access policies assigned to the token. */
    policies?: {
        id: string;
        effect: "allow" | "deny";
        permissionGroups: {
            id: string;
            meta?: {
                key?: string | null;
                value?: string | null;
            } | null;
            name?: string | null;
        }[];
        resources: Record<string, unknown>;
    }[] | null;
    /** Status of the token. */
    status?: "active" | "disabled" | "expired" | null;
}
export declare const UpdateTokenResponse: Schema.Schema<UpdateTokenResponse>;
export type UpdateTokenError = DefaultErrors | InvalidRoute | MethodNotAllowed | TokenNotFound | PermissionGroupNotFound;
export declare const updateToken: API.OperationMethod<UpdateTokenRequest, UpdateTokenResponse, UpdateTokenError, Credentials | HttpClient.HttpClient>;
export interface DeleteTokenRequest {
    tokenId: string;
    /** Account identifier tag. */
    accountId: string;
}
export declare const DeleteTokenRequest: Schema.Schema<DeleteTokenRequest>;
export interface DeleteTokenResponse {
    /** Identifier */
    id: string;
}
export declare const DeleteTokenResponse: Schema.Schema<DeleteTokenResponse>;
export type DeleteTokenError = DefaultErrors | InvalidRoute | MethodNotAllowed | TokenNotFound;
export declare const deleteToken: API.OperationMethod<DeleteTokenRequest, DeleteTokenResponse, DeleteTokenError, Credentials | HttpClient.HttpClient>;
export interface VerifyTokenRequest {
    /** Account identifier tag. */
    accountId: string;
}
export declare const VerifyTokenRequest: Schema.Schema<VerifyTokenRequest>;
export interface VerifyTokenResponse {
    /** Token identifier tag. */
    id: string;
    /** Status of the token. */
    status: "active" | "disabled" | "expired";
    /** The expiration time on or after which the JWT MUST NOT be accepted for processing. */
    expiresOn?: string | null;
    /** The time before which the token MUST NOT be accepted for processing. */
    notBefore?: string | null;
}
export declare const VerifyTokenResponse: Schema.Schema<VerifyTokenResponse>;
export type VerifyTokenError = DefaultErrors | MissingAuthenticationToken | InvalidRoute;
export declare const verifyToken: API.OperationMethod<VerifyTokenRequest, VerifyTokenResponse, VerifyTokenError, Credentials | HttpClient.HttpClient>;
export interface GetTokenPermissionGroupRequest {
    /** Path param: Account identifier tag. */
    accountId: string;
    /** Query param: Filter by the name of the permission group. The value must be URL-encoded. */
    name?: string;
    /** Query param: Filter by the scope of the permission group. The value must be URL-encoded. */
    scope?: string;
}
export declare const GetTokenPermissionGroupRequest: Schema.Schema<GetTokenPermissionGroupRequest>;
export type GetTokenPermissionGroupResponse = {
    id?: string | null;
    name?: string | null;
    scopes?: ("com.cloudflare.api.account" | "com.cloudflare.api.account.zone" | "com.cloudflare.api.user" | "com.cloudflare.edge.r2.bucket")[] | null;
}[];
export declare const GetTokenPermissionGroupResponse: Schema.Schema<GetTokenPermissionGroupResponse>;
export type GetTokenPermissionGroupError = DefaultErrors | InvalidRoute;
export declare const getTokenPermissionGroup: API.OperationMethod<GetTokenPermissionGroupRequest, GetTokenPermissionGroupResponse, GetTokenPermissionGroupError, Credentials | HttpClient.HttpClient>;
export interface ListTokenPermissionGroupsRequest {
    /** Path param: Account identifier tag. */
    accountId: string;
    /** Query param: Filter by the name of the permission group. The value must be URL-encoded. */
    name?: string;
    /** Query param: Filter by the scope of the permission group. The value must be URL-encoded. */
    scope?: string;
}
export declare const ListTokenPermissionGroupsRequest: Schema.Schema<ListTokenPermissionGroupsRequest>;
export interface ListTokenPermissionGroupsResponse {
    result: {
        id?: string | null;
        name?: string | null;
        scopes?: ("com.cloudflare.api.account" | "com.cloudflare.api.account.zone" | "com.cloudflare.api.user" | "com.cloudflare.edge.r2.bucket")[] | null;
    }[];
}
export declare const ListTokenPermissionGroupsResponse: Schema.Schema<ListTokenPermissionGroupsResponse>;
export type ListTokenPermissionGroupsError = DefaultErrors;
export declare const listTokenPermissionGroups: API.PaginatedOperationMethod<ListTokenPermissionGroupsRequest, ListTokenPermissionGroupsResponse, ListTokenPermissionGroupsError, Credentials | HttpClient.HttpClient>;
export interface PutTokenValueRequest {
    tokenId: string;
    /** Path param: Account identifier tag. */
    accountId: string;
    /** Body param: */
    body: unknown;
}
export declare const PutTokenValueRequest: Schema.Schema<PutTokenValueRequest>;
export type PutTokenValueResponse = string;
export declare const PutTokenValueResponse: Schema.Schema<PutTokenValueResponse>;
export type PutTokenValueError = DefaultErrors | InvalidRoute | TokenNotFound;
export declare const putTokenValue: API.OperationMethod<PutTokenValueRequest, PutTokenValueResponse, PutTokenValueError, Credentials | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=accounts.d.ts.map