// AUTO-GENERATED by scripts/generate.ts from .generated-specs. Do not edit.
import * as S from "@distilled.cloud/core/schema";
import * as API from "@distilled.cloud/core/api";
import * as T from "../traits.ts";
import {
  CloudflareProtocol,
  CloudflarePaginatedProtocol,
  type CloudflareOpError,
  type CloudflareOpContext,
} from "../protocol.ts";
import { cloudflarePaginate, ResultInfo } from "../pagination.ts";
import { CloudflareError, CloudflareRateLimited } from "../errors.ts";
import * as Retry from "../retry.ts";

export type { CloudflareOpError, CloudflareOpContext };

/** Fallback camelCase→wire mapping for opaque content (mined from the distilled SDK). */
const KEY_DICTIONARY: Record<string, string | ReadonlyArray<string>> = {
  accountCreation: "account_creation",
  accountDeletion: "account_deletion",
  accountMigration: "account_migration",
  accountMobility: "account_mobility",
  accountType: "account_type",
  businessAddress: "business_address",
  businessEmail: "business_email",
  businessName: "business_name",
  businessPhone: "business_phone",
  cardExpiryMonth: "card_expiry_month",
  cardExpiryYear: "card_expiry_year",
  cardNumber: "card_number",
  createTime: "create_time",
  createdOn: "created_on",
  currentPeriodEnd: "current_period_end",
  currentPeriodStart: "current_period_start",
  deviceData: "device_data",
  editedOn: "edited_on",
  enterpriseBillingEmail: "enterprise_billing_email",
  enterprisePrimaryEmail: "enterprise_primary_email",
  expiresOn: "expires_on",
  externalMetadata: "external_metadata",
  externallyManaged: "externally_managed",
  firstName: "first_name",
  hasBusinessZones: "has_business_zones",
  hasEnterpriseZones: "has_enterprise_zones",
  hasProZones: "has_pro_zones",
  hierarchyTags: "hierarchy_tags",
  invitedBy: "invited_by",
  invitedMemberEmail: "invited_member_email",
  invitedMemberId: "invited_member_id",
  invitedOn: "invited_on",
  isContract: "is_contract",
  isPartner: "is_partner",
  issuedOn: "issued_on",
  lastName: "last_name",
  lastUsedOn: "last_used_on",
  managedBy: "managed_by",
  modifiedOn: "modified_on",
  nextBillDate: "next_bill_date",
  notBefore: "not_before",
  notIn: "not_in",
  occurredAt: "occurred_at",
  organizationId: "organization_id",
  organizationIsEnforcingTwofactor: "organization_is_enforcing_twofactor",
  organizationName: "organization_name",
  paymentAddress: "payment_address",
  paymentAddress2: "payment_address2",
  paymentCity: "payment_city",
  paymentCountry: "payment_country",
  paymentEmail: "payment_email",
  paymentFirstName: "payment_first_name",
  paymentGateway: "payment_gateway",
  paymentLastName: "payment_last_name",
  paymentNonce: "payment_nonce",
  paymentState: "payment_state",
  paymentZipcode: "payment_zipcode",
  perPage: "per_page",
  permissionGroups: "permission_groups",
  primaryEmail: "primary_email",
  publicName: "public_name",
  ratePlan: "rate_plan",
  requestIp: "request_ip",
  resultInfo: "result_info",
  subOrgCreation: "sub_org_creation",
  subscriptionId: "subscription_id",
  taxIdType: "tax_id_type",
  totalCount: "total_count",
  twoFactorAuthenticationEnabled: "two_factor_authentication_enabled",
  twoFactorAuthenticationLocked: "two_factor_authentication_locked",
  useLegacy: "use_legacy",
  validationCode: "validation_code",
};

export class Forbidden
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<Forbidden>()("Forbidden", {
      code: S.Number,
      message: S.String,
    }),
    [{ status: 403 }],
  ) {}

export class InvalidRoute
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<InvalidRoute>()("InvalidRoute", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 7003 }],
  ) {}

export class InvalidTokenName
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<InvalidTokenName>()("InvalidTokenName", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 400, message: { includes: "name must have a length" } }],
  ) {}

export class MethodNotAllowed
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<MethodNotAllowed>()("MethodNotAllowed", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 7001 }],
  ) {}

export class PermissionGroupNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<PermissionGroupNotFound>()(
      "PermissionGroupNotFound",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ code: 1001, message: { includes: "Permission group" } }],
  ) {}

export class TokenNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<TokenNotFound>()("TokenNotFound", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 1003 }],
  ) {}

export type TokensCreateRequestPoliciesItemEffect = "allow" | "deny";
export const TokensCreateRequestPoliciesItemEffect = /*@__PURE__*/ S.String;

export interface TokensCreateRequestPoliciesItemPermissionGroupsItemMeta {
  key?: string;
  value?: string;
}
export const TokensCreateRequestPoliciesItemPermissionGroupsItemMeta =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: S.optional(S.String),
      value: S.optional(S.String),
    }),
  ).annotate({
    identifier: "TokensCreateRequestPoliciesItemPermissionGroupsItemMeta",
  }) as any as S.Schema<TokensCreateRequestPoliciesItemPermissionGroupsItemMeta>;

export interface TokensCreateRequestPoliciesItemPermissionGroupsItem {
  /** Identifier of the permission group. */
  id: string;
  /** Attributes associated to the permission group. */
  meta?: TokensCreateRequestPoliciesItemPermissionGroupsItemMeta;
  /** Name of the permission group. */
  name?: string;
}
export const TokensCreateRequestPoliciesItemPermissionGroupsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      meta: S.optional(TokensCreateRequestPoliciesItemPermissionGroupsItemMeta),
      name: S.optional(S.String),
    }),
  ).annotate({
    identifier: "TokensCreateRequestPoliciesItemPermissionGroupsItem",
  }) as any as S.Schema<TokensCreateRequestPoliciesItemPermissionGroupsItem>;

export type TokensCreateRequestPoliciesItemPermissionGroupsList =
  Array<TokensCreateRequestPoliciesItemPermissionGroupsItem>;
export const TokensCreateRequestPoliciesItemPermissionGroupsList =
  /*@__PURE__*/ S.Array(
    TokensCreateRequestPoliciesItemPermissionGroupsItem,
  ) as any as S.Schema<TokensCreateRequestPoliciesItemPermissionGroupsList>;

export type TokensCreateRequestPoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap =
  { [key: string]: string | undefined };
export const TokensCreateRequestPoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<TokensCreateRequestPoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap>;

export type TokensCreateRequestPoliciesItemResourcesValue =
  | string
  | TokensCreateRequestPoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap;
export const TokensCreateRequestPoliciesItemResourcesValue =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export type TokensCreateRequestPoliciesItemResourcesMap = {
  [key: string]: TokensCreateRequestPoliciesItemResourcesValue | undefined;
};
export const TokensCreateRequestPoliciesItemResourcesMap =
  /*@__PURE__*/ S.Record(
    S.String,
    TokensCreateRequestPoliciesItemResourcesValue,
  ) as any as S.Schema<TokensCreateRequestPoliciesItemResourcesMap>;

export interface TokensCreateRequestPoliciesItem {
  /** Allow or deny operations against the resources. */
  effect: TokensCreateRequestPoliciesItemEffect | (string & {});
  /** A set of permission groups that are specified to the policy. */
  permissionGroups: TokensCreateRequestPoliciesItemPermissionGroupsList;
  /** A list of resource names that the policy applies to. */
  resources: TokensCreateRequestPoliciesItemResourcesMap;
}
export const TokensCreateRequestPoliciesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    effect: TokensCreateRequestPoliciesItemEffect,
    permissionGroups: TokensCreateRequestPoliciesItemPermissionGroupsList.pipe(
      T.Body("permission_groups"),
    ),
    resources: TokensCreateRequestPoliciesItemResourcesMap,
  }),
).annotate({
  identifier: "TokensCreateRequestPoliciesItem",
}) as any as S.Schema<TokensCreateRequestPoliciesItem>;

export type TokensCreateRequestPoliciesList =
  Array<TokensCreateRequestPoliciesItem>;
export const TokensCreateRequestPoliciesList = /*@__PURE__*/ S.Array(
  TokensCreateRequestPoliciesItem,
) as any as S.Schema<TokensCreateRequestPoliciesList>;

export type TokensCreateRequestConditionRequestIpInList = Array<string>;
export const TokensCreateRequestConditionRequestIpInList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<TokensCreateRequestConditionRequestIpInList>;

export type TokensCreateRequestConditionRequestIpNotInList = Array<string>;
export const TokensCreateRequestConditionRequestIpNotInList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<TokensCreateRequestConditionRequestIpNotInList>;

export interface TokensCreateRequestConditionRequestIp {
  /** List of IPv4/IPv6 CIDR addresses. */
  in?: TokensCreateRequestConditionRequestIpInList;
  /** List of IPv4/IPv6 CIDR addresses. */
  notIn?: TokensCreateRequestConditionRequestIpNotInList;
}
export const TokensCreateRequestConditionRequestIp = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      in: S.optional(TokensCreateRequestConditionRequestIpInList),
      notIn: S.optional(
        TokensCreateRequestConditionRequestIpNotInList.pipe(T.Body("not_in")),
      ),
    }),
).annotate({
  identifier: "TokensCreateRequestConditionRequestIp",
}) as any as S.Schema<TokensCreateRequestConditionRequestIp>;

export interface TokensCreateRequestCondition {
  /** Client IP restrictions. */
  requestIp?: TokensCreateRequestConditionRequestIp;
}
export const TokensCreateRequestCondition = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    requestIp: S.optional(
      TokensCreateRequestConditionRequestIp.pipe(T.Body("request_ip")),
    ),
  }),
).annotate({
  identifier: "TokensCreateRequestCondition",
}) as any as S.Schema<TokensCreateRequestCondition>;

export interface CreateTokenRequest {
  /** Token name. */
  name: string;
  /** List of access policies assigned to the token. */
  policies: TokensCreateRequestPoliciesList;
  condition?: TokensCreateRequestCondition;
  /** The expiration time on or after which the JWT MUST NOT be accepted for processing. */
  expiresOn?: string;
  /** The time before which the token MUST NOT be accepted for processing. */
  notBefore?: string;
}
export const CreateTokenRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    name: S.String,
    policies: TokensCreateRequestPoliciesList,
    condition: S.optional(TokensCreateRequestCondition),
    expiresOn: S.optional(S.String.pipe(T.Body("expires_on"))),
    notBefore: S.optional(S.String.pipe(T.Body("not_before"))),
  })
    .pipe(T.Http({ method: "POST", uri: "/user/tokens", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateTokenRequest",
}) as any as S.Schema<CreateTokenRequest>;

export type TokensCreateResponseConditionRequestIpInList = Array<string>;
export const TokensCreateResponseConditionRequestIpInList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<TokensCreateResponseConditionRequestIpInList>;

export type TokensCreateResponseConditionRequestIpNotInList = Array<string>;
export const TokensCreateResponseConditionRequestIpNotInList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<TokensCreateResponseConditionRequestIpNotInList>;

export interface TokensCreateResponseConditionRequestIp {
  /** List of IPv4/IPv6 CIDR addresses. */
  in?: TokensCreateResponseConditionRequestIpInList | null;
  /** List of IPv4/IPv6 CIDR addresses. */
  notIn?: TokensCreateResponseConditionRequestIpNotInList | null;
}
export const TokensCreateResponseConditionRequestIp = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      in: S.optional(S.NullOr(TokensCreateResponseConditionRequestIpInList)),
      notIn: S.optional(
        S.NullOr(TokensCreateResponseConditionRequestIpNotInList).pipe(
          T.Body("not_in"),
        ),
      ),
    }),
).annotate({
  identifier: "TokensCreateResponseConditionRequestIp",
}) as any as S.Schema<TokensCreateResponseConditionRequestIp>;

export interface TokensCreateResponseCondition {
  /** Client IP restrictions. */
  requestIp?: TokensCreateResponseConditionRequestIp | null;
}
export const TokensCreateResponseCondition = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    requestIp: S.optional(
      S.NullOr(TokensCreateResponseConditionRequestIp).pipe(
        T.Body("request_ip"),
      ),
    ),
  }),
).annotate({
  identifier: "TokensCreateResponseCondition",
}) as any as S.Schema<TokensCreateResponseCondition>;

export type TokensCreateResponsePoliciesItemEffect = "allow" | "deny";
export const TokensCreateResponsePoliciesItemEffect = /*@__PURE__*/ S.String;

export interface TokensCreateResponsePoliciesItemPermissionGroupsItemMeta {
  key?: string | null;
  value?: string | null;
}
export const TokensCreateResponsePoliciesItemPermissionGroupsItemMeta =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: S.optional(S.NullOr(S.String)),
      value: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "TokensCreateResponsePoliciesItemPermissionGroupsItemMeta",
  }) as any as S.Schema<TokensCreateResponsePoliciesItemPermissionGroupsItemMeta>;

export interface TokensCreateResponsePoliciesItemPermissionGroupsItem {
  /** Identifier of the permission group. */
  id: string;
  /** Attributes associated to the permission group. */
  meta?: TokensCreateResponsePoliciesItemPermissionGroupsItemMeta | null;
  /** Name of the permission group. */
  name?: string | null;
}
export const TokensCreateResponsePoliciesItemPermissionGroupsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      id: S.String,
      meta: S.optional(
        S.NullOr(TokensCreateResponsePoliciesItemPermissionGroupsItemMeta),
      ),
      name: S.optional(S.NullOr(S.String)),
    }),
  ).annotate({
    identifier: "TokensCreateResponsePoliciesItemPermissionGroupsItem",
  }) as any as S.Schema<TokensCreateResponsePoliciesItemPermissionGroupsItem>;

export type TokensCreateResponsePoliciesItemPermissionGroupsList =
  Array<TokensCreateResponsePoliciesItemPermissionGroupsItem>;
export const TokensCreateResponsePoliciesItemPermissionGroupsList =
  /*@__PURE__*/ S.Array(
    TokensCreateResponsePoliciesItemPermissionGroupsItem,
  ) as any as S.Schema<TokensCreateResponsePoliciesItemPermissionGroupsList>;

export type TokensCreateResponsePoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap =
  { [key: string]: string | undefined };
export const TokensCreateResponsePoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<TokensCreateResponsePoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap>;

export type TokensCreateResponsePoliciesItemResourcesValue =
  | string
  | TokensCreateResponsePoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap;
export const TokensCreateResponsePoliciesItemResourcesValue =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export type TokensCreateResponsePoliciesItemResourcesMap = {
  [key: string]: TokensCreateResponsePoliciesItemResourcesValue | undefined;
};
export const TokensCreateResponsePoliciesItemResourcesMap =
  /*@__PURE__*/ S.Record(
    S.String,
    TokensCreateResponsePoliciesItemResourcesValue,
  ) as any as S.Schema<TokensCreateResponsePoliciesItemResourcesMap>;

export interface TokensCreateResponsePoliciesItem {
  /** Policy identifier. */
  id: string;
  /** Allow or deny operations against the resources. */
  effect: TokensCreateResponsePoliciesItemEffect;
  /** A set of permission groups that are specified to the policy. */
  permissionGroups: TokensCreateResponsePoliciesItemPermissionGroupsList;
  /** A list of resource names that the policy applies to. */
  resources: TokensCreateResponsePoliciesItemResourcesMap;
}
export const TokensCreateResponsePoliciesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    effect: TokensCreateResponsePoliciesItemEffect,
    permissionGroups: TokensCreateResponsePoliciesItemPermissionGroupsList.pipe(
      T.Body("permission_groups"),
    ),
    resources: TokensCreateResponsePoliciesItemResourcesMap,
  }),
).annotate({
  identifier: "TokensCreateResponsePoliciesItem",
}) as any as S.Schema<TokensCreateResponsePoliciesItem>;

export type TokensCreateResponsePoliciesList =
  Array<TokensCreateResponsePoliciesItem>;
export const TokensCreateResponsePoliciesList = /*@__PURE__*/ S.Array(
  TokensCreateResponsePoliciesItem,
) as any as S.Schema<TokensCreateResponsePoliciesList>;

export type TokensCreateResponseStatus = "active" | "disabled" | "expired";
export const TokensCreateResponseStatus = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateTokenResponse {
  /** Token identifier tag. */
  id?: string | null;
  condition?: TokensCreateResponseCondition | 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?: TokensCreateResponsePoliciesList | null;
  /** Status of the token. */
  status?: TokensCreateResponseStatus | null;
  /** The token value. */
  value?: string | null;
}
export const CreateTokenResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    condition: S.optional(S.NullOr(TokensCreateResponseCondition)),
    expiresOn: S.optional(S.NullOr(S.String).pipe(T.Body("expires_on"))),
    issuedOn: S.optional(S.NullOr(S.String).pipe(T.Body("issued_on"))),
    lastUsedOn: S.optional(S.NullOr(S.String).pipe(T.Body("last_used_on"))),
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    name: S.optional(S.NullOr(S.String)),
    notBefore: S.optional(S.NullOr(S.String).pipe(T.Body("not_before"))),
    policies: S.optional(S.NullOr(TokensCreateResponsePoliciesList)),
    status: S.optional(S.NullOr(TokensCreateResponseStatus)),
    value: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateTokenResponse",
}) as any as S.Schema<CreateTokenResponse>;

export interface DeleteOrganizationRequest {
  /** Identifier */
  organizationId: string;
}
export const DeleteOrganizationRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    organizationId: S.String.pipe(T.Label("organization_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/user/organizations/{organization_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteOrganizationRequest",
}) as any as S.Schema<DeleteOrganizationRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface DeleteOrganizationResponse {
  /** Identifier */
  id?: string | null;
}
export const DeleteOrganizationResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteOrganizationResponse",
}) as any as S.Schema<DeleteOrganizationResponse>;

export interface DeleteSubscriptionRequest {
  /** Subscription identifier tag. */
  identifier: string;
}
export const DeleteSubscriptionRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    identifier: S.String.pipe(T.Label()),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/user/subscriptions/{identifier}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteSubscriptionRequest",
}) as any as S.Schema<DeleteSubscriptionRequest>;

/** Raw response payload (operation does not use the standard v4 result envelope). */
export interface DeleteSubscriptionResponse {
  /** Subscription identifier tag. */
  subscriptionId?: string | null;
}
export const DeleteSubscriptionResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    subscriptionId: S.optional(
      S.NullOr(S.String).pipe(T.Body("subscription_id")),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteSubscriptionResponse",
}) as any as S.Schema<DeleteSubscriptionResponse>;

export interface DeleteTokenRequest {
  /** Token identifier tag. */
  tokenId: string;
}
export const DeleteTokenRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    tokenId: S.String.pipe(T.Label("token_id")),
  })
    .pipe(
      T.Http({ method: "DELETE", uri: "/user/tokens/{token_id}", code: 200 }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteTokenRequest",
}) as any as S.Schema<DeleteTokenRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteTokenResponse {
  /** Identifier */
  id: string;
}
export const DeleteTokenResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteTokenResponse",
}) as any as S.Schema<DeleteTokenResponse>;

export interface GetBillingProfileRequest {}
export const GetBillingProfileRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({})
    .pipe(T.Http({ method: "GET", uri: "/user/billing/profile", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetBillingProfileRequest",
}) as any as S.Schema<GetBillingProfileRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetBillingProfileResponse {
  /** Billing item identifier tag. */
  id?: string | null;
  accountType?: string | null;
  address?: string | null;
  address2?: string | null;
  balance?: string | null;
  cardExpiryMonth?: number | null;
  cardExpiryYear?: number | null;
  cardNumber?: string | null;
  city?: string | null;
  company?: string | null;
  country?: string | null;
  createdOn?: string | null;
  deviceData?: string | null;
  editedOn?: string | null;
  enterpriseBillingEmail?: string | null;
  enterprisePrimaryEmail?: string | null;
  firstName?: string | null;
  isPartner?: boolean | null;
  lastName?: string | null;
  nextBillDate?: string | null;
  paymentAddress?: string | null;
  paymentAddress2?: string | null;
  paymentCity?: string | null;
  paymentCountry?: string | null;
  paymentEmail?: string | null;
  paymentFirstName?: string | null;
  paymentGateway?: string | null;
  paymentLastName?: string | null;
  paymentNonce?: string | null;
  paymentState?: string | null;
  paymentZipcode?: string | null;
  primaryEmail?: string | null;
  state?: string | null;
  taxIdType?: string | null;
  telephone?: string | null;
  useLegacy?: boolean | null;
  validationCode?: string | null;
  vat?: string | null;
  zipcode?: string | null;
}
export const GetBillingProfileResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    accountType: S.optional(S.NullOr(S.String).pipe(T.Body("account_type"))),
    address: S.optional(S.NullOr(S.String)),
    address2: S.optional(S.NullOr(S.String)),
    balance: S.optional(S.NullOr(S.String)),
    cardExpiryMonth: S.optional(
      S.NullOr(S.Number).pipe(T.Body("card_expiry_month")),
    ),
    cardExpiryYear: S.optional(
      S.NullOr(S.Number).pipe(T.Body("card_expiry_year")),
    ),
    cardNumber: S.optional(S.NullOr(S.String).pipe(T.Body("card_number"))),
    city: S.optional(S.NullOr(S.String)),
    company: S.optional(S.NullOr(S.String)),
    country: S.optional(S.NullOr(S.String)),
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    deviceData: S.optional(S.NullOr(S.String).pipe(T.Body("device_data"))),
    editedOn: S.optional(S.NullOr(S.String).pipe(T.Body("edited_on"))),
    enterpriseBillingEmail: S.optional(
      S.NullOr(S.String).pipe(T.Body("enterprise_billing_email")),
    ),
    enterprisePrimaryEmail: S.optional(
      S.NullOr(S.String).pipe(T.Body("enterprise_primary_email")),
    ),
    firstName: S.optional(S.NullOr(S.String).pipe(T.Body("first_name"))),
    isPartner: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_partner"))),
    lastName: S.optional(S.NullOr(S.String).pipe(T.Body("last_name"))),
    nextBillDate: S.optional(S.NullOr(S.String).pipe(T.Body("next_bill_date"))),
    paymentAddress: S.optional(
      S.NullOr(S.String).pipe(T.Body("payment_address")),
    ),
    paymentAddress2: S.optional(
      S.NullOr(S.String).pipe(T.Body("payment_address2")),
    ),
    paymentCity: S.optional(S.NullOr(S.String).pipe(T.Body("payment_city"))),
    paymentCountry: S.optional(
      S.NullOr(S.String).pipe(T.Body("payment_country")),
    ),
    paymentEmail: S.optional(S.NullOr(S.String).pipe(T.Body("payment_email"))),
    paymentFirstName: S.optional(
      S.NullOr(S.String).pipe(T.Body("payment_first_name")),
    ),
    paymentGateway: S.optional(
      S.NullOr(S.String).pipe(T.Body("payment_gateway")),
    ),
    paymentLastName: S.optional(
      S.NullOr(S.String).pipe(T.Body("payment_last_name")),
    ),
    paymentNonce: S.optional(S.NullOr(S.String).pipe(T.Body("payment_nonce"))),
    paymentState: S.optional(S.NullOr(S.String).pipe(T.Body("payment_state"))),
    paymentZipcode: S.optional(
      S.NullOr(S.String).pipe(T.Body("payment_zipcode")),
    ),
    primaryEmail: S.optional(S.NullOr(S.String).pipe(T.Body("primary_email"))),
    state: S.optional(S.NullOr(S.String)),
    taxIdType: S.optional(S.NullOr(S.String).pipe(T.Body("tax_id_type"))),
    telephone: S.optional(S.NullOr(S.String)),
    useLegacy: S.optional(S.NullOr(S.Boolean).pipe(T.Body("use_legacy"))),
    validationCode: S.optional(
      S.NullOr(S.String).pipe(T.Body("validation_code")),
    ),
    vat: S.optional(S.NullOr(S.String)),
    zipcode: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetBillingProfileResponse",
}) as any as S.Schema<GetBillingProfileResponse>;

export interface GetInviteRequest {
  /** Invite identifier tag. */
  inviteId: string;
}
export const GetInviteRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    inviteId: S.String.pipe(T.Label("invite_id")),
  })
    .pipe(
      T.Http({ method: "GET", uri: "/user/invites/{invite_id}", code: 200 }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetInviteRequest",
}) as any as S.Schema<GetInviteRequest>;

export type InvitesGetResponseRolesList = Array<string>;
export const InvitesGetResponseRolesList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<InvitesGetResponseRolesList>;

export type InvitesGetResponseStatus =
  | "pending"
  | "accepted"
  | "rejected"
  | "expired";
export const InvitesGetResponseStatus = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetInviteResponse {
  /** ID of the user to add to the organization. */
  invitedMemberId: string;
  /** ID of the organization the user will be added to. */
  organizationId: string;
  /** Invite identifier tag. */
  id?: string | null;
  /** When the invite is no longer active. */
  expiresOn?: string | null;
  /** The email address of the user who created the invite. */
  invitedBy?: string | null;
  /** Email address of the user to add to the organization. */
  invitedMemberEmail?: string | null;
  /** When the invite was sent. */
  invitedOn?: string | null;
  organizationIsEnforcingTwofactor?: boolean | null;
  /** Organization name. */
  organizationName?: string | null;
  /** List of role names the membership has for this account. */
  roles?: InvitesGetResponseRolesList | null;
  /** Current status of the invitation. */
  status?: InvitesGetResponseStatus | null;
}
export const GetInviteResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    invitedMemberId: S.String.pipe(T.Body("invited_member_id")),
    organizationId: S.String.pipe(T.Body("organization_id")),
    id: S.optional(S.NullOr(S.String)),
    expiresOn: S.optional(S.NullOr(S.String).pipe(T.Body("expires_on"))),
    invitedBy: S.optional(S.NullOr(S.String).pipe(T.Body("invited_by"))),
    invitedMemberEmail: S.optional(
      S.NullOr(S.String).pipe(T.Body("invited_member_email")),
    ),
    invitedOn: S.optional(S.NullOr(S.String).pipe(T.Body("invited_on"))),
    organizationIsEnforcingTwofactor: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("organization_is_enforcing_twofactor")),
    ),
    organizationName: S.optional(
      S.NullOr(S.String).pipe(T.Body("organization_name")),
    ),
    roles: S.optional(S.NullOr(InvitesGetResponseRolesList)),
    status: S.optional(S.NullOr(InvitesGetResponseStatus)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetInviteResponse",
}) as any as S.Schema<GetInviteResponse>;

export interface GetOrganizationRequest {
  /** Identifier */
  organizationId: string;
}
export const GetOrganizationRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    organizationId: S.String.pipe(T.Label("organization_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/user/organizations/{organization_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetOrganizationRequest",
}) as any as S.Schema<GetOrganizationRequest>;

export type GetOrganizationResponse = unknown;
export const GetOrganizationResponse = /*@__PURE__*/ S.suspend(() =>
  S.Unknown.pipe(T.EnvelopePayloadRoot(), T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetOrganizationResponse",
}) as any as S.Schema<GetOrganizationResponse>;

export interface GetSubscriptionRequest {}
export const GetSubscriptionRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({})
    .pipe(T.Http({ method: "GET", uri: "/user/subscriptions", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSubscriptionRequest",
}) as any as S.Schema<GetSubscriptionRequest>;

export type SubscriptionsGetResultItemFrequency =
  | "weekly"
  | "monthly"
  | "quarterly"
  | "yearly";
export const SubscriptionsGetResultItemFrequency = /*@__PURE__*/ S.String;

export type SubscriptionsGetResultItemRatePlanId =
  | "free"
  | "lite"
  | "pro"
  | "pro_plus"
  | "business"
  | "enterprise"
  | "partners_free"
  | "partners_pro"
  | "partners_business"
  | "partners_enterprise";
export const SubscriptionsGetResultItemRatePlanId = /*@__PURE__*/ S.String;

export type SubscriptionsGetResultItemRatePlanSetsList = Array<string>;
export const SubscriptionsGetResultItemRatePlanSetsList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<SubscriptionsGetResultItemRatePlanSetsList>;

export interface SubscriptionsGetResultItemRatePlan {
  /** The ID of the rate plan. */
  id?: SubscriptionsGetResultItemRatePlanId | null;
  /** The currency applied to the rate plan subscription. */
  currency?: string | null;
  /** Whether this rate plan is managed externally from Cloudflare. */
  externallyManaged?: boolean | null;
  /** Whether a rate plan is enterprise-based (or newly adopted term contract). */
  isContract?: boolean | null;
  /** The full name of the rate plan. */
  publicName?: string | null;
  /** The scope that this rate plan applies to. */
  scope?: string | null;
  /** The list of sets this rate plan applies to. Returns array of strings. */
  sets?: SubscriptionsGetResultItemRatePlanSetsList | null;
}
export const SubscriptionsGetResultItemRatePlan = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(SubscriptionsGetResultItemRatePlanId)),
    currency: S.optional(S.NullOr(S.String)),
    externallyManaged: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("externally_managed")),
    ),
    isContract: S.optional(S.NullOr(S.Boolean).pipe(T.Body("is_contract"))),
    publicName: S.optional(S.NullOr(S.String).pipe(T.Body("public_name"))),
    scope: S.optional(S.NullOr(S.String)),
    sets: S.optional(S.NullOr(SubscriptionsGetResultItemRatePlanSetsList)),
  }),
).annotate({
  identifier: "SubscriptionsGetResultItemRatePlan",
}) as any as S.Schema<SubscriptionsGetResultItemRatePlan>;

export type SubscriptionsGetResultItemState =
  | "Trial"
  | "Provisioned"
  | "Paid"
  | "AwaitingPayment"
  | "Cancelled"
  | "Failed"
  | "Expired";
export const SubscriptionsGetResultItemState = /*@__PURE__*/ S.String;

export interface SubscriptionsGetResultItem {
  /** 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?: SubscriptionsGetResultItemFrequency | null;
  /** The price of the subscription that will be billed, in US dollars. */
  price?: number | null;
  /** The rate plan applied to the subscription. */
  ratePlan?: SubscriptionsGetResultItemRatePlan | null;
  /** The state that the subscription is in. */
  state?: SubscriptionsGetResultItemState | null;
}
export const SubscriptionsGetResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    currency: S.optional(S.NullOr(S.String)),
    currentPeriodEnd: S.optional(
      S.NullOr(S.String).pipe(T.Body("current_period_end")),
    ),
    currentPeriodStart: S.optional(
      S.NullOr(S.String).pipe(T.Body("current_period_start")),
    ),
    frequency: S.optional(S.NullOr(SubscriptionsGetResultItemFrequency)),
    price: S.optional(S.NullOr(S.Number)),
    ratePlan: S.optional(
      S.NullOr(SubscriptionsGetResultItemRatePlan).pipe(T.Body("rate_plan")),
    ),
    state: S.optional(S.NullOr(SubscriptionsGetResultItemState)),
  }),
).annotate({
  identifier: "SubscriptionsGetResultItem",
}) as any as S.Schema<SubscriptionsGetResultItem>;

export type SubscriptionsGetResultList = Array<SubscriptionsGetResultItem>;
export const SubscriptionsGetResultList = /*@__PURE__*/ S.Array(
  SubscriptionsGetResultItem,
) as any as S.Schema<SubscriptionsGetResultList>;

export interface GetSubscriptionResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: SubscriptionsGetResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const GetSubscriptionResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: SubscriptionsGetResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSubscriptionResponse",
}) as any as S.Schema<GetSubscriptionResponse>;

export interface GetTokenRequest {
  /** Token identifier tag. */
  tokenId: string;
}
export const GetTokenRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    tokenId: S.String.pipe(T.Label("token_id")),
  })
    .pipe(T.Http({ method: "GET", uri: "/user/tokens/{token_id}", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetTokenRequest",
}) as any as S.Schema<GetTokenRequest>;

export type TokensGetResponseConditionRequestIpInList = Array<string>;
export const TokensGetResponseConditionRequestIpInList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<TokensGetResponseConditionRequestIpInList>;

export type TokensGetResponseConditionRequestIpNotInList = Array<string>;
export const TokensGetResponseConditionRequestIpNotInList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<TokensGetResponseConditionRequestIpNotInList>;

export interface TokensGetResponseConditionRequestIp {
  /** List of IPv4/IPv6 CIDR addresses. */
  in?: TokensGetResponseConditionRequestIpInList | null;
  /** List of IPv4/IPv6 CIDR addresses. */
  notIn?: TokensGetResponseConditionRequestIpNotInList | null;
}
export const TokensGetResponseConditionRequestIp = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    in: S.optional(S.NullOr(TokensGetResponseConditionRequestIpInList)),
    notIn: S.optional(
      S.NullOr(TokensGetResponseConditionRequestIpNotInList).pipe(
        T.Body("not_in"),
      ),
    ),
  }),
).annotate({
  identifier: "TokensGetResponseConditionRequestIp",
}) as any as S.Schema<TokensGetResponseConditionRequestIp>;

export interface TokensGetResponseCondition {
  /** Client IP restrictions. */
  requestIp?: TokensGetResponseConditionRequestIp | null;
}
export const TokensGetResponseCondition = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    requestIp: S.optional(
      S.NullOr(TokensGetResponseConditionRequestIp).pipe(T.Body("request_ip")),
    ),
  }),
).annotate({
  identifier: "TokensGetResponseCondition",
}) as any as S.Schema<TokensGetResponseCondition>;

export type TokensGetResponsePoliciesItemEffect = "allow" | "deny";
export const TokensGetResponsePoliciesItemEffect = /*@__PURE__*/ S.String;

export type TokensGetResponsePoliciesItemPermissionGroupsItemMeta =
  TokensCreateResponsePoliciesItemPermissionGroupsItemMeta;
export const TokensGetResponsePoliciesItemPermissionGroupsItemMeta =
  TokensCreateResponsePoliciesItemPermissionGroupsItemMeta;

export type TokensGetResponsePoliciesItemPermissionGroupsItem =
  TokensCreateResponsePoliciesItemPermissionGroupsItem;
export const TokensGetResponsePoliciesItemPermissionGroupsItem =
  TokensCreateResponsePoliciesItemPermissionGroupsItem;

export type TokensGetResponsePoliciesItemPermissionGroupsList =
  Array<TokensCreateResponsePoliciesItemPermissionGroupsItem>;
export const TokensGetResponsePoliciesItemPermissionGroupsList =
  /*@__PURE__*/ S.Array(
    TokensCreateResponsePoliciesItemPermissionGroupsItem,
  ) as any as S.Schema<TokensGetResponsePoliciesItemPermissionGroupsList>;

export type TokensGetResponsePoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap =
  { [key: string]: string | undefined };
export const TokensGetResponsePoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<TokensGetResponsePoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap>;

export type TokensGetResponsePoliciesItemResourcesValue =
  | string
  | TokensGetResponsePoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap;
export const TokensGetResponsePoliciesItemResourcesValue =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export type TokensGetResponsePoliciesItemResourcesMap = {
  [key: string]: TokensGetResponsePoliciesItemResourcesValue | undefined;
};
export const TokensGetResponsePoliciesItemResourcesMap = /*@__PURE__*/ S.Record(
  S.String,
  TokensGetResponsePoliciesItemResourcesValue,
) as any as S.Schema<TokensGetResponsePoliciesItemResourcesMap>;

export interface TokensGetResponsePoliciesItem {
  /** Policy identifier. */
  id: string;
  /** Allow or deny operations against the resources. */
  effect: TokensGetResponsePoliciesItemEffect;
  /** A set of permission groups that are specified to the policy. */
  permissionGroups: TokensGetResponsePoliciesItemPermissionGroupsList;
  /** A list of resource names that the policy applies to. */
  resources: TokensGetResponsePoliciesItemResourcesMap;
}
export const TokensGetResponsePoliciesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    effect: TokensGetResponsePoliciesItemEffect,
    permissionGroups: TokensGetResponsePoliciesItemPermissionGroupsList.pipe(
      T.Body("permission_groups"),
    ),
    resources: TokensGetResponsePoliciesItemResourcesMap,
  }),
).annotate({
  identifier: "TokensGetResponsePoliciesItem",
}) as any as S.Schema<TokensGetResponsePoliciesItem>;

export type TokensGetResponsePoliciesList =
  Array<TokensGetResponsePoliciesItem>;
export const TokensGetResponsePoliciesList = /*@__PURE__*/ S.Array(
  TokensGetResponsePoliciesItem,
) as any as S.Schema<TokensGetResponsePoliciesList>;

export type TokensGetResponseStatus = "active" | "disabled" | "expired";
export const TokensGetResponseStatus = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetTokenResponse {
  /** Token identifier tag. */
  id?: string | null;
  condition?: TokensGetResponseCondition | 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?: TokensGetResponsePoliciesList | null;
  /** Status of the token. */
  status?: TokensGetResponseStatus | null;
}
export const GetTokenResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    condition: S.optional(S.NullOr(TokensGetResponseCondition)),
    expiresOn: S.optional(S.NullOr(S.String).pipe(T.Body("expires_on"))),
    issuedOn: S.optional(S.NullOr(S.String).pipe(T.Body("issued_on"))),
    lastUsedOn: S.optional(S.NullOr(S.String).pipe(T.Body("last_used_on"))),
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    name: S.optional(S.NullOr(S.String)),
    notBefore: S.optional(S.NullOr(S.String).pipe(T.Body("not_before"))),
    policies: S.optional(S.NullOr(TokensGetResponsePoliciesList)),
    status: S.optional(S.NullOr(TokensGetResponseStatus)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetTokenResponse",
}) as any as S.Schema<GetTokenResponse>;

export interface GetUserRequest {}
export const GetUserRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({})
    .pipe(T.Http({ method: "GET", uri: "/user", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "GetUserRequest" }) as any as S.Schema<GetUserRequest>;

export type GetResponseBetasList = Array<string>;
export const GetResponseBetasList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<GetResponseBetasList>;

export type GetResponseOrganizationsItemPermissionsList = Array<unknown>;
export const GetResponseOrganizationsItemPermissionsList =
  /*@__PURE__*/ S.Array(
    S.Unknown,
  ) as any as S.Schema<GetResponseOrganizationsItemPermissionsList>;

export type GetResponseOrganizationsItemRolesList = Array<string>;
export const GetResponseOrganizationsItemRolesList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<GetResponseOrganizationsItemRolesList>;

export type GetResponseOrganizationsItemStatus = "member" | "invited";
export const GetResponseOrganizationsItemStatus = /*@__PURE__*/ S.String;

export interface GetResponseOrganizationsItem {
  /** Identifier */
  id?: string | null;
  /** Organization name. */
  name?: string | null;
  /** Access permissions for this User. */
  permissions?: GetResponseOrganizationsItemPermissionsList | null;
  /** List of roles that a user has within an organization. */
  roles?: GetResponseOrganizationsItemRolesList | null;
  /** Whether the user is a member of the organization or has an invitation pending. */
  status?: GetResponseOrganizationsItemStatus | null;
}
export const GetResponseOrganizationsItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    name: S.optional(S.NullOr(S.String)),
    permissions: S.optional(
      S.NullOr(GetResponseOrganizationsItemPermissionsList),
    ),
    roles: S.optional(S.NullOr(GetResponseOrganizationsItemRolesList)),
    status: S.optional(S.NullOr(GetResponseOrganizationsItemStatus)),
  }),
).annotate({
  identifier: "GetResponseOrganizationsItem",
}) as any as S.Schema<GetResponseOrganizationsItem>;

export type GetResponseOrganizationsList = Array<GetResponseOrganizationsItem>;
export const GetResponseOrganizationsList = /*@__PURE__*/ S.Array(
  GetResponseOrganizationsItem,
) as any as S.Schema<GetResponseOrganizationsList>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetUserResponse {
  /** Identifier of the user. */
  id: string;
  /** Current email address of the user. */
  email: string;
  /** Lists the betas that the user is participating in. */
  betas?: GetResponseBetasList | null;
  /** The country in which the user lives. */
  country?: string | null;
  /** User's first name */
  firstName?: string | null;
  /** Indicates whether user has any business zones */
  hasBusinessZones?: boolean | null;
  /** Indicates whether user has any enterprise zones */
  hasEnterpriseZones?: boolean | null;
  /** Indicates whether user has any pro zones */
  hasProZones?: boolean | null;
  /** User's last name */
  lastName?: string | null;
  organizations?: GetResponseOrganizationsList | null;
  /** Indicates whether user has been suspended */
  suspended?: boolean | null;
  /** User's telephone number */
  telephone?: string | null;
  /** Indicates whether two-factor authentication is enabled for the user account. Does not apply to API authentication. */
  twoFactorAuthenticationEnabled?: boolean | null;
  /** Indicates whether two-factor authentication is required by one of the accounts that the user is a member of. */
  twoFactorAuthenticationLocked?: boolean | null;
  /** The zipcode or postal code where the user lives. */
  zipcode?: string | null;
}
export const GetUserResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    email: S.String,
    betas: S.optional(S.NullOr(GetResponseBetasList)),
    country: S.optional(S.NullOr(S.String)),
    firstName: S.optional(S.NullOr(S.String).pipe(T.Body("first_name"))),
    hasBusinessZones: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("has_business_zones")),
    ),
    hasEnterpriseZones: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("has_enterprise_zones")),
    ),
    hasProZones: S.optional(S.NullOr(S.Boolean).pipe(T.Body("has_pro_zones"))),
    lastName: S.optional(S.NullOr(S.String).pipe(T.Body("last_name"))),
    organizations: S.optional(S.NullOr(GetResponseOrganizationsList)),
    suspended: S.optional(S.NullOr(S.Boolean)),
    telephone: S.optional(S.NullOr(S.String)),
    twoFactorAuthenticationEnabled: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("two_factor_authentication_enabled")),
    ),
    twoFactorAuthenticationLocked: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("two_factor_authentication_locked")),
    ),
    zipcode: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetUserResponse",
}) as any as S.Schema<GetUserResponse>;

export interface AuditLogsListRequestAction {
  /** Filters by the action type. */
  type?: string;
}
export const AuditLogsListRequestAction = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    type: S.optional(S.String),
  }),
).annotate({
  identifier: "AuditLogsListRequestAction",
}) as any as S.Schema<AuditLogsListRequestAction>;

export interface AuditLogsListRequestActor {
  /** Filters by the email address of the actor that made the change. */
  email?: string;
  /** Filters by the IP address of the request that made the change by specific IP address or valid CIDR Range. */
  ip?: string;
}
export const AuditLogsListRequestActor = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    email: S.optional(S.String),
    ip: S.optional(S.String),
  }),
).annotate({
  identifier: "AuditLogsListRequestActor",
}) as any as S.Schema<AuditLogsListRequestActor>;

export type AuditLogsListRequestDirection = "desc" | "asc";
export const AuditLogsListRequestDirection = /*@__PURE__*/ S.String;

export interface AuditLogsListRequestZone {
  /** Filters by the name of the zone associated to the change. */
  name?: string;
}
export const AuditLogsListRequestZone = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    name: S.optional(S.String),
  }),
).annotate({
  identifier: "AuditLogsListRequestZone",
}) as any as S.Schema<AuditLogsListRequestZone>;

export interface ListAuditLogsRequest {
  /** Finds a specific log by its ID. */
  id?: string;
  action?: AuditLogsListRequestAction;
  actor?: AuditLogsListRequestActor;
  /** Limits the returned results to logs older than the specified date. A `full-date` that conforms to RFC3339. */
  before?: string;
  /** Changes the direction of the chronological sorting. */
  direction?: AuditLogsListRequestDirection | (string & {});
  /** Indicates that this request is an export of logs in CSV format. */
  export?: boolean;
  /** Indicates whether or not to hide user level audit logs. */
  hideUserLogs?: boolean;
  /** Defines which page of results to return. */
  page?: number;
  /** Sets the number of results to return per page. */
  perPage?: number;
  /** Limits the returned results to logs newer than the specified date. A `full-date` that conforms to RFC3339. */
  since?: string;
  zone?: AuditLogsListRequestZone;
}
export const ListAuditLogsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.String.pipe(T.Query())),
    action: S.optional(AuditLogsListRequestAction.pipe(T.DeepQuery("action"))),
    actor: S.optional(AuditLogsListRequestActor.pipe(T.DeepQuery("actor"))),
    before: S.optional(S.String.pipe(T.Query())),
    direction: S.optional(AuditLogsListRequestDirection.pipe(T.Query())),
    export: S.optional(S.Boolean.pipe(T.Query())),
    hideUserLogs: S.optional(S.Boolean.pipe(T.Query("hide_user_logs"))),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    since: S.optional(S.String.pipe(T.Query())),
    zone: S.optional(AuditLogsListRequestZone.pipe(T.DeepQuery("zone"))),
  })
    .pipe(T.Http({ method: "GET", uri: "/user/audit_logs", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListAuditLogsRequest",
}) as any as S.Schema<ListAuditLogsRequest>;

export interface AuditLogsListResultItemAction {
  /** A boolean that indicates if the action attempted was successful. */
  result?: boolean | null;
  /** A short string that describes the action that was performed. */
  type?: string | null;
}
export const AuditLogsListResultItemAction = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: S.optional(S.NullOr(S.Boolean)),
    type: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "AuditLogsListResultItemAction",
}) as any as S.Schema<AuditLogsListResultItemAction>;

export type AuditLogsListResultItemActorType = "user" | "admin" | "Cloudflare";
export const AuditLogsListResultItemActorType = /*@__PURE__*/ S.String;

export interface AuditLogsListResultItemActor {
  /** The ID of the actor that performed the action. If a user performed the action, this will be their User ID. */
  id?: string | null;
  /** The email of the user that performed the action. */
  email?: string | null;
  /** The IP address of the request that performed the action. */
  ip?: string | null;
  /** The type of actor, whether a User, Cloudflare Admin, or an Automated System. */
  type?: AuditLogsListResultItemActorType | null;
}
export const AuditLogsListResultItemActor = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    email: S.optional(S.NullOr(S.String)),
    ip: S.optional(S.NullOr(S.String)),
    type: S.optional(S.NullOr(AuditLogsListResultItemActorType)),
  }),
).annotate({
  identifier: "AuditLogsListResultItemActor",
}) as any as S.Schema<AuditLogsListResultItemActor>;

export interface AuditLogsListResultItemOwner {
  /** Identifier */
  id?: string | null;
}
export const AuditLogsListResultItemOwner = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "AuditLogsListResultItemOwner",
}) as any as S.Schema<AuditLogsListResultItemOwner>;

export interface AuditLogsListResultItemResource {
  /** An identifier for the resource that was affected by the action. */
  id?: string | null;
  /** A short string that describes the resource that was affected by the action. */
  type?: string | null;
}
export const AuditLogsListResultItemResource = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    type: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "AuditLogsListResultItemResource",
}) as any as S.Schema<AuditLogsListResultItemResource>;

export interface AuditLogsListResultItem {
  /** A string that uniquely identifies the audit log. */
  id?: string | null;
  action?: AuditLogsListResultItemAction | null;
  actor?: AuditLogsListResultItemActor | null;
  /** The source of the event. */
  interface?: string | null;
  /** An object which can lend more context to the action being logged. This is a flexible value and varies between different actions. */
  metadata?: unknown | null;
  /** The new value of the resource that was modified. */
  newValue?: string | null;
  /** The value of the resource before it was modified. */
  oldValue?: string | null;
  owner?: AuditLogsListResultItemOwner | null;
  resource?: AuditLogsListResultItemResource | null;
  /** A UTC RFC3339 timestamp that specifies when the action being logged occured. */
  when?: string | null;
}
export const AuditLogsListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    action: S.optional(S.NullOr(AuditLogsListResultItemAction)),
    actor: S.optional(S.NullOr(AuditLogsListResultItemActor)),
    interface: S.optional(S.NullOr(S.String)),
    metadata: S.optional(S.NullOr(S.Unknown)),
    newValue: S.optional(S.NullOr(S.String)),
    oldValue: S.optional(S.NullOr(S.String)),
    owner: S.optional(S.NullOr(AuditLogsListResultItemOwner)),
    resource: S.optional(S.NullOr(AuditLogsListResultItemResource)),
    when: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "AuditLogsListResultItem",
}) as any as S.Schema<AuditLogsListResultItem>;

export type AuditLogsListResultList = Array<AuditLogsListResultItem>;
export const AuditLogsListResultList = /*@__PURE__*/ S.Array(
  AuditLogsListResultItem,
) as any as S.Schema<AuditLogsListResultList>;

export interface ListAuditLogsResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: AuditLogsListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListAuditLogsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: AuditLogsListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListAuditLogsResponse",
}) as any as S.Schema<ListAuditLogsResponse>;

export type BillingHistoryListRequestOrder = "type" | "occurred_at" | "action";
export const BillingHistoryListRequestOrder = /*@__PURE__*/ S.String;

export interface ListBillingHistoriesRequest {
  /** The billing item action. */
  action?: string;
  /** When the billing item was created. */
  occurredAt?: string;
  /** Field to order billing history by. */
  order?: BillingHistoryListRequestOrder | (string & {});
  /** Page number of paginated results. */
  page?: number;
  /** Number of items per page. */
  perPage?: number;
  /** The billing item type. */
  type?: string;
}
export const ListBillingHistoriesRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    action: S.optional(S.String.pipe(T.Query())),
    occurredAt: S.optional(S.String.pipe(T.Query("occurred_at"))),
    order: S.optional(BillingHistoryListRequestOrder.pipe(T.Query())),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    type: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(T.Http({ method: "GET", uri: "/user/billing/history", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListBillingHistoriesRequest",
}) as any as S.Schema<ListBillingHistoriesRequest>;

export interface BillingHistoryListResultItemZone {
  name?: string | null;
}
export const BillingHistoryListResultItemZone = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    name: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "BillingHistoryListResultItemZone",
}) as any as S.Schema<BillingHistoryListResultItemZone>;

export interface BillingHistoryListResultItem {
  /** Billing item identifier tag. */
  id: string;
  /** The billing item action. */
  action: string;
  /** The amount associated with this billing item. */
  amount: number;
  /** The monetary unit in which pricing information is displayed. */
  currency: string;
  /** The billing item description. */
  description: string;
  /** When the billing item was created. */
  occurredAt: string;
  /** The billing item type. */
  type: string;
  zone: BillingHistoryListResultItemZone;
}
export const BillingHistoryListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    action: S.String,
    amount: S.Number,
    currency: S.String,
    description: S.String,
    occurredAt: S.String.pipe(T.Body("occurred_at")),
    type: S.String,
    zone: BillingHistoryListResultItemZone,
  }),
).annotate({
  identifier: "BillingHistoryListResultItem",
}) as any as S.Schema<BillingHistoryListResultItem>;

export type BillingHistoryListResultList = Array<BillingHistoryListResultItem>;
export const BillingHistoryListResultList = /*@__PURE__*/ S.Array(
  BillingHistoryListResultItem,
) as any as S.Schema<BillingHistoryListResultList>;

export interface ListBillingHistoriesResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: BillingHistoryListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListBillingHistoriesResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: BillingHistoryListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListBillingHistoriesResponse",
}) as any as S.Schema<ListBillingHistoriesResponse>;

export interface ListInvitesRequest {}
export const ListInvitesRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({})
    .pipe(T.Http({ method: "GET", uri: "/user/invites", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListInvitesRequest",
}) as any as S.Schema<ListInvitesRequest>;

export type InvitesListResultItemRolesList = Array<string>;
export const InvitesListResultItemRolesList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<InvitesListResultItemRolesList>;

export type InvitesListResultItemStatus =
  | "pending"
  | "accepted"
  | "rejected"
  | "expired";
export const InvitesListResultItemStatus = /*@__PURE__*/ S.String;

export interface InvitesListResultItem {
  /** ID of the user to add to the organization. */
  invitedMemberId: string;
  /** ID of the organization the user will be added to. */
  organizationId: string;
  /** Invite identifier tag. */
  id?: string | null;
  /** When the invite is no longer active. */
  expiresOn?: string | null;
  /** The email address of the user who created the invite. */
  invitedBy?: string | null;
  /** Email address of the user to add to the organization. */
  invitedMemberEmail?: string | null;
  /** When the invite was sent. */
  invitedOn?: string | null;
  organizationIsEnforcingTwofactor?: boolean | null;
  /** Organization name. */
  organizationName?: string | null;
  /** List of role names the membership has for this account. */
  roles?: InvitesListResultItemRolesList | null;
  /** Current status of the invitation. */
  status?: InvitesListResultItemStatus | null;
}
export const InvitesListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    invitedMemberId: S.String.pipe(T.Body("invited_member_id")),
    organizationId: S.String.pipe(T.Body("organization_id")),
    id: S.optional(S.NullOr(S.String)),
    expiresOn: S.optional(S.NullOr(S.String).pipe(T.Body("expires_on"))),
    invitedBy: S.optional(S.NullOr(S.String).pipe(T.Body("invited_by"))),
    invitedMemberEmail: S.optional(
      S.NullOr(S.String).pipe(T.Body("invited_member_email")),
    ),
    invitedOn: S.optional(S.NullOr(S.String).pipe(T.Body("invited_on"))),
    organizationIsEnforcingTwofactor: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("organization_is_enforcing_twofactor")),
    ),
    organizationName: S.optional(
      S.NullOr(S.String).pipe(T.Body("organization_name")),
    ),
    roles: S.optional(S.NullOr(InvitesListResultItemRolesList)),
    status: S.optional(S.NullOr(InvitesListResultItemStatus)),
  }),
).annotate({
  identifier: "InvitesListResultItem",
}) as any as S.Schema<InvitesListResultItem>;

export type InvitesListResultList = Array<InvitesListResultItem>;
export const InvitesListResultList = /*@__PURE__*/ S.Array(
  InvitesListResultItem,
) as any as S.Schema<InvitesListResultList>;

export interface ListInvitesResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: InvitesListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListInvitesResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: InvitesListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListInvitesResponse",
}) as any as S.Schema<ListInvitesResponse>;

export type OrganizationsListRequestDirection = "asc" | "desc";
export const OrganizationsListRequestDirection = /*@__PURE__*/ S.String;

export type OrganizationsListRequestMatch = "any" | "all";
export const OrganizationsListRequestMatch = /*@__PURE__*/ S.String;

export type OrganizationsListRequestOrder = "id" | "name" | "status";
export const OrganizationsListRequestOrder = /*@__PURE__*/ S.String;

export type OrganizationsListRequestStatus = "member" | "invited";
export const OrganizationsListRequestStatus = /*@__PURE__*/ S.String;

export interface ListOrganizationsRequest {
  /** Direction to order organizations. */
  direction?: OrganizationsListRequestDirection | (string & {});
  /** Whether to match all search requirements or at least one (any). */
  match?: OrganizationsListRequestMatch | (string & {});
  /** Organization name. */
  name?: string;
  /** Field to order organizations by. */
  order?: OrganizationsListRequestOrder | (string & {});
  /** Page number of paginated results. */
  page?: number;
  /** Number of organizations per page. */
  perPage?: number;
  /** Whether the user is a member of the organization or has an inivitation pending. */
  status?: OrganizationsListRequestStatus | (string & {});
}
export const ListOrganizationsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    direction: S.optional(OrganizationsListRequestDirection.pipe(T.Query())),
    match: S.optional(OrganizationsListRequestMatch.pipe(T.Query())),
    name: S.optional(S.String.pipe(T.Query())),
    order: S.optional(OrganizationsListRequestOrder.pipe(T.Query())),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    status: S.optional(OrganizationsListRequestStatus.pipe(T.Query())),
  })
    .pipe(T.Http({ method: "GET", uri: "/user/organizations", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListOrganizationsRequest",
}) as any as S.Schema<ListOrganizationsRequest>;

export type OrganizationsListResultItemPermissionsList = Array<unknown>;
export const OrganizationsListResultItemPermissionsList = /*@__PURE__*/ S.Array(
  S.Unknown,
) as any as S.Schema<OrganizationsListResultItemPermissionsList>;

export type OrganizationsListResultItemRolesList = Array<string>;
export const OrganizationsListResultItemRolesList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<OrganizationsListResultItemRolesList>;

export type OrganizationsListResultItemStatus = "member" | "invited";
export const OrganizationsListResultItemStatus = /*@__PURE__*/ S.String;

export interface OrganizationsListResultItem {
  /** Identifier */
  id?: string | null;
  /** Organization name. */
  name?: string | null;
  /** Access permissions for this User. */
  permissions?: OrganizationsListResultItemPermissionsList | null;
  /** List of roles that a user has within an organization. */
  roles?: OrganizationsListResultItemRolesList | null;
  /** Whether the user is a member of the organization or has an invitation pending. */
  status?: OrganizationsListResultItemStatus | null;
}
export const OrganizationsListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    name: S.optional(S.NullOr(S.String)),
    permissions: S.optional(
      S.NullOr(OrganizationsListResultItemPermissionsList),
    ),
    roles: S.optional(S.NullOr(OrganizationsListResultItemRolesList)),
    status: S.optional(S.NullOr(OrganizationsListResultItemStatus)),
  }),
).annotate({
  identifier: "OrganizationsListResultItem",
}) as any as S.Schema<OrganizationsListResultItem>;

export type OrganizationsListResultList = Array<OrganizationsListResultItem>;
export const OrganizationsListResultList = /*@__PURE__*/ S.Array(
  OrganizationsListResultItem,
) as any as S.Schema<OrganizationsListResultList>;

export interface ListOrganizationsResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: OrganizationsListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListOrganizationsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: OrganizationsListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListOrganizationsResponse",
}) as any as S.Schema<ListOrganizationsResponse>;

export interface ListTenantsRequest {}
export const ListTenantsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({})
    .pipe(T.Http({ method: "GET", uri: "/user/tenants", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListTenantsRequest",
}) as any as S.Schema<ListTenantsRequest>;

export interface TenantsListResultItemMetaFlags {
  accountCreation: string;
  accountDeletion: string;
  accountMigration: string;
  accountMobility: string;
  subOrgCreation: string;
}
export const TenantsListResultItemMetaFlags = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountCreation: S.String.pipe(T.Body("account_creation")),
    accountDeletion: S.String.pipe(T.Body("account_deletion")),
    accountMigration: S.String.pipe(T.Body("account_migration")),
    accountMobility: S.String.pipe(T.Body("account_mobility")),
    subOrgCreation: S.String.pipe(T.Body("sub_org_creation")),
  }),
).annotate({
  identifier: "TenantsListResultItemMetaFlags",
}) as any as S.Schema<TenantsListResultItemMetaFlags>;

export type TenantsListResultItemMetaHierarchyTagsList = Array<string>;
export const TenantsListResultItemMetaHierarchyTagsList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<TenantsListResultItemMetaHierarchyTagsList>;

export interface TenantsListResultItemMeta {
  /** Enable features for Organizations. */
  flags?: TenantsListResultItemMetaFlags | null;
  /** Ordered chain of organization tags from the root organization down to */
  hierarchyTags?: TenantsListResultItemMetaHierarchyTagsList | null;
  managedBy?: string | null;
}
export const TenantsListResultItemMeta = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    flags: S.optional(S.NullOr(TenantsListResultItemMetaFlags)),
    hierarchyTags: S.optional(
      S.NullOr(TenantsListResultItemMetaHierarchyTagsList).pipe(
        T.Body("hierarchy_tags"),
      ),
    ),
    managedBy: S.optional(S.NullOr(S.String).pipe(T.Body("managed_by"))),
  }),
).annotate({
  identifier: "TenantsListResultItemMeta",
}) as any as S.Schema<TenantsListResultItemMeta>;

export interface TenantsListResultItemParent {
  id: string;
  name: string;
}
export const TenantsListResultItemParent = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    name: S.String,
  }),
).annotate({
  identifier: "TenantsListResultItemParent",
}) as any as S.Schema<TenantsListResultItemParent>;

export interface TenantsListResultItemProfile {
  businessAddress: string;
  businessEmail: string;
  businessName: string;
  businessPhone: string;
  externalMetadata: string;
}
export const TenantsListResultItemProfile = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    businessAddress: S.String.pipe(T.Body("business_address")),
    businessEmail: S.String.pipe(T.Body("business_email")),
    businessName: S.String.pipe(T.Body("business_name")),
    businessPhone: S.String.pipe(T.Body("business_phone")),
    externalMetadata: S.String.pipe(T.Body("external_metadata")),
  }),
).annotate({
  identifier: "TenantsListResultItemProfile",
}) as any as S.Schema<TenantsListResultItemProfile>;

export interface TenantsListResultItem {
  id: string;
  createTime: string;
  meta: TenantsListResultItemMeta;
  name: string;
  parent?: TenantsListResultItemParent | null;
  profile?: TenantsListResultItemProfile | null;
}
export const TenantsListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    createTime: S.String.pipe(T.Body("create_time")),
    meta: TenantsListResultItemMeta,
    name: S.String,
    parent: S.optional(S.NullOr(TenantsListResultItemParent)),
    profile: S.optional(S.NullOr(TenantsListResultItemProfile)),
  }),
).annotate({
  identifier: "TenantsListResultItem",
}) as any as S.Schema<TenantsListResultItem>;

export type TenantsListResultList = Array<TenantsListResultItem>;
export const TenantsListResultList = /*@__PURE__*/ S.Array(
  TenantsListResultItem,
) as any as S.Schema<TenantsListResultList>;

export interface ListTenantsResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: TenantsListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListTenantsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: TenantsListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListTenantsResponse",
}) as any as S.Schema<ListTenantsResponse>;

export interface ListTokenPermissionGroupsRequest {
  /** Filter by the name of the permission group. */
  name?: string;
  /** Filter by the scope of the permission group. */
  scope?: string;
}
export const ListTokenPermissionGroupsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    name: S.optional(S.String.pipe(T.Query())),
    scope: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/user/tokens/permission_groups",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListTokenPermissionGroupsRequest",
}) as any as S.Schema<ListTokenPermissionGroupsRequest>;

export type TokensPermissionGroupsListResultItemCategory =
  | "developer_platform"
  | "ai_and_machine_learning"
  | "dns_and_zones"
  | "app_security"
  | "rules_and_configuration"
  | "cloudflare_one_and_zero_trust"
  | "analytics_and_logs"
  | "network_services"
  | "media"
  | "email_and_messaging"
  | "cache_and_performance"
  | "account_and_billing"
  | "other";
export const TokensPermissionGroupsListResultItemCategory =
  /*@__PURE__*/ S.String;

export type TokensPermissionGroupsListResultItemScopesItem =
  | "com.cloudflare.api.account"
  | "com.cloudflare.api.account.zone"
  | "com.cloudflare.api.user"
  | "com.cloudflare.edge.r2.bucket";
export const TokensPermissionGroupsListResultItemScopesItem =
  /*@__PURE__*/ S.String;

export type TokensPermissionGroupsListResultItemScopesList =
  Array<TokensPermissionGroupsListResultItemScopesItem>;
export const TokensPermissionGroupsListResultItemScopesList =
  /*@__PURE__*/ S.Array(
    TokensPermissionGroupsListResultItemScopesItem,
  ) as any as S.Schema<TokensPermissionGroupsListResultItemScopesList>;

export interface TokensPermissionGroupsListResultItem {
  /** Public ID. */
  id?: string | null;
  /** Product category that this permission group belongs to. */
  category?: TokensPermissionGroupsListResultItemCategory | null;
  /** Permission Group Name */
  name?: string | null;
  /** Resources to which the Permission Group is scoped */
  scopes?: TokensPermissionGroupsListResultItemScopesList | null;
}
export const TokensPermissionGroupsListResultItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.optional(S.NullOr(S.String)),
      category: S.optional(
        S.NullOr(TokensPermissionGroupsListResultItemCategory),
      ),
      name: S.optional(S.NullOr(S.String)),
      scopes: S.optional(
        S.NullOr(TokensPermissionGroupsListResultItemScopesList),
      ),
    }),
).annotate({
  identifier: "TokensPermissionGroupsListResultItem",
}) as any as S.Schema<TokensPermissionGroupsListResultItem>;

export type TokensPermissionGroupsListResultList =
  Array<TokensPermissionGroupsListResultItem>;
export const TokensPermissionGroupsListResultList = /*@__PURE__*/ S.Array(
  TokensPermissionGroupsListResultItem,
) as any as S.Schema<TokensPermissionGroupsListResultList>;

export interface ListTokenPermissionGroupsResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: TokensPermissionGroupsListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListTokenPermissionGroupsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: TokensPermissionGroupsListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListTokenPermissionGroupsResponse",
}) as any as S.Schema<ListTokenPermissionGroupsResponse>;

export type TokensListRequestDirection = "asc" | "desc";
export const TokensListRequestDirection = /*@__PURE__*/ S.String;

export interface ListTokensRequest {
  /** Direction to order results. */
  direction?: TokensListRequestDirection | (string & {});
  /** Page number of paginated results. */
  page?: number;
  /** Maximum number of results per page. */
  perPage?: number;
}
export const ListTokensRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    direction: S.optional(TokensListRequestDirection.pipe(T.Query())),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
  })
    .pipe(T.Http({ method: "GET", uri: "/user/tokens", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListTokensRequest",
}) as any as S.Schema<ListTokensRequest>;

export type TokensListResultItemConditionRequestIpInList = Array<string>;
export const TokensListResultItemConditionRequestIpInList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<TokensListResultItemConditionRequestIpInList>;

export type TokensListResultItemConditionRequestIpNotInList = Array<string>;
export const TokensListResultItemConditionRequestIpNotInList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<TokensListResultItemConditionRequestIpNotInList>;

export interface TokensListResultItemConditionRequestIp {
  /** List of IPv4/IPv6 CIDR addresses. */
  in?: TokensListResultItemConditionRequestIpInList | null;
  /** List of IPv4/IPv6 CIDR addresses. */
  notIn?: TokensListResultItemConditionRequestIpNotInList | null;
}
export const TokensListResultItemConditionRequestIp = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      in: S.optional(S.NullOr(TokensListResultItemConditionRequestIpInList)),
      notIn: S.optional(
        S.NullOr(TokensListResultItemConditionRequestIpNotInList).pipe(
          T.Body("not_in"),
        ),
      ),
    }),
).annotate({
  identifier: "TokensListResultItemConditionRequestIp",
}) as any as S.Schema<TokensListResultItemConditionRequestIp>;

export interface TokensListResultItemCondition {
  /** Client IP restrictions. */
  requestIp?: TokensListResultItemConditionRequestIp | null;
}
export const TokensListResultItemCondition = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    requestIp: S.optional(
      S.NullOr(TokensListResultItemConditionRequestIp).pipe(
        T.Body("request_ip"),
      ),
    ),
  }),
).annotate({
  identifier: "TokensListResultItemCondition",
}) as any as S.Schema<TokensListResultItemCondition>;

export type TokensListResultItemPoliciesItemEffect = "allow" | "deny";
export const TokensListResultItemPoliciesItemEffect = /*@__PURE__*/ S.String;

export type TokensListResultItemPoliciesItemPermissionGroupsItemMeta =
  TokensCreateResponsePoliciesItemPermissionGroupsItemMeta;
export const TokensListResultItemPoliciesItemPermissionGroupsItemMeta =
  TokensCreateResponsePoliciesItemPermissionGroupsItemMeta;

export type TokensListResultItemPoliciesItemPermissionGroupsItem =
  TokensCreateResponsePoliciesItemPermissionGroupsItem;
export const TokensListResultItemPoliciesItemPermissionGroupsItem =
  TokensCreateResponsePoliciesItemPermissionGroupsItem;

export type TokensListResultItemPoliciesItemPermissionGroupsList =
  Array<TokensCreateResponsePoliciesItemPermissionGroupsItem>;
export const TokensListResultItemPoliciesItemPermissionGroupsList =
  /*@__PURE__*/ S.Array(
    TokensCreateResponsePoliciesItemPermissionGroupsItem,
  ) as any as S.Schema<TokensListResultItemPoliciesItemPermissionGroupsList>;

export type TokensListResultItemPoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap =
  { [key: string]: string | undefined };
export const TokensListResultItemPoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<TokensListResultItemPoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap>;

export type TokensListResultItemPoliciesItemResourcesValue =
  | string
  | TokensListResultItemPoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap;
export const TokensListResultItemPoliciesItemResourcesValue =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export type TokensListResultItemPoliciesItemResourcesMap = {
  [key: string]: TokensListResultItemPoliciesItemResourcesValue | undefined;
};
export const TokensListResultItemPoliciesItemResourcesMap =
  /*@__PURE__*/ S.Record(
    S.String,
    TokensListResultItemPoliciesItemResourcesValue,
  ) as any as S.Schema<TokensListResultItemPoliciesItemResourcesMap>;

export interface TokensListResultItemPoliciesItem {
  /** Policy identifier. */
  id: string;
  /** Allow or deny operations against the resources. */
  effect: TokensListResultItemPoliciesItemEffect;
  /** A set of permission groups that are specified to the policy. */
  permissionGroups: TokensListResultItemPoliciesItemPermissionGroupsList;
  /** A list of resource names that the policy applies to. */
  resources: TokensListResultItemPoliciesItemResourcesMap;
}
export const TokensListResultItemPoliciesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    effect: TokensListResultItemPoliciesItemEffect,
    permissionGroups: TokensListResultItemPoliciesItemPermissionGroupsList.pipe(
      T.Body("permission_groups"),
    ),
    resources: TokensListResultItemPoliciesItemResourcesMap,
  }),
).annotate({
  identifier: "TokensListResultItemPoliciesItem",
}) as any as S.Schema<TokensListResultItemPoliciesItem>;

export type TokensListResultItemPoliciesList =
  Array<TokensListResultItemPoliciesItem>;
export const TokensListResultItemPoliciesList = /*@__PURE__*/ S.Array(
  TokensListResultItemPoliciesItem,
) as any as S.Schema<TokensListResultItemPoliciesList>;

export type TokensListResultItemStatus = "active" | "disabled" | "expired";
export const TokensListResultItemStatus = /*@__PURE__*/ S.String;

export interface TokensListResultItem {
  /** Token identifier tag. */
  id?: string | null;
  condition?: TokensListResultItemCondition | 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?: TokensListResultItemPoliciesList | null;
  /** Status of the token. */
  status?: TokensListResultItemStatus | null;
}
export const TokensListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    condition: S.optional(S.NullOr(TokensListResultItemCondition)),
    expiresOn: S.optional(S.NullOr(S.String).pipe(T.Body("expires_on"))),
    issuedOn: S.optional(S.NullOr(S.String).pipe(T.Body("issued_on"))),
    lastUsedOn: S.optional(S.NullOr(S.String).pipe(T.Body("last_used_on"))),
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    name: S.optional(S.NullOr(S.String)),
    notBefore: S.optional(S.NullOr(S.String).pipe(T.Body("not_before"))),
    policies: S.optional(S.NullOr(TokensListResultItemPoliciesList)),
    status: S.optional(S.NullOr(TokensListResultItemStatus)),
  }),
).annotate({
  identifier: "TokensListResultItem",
}) as any as S.Schema<TokensListResultItem>;

export type TokensListResultList = Array<TokensListResultItem>;
export const TokensListResultList = /*@__PURE__*/ S.Array(
  TokensListResultItem,
) as any as S.Schema<TokensListResultList>;

export interface ListTokensResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: TokensListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListTokensResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: TokensListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListTokensResponse",
}) as any as S.Schema<ListTokensResponse>;

export type InvitesEditRequestStatus = "accepted" | "rejected";
export const InvitesEditRequestStatus = /*@__PURE__*/ S.String;

export interface PatchInviteRequest {
  /** Invite identifier tag. */
  inviteId: string;
  /** Status of your response to the invitation (rejected or accepted). */
  status: InvitesEditRequestStatus | (string & {});
}
export const PatchInviteRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    inviteId: S.String.pipe(T.Label("invite_id")),
    status: InvitesEditRequestStatus,
  })
    .pipe(
      T.Http({ method: "PATCH", uri: "/user/invites/{invite_id}", code: 200 }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchInviteRequest",
}) as any as S.Schema<PatchInviteRequest>;

export type InvitesEditResponseRolesList = Array<string>;
export const InvitesEditResponseRolesList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<InvitesEditResponseRolesList>;

export type InvitesEditResponseStatus =
  | "pending"
  | "accepted"
  | "rejected"
  | "expired";
export const InvitesEditResponseStatus = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PatchInviteResponse {
  /** ID of the user to add to the organization. */
  invitedMemberId: string;
  /** ID of the organization the user will be added to. */
  organizationId: string;
  /** Invite identifier tag. */
  id?: string | null;
  /** When the invite is no longer active. */
  expiresOn?: string | null;
  /** The email address of the user who created the invite. */
  invitedBy?: string | null;
  /** Email address of the user to add to the organization. */
  invitedMemberEmail?: string | null;
  /** When the invite was sent. */
  invitedOn?: string | null;
  organizationIsEnforcingTwofactor?: boolean | null;
  /** Organization name. */
  organizationName?: string | null;
  /** List of role names the membership has for this account. */
  roles?: InvitesEditResponseRolesList | null;
  /** Current status of the invitation. */
  status?: InvitesEditResponseStatus | null;
}
export const PatchInviteResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    invitedMemberId: S.String.pipe(T.Body("invited_member_id")),
    organizationId: S.String.pipe(T.Body("organization_id")),
    id: S.optional(S.NullOr(S.String)),
    expiresOn: S.optional(S.NullOr(S.String).pipe(T.Body("expires_on"))),
    invitedBy: S.optional(S.NullOr(S.String).pipe(T.Body("invited_by"))),
    invitedMemberEmail: S.optional(
      S.NullOr(S.String).pipe(T.Body("invited_member_email")),
    ),
    invitedOn: S.optional(S.NullOr(S.String).pipe(T.Body("invited_on"))),
    organizationIsEnforcingTwofactor: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("organization_is_enforcing_twofactor")),
    ),
    organizationName: S.optional(
      S.NullOr(S.String).pipe(T.Body("organization_name")),
    ),
    roles: S.optional(S.NullOr(InvitesEditResponseRolesList)),
    status: S.optional(S.NullOr(InvitesEditResponseStatus)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchInviteResponse",
}) as any as S.Schema<PatchInviteResponse>;

export interface PatchUserRequest {
  /** The country in which the user lives. */
  country?: string;
  /** User's first name */
  firstName?: string;
  /** User's last name */
  lastName?: string;
  /** User's telephone number */
  telephone?: string;
  /** The zipcode or postal code where the user lives. */
  zipcode?: string;
}
export const PatchUserRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    country: S.optional(S.String),
    firstName: S.optional(S.String.pipe(T.Body("first_name"))),
    lastName: S.optional(S.String.pipe(T.Body("last_name"))),
    telephone: S.optional(S.String),
    zipcode: S.optional(S.String),
  })
    .pipe(T.Http({ method: "PATCH", uri: "/user", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchUserRequest",
}) as any as S.Schema<PatchUserRequest>;

export type EditResponseBetasList = Array<string>;
export const EditResponseBetasList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<EditResponseBetasList>;

export type EditResponseOrganizationsItemPermissionsList = Array<unknown>;
export const EditResponseOrganizationsItemPermissionsList =
  /*@__PURE__*/ S.Array(
    S.Unknown,
  ) as any as S.Schema<EditResponseOrganizationsItemPermissionsList>;

export type EditResponseOrganizationsItemRolesList = Array<string>;
export const EditResponseOrganizationsItemRolesList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<EditResponseOrganizationsItemRolesList>;

export type EditResponseOrganizationsItemStatus = "member" | "invited";
export const EditResponseOrganizationsItemStatus = /*@__PURE__*/ S.String;

export interface EditResponseOrganizationsItem {
  /** Identifier */
  id?: string | null;
  /** Organization name. */
  name?: string | null;
  /** Access permissions for this User. */
  permissions?: EditResponseOrganizationsItemPermissionsList | null;
  /** List of roles that a user has within an organization. */
  roles?: EditResponseOrganizationsItemRolesList | null;
  /** Whether the user is a member of the organization or has an invitation pending. */
  status?: EditResponseOrganizationsItemStatus | null;
}
export const EditResponseOrganizationsItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    name: S.optional(S.NullOr(S.String)),
    permissions: S.optional(
      S.NullOr(EditResponseOrganizationsItemPermissionsList),
    ),
    roles: S.optional(S.NullOr(EditResponseOrganizationsItemRolesList)),
    status: S.optional(S.NullOr(EditResponseOrganizationsItemStatus)),
  }),
).annotate({
  identifier: "EditResponseOrganizationsItem",
}) as any as S.Schema<EditResponseOrganizationsItem>;

export type EditResponseOrganizationsList =
  Array<EditResponseOrganizationsItem>;
export const EditResponseOrganizationsList = /*@__PURE__*/ S.Array(
  EditResponseOrganizationsItem,
) as any as S.Schema<EditResponseOrganizationsList>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PatchUserResponse {
  /** Identifier of the user. */
  id: string;
  /** Current email address of the user. */
  email: string;
  /** Lists the betas that the user is participating in. */
  betas?: EditResponseBetasList | null;
  /** The country in which the user lives. */
  country?: string | null;
  /** User's first name */
  firstName?: string | null;
  /** Indicates whether user has any business zones */
  hasBusinessZones?: boolean | null;
  /** Indicates whether user has any enterprise zones */
  hasEnterpriseZones?: boolean | null;
  /** Indicates whether user has any pro zones */
  hasProZones?: boolean | null;
  /** User's last name */
  lastName?: string | null;
  organizations?: EditResponseOrganizationsList | null;
  /** Indicates whether user has been suspended */
  suspended?: boolean | null;
  /** User's telephone number */
  telephone?: string | null;
  /** Indicates whether two-factor authentication is enabled for the user account. Does not apply to API authentication. */
  twoFactorAuthenticationEnabled?: boolean | null;
  /** Indicates whether two-factor authentication is required by one of the accounts that the user is a member of. */
  twoFactorAuthenticationLocked?: boolean | null;
  /** The zipcode or postal code where the user lives. */
  zipcode?: string | null;
}
export const PatchUserResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    email: S.String,
    betas: S.optional(S.NullOr(EditResponseBetasList)),
    country: S.optional(S.NullOr(S.String)),
    firstName: S.optional(S.NullOr(S.String).pipe(T.Body("first_name"))),
    hasBusinessZones: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("has_business_zones")),
    ),
    hasEnterpriseZones: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("has_enterprise_zones")),
    ),
    hasProZones: S.optional(S.NullOr(S.Boolean).pipe(T.Body("has_pro_zones"))),
    lastName: S.optional(S.NullOr(S.String).pipe(T.Body("last_name"))),
    organizations: S.optional(S.NullOr(EditResponseOrganizationsList)),
    suspended: S.optional(S.NullOr(S.Boolean)),
    telephone: S.optional(S.NullOr(S.String)),
    twoFactorAuthenticationEnabled: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("two_factor_authentication_enabled")),
    ),
    twoFactorAuthenticationLocked: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("two_factor_authentication_locked")),
    ),
    zipcode: S.optional(S.NullOr(S.String)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchUserResponse",
}) as any as S.Schema<PatchUserResponse>;

export type SubscriptionsUpdateRequestFrequency =
  | "weekly"
  | "monthly"
  | "quarterly"
  | "yearly";
export const SubscriptionsUpdateRequestFrequency = /*@__PURE__*/ S.String;

export type SubscriptionsUpdateRequestRatePlanId =
  | "free"
  | "lite"
  | "pro"
  | "pro_plus"
  | "business"
  | "enterprise"
  | "partners_free"
  | "partners_pro"
  | "partners_business"
  | "partners_enterprise";
export const SubscriptionsUpdateRequestRatePlanId = /*@__PURE__*/ S.String;

export type SubscriptionsUpdateRequestRatePlanSetsList = Array<string>;
export const SubscriptionsUpdateRequestRatePlanSetsList = /*@__PURE__*/ S.Array(
  S.String,
) as any as S.Schema<SubscriptionsUpdateRequestRatePlanSetsList>;

export interface SubscriptionsUpdateRequestRatePlan {
  /** The ID of the rate plan. */
  id?: SubscriptionsUpdateRequestRatePlanId | (string & {});
  /** The currency applied to the rate plan subscription. */
  currency?: string;
  /** Whether this rate plan is managed externally from Cloudflare. */
  externallyManaged?: boolean;
  /** Whether a rate plan is enterprise-based (or newly adopted term contract). */
  isContract?: boolean;
  /** The full name of the rate plan. */
  publicName?: string;
  /** The scope that this rate plan applies to. */
  scope?: string;
  /** The list of sets this rate plan applies to. Returns array of strings. */
  sets?: SubscriptionsUpdateRequestRatePlanSetsList;
}
export const SubscriptionsUpdateRequestRatePlan = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(SubscriptionsUpdateRequestRatePlanId),
    currency: S.optional(S.String),
    externallyManaged: S.optional(S.Boolean.pipe(T.Body("externally_managed"))),
    isContract: S.optional(S.Boolean.pipe(T.Body("is_contract"))),
    publicName: S.optional(S.String.pipe(T.Body("public_name"))),
    scope: S.optional(S.String),
    sets: S.optional(SubscriptionsUpdateRequestRatePlanSetsList),
  }),
).annotate({
  identifier: "SubscriptionsUpdateRequestRatePlan",
}) as any as S.Schema<SubscriptionsUpdateRequestRatePlan>;

export interface PutSubscriptionRequest {
  /** Subscription identifier tag. */
  identifier: string;
  /** How often the subscription is renewed automatically. */
  frequency?: SubscriptionsUpdateRequestFrequency | (string & {});
  /** The rate plan applied to the subscription. */
  ratePlan?: SubscriptionsUpdateRequestRatePlan;
}
export const PutSubscriptionRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    identifier: S.String.pipe(T.Label()),
    frequency: S.optional(SubscriptionsUpdateRequestFrequency),
    ratePlan: S.optional(
      SubscriptionsUpdateRequestRatePlan.pipe(T.Body("rate_plan")),
    ),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/user/subscriptions/{identifier}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutSubscriptionRequest",
}) as any as S.Schema<PutSubscriptionRequest>;

export type PutSubscriptionResponse = unknown;
export const PutSubscriptionResponse = /*@__PURE__*/ S.suspend(() =>
  S.Unknown.pipe(T.EnvelopePayloadRoot(), T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutSubscriptionResponse",
}) as any as S.Schema<PutSubscriptionResponse>;

export interface PutTokenValueRequest {
  /** Token identifier tag. */
  tokenId: string;
}
export const PutTokenValueRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    tokenId: S.String.pipe(T.Label("token_id")),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/user/tokens/{token_id}/value",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutTokenValueRequest",
}) as any as S.Schema<PutTokenValueRequest>;

export type PutTokenValueResponse = unknown;
export const PutTokenValueResponse = /*@__PURE__*/ S.suspend(() =>
  S.Unknown.pipe(T.EnvelopePayloadRoot(), T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutTokenValueResponse",
}) as any as S.Schema<PutTokenValueResponse>;

export type TokensUpdateRequestPoliciesItemEffect = "allow" | "deny";
export const TokensUpdateRequestPoliciesItemEffect = /*@__PURE__*/ S.String;

export type TokensUpdateRequestPoliciesItemPermissionGroupsItemMeta =
  TokensCreateRequestPoliciesItemPermissionGroupsItemMeta;
export const TokensUpdateRequestPoliciesItemPermissionGroupsItemMeta =
  TokensCreateRequestPoliciesItemPermissionGroupsItemMeta;

export type TokensUpdateRequestPoliciesItemPermissionGroupsItem =
  TokensCreateRequestPoliciesItemPermissionGroupsItem;
export const TokensUpdateRequestPoliciesItemPermissionGroupsItem =
  TokensCreateRequestPoliciesItemPermissionGroupsItem;

export type TokensUpdateRequestPoliciesItemPermissionGroupsList =
  Array<TokensCreateRequestPoliciesItemPermissionGroupsItem>;
export const TokensUpdateRequestPoliciesItemPermissionGroupsList =
  /*@__PURE__*/ S.Array(
    TokensCreateRequestPoliciesItemPermissionGroupsItem,
  ) as any as S.Schema<TokensUpdateRequestPoliciesItemPermissionGroupsList>;

export type TokensUpdateRequestPoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap =
  { [key: string]: string | undefined };
export const TokensUpdateRequestPoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<TokensUpdateRequestPoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap>;

export type TokensUpdateRequestPoliciesItemResourcesValue =
  | string
  | TokensUpdateRequestPoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap;
export const TokensUpdateRequestPoliciesItemResourcesValue =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export type TokensUpdateRequestPoliciesItemResourcesMap = {
  [key: string]: TokensUpdateRequestPoliciesItemResourcesValue | undefined;
};
export const TokensUpdateRequestPoliciesItemResourcesMap =
  /*@__PURE__*/ S.Record(
    S.String,
    TokensUpdateRequestPoliciesItemResourcesValue,
  ) as any as S.Schema<TokensUpdateRequestPoliciesItemResourcesMap>;

export interface TokensUpdateRequestPoliciesItem {
  /** Allow or deny operations against the resources. */
  effect: TokensUpdateRequestPoliciesItemEffect | (string & {});
  /** A set of permission groups that are specified to the policy. */
  permissionGroups: TokensUpdateRequestPoliciesItemPermissionGroupsList;
  /** A list of resource names that the policy applies to. */
  resources: TokensUpdateRequestPoliciesItemResourcesMap;
}
export const TokensUpdateRequestPoliciesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    effect: TokensUpdateRequestPoliciesItemEffect,
    permissionGroups: TokensUpdateRequestPoliciesItemPermissionGroupsList.pipe(
      T.Body("permission_groups"),
    ),
    resources: TokensUpdateRequestPoliciesItemResourcesMap,
  }),
).annotate({
  identifier: "TokensUpdateRequestPoliciesItem",
}) as any as S.Schema<TokensUpdateRequestPoliciesItem>;

export type TokensUpdateRequestPoliciesList =
  Array<TokensUpdateRequestPoliciesItem>;
export const TokensUpdateRequestPoliciesList = /*@__PURE__*/ S.Array(
  TokensUpdateRequestPoliciesItem,
) as any as S.Schema<TokensUpdateRequestPoliciesList>;

export type TokensUpdateRequestConditionRequestIpInList = Array<string>;
export const TokensUpdateRequestConditionRequestIpInList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<TokensUpdateRequestConditionRequestIpInList>;

export type TokensUpdateRequestConditionRequestIpNotInList = Array<string>;
export const TokensUpdateRequestConditionRequestIpNotInList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<TokensUpdateRequestConditionRequestIpNotInList>;

export interface TokensUpdateRequestConditionRequestIp {
  /** List of IPv4/IPv6 CIDR addresses. */
  in?: TokensUpdateRequestConditionRequestIpInList;
  /** List of IPv4/IPv6 CIDR addresses. */
  notIn?: TokensUpdateRequestConditionRequestIpNotInList;
}
export const TokensUpdateRequestConditionRequestIp = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      in: S.optional(TokensUpdateRequestConditionRequestIpInList),
      notIn: S.optional(
        TokensUpdateRequestConditionRequestIpNotInList.pipe(T.Body("not_in")),
      ),
    }),
).annotate({
  identifier: "TokensUpdateRequestConditionRequestIp",
}) as any as S.Schema<TokensUpdateRequestConditionRequestIp>;

export interface TokensUpdateRequestCondition {
  /** Client IP restrictions. */
  requestIp?: TokensUpdateRequestConditionRequestIp;
}
export const TokensUpdateRequestCondition = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    requestIp: S.optional(
      TokensUpdateRequestConditionRequestIp.pipe(T.Body("request_ip")),
    ),
  }),
).annotate({
  identifier: "TokensUpdateRequestCondition",
}) as any as S.Schema<TokensUpdateRequestCondition>;

export type TokensUpdateRequestStatus = "active" | "disabled" | "expired";
export const TokensUpdateRequestStatus = /*@__PURE__*/ S.String;

export interface UpdateTokenRequest {
  /** Token identifier tag. */
  tokenId: string;
  /** Token name. */
  name: string;
  /** List of access policies assigned to the token. */
  policies: TokensUpdateRequestPoliciesList;
  condition?: TokensUpdateRequestCondition;
  /** The expiration time on or after which the JWT MUST NOT be accepted for processing. */
  expiresOn?: string;
  /** The time before which the token MUST NOT be accepted for processing. */
  notBefore?: string;
  /** Status of the token. */
  status?: TokensUpdateRequestStatus | (string & {});
}
export const UpdateTokenRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    tokenId: S.String.pipe(T.Label("token_id")),
    name: S.String,
    policies: TokensUpdateRequestPoliciesList,
    condition: S.optional(TokensUpdateRequestCondition),
    expiresOn: S.optional(S.String.pipe(T.Body("expires_on"))),
    notBefore: S.optional(S.String.pipe(T.Body("not_before"))),
    status: S.optional(TokensUpdateRequestStatus),
  })
    .pipe(T.Http({ method: "PUT", uri: "/user/tokens/{token_id}", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateTokenRequest",
}) as any as S.Schema<UpdateTokenRequest>;

export type TokensUpdateResponseConditionRequestIpInList = Array<string>;
export const TokensUpdateResponseConditionRequestIpInList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<TokensUpdateResponseConditionRequestIpInList>;

export type TokensUpdateResponseConditionRequestIpNotInList = Array<string>;
export const TokensUpdateResponseConditionRequestIpNotInList =
  /*@__PURE__*/ S.Array(
    S.String,
  ) as any as S.Schema<TokensUpdateResponseConditionRequestIpNotInList>;

export interface TokensUpdateResponseConditionRequestIp {
  /** List of IPv4/IPv6 CIDR addresses. */
  in?: TokensUpdateResponseConditionRequestIpInList | null;
  /** List of IPv4/IPv6 CIDR addresses. */
  notIn?: TokensUpdateResponseConditionRequestIpNotInList | null;
}
export const TokensUpdateResponseConditionRequestIp = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      in: S.optional(S.NullOr(TokensUpdateResponseConditionRequestIpInList)),
      notIn: S.optional(
        S.NullOr(TokensUpdateResponseConditionRequestIpNotInList).pipe(
          T.Body("not_in"),
        ),
      ),
    }),
).annotate({
  identifier: "TokensUpdateResponseConditionRequestIp",
}) as any as S.Schema<TokensUpdateResponseConditionRequestIp>;

export interface TokensUpdateResponseCondition {
  /** Client IP restrictions. */
  requestIp?: TokensUpdateResponseConditionRequestIp | null;
}
export const TokensUpdateResponseCondition = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    requestIp: S.optional(
      S.NullOr(TokensUpdateResponseConditionRequestIp).pipe(
        T.Body("request_ip"),
      ),
    ),
  }),
).annotate({
  identifier: "TokensUpdateResponseCondition",
}) as any as S.Schema<TokensUpdateResponseCondition>;

export type TokensUpdateResponsePoliciesItemEffect = "allow" | "deny";
export const TokensUpdateResponsePoliciesItemEffect = /*@__PURE__*/ S.String;

export type TokensUpdateResponsePoliciesItemPermissionGroupsItemMeta =
  TokensCreateResponsePoliciesItemPermissionGroupsItemMeta;
export const TokensUpdateResponsePoliciesItemPermissionGroupsItemMeta =
  TokensCreateResponsePoliciesItemPermissionGroupsItemMeta;

export type TokensUpdateResponsePoliciesItemPermissionGroupsItem =
  TokensCreateResponsePoliciesItemPermissionGroupsItem;
export const TokensUpdateResponsePoliciesItemPermissionGroupsItem =
  TokensCreateResponsePoliciesItemPermissionGroupsItem;

export type TokensUpdateResponsePoliciesItemPermissionGroupsList =
  Array<TokensCreateResponsePoliciesItemPermissionGroupsItem>;
export const TokensUpdateResponsePoliciesItemPermissionGroupsList =
  /*@__PURE__*/ S.Array(
    TokensCreateResponsePoliciesItemPermissionGroupsItem,
  ) as any as S.Schema<TokensUpdateResponsePoliciesItemPermissionGroupsList>;

export type TokensUpdateResponsePoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap =
  { [key: string]: string | undefined };
export const TokensUpdateResponsePoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap =
  /*@__PURE__*/ S.Record(
    S.String,
    S.String,
  ) as any as S.Schema<TokensUpdateResponsePoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap>;

export type TokensUpdateResponsePoliciesItemResourcesValue =
  | string
  | TokensUpdateResponsePoliciesItemResourcesIAMResourcesTypeObjectNestedValueMap;
export const TokensUpdateResponsePoliciesItemResourcesValue =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], []]));

export type TokensUpdateResponsePoliciesItemResourcesMap = {
  [key: string]: TokensUpdateResponsePoliciesItemResourcesValue | undefined;
};
export const TokensUpdateResponsePoliciesItemResourcesMap =
  /*@__PURE__*/ S.Record(
    S.String,
    TokensUpdateResponsePoliciesItemResourcesValue,
  ) as any as S.Schema<TokensUpdateResponsePoliciesItemResourcesMap>;

export interface TokensUpdateResponsePoliciesItem {
  /** Policy identifier. */
  id: string;
  /** Allow or deny operations against the resources. */
  effect: TokensUpdateResponsePoliciesItemEffect;
  /** A set of permission groups that are specified to the policy. */
  permissionGroups: TokensUpdateResponsePoliciesItemPermissionGroupsList;
  /** A list of resource names that the policy applies to. */
  resources: TokensUpdateResponsePoliciesItemResourcesMap;
}
export const TokensUpdateResponsePoliciesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    effect: TokensUpdateResponsePoliciesItemEffect,
    permissionGroups: TokensUpdateResponsePoliciesItemPermissionGroupsList.pipe(
      T.Body("permission_groups"),
    ),
    resources: TokensUpdateResponsePoliciesItemResourcesMap,
  }),
).annotate({
  identifier: "TokensUpdateResponsePoliciesItem",
}) as any as S.Schema<TokensUpdateResponsePoliciesItem>;

export type TokensUpdateResponsePoliciesList =
  Array<TokensUpdateResponsePoliciesItem>;
export const TokensUpdateResponsePoliciesList = /*@__PURE__*/ S.Array(
  TokensUpdateResponsePoliciesItem,
) as any as S.Schema<TokensUpdateResponsePoliciesList>;

export type TokensUpdateResponseStatus = "active" | "disabled" | "expired";
export const TokensUpdateResponseStatus = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface UpdateTokenResponse {
  /** Token identifier tag. */
  id?: string | null;
  condition?: TokensUpdateResponseCondition | 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?: TokensUpdateResponsePoliciesList | null;
  /** Status of the token. */
  status?: TokensUpdateResponseStatus | null;
}
export const UpdateTokenResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    condition: S.optional(S.NullOr(TokensUpdateResponseCondition)),
    expiresOn: S.optional(S.NullOr(S.String).pipe(T.Body("expires_on"))),
    issuedOn: S.optional(S.NullOr(S.String).pipe(T.Body("issued_on"))),
    lastUsedOn: S.optional(S.NullOr(S.String).pipe(T.Body("last_used_on"))),
    modifiedOn: S.optional(S.NullOr(S.String).pipe(T.Body("modified_on"))),
    name: S.optional(S.NullOr(S.String)),
    notBefore: S.optional(S.NullOr(S.String).pipe(T.Body("not_before"))),
    policies: S.optional(S.NullOr(TokensUpdateResponsePoliciesList)),
    status: S.optional(S.NullOr(TokensUpdateResponseStatus)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateTokenResponse",
}) as any as S.Schema<UpdateTokenResponse>;

export interface VerifyTokenRequest {}
export const VerifyTokenRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({})
    .pipe(T.Http({ method: "GET", uri: "/user/tokens/verify", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "VerifyTokenRequest",
}) as any as S.Schema<VerifyTokenRequest>;

export type TokensVerifyResponseStatus = "active" | "disabled" | "expired";
export const TokensVerifyResponseStatus = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface VerifyTokenResponse {
  /** Token identifier tag. */
  id: string;
  /** Status of the token. */
  status: TokensVerifyResponseStatus;
  /** 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 const VerifyTokenResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    status: TokensVerifyResponseStatus,
    expiresOn: S.optional(S.NullOr(S.String).pipe(T.Body("expires_on"))),
    notBefore: S.optional(S.NullOr(S.String).pipe(T.Body("not_before"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "VerifyTokenResponse",
}) as any as S.Schema<VerifyTokenResponse>;

export type CreateTokenError =
  | InvalidRoute
  | InvalidTokenName
  | PermissionGroupNotFound
  | CloudflareOpError;
/** Create a new access token. */
export const createToken: API.OperationMethod<
  CreateTokenRequest,
  CreateTokenResponse,
  CreateTokenError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateTokenRequest,
  output: CreateTokenResponse,
  errors: [
    InvalidRoute,
    InvalidTokenName,
    PermissionGroupNotFound,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteOrganizationError = CloudflareOpError;
/** Removes association to an organization. */
export const deleteOrganization: API.OperationMethod<
  DeleteOrganizationRequest,
  DeleteOrganizationResponse,
  DeleteOrganizationError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteOrganizationRequest,
  output: DeleteOrganizationResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteSubscriptionError = CloudflareOpError;
/** Deletes a user's subscription. */
export const deleteSubscription: API.OperationMethod<
  DeleteSubscriptionRequest,
  DeleteSubscriptionResponse,
  DeleteSubscriptionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteSubscriptionRequest,
  output: DeleteSubscriptionResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteTokenError =
  | InvalidRoute
  | MethodNotAllowed
  | TokenNotFound
  | CloudflareOpError;
/** Destroy a token. */
export const deleteToken: API.OperationMethod<
  DeleteTokenRequest,
  DeleteTokenResponse,
  DeleteTokenError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteTokenRequest,
  output: DeleteTokenResponse,
  errors: [
    InvalidRoute,
    MethodNotAllowed,
    TokenNotFound,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetBillingProfileError = CloudflareOpError;
/** Accesses your billing profile object. */
export const getBillingProfile: API.OperationMethod<
  GetBillingProfileRequest,
  GetBillingProfileResponse,
  GetBillingProfileError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetBillingProfileRequest,
  output: GetBillingProfileResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetInviteError = CloudflareOpError;
/** Gets the details of an invitation. */
export const getInvite: API.OperationMethod<
  GetInviteRequest,
  GetInviteResponse,
  GetInviteError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetInviteRequest,
  output: GetInviteResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetOrganizationError = CloudflareOpError;
/** Gets a specific organization the user is associated with. */
export const getOrganization: API.OperationMethod<
  GetOrganizationRequest,
  GetOrganizationResponse,
  GetOrganizationError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetOrganizationRequest,
  output: GetOrganizationResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetSubscriptionError = CloudflareOpError;
/** Lists all of a user's subscriptions. */
export const getSubscription: API.PaginatedOperationMethod<
  GetSubscriptionRequest,
  GetSubscriptionResponse,
  GetSubscriptionError,
  CloudflareOpContext,
  SubscriptionsGetResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: GetSubscriptionRequest,
    output: GetSubscriptionResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: { mode: "single", items: "result" } as const,
  }),
  cloudflarePaginate,
) as any;

export type GetTokenError = InvalidRoute | TokenNotFound | CloudflareOpError;
/** Get information about a specific token. */
export const getToken: API.OperationMethod<
  GetTokenRequest,
  GetTokenResponse,
  GetTokenError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetTokenRequest,
  output: GetTokenResponse,
  errors: [InvalidRoute, TokenNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetUserError = CloudflareOpError;
/** Retrieves detailed information about the currently authenticated user, including email, name, and account memberships. */
export const getUser: API.OperationMethod<
  GetUserRequest,
  GetUserResponse,
  GetUserError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetUserRequest,
  output: GetUserResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListAuditLogsError = CloudflareOpError;
/** Gets a list of audit logs for a user account. Can be filtered by who made the change, on which zone, and the timeframe of the change. */
export const listAuditLogs: API.PaginatedOperationMethod<
  ListAuditLogsRequest,
  ListAuditLogsResponse,
  ListAuditLogsError,
  CloudflareOpContext,
  AuditLogsListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListAuditLogsRequest,
    output: ListAuditLogsResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListBillingHistoriesError = CloudflareOpError;
/** Accesses your billing history object. */
export const listBillingHistories: API.PaginatedOperationMethod<
  ListBillingHistoriesRequest,
  ListBillingHistoriesResponse,
  ListBillingHistoriesError,
  CloudflareOpContext,
  BillingHistoryListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListBillingHistoriesRequest,
    output: ListBillingHistoriesResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListInvitesError = CloudflareOpError;
/** Lists all invitations associated with my user. */
export const listInvites: API.PaginatedOperationMethod<
  ListInvitesRequest,
  ListInvitesResponse,
  ListInvitesError,
  CloudflareOpContext,
  InvitesListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListInvitesRequest,
    output: ListInvitesResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: { mode: "single", items: "result" } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListOrganizationsError = CloudflareOpError;
/** Lists organizations the user is associated with. */
export const listOrganizations: API.PaginatedOperationMethod<
  ListOrganizationsRequest,
  ListOrganizationsResponse,
  ListOrganizationsError,
  CloudflareOpContext,
  OrganizationsListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListOrganizationsRequest,
    output: ListOrganizationsResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListTenantsError = CloudflareOpError;
/** Retrieves list of tenants the authenticated user / method has access to. */
export const listTenants: API.PaginatedOperationMethod<
  ListTenantsRequest,
  ListTenantsResponse,
  ListTenantsError,
  CloudflareOpContext,
  TenantsListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListTenantsRequest,
    output: ListTenantsResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: { mode: "single", items: "result" } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListTokenPermissionGroupsError = CloudflareOpError;
/** Find all available permission groups for API Tokens. */
export const listTokenPermissionGroups: API.PaginatedOperationMethod<
  ListTokenPermissionGroupsRequest,
  ListTokenPermissionGroupsResponse,
  ListTokenPermissionGroupsError,
  CloudflareOpContext,
  TokensPermissionGroupsListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListTokenPermissionGroupsRequest,
    output: ListTokenPermissionGroupsResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: { mode: "single", items: "result" } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListTokensError = CloudflareOpError;
/** List all access tokens you created. */
export const listTokens: API.PaginatedOperationMethod<
  ListTokensRequest,
  ListTokensResponse,
  ListTokensError,
  CloudflareOpContext,
  TokensListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListTokensRequest,
    output: ListTokensResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type PatchInviteError = CloudflareOpError;
/** Responds to an invitation. */
export const patchInvite: API.OperationMethod<
  PatchInviteRequest,
  PatchInviteResponse,
  PatchInviteError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchInviteRequest,
  output: PatchInviteResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PatchUserError = CloudflareOpError;
/** Edit part of your user details. */
export const patchUser: API.OperationMethod<
  PatchUserRequest,
  PatchUserResponse,
  PatchUserError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchUserRequest,
  output: PatchUserResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PutSubscriptionError = CloudflareOpError;
/** Updates a user's subscriptions. */
export const putSubscription: API.OperationMethod<
  PutSubscriptionRequest,
  PutSubscriptionResponse,
  PutSubscriptionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PutSubscriptionRequest,
  output: PutSubscriptionResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PutTokenValueError =
  | InvalidRoute
  | TokenNotFound
  | CloudflareOpError;
/** Roll the token secret. */
export const putTokenValue: API.OperationMethod<
  PutTokenValueRequest,
  PutTokenValueResponse,
  PutTokenValueError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PutTokenValueRequest,
  output: PutTokenValueResponse,
  errors: [InvalidRoute, TokenNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type UpdateTokenError =
  | InvalidRoute
  | MethodNotAllowed
  | TokenNotFound
  | PermissionGroupNotFound
  | CloudflareOpError;
/** Update an existing token. */
export const updateToken: API.OperationMethod<
  UpdateTokenRequest,
  UpdateTokenResponse,
  UpdateTokenError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdateTokenRequest,
  output: UpdateTokenResponse,
  errors: [
    InvalidRoute,
    MethodNotAllowed,
    TokenNotFound,
    PermissionGroupNotFound,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type VerifyTokenError = Forbidden | CloudflareOpError;
/** Test whether a token works. */
export const verifyToken: API.OperationMethod<
  VerifyTokenRequest,
  VerifyTokenResponse,
  VerifyTokenError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: VerifyTokenRequest,
  output: VerifyTokenResponse,
  errors: [Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));