@distilled.cloud/cloudflare 0.0.0 → 0.2.0-alpha

package/lib/services/accounts.d.ts

@@ -0,0 +1,682 @@
+/**
+ * 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";
+import { type DefaultErrors } from "../errors";
+declare const AccountCreationForbidden_base: Schema.ErrorClass<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.ErrorClass<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.ErrorClass<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.ErrorClass<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.ErrorClass<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.ErrorClass<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.ErrorClass<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.ErrorClass<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.ErrorClass<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.ErrorClass<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.ErrorClass<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.ErrorClass<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 UpdateAccountTypeNotSupported_base: Schema.ErrorClass<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.ErrorClass<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 type ListAccountsResponse = {
+    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;
+}[];
+export declare const ListAccountsResponse: Schema.Schema<ListAccountsResponse>;
+export type ListAccountsError = DefaultErrors;
+export declare const listAccounts: API.OperationMethod<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;
+    /** 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 type ListLogAuditsResponse = {
+    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;
+}[];
+export declare const ListLogAuditsResponse: Schema.Schema<ListLogAuditsResponse>;
+export type ListLogAuditsError = DefaultErrors;
+export declare const listLogAudits: API.OperationMethod<ListLogAuditsRequest, ListLogAuditsResponse, ListLogAuditsError, Credentials | HttpClient.HttpClient>;
+export interface GetMemberRequest {
+    memberId: string;
+    /** Account identifier tag. */
+    accountId: string;
+}
+export declare const GetMemberRequest: Schema.Schema<GetMemberRequest>;
+export type GetMemberResponse = unknown;
+export declare const GetMemberResponse: Schema.Schema<unknown>;
+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;
+    /** 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 type ListMembersResponse = unknown;
+export declare const ListMembersResponse: Schema.Schema<unknown>;
+export type ListMembersError = DefaultErrors;
+export declare const listMembers: API.OperationMethod<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 type CreateMemberResponse = unknown;
+export declare const CreateMemberResponse: Schema.Schema<unknown>;
+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?: unknown[];
+}
+export declare const UpdateMemberRequest: Schema.Schema<UpdateMemberRequest>;
+export type UpdateMemberResponse = unknown;
+export declare const UpdateMemberResponse: Schema.Schema<unknown>;
+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 type GetRoleResponse = unknown;
+export declare const GetRoleResponse: Schema.Schema<unknown>;
+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;
+}
+export declare const ListRolesRequest: Schema.Schema<ListRolesRequest>;
+export type ListRolesResponse = unknown;
+export declare const ListRolesResponse: Schema.Schema<unknown>;
+export type ListRolesError = DefaultErrors;
+export declare const listRoles: API.OperationMethod<ListRolesRequest, ListRolesResponse, ListRolesError, Credentials | HttpClient.HttpClient>;
+export interface GetSubscriptionRequest {
+    /** Identifier */
+    accountId: string;
+}
+export declare const GetSubscriptionRequest: Schema.Schema<GetSubscriptionRequest>;
+export type GetSubscriptionResponse = unknown;
+export declare const GetSubscriptionResponse: Schema.Schema<unknown>;
+export type GetSubscriptionError = DefaultErrors;
+export declare const getSubscription: API.OperationMethod<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?: unknown;
+}
+export declare const CreateSubscriptionRequest: Schema.Schema<CreateSubscriptionRequest>;
+export type CreateSubscriptionResponse = unknown;
+export declare const CreateSubscriptionResponse: Schema.Schema<unknown>;
+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?: unknown;
+}
+export declare const UpdateSubscriptionRequest: Schema.Schema<UpdateSubscriptionRequest>;
+export type UpdateSubscriptionResponse = unknown;
+export declare const UpdateSubscriptionResponse: Schema.Schema<unknown>;
+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 type GetTokenResponse = unknown;
+export declare const GetTokenResponse: Schema.Schema<unknown>;
+export type GetTokenError = DefaultErrors | InvalidRoute;
+export declare const getToken: API.OperationMethod<GetTokenRequest, GetTokenResponse, GetTokenError, Credentials | HttpClient.HttpClient>;
+export interface ListTokensRequest {
+    /** Path param: Account identifier tag. */
+    accountId: string;
+    /** Query param: Direction to order results. */
+    direction?: "asc" | "desc";
+}
+export declare const ListTokensRequest: Schema.Schema<ListTokensRequest>;
+export type ListTokensResponse = unknown;
+export declare const ListTokensResponse: Schema.Schema<unknown>;
+export type ListTokensError = DefaultErrors;
+export declare const listTokens: API.OperationMethod<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: 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?: 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;
+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: 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 type UpdateTokenResponse = unknown;
+export declare const UpdateTokenResponse: Schema.Schema<unknown>;
+export type UpdateTokenError = DefaultErrors | InvalidRoute | MethodNotAllowed;
+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;
+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 type ListTokenPermissionGroupsResponse = {
+    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.OperationMethod<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 = unknown;
+export declare const PutTokenValueResponse: Schema.Schema<unknown>;
+export type PutTokenValueError = DefaultErrors | InvalidRoute;
+export declare const putTokenValue: API.OperationMethod<PutTokenValueRequest, PutTokenValueResponse, PutTokenValueError, Credentials | HttpClient.HttpClient>;
+export {};
+//# sourceMappingURL=accounts.d.ts.map