// 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>> = {
  abuseContactEmail: "abuse_contact_email",
  cachePurge: "cache_purge",
  cfRayId: "cf_ray_id",
  createdOn: "created_on",
  currentPeriodEnd: "current_period_end",
  currentPeriodStart: "current_period_start",
  dnsRecords: "dns_records",
  enforceTwofactor: "enforce_twofactor",
  expiresOn: "expires_on",
  externallyManaged: "externally_managed",
  firstName: "first_name",
  ipAddress: "ip_address",
  isContract: "is_contract",
  issuedOn: "issued_on",
  lastName: "last_name",
  lastUsedOn: "last_used_on",
  managedBy: "managed_by",
  modifiedOn: "modified_on",
  notBefore: "not_before",
  notIn: "not_in",
  parentOrgId: "parent_org_id",
  parentOrgName: "parent_org_name",
  perPage: "per_page",
  permissionGroups: "permission_groups",
  publicName: "public_name",
  ratePlan: "rate_plan",
  requestIp: "request_ip",
  resourceGroups: "resource_groups",
  resultInfo: "result_info",
  statusCode: "status_code",
  subscriptionId: "subscription_id",
  tokenId: "token_id",
  tokenName: "token_name",
  totalCount: "total_count",
  twoFactorAuthenticationEnabled: "two_factor_authentication_enabled",
  userAgent: "user_agent",
  zoneSettings: "zone_settings",
};

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

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

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

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

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

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

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 JsonDecodeFailure
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<JsonDecodeFailure>()("JsonDecodeFailure", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 1198 }],
  ) {}

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

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

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

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

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 TokenManagedByCloudflare
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<TokenManagedByCloudflare>()(
      "TokenManagedByCloudflare",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ code: 1001 }],
  ) {}

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

export class UpdateAccountTypeNotSupported
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<UpdateAccountTypeNotSupported>()(
      "UpdateAccountTypeNotSupported",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ code: 1001, message: { includes: "account type is not supported" } }],
  ) {}

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

export type CreateRequestType = "standard" | "enterprise";
export const CreateRequestType = /*@__PURE__*/ S.String;

export interface CreateRequestUnit {
  /** Tenant unit ID */
  id?: string;
}
export const CreateRequestUnit = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.String),
  }),
).annotate({
  identifier: "CreateRequestUnit",
}) as any as S.Schema<CreateRequestUnit>;

export interface CreateAccountRequest {
  /** Account name */
  name: string;
  type?: CreateRequestType | (string & {});
  /** information related to the tenant unit, and optionally, an id of the unit to create the account on. see https://developers.cloudflare.com/tenant/how-to/manage-accounts/ */
  unit?: CreateRequestUnit;
}
export const CreateAccountRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    name: S.String,
    type: S.optional(CreateRequestType),
    unit: S.optional(CreateRequestUnit),
  })
    .pipe(T.Http({ method: "POST", uri: "/accounts", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateAccountRequest",
}) as any as S.Schema<CreateAccountRequest>;

export type CreateResponseType = "standard" | "enterprise";
export const CreateResponseType = /*@__PURE__*/ S.String;

export interface CreateResponseManagedBy {
  /** ID of the parent Organization, if one exists */
  parentOrgId?: string | null;
  /** Name of the parent Organization, if one exists */
  parentOrgName?: string | null;
}
export const CreateResponseManagedBy = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    parentOrgId: S.optional(S.NullOr(S.String).pipe(T.Body("parent_org_id"))),
    parentOrgName: S.optional(
      S.NullOr(S.String).pipe(T.Body("parent_org_name")),
    ),
  }),
).annotate({
  identifier: "CreateResponseManagedBy",
}) as any as S.Schema<CreateResponseManagedBy>;

export interface CreateResponseSettings {
  /** Sets an abuse contact email to notify for abuse reports. */
  abuseContactEmail?: string | null;
  /** Indicates whether membership in this account requires that */
  enforceTwofactor?: boolean | null;
}
export const CreateResponseSettings = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    abuseContactEmail: S.optional(
      S.NullOr(S.String).pipe(T.Body("abuse_contact_email")),
    ),
    enforceTwofactor: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("enforce_twofactor")),
    ),
  }),
).annotate({
  identifier: "CreateResponseSettings",
}) as any as S.Schema<CreateResponseSettings>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateAccountResponse {
  /** Identifier */
  id: string;
  /** Account name */
  name: string;
  type: CreateResponseType;
  /** Timestamp for the creation of the account */
  createdOn?: string | null;
  /** Parent container details */
  managedBy?: CreateResponseManagedBy | null;
  /** Account settings */
  settings?: CreateResponseSettings | null;
}
export const CreateAccountResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    name: S.String,
    type: CreateResponseType,
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    managedBy: S.optional(
      S.NullOr(CreateResponseManagedBy).pipe(T.Body("managed_by")),
    ),
    settings: S.optional(S.NullOr(CreateResponseSettings)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateAccountResponse",
}) as any as S.Schema<CreateAccountResponse>;

export interface CreateAccountOrganizationRequest {
  accountId: string;
  destinationOrganizationId: string;
}
export const CreateAccountOrganizationRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    destinationOrganizationId: S.String.pipe(
      T.Body("destination_organization_id"),
    ),
  })
    .pipe(
      T.Http({ method: "POST", uri: "/accounts/{account_id}/move", code: 200 }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateAccountOrganizationRequest",
}) as any as S.Schema<CreateAccountOrganizationRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateAccountOrganizationResponse {
  accountId: string;
  destinationOrganizationId: string;
  sourceOrganizationId: string;
}
export const CreateAccountOrganizationResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Body("account_id")),
    destinationOrganizationId: S.String.pipe(
      T.Body("destination_organization_id"),
    ),
    sourceOrganizationId: S.String.pipe(T.Body("source_organization_id")),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateAccountOrganizationResponse",
}) as any as S.Schema<CreateAccountOrganizationResponse>;

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

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

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

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

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

export type MembersCreateRequestPoliciesItemResourceGroupsItem =
  MembersCreateRequestPoliciesItemPermissionGroupsItem;
export const MembersCreateRequestPoliciesItemResourceGroupsItem =
  MembersCreateRequestPoliciesItemPermissionGroupsItem;

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

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

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

export interface CreateMemberRequest {
  /** Account identifier tag. */
  accountId: string;
  /** The contact email address of the user. */
  email: string;
  /** Array of roles associated with this member. */
  roles?: MembersCreateRequestRolesList;
  /** Status of the member invitation. If not provided during creation, defaults to 'pending'. */
  status?: MembersCreateRequestStatus | (string & {});
  /** Array of policies associated with this member. */
  policies?: MembersCreateRequestPoliciesList;
}
export const CreateMemberRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    email: S.String,
    roles: S.optional(MembersCreateRequestRolesList),
    status: S.optional(MembersCreateRequestStatus),
    policies: S.optional(MembersCreateRequestPoliciesList),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/members",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateMemberRequest",
}) as any as S.Schema<CreateMemberRequest>;

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

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

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

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

export interface MembersCreateResponsePoliciesItemResourceGroupsItemScopeItemObjectsItem {
  /** This is a combination of pre-defined resource name and identifier (like Zone ID etc.) */
  key: string;
}
export const MembersCreateResponsePoliciesItemResourceGroupsItemScopeItemObjectsItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: S.String,
    }),
  ).annotate({
    identifier:
      "MembersCreateResponsePoliciesItemResourceGroupsItemScopeItemObjectsItem",
  }) as any as S.Schema<MembersCreateResponsePoliciesItemResourceGroupsItemScopeItemObjectsItem>;

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

export interface MembersCreateResponsePoliciesItemResourceGroupsItemScopeItem {
  /** This is a combination of pre-defined resource name and identifier (like Account ID etc.) */
  key: string;
  /** A list of scope objects for additional context. */
  objects: MembersCreateResponsePoliciesItemResourceGroupsItemScopeItemObjectsList;
}
export const MembersCreateResponsePoliciesItemResourceGroupsItemScopeItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: S.String,
      objects:
        MembersCreateResponsePoliciesItemResourceGroupsItemScopeItemObjectsList,
    }),
  ).annotate({
    identifier: "MembersCreateResponsePoliciesItemResourceGroupsItemScopeItem",
  }) as any as S.Schema<MembersCreateResponsePoliciesItemResourceGroupsItemScopeItem>;

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

export type MembersCreateResponsePoliciesItemResourceGroupsItemMeta =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;
export const MembersCreateResponsePoliciesItemResourceGroupsItemMeta =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;

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

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

export interface MembersCreateResponsePoliciesItem {
  /** Policy identifier. */
  id?: string | null;
  /** Allow or deny operations against the resources. */
  access?: MembersCreateResponsePoliciesItemAccess | null;
  /** A set of permission groups that are specified to the policy. */
  permissionGroups?: MembersCreateResponsePoliciesItemPermissionGroupsList | null;
  /** A list of resource groups that the policy applies to. */
  resourceGroups?: MembersCreateResponsePoliciesItemResourceGroupsList | null;
}
export const MembersCreateResponsePoliciesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    access: S.optional(S.NullOr(MembersCreateResponsePoliciesItemAccess)),
    permissionGroups: S.optional(
      S.NullOr(MembersCreateResponsePoliciesItemPermissionGroupsList).pipe(
        T.Body("permission_groups"),
      ),
    ),
    resourceGroups: S.optional(
      S.NullOr(MembersCreateResponsePoliciesItemResourceGroupsList).pipe(
        T.Body("resource_groups"),
      ),
    ),
  }),
).annotate({
  identifier: "MembersCreateResponsePoliciesItem",
}) as any as S.Schema<MembersCreateResponsePoliciesItem>;

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

export interface MembersCreateResponseRolesItemPermissionsAnalytics {
  read?: boolean | null;
  write?: boolean | null;
}
export const MembersCreateResponseRolesItemPermissionsAnalytics =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      read: S.optional(S.NullOr(S.Boolean)),
      write: S.optional(S.NullOr(S.Boolean)),
    }),
  ).annotate({
    identifier: "MembersCreateResponseRolesItemPermissionsAnalytics",
  }) as any as S.Schema<MembersCreateResponseRolesItemPermissionsAnalytics>;

export interface MembersCreateResponseRolesItemPermissions {
  analytics?: MembersCreateResponseRolesItemPermissionsAnalytics | null;
  billing?: MembersCreateResponseRolesItemPermissionsAnalytics | null;
  cachePurge?: MembersCreateResponseRolesItemPermissionsAnalytics | null;
  dns?: MembersCreateResponseRolesItemPermissionsAnalytics | null;
  dnsRecords?: MembersCreateResponseRolesItemPermissionsAnalytics | null;
  lb?: MembersCreateResponseRolesItemPermissionsAnalytics | null;
  logs?: MembersCreateResponseRolesItemPermissionsAnalytics | null;
  organization?: MembersCreateResponseRolesItemPermissionsAnalytics | null;
  ssl?: MembersCreateResponseRolesItemPermissionsAnalytics | null;
  waf?: MembersCreateResponseRolesItemPermissionsAnalytics | null;
  zoneSettings?: MembersCreateResponseRolesItemPermissionsAnalytics | null;
  zones?: MembersCreateResponseRolesItemPermissionsAnalytics | null;
}
export const MembersCreateResponseRolesItemPermissions =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      analytics: S.optional(
        S.NullOr(MembersCreateResponseRolesItemPermissionsAnalytics),
      ),
      billing: S.optional(
        S.NullOr(MembersCreateResponseRolesItemPermissionsAnalytics),
      ),
      cachePurge: S.optional(
        S.NullOr(MembersCreateResponseRolesItemPermissionsAnalytics).pipe(
          T.Body("cache_purge"),
        ),
      ),
      dns: S.optional(
        S.NullOr(MembersCreateResponseRolesItemPermissionsAnalytics),
      ),
      dnsRecords: S.optional(
        S.NullOr(MembersCreateResponseRolesItemPermissionsAnalytics).pipe(
          T.Body("dns_records"),
        ),
      ),
      lb: S.optional(
        S.NullOr(MembersCreateResponseRolesItemPermissionsAnalytics),
      ),
      logs: S.optional(
        S.NullOr(MembersCreateResponseRolesItemPermissionsAnalytics),
      ),
      organization: S.optional(
        S.NullOr(MembersCreateResponseRolesItemPermissionsAnalytics),
      ),
      ssl: S.optional(
        S.NullOr(MembersCreateResponseRolesItemPermissionsAnalytics),
      ),
      waf: S.optional(
        S.NullOr(MembersCreateResponseRolesItemPermissionsAnalytics),
      ),
      zoneSettings: S.optional(
        S.NullOr(MembersCreateResponseRolesItemPermissionsAnalytics).pipe(
          T.Body("zone_settings"),
        ),
      ),
      zones: S.optional(
        S.NullOr(MembersCreateResponseRolesItemPermissionsAnalytics),
      ),
    }),
  ).annotate({
    identifier: "MembersCreateResponseRolesItemPermissions",
  }) as any as S.Schema<MembersCreateResponseRolesItemPermissions>;

export interface MembersCreateResponseRolesItem {
  /** Role identifier tag. */
  id: string;
  /** Description of role's permissions. */
  description: string;
  /** Role name. */
  name: string;
  permissions: MembersCreateResponseRolesItemPermissions;
}
export const MembersCreateResponseRolesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    description: S.String,
    name: S.String,
    permissions: MembersCreateResponseRolesItemPermissions,
  }),
).annotate({
  identifier: "MembersCreateResponseRolesItem",
}) as any as S.Schema<MembersCreateResponseRolesItem>;

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

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

export interface MembersCreateResponseUser {
  /** The contact email address of the user. */
  email: string;
  /** Identifier */
  id?: string | null;
  /** User's first name */
  firstName?: string | null;
  /** User's last name */
  lastName?: string | null;
  /** Indicates whether two-factor authentication is enabled for the user account. Does not apply to API authentication. */
  twoFactorAuthenticationEnabled?: boolean | null;
}
export const MembersCreateResponseUser = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    email: S.String,
    id: S.optional(S.NullOr(S.String)),
    firstName: S.optional(S.NullOr(S.String).pipe(T.Body("first_name"))),
    lastName: S.optional(S.NullOr(S.String).pipe(T.Body("last_name"))),
    twoFactorAuthenticationEnabled: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("two_factor_authentication_enabled")),
    ),
  }),
).annotate({
  identifier: "MembersCreateResponseUser",
}) as any as S.Schema<MembersCreateResponseUser>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateMemberResponse {
  /** Membership identifier tag. */
  id?: string | null;
  /** The contact email address of the user. */
  email?: string | null;
  /** Access policy for the membership */
  policies?: MembersCreateResponsePoliciesList | null;
  /** Roles assigned to this Member. */
  roles?: MembersCreateResponseRolesList | null;
  /** A member's status in the account. */
  status?: MembersCreateResponseStatus | null;
  /** Details of the user associated to the membership. */
  user?: MembersCreateResponseUser | null;
}
export const CreateMemberResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    email: S.optional(S.NullOr(S.String)),
    policies: S.optional(S.NullOr(MembersCreateResponsePoliciesList)),
    roles: S.optional(S.NullOr(MembersCreateResponseRolesList)),
    status: S.optional(S.NullOr(MembersCreateResponseStatus)),
    user: S.optional(S.NullOr(MembersCreateResponseUser)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateMemberResponse",
}) as any as S.Schema<CreateMemberResponse>;

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

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

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

export interface SubscriptionsCreateRequestRatePlan {
  /** The ID of the rate plan. */
  id?: SubscriptionsCreateRequestRatePlanId | (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?: SubscriptionsCreateRequestRatePlanSetsList;
}
export const SubscriptionsCreateRequestRatePlan = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(SubscriptionsCreateRequestRatePlanId),
    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(SubscriptionsCreateRequestRatePlanSetsList),
  }),
).annotate({
  identifier: "SubscriptionsCreateRequestRatePlan",
}) as any as S.Schema<SubscriptionsCreateRequestRatePlan>;

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

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

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

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

export interface SubscriptionsCreateResponseRatePlan {
  /** The ID of the rate plan. */
  id?: SubscriptionsCreateResponseRatePlanId | 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?: SubscriptionsCreateResponseRatePlanSetsList | null;
}
export const SubscriptionsCreateResponseRatePlan = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(SubscriptionsCreateResponseRatePlanId)),
    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(SubscriptionsCreateResponseRatePlanSetsList)),
  }),
).annotate({
  identifier: "SubscriptionsCreateResponseRatePlan",
}) as any as S.Schema<SubscriptionsCreateResponseRatePlan>;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateSubscriptionResponse {
  /** Subscription identifier tag. */
  id?: string | null;
  /** The monetary unit in which pricing information is displayed. */
  currency?: string | null;
  /** The end of the current period and also when the next billing is due. */
  currentPeriodEnd?: string | null;
  /** When the current billing period started. May match initial_period_start if this is the first period. */
  currentPeriodStart?: string | null;
  /** How often the subscription is renewed automatically. */
  frequency?: SubscriptionsCreateResponseFrequency | null;
  /** The price of the subscription that will be billed, in US dollars. */
  price?: number | null;
  /** The rate plan applied to the subscription. */
  ratePlan?: SubscriptionsCreateResponseRatePlan | null;
  /** The state that the subscription is in. */
  state?: SubscriptionsCreateResponseState | null;
}
export const CreateSubscriptionResponse = /*@__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(SubscriptionsCreateResponseFrequency)),
    price: S.optional(S.NullOr(S.Number)),
    ratePlan: S.optional(
      S.NullOr(SubscriptionsCreateResponseRatePlan).pipe(T.Body("rate_plan")),
    ),
    state: S.optional(S.NullOr(SubscriptionsCreateResponseState)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateSubscriptionResponse",
}) as any as S.Schema<CreateSubscriptionResponse>;

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 {
  /** Account identifier tag. */
  accountId: string;
  /** 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({
    accountId: S.String.pipe(T.Label("account_id")),
    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: "/accounts/{account_id}/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 type TokensCreateResponsePoliciesItemPermissionGroupsItemMeta =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;
export const TokensCreateResponsePoliciesItemPermissionGroupsItemMeta =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;

export type TokensCreateResponsePoliciesItemPermissionGroupsItem =
  MembersCreateResponsePoliciesItemPermissionGroupsItem;
export const TokensCreateResponsePoliciesItemPermissionGroupsItem =
  MembersCreateResponsePoliciesItemPermissionGroupsItem;

export type TokensCreateResponsePoliciesItemPermissionGroupsList =
  Array<MembersCreateResponsePoliciesItemPermissionGroupsItem>;
export const TokensCreateResponsePoliciesItemPermissionGroupsList =
  /*@__PURE__*/ S.Array(
    MembersCreateResponsePoliciesItemPermissionGroupsItem,
  ) 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 DeleteAccountRequest {
  /** The account ID of the account to be deleted */
  accountId: string;
}
export const DeleteAccountRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(
      T.Http({ method: "DELETE", uri: "/accounts/{account_id}", code: 200 }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteAccountRequest",
}) as any as S.Schema<DeleteAccountRequest>;

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

export interface DeleteMemberRequest {
  /** Account identifier tag. */
  accountId: string;
  /** Membership identifier tag. */
  memberId: string;
}
export const DeleteMemberRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    memberId: S.String.pipe(T.Label("member_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/members/{member_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteMemberRequest",
}) as any as S.Schema<DeleteMemberRequest>;

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

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

/** Unwrapped `result` payload of the Cloudflare v4 response 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 {
  /** Account identifier tag. */
  accountId: string;
  /** Token identifier tag. */
  tokenId: string;
}
export const DeleteTokenRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    tokenId: S.String.pipe(T.Label("token_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/accounts/{account_id}/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 GetAccountRequest {
  /** Account identifier tag. */
  accountId: string;
}
export const GetAccountRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(T.Http({ method: "GET", uri: "/accounts/{account_id}", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetAccountRequest",
}) as any as S.Schema<GetAccountRequest>;

export type GetResponseType = "standard" | "enterprise";
export const GetResponseType = /*@__PURE__*/ S.String;

export type GetResponseManagedBy = CreateResponseManagedBy;
export const GetResponseManagedBy = CreateResponseManagedBy;

export type GetResponseSettings = CreateResponseSettings;
export const GetResponseSettings = CreateResponseSettings;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetAccountResponse {
  /** Identifier */
  id: string;
  /** Account name */
  name: string;
  type: GetResponseType;
  /** Timestamp for the creation of the account */
  createdOn?: string | null;
  /** Parent container details */
  managedBy?: CreateResponseManagedBy | null;
  /** Account settings */
  settings?: CreateResponseSettings | null;
}
export const GetAccountResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    name: S.String,
    type: GetResponseType,
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    managedBy: S.optional(
      S.NullOr(CreateResponseManagedBy).pipe(T.Body("managed_by")),
    ),
    settings: S.optional(S.NullOr(CreateResponseSettings)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetAccountResponse",
}) as any as S.Schema<GetAccountResponse>;

export interface GetAccountProfileRequest {
  accountId: string;
}
export const GetAccountProfileRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/profile",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetAccountProfileRequest",
}) as any as S.Schema<GetAccountProfileRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetAccountProfileResponse {
  businessAddress: string;
  businessEmail: string;
  businessName: string;
  businessPhone: string;
  externalMetadata: string;
}
export const GetAccountProfileResponse = /*@__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")),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetAccountProfileResponse",
}) as any as S.Schema<GetAccountProfileResponse>;

export interface GetMemberRequest {
  /** Account identifier tag. */
  accountId: string;
  /** Membership identifier tag. */
  memberId: string;
}
export const GetMemberRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    memberId: S.String.pipe(T.Label("member_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/members/{member_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetMemberRequest",
}) as any as S.Schema<GetMemberRequest>;

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

export type MembersGetResponsePoliciesItemPermissionGroupsItemMeta =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;
export const MembersGetResponsePoliciesItemPermissionGroupsItemMeta =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;

export type MembersGetResponsePoliciesItemPermissionGroupsItem =
  MembersCreateResponsePoliciesItemPermissionGroupsItem;
export const MembersGetResponsePoliciesItemPermissionGroupsItem =
  MembersCreateResponsePoliciesItemPermissionGroupsItem;

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

export type MembersGetResponsePoliciesItemResourceGroupsItemScopeItemObjectsItem =
  MembersCreateResponsePoliciesItemResourceGroupsItemScopeItemObjectsItem;
export const MembersGetResponsePoliciesItemResourceGroupsItemScopeItemObjectsItem =
  MembersCreateResponsePoliciesItemResourceGroupsItemScopeItemObjectsItem;

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

export interface MembersGetResponsePoliciesItemResourceGroupsItemScopeItem {
  /** This is a combination of pre-defined resource name and identifier (like Account ID etc.) */
  key: string;
  /** A list of scope objects for additional context. */
  objects: MembersGetResponsePoliciesItemResourceGroupsItemScopeItemObjectsList;
}
export const MembersGetResponsePoliciesItemResourceGroupsItemScopeItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: S.String,
      objects:
        MembersGetResponsePoliciesItemResourceGroupsItemScopeItemObjectsList,
    }),
  ).annotate({
    identifier: "MembersGetResponsePoliciesItemResourceGroupsItemScopeItem",
  }) as any as S.Schema<MembersGetResponsePoliciesItemResourceGroupsItemScopeItem>;

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

export type MembersGetResponsePoliciesItemResourceGroupsItemMeta =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;
export const MembersGetResponsePoliciesItemResourceGroupsItemMeta =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;

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

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

export interface MembersGetResponsePoliciesItem {
  /** Policy identifier. */
  id?: string | null;
  /** Allow or deny operations against the resources. */
  access?: MembersGetResponsePoliciesItemAccess | null;
  /** A set of permission groups that are specified to the policy. */
  permissionGroups?: MembersGetResponsePoliciesItemPermissionGroupsList | null;
  /** A list of resource groups that the policy applies to. */
  resourceGroups?: MembersGetResponsePoliciesItemResourceGroupsList | null;
}
export const MembersGetResponsePoliciesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    access: S.optional(S.NullOr(MembersGetResponsePoliciesItemAccess)),
    permissionGroups: S.optional(
      S.NullOr(MembersGetResponsePoliciesItemPermissionGroupsList).pipe(
        T.Body("permission_groups"),
      ),
    ),
    resourceGroups: S.optional(
      S.NullOr(MembersGetResponsePoliciesItemResourceGroupsList).pipe(
        T.Body("resource_groups"),
      ),
    ),
  }),
).annotate({
  identifier: "MembersGetResponsePoliciesItem",
}) as any as S.Schema<MembersGetResponsePoliciesItem>;

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

export type MembersGetResponseRolesItemPermissionsAnalytics =
  MembersCreateResponseRolesItemPermissionsAnalytics;
export const MembersGetResponseRolesItemPermissionsAnalytics =
  MembersCreateResponseRolesItemPermissionsAnalytics;

export type MembersGetResponseRolesItemPermissions =
  MembersCreateResponseRolesItemPermissions;
export const MembersGetResponseRolesItemPermissions =
  MembersCreateResponseRolesItemPermissions;

export type MembersGetResponseRolesItem = MembersCreateResponseRolesItem;
export const MembersGetResponseRolesItem = MembersCreateResponseRolesItem;

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

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

export type MembersGetResponseUser = MembersCreateResponseUser;
export const MembersGetResponseUser = MembersCreateResponseUser;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetMemberResponse {
  /** Membership identifier tag. */
  id?: string | null;
  /** The contact email address of the user. */
  email?: string | null;
  /** Access policy for the membership */
  policies?: MembersGetResponsePoliciesList | null;
  /** Roles assigned to this Member. */
  roles?: MembersGetResponseRolesList | null;
  /** A member's status in the account. */
  status?: MembersGetResponseStatus | null;
  /** Details of the user associated to the membership. */
  user?: MembersCreateResponseUser | null;
}
export const GetMemberResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    email: S.optional(S.NullOr(S.String)),
    policies: S.optional(S.NullOr(MembersGetResponsePoliciesList)),
    roles: S.optional(S.NullOr(MembersGetResponseRolesList)),
    status: S.optional(S.NullOr(MembersGetResponseStatus)),
    user: S.optional(S.NullOr(MembersCreateResponseUser)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetMemberResponse",
}) as any as S.Schema<GetMemberResponse>;

export interface GetRoleRequest {
  /** Account identifier tag. */
  accountId: string;
  /** Role identifier tag. */
  roleId: string;
}
export const GetRoleRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    roleId: S.String.pipe(T.Label("role_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/roles/{role_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({ identifier: "GetRoleRequest" }) as any as S.Schema<GetRoleRequest>;

export type RolesGetResponsePermissionsAnalytics =
  MembersCreateResponseRolesItemPermissionsAnalytics;
export const RolesGetResponsePermissionsAnalytics =
  MembersCreateResponseRolesItemPermissionsAnalytics;

export type RolesGetResponsePermissions =
  MembersCreateResponseRolesItemPermissions;
export const RolesGetResponsePermissions =
  MembersCreateResponseRolesItemPermissions;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetRoleResponse {
  /** Role identifier tag. */
  id: string;
  /** Description of role's permissions. */
  description: string;
  /** Role name. */
  name: string;
  permissions: MembersCreateResponseRolesItemPermissions;
}
export const GetRoleResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    description: S.String,
    name: S.String,
    permissions: MembersCreateResponseRolesItemPermissions,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetRoleResponse",
}) as any as S.Schema<GetRoleResponse>;

export interface GetSubscriptionRequest {
  /** Identifier */
  accountId: string;
}
export const GetSubscriptionRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/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 {
  /** Account identifier tag. */
  accountId: string;
  /** Token identifier tag. */
  tokenId: string;
}
export const GetTokenRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    tokenId: S.String.pipe(T.Label("token_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/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 =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;
export const TokensGetResponsePoliciesItemPermissionGroupsItemMeta =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;

export type TokensGetResponsePoliciesItemPermissionGroupsItem =
  MembersCreateResponsePoliciesItemPermissionGroupsItem;
export const TokensGetResponsePoliciesItemPermissionGroupsItem =
  MembersCreateResponsePoliciesItemPermissionGroupsItem;

export type TokensGetResponsePoliciesItemPermissionGroupsList =
  Array<MembersCreateResponsePoliciesItemPermissionGroupsItem>;
export const TokensGetResponsePoliciesItemPermissionGroupsList =
  /*@__PURE__*/ S.Array(
    MembersCreateResponsePoliciesItemPermissionGroupsItem,
  ) 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 GetTokenPermissionGroupRequest {
  /** Account identifier tag. */
  accountId: string;
  /** Filter by the name of the permission group. */
  name?: string;
  /** Filter by the scope of the permission group. */
  scope?: string;
}
export const GetTokenPermissionGroupRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    name: S.optional(S.String.pipe(T.Query())),
    scope: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/tokens/permission_groups",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetTokenPermissionGroupRequest",
}) as any as S.Schema<GetTokenPermissionGroupRequest>;

export type TokensPermissionGroupsGetResultItemCategory =
  | "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 TokensPermissionGroupsGetResultItemCategory =
  /*@__PURE__*/ S.String;

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

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

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

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

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

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

export interface ListAccountsRequest {
  /** Direction to order results. */
  direction?: ListRequestDirection | (string & {});
  /** Name of the account. */
  name?: string;
  /** Page number of paginated results. */
  page?: number;
  /** Maximum number of results per page. */
  perPage?: number;
}
export const ListAccountsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    direction: S.optional(ListRequestDirection.pipe(T.Query())),
    name: S.optional(S.String.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: "/accounts", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListAccountsRequest",
}) as any as S.Schema<ListAccountsRequest>;

export type ListResultItemType = "standard" | "enterprise";
export const ListResultItemType = /*@__PURE__*/ S.String;

export type ListResultItemManagedBy = CreateResponseManagedBy;
export const ListResultItemManagedBy = CreateResponseManagedBy;

export type ListResultItemSettings = CreateResponseSettings;
export const ListResultItemSettings = CreateResponseSettings;

export interface ListResultItem {
  /** Identifier */
  id: string;
  /** Account name */
  name: string;
  type: ListResultItemType;
  /** Timestamp for the creation of the account */
  createdOn?: string | null;
  /** Parent container details */
  managedBy?: CreateResponseManagedBy | null;
  /** Account settings */
  settings?: CreateResponseSettings | null;
}
export const ListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    name: S.String,
    type: ListResultItemType,
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    managedBy: S.optional(
      S.NullOr(CreateResponseManagedBy).pipe(T.Body("managed_by")),
    ),
    settings: S.optional(S.NullOr(CreateResponseSettings)),
  }),
).annotate({ identifier: "ListResultItem" }) as any as S.Schema<ListResultItem>;

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

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

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

export interface LogsAuditListRequestId {
  /** Filters out audit logs by their IDs. */
  not?: LogsAuditListRequestIdNotList;
}
export const LogsAuditListRequestId = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestIdNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestId",
}) as any as S.Schema<LogsAuditListRequestId>;

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

export interface LogsAuditListRequestAccountName {
  /** Filters out audit logs by the account name. */
  not?: LogsAuditListRequestAccountNameNotList;
}
export const LogsAuditListRequestAccountName = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestAccountNameNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestAccountName",
}) as any as S.Schema<LogsAuditListRequestAccountName>;

export type LogsAuditListRequestActionResultNotItem = "success" | "failure";
export const LogsAuditListRequestActionResultNotItem = /*@__PURE__*/ S.String;

export type LogsAuditListRequestActionResultNotList = Array<
  LogsAuditListRequestActionResultNotItem | (string & {})
>;
export const LogsAuditListRequestActionResultNotList = /*@__PURE__*/ S.Array(
  LogsAuditListRequestActionResultNotItem,
) as any as S.Schema<LogsAuditListRequestActionResultNotList>;

export interface LogsAuditListRequestActionResult {
  /** Filters out audit logs by whether the action was successful or not. */
  not?: LogsAuditListRequestActionResultNotList;
}
export const LogsAuditListRequestActionResult = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestActionResultNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestActionResult",
}) as any as S.Schema<LogsAuditListRequestActionResult>;

export type LogsAuditListRequestActionTypeNotItem =
  | "create"
  | "delete"
  | "view"
  | "update";
export const LogsAuditListRequestActionTypeNotItem = /*@__PURE__*/ S.String;

export type LogsAuditListRequestActionTypeNotList = Array<
  LogsAuditListRequestActionTypeNotItem | (string & {})
>;
export const LogsAuditListRequestActionTypeNotList = /*@__PURE__*/ S.Array(
  LogsAuditListRequestActionTypeNotItem,
) as any as S.Schema<LogsAuditListRequestActionTypeNotList>;

export interface LogsAuditListRequestActionType {
  /** Filters out audit logs by the action type. */
  not?: LogsAuditListRequestActionTypeNotList;
}
export const LogsAuditListRequestActionType = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestActionTypeNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestActionType",
}) as any as S.Schema<LogsAuditListRequestActionType>;

export type LogsAuditListRequestActorContextNotItem =
  | "api_key"
  | "api_token"
  | "dash"
  | "oauth"
  | "origin_ca_key";
export const LogsAuditListRequestActorContextNotItem = /*@__PURE__*/ S.String;

export type LogsAuditListRequestActorContextNotList = Array<
  LogsAuditListRequestActorContextNotItem | (string & {})
>;
export const LogsAuditListRequestActorContextNotList = /*@__PURE__*/ S.Array(
  LogsAuditListRequestActorContextNotItem,
) as any as S.Schema<LogsAuditListRequestActorContextNotList>;

export interface LogsAuditListRequestActorContext {
  /** Filters out audit logs by the actor context. */
  not?: LogsAuditListRequestActorContextNotList;
}
export const LogsAuditListRequestActorContext = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestActorContextNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestActorContext",
}) as any as S.Schema<LogsAuditListRequestActorContext>;

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

export interface LogsAuditListRequestActorEmail {
  /** Filters out audit logs by the actor's email address. */
  not?: LogsAuditListRequestActorEmailNotList;
}
export const LogsAuditListRequestActorEmail = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestActorEmailNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestActorEmail",
}) as any as S.Schema<LogsAuditListRequestActorEmail>;

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

export interface LogsAuditListRequestActorId {
  /** Filters out audit logs by the actor ID. This can be either the Account ID or User ID. */
  not?: LogsAuditListRequestActorIdNotList;
}
export const LogsAuditListRequestActorId = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestActorIdNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestActorId",
}) as any as S.Schema<LogsAuditListRequestActorId>;

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

export interface LogsAuditListRequestActorIpAddress {
  /** Filters out audit logs IP address where the action was initiated. */
  not?: LogsAuditListRequestActorIpAddressNotList;
}
export const LogsAuditListRequestActorIpAddress = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestActorIpAddressNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestActorIpAddress",
}) as any as S.Schema<LogsAuditListRequestActorIpAddress>;

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

export interface LogsAuditListRequestActorTokenId {
  /** Filters out audit logs by the API token ID when the actor context is an api_token or oauth. */
  not?: LogsAuditListRequestActorTokenIdNotList;
}
export const LogsAuditListRequestActorTokenId = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestActorTokenIdNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestActorTokenId",
}) as any as S.Schema<LogsAuditListRequestActorTokenId>;

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

export interface LogsAuditListRequestActorTokenName {
  /** Filters out audit logs by the API token name when the actor context is an api_token or oauth. */
  not?: LogsAuditListRequestActorTokenNameNotList;
}
export const LogsAuditListRequestActorTokenName = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestActorTokenNameNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestActorTokenName",
}) as any as S.Schema<LogsAuditListRequestActorTokenName>;

export type LogsAuditListRequestActorTypeNotItem =
  | "account"
  | "cloudflare_admin"
  | "system"
  | "user";
export const LogsAuditListRequestActorTypeNotItem = /*@__PURE__*/ S.String;

export type LogsAuditListRequestActorTypeNotList = Array<
  LogsAuditListRequestActorTypeNotItem | (string & {})
>;
export const LogsAuditListRequestActorTypeNotList = /*@__PURE__*/ S.Array(
  LogsAuditListRequestActorTypeNotItem,
) as any as S.Schema<LogsAuditListRequestActorTypeNotList>;

export interface LogsAuditListRequestActorType {
  /** Filters out audit logs by the actor type. */
  not?: LogsAuditListRequestActorTypeNotList;
}
export const LogsAuditListRequestActorType = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestActorTypeNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestActorType",
}) as any as S.Schema<LogsAuditListRequestActorType>;

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

export interface LogsAuditListRequestAuditLogId {
  /** Filters out audit logs by their IDs. */
  not?: LogsAuditListRequestAuditLogIdNotList;
}
export const LogsAuditListRequestAuditLogId = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestAuditLogIdNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestAuditLogId",
}) as any as S.Schema<LogsAuditListRequestAuditLogId>;

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

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

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

export interface LogsAuditListRequestRawCfRayId {
  /** Filters out audit logs by the response CF Ray ID. */
  not?: LogsAuditListRequestRawCfRayIdNotList;
}
export const LogsAuditListRequestRawCfRayId = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestRawCfRayIdNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestRawCfRayId",
}) as any as S.Schema<LogsAuditListRequestRawCfRayId>;

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

export interface LogsAuditListRequestRawMethod {
  /** Filters out audit logs by the HTTP method for the API call. */
  not?: LogsAuditListRequestRawMethodNotList;
}
export const LogsAuditListRequestRawMethod = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestRawMethodNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestRawMethod",
}) as any as S.Schema<LogsAuditListRequestRawMethod>;

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

export interface LogsAuditListRequestRawStatusCode {
  /** Filters out audit logs by the response status code that was returned. */
  not?: LogsAuditListRequestRawStatusCodeNotList;
}
export const LogsAuditListRequestRawStatusCode = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestRawStatusCodeNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestRawStatusCode",
}) as any as S.Schema<LogsAuditListRequestRawStatusCode>;

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

export interface LogsAuditListRequestRawUri {
  /** Filters out audit logs by the request URI. */
  not?: LogsAuditListRequestRawUriNotList;
}
export const LogsAuditListRequestRawUri = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestRawUriNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestRawUri",
}) as any as S.Schema<LogsAuditListRequestRawUri>;

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

export interface LogsAuditListRequestResourceId {
  /** Filters out audit logs by the resource ID. */
  not?: LogsAuditListRequestResourceIdNotList;
}
export const LogsAuditListRequestResourceId = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestResourceIdNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestResourceId",
}) as any as S.Schema<LogsAuditListRequestResourceId>;

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

export interface LogsAuditListRequestResourceProduct {
  /** Filters out audit logs by the Cloudflare product associated with the changed resource. */
  not?: LogsAuditListRequestResourceProductNotList;
}
export const LogsAuditListRequestResourceProduct = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestResourceProductNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestResourceProduct",
}) as any as S.Schema<LogsAuditListRequestResourceProduct>;

export type LogsAuditListRequestResourceScopeNotItem =
  | "accounts"
  | "user"
  | "zones"
  | "memberships";
export const LogsAuditListRequestResourceScopeNotItem = /*@__PURE__*/ S.String;

export type LogsAuditListRequestResourceScopeNotList = Array<
  LogsAuditListRequestResourceScopeNotItem | (string & {})
>;
export const LogsAuditListRequestResourceScopeNotList = /*@__PURE__*/ S.Array(
  LogsAuditListRequestResourceScopeNotItem,
) as any as S.Schema<LogsAuditListRequestResourceScopeNotList>;

export interface LogsAuditListRequestResourceScope {
  /** Filters out audit logs by the resource scope, specifying whether the resource is associated with an user, an account, a zone, or a membership. */
  not?: LogsAuditListRequestResourceScopeNotList;
}
export const LogsAuditListRequestResourceScope = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestResourceScopeNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestResourceScope",
}) as any as S.Schema<LogsAuditListRequestResourceScope>;

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

export interface LogsAuditListRequestResourceType {
  /** Filters out audit logs based on the unique type of resource changed by the action. */
  not?: LogsAuditListRequestResourceTypeNotList;
}
export const LogsAuditListRequestResourceType = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestResourceTypeNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestResourceType",
}) as any as S.Schema<LogsAuditListRequestResourceType>;

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

export interface LogsAuditListRequestZoneId {
  /** Filters out audit logs by the zone ID. */
  not?: LogsAuditListRequestZoneIdNotList;
}
export const LogsAuditListRequestZoneId = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestZoneIdNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestZoneId",
}) as any as S.Schema<LogsAuditListRequestZoneId>;

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

export interface LogsAuditListRequestZoneName {
  /** Filters out audit logs by the zone name associated with the change. */
  not?: LogsAuditListRequestZoneNameNotList;
}
export const LogsAuditListRequestZoneName = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    not: S.optional(LogsAuditListRequestZoneNameNotList),
  }),
).annotate({
  identifier: "LogsAuditListRequestZoneName",
}) as any as S.Schema<LogsAuditListRequestZoneName>;

export interface ListLogAuditsRequest {
  /** The unique id that identifies the account. */
  accountId: string;
  /** Limits the returned results to logs older than the specified date. This can be a date string 2019-04-30 (interpreted in UTC) or an absolute timestamp that conforms to RFC3339. */
  before: string;
  /** Limits the returned results to logs newer than the specified date. This can be a date string 2019-04-30 (interpreted in UTC) or an absolute timestamp that conforms to RFC3339. */
  since: string;
  id?: LogsAuditListRequestId;
  accountName?: LogsAuditListRequestAccountName;
  actionResult?: LogsAuditListRequestActionResult;
  actionType?: LogsAuditListRequestActionType;
  actorContext?: LogsAuditListRequestActorContext;
  actorEmail?: LogsAuditListRequestActorEmail;
  actorId?: LogsAuditListRequestActorId;
  actorIpAddress?: LogsAuditListRequestActorIpAddress;
  actorTokenId?: LogsAuditListRequestActorTokenId;
  actorTokenName?: LogsAuditListRequestActorTokenName;
  actorType?: LogsAuditListRequestActorType;
  auditLogId?: LogsAuditListRequestAuditLogId;
  /** The cursor is an opaque token used to paginate through large sets of records. It indicates the position from which to continue when requesting the next set of records. A valid cursor value can be obtained from the cursor object in the result_info structure of a previous response. */
  cursor?: string;
  /** Sets sorting order. */
  direction?: LogsAuditListRequestDirection | (string & {});
  /** The number limits the objects to return. The cursor attribute may be used to iterate over the next batch of objects if there are more than the limit. */
  limit?: number;
  /** Filters audit logs by one or more predefined product categories. Each product category expands into a curated set of resource_product values and is unioned with any explicit resource_product filter. Matched case-insensitively; unknown product categories return 400. Repeatable. Use the audit log product categories endpoint to discover the available values. */
  productCategory?: LogsAuditListRequestProductCategoryList;
  rawCfRayId?: LogsAuditListRequestRawCfRayId;
  rawMethod?: LogsAuditListRequestRawMethod;
  rawStatusCode?: LogsAuditListRequestRawStatusCode;
  rawUri?: LogsAuditListRequestRawUri;
  resourceId?: LogsAuditListRequestResourceId;
  resourceProduct?: LogsAuditListRequestResourceProduct;
  resourceScope?: LogsAuditListRequestResourceScope;
  resourceType?: LogsAuditListRequestResourceType;
  zoneId?: LogsAuditListRequestZoneId;
  zoneName?: LogsAuditListRequestZoneName;
}
export const ListLogAuditsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    before: S.String.pipe(T.Query()),
    since: S.String.pipe(T.Query()),
    id: S.optional(LogsAuditListRequestId.pipe(T.DeepQuery("id"))),
    accountName: S.optional(
      LogsAuditListRequestAccountName.pipe(
        T.Body("account_name"),
        T.DeepQuery("account_name"),
      ),
    ),
    actionResult: S.optional(
      LogsAuditListRequestActionResult.pipe(
        T.Body("action_result"),
        T.DeepQuery("action_result"),
      ),
    ),
    actionType: S.optional(
      LogsAuditListRequestActionType.pipe(
        T.Body("action_type"),
        T.DeepQuery("action_type"),
      ),
    ),
    actorContext: S.optional(
      LogsAuditListRequestActorContext.pipe(
        T.Body("actor_context"),
        T.DeepQuery("actor_context"),
      ),
    ),
    actorEmail: S.optional(
      LogsAuditListRequestActorEmail.pipe(
        T.Body("actor_email"),
        T.DeepQuery("actor_email"),
      ),
    ),
    actorId: S.optional(
      LogsAuditListRequestActorId.pipe(
        T.Body("actor_id"),
        T.DeepQuery("actor_id"),
      ),
    ),
    actorIpAddress: S.optional(
      LogsAuditListRequestActorIpAddress.pipe(
        T.Body("actor_ip_address"),
        T.DeepQuery("actor_ip_address"),
      ),
    ),
    actorTokenId: S.optional(
      LogsAuditListRequestActorTokenId.pipe(
        T.Body("actor_token_id"),
        T.DeepQuery("actor_token_id"),
      ),
    ),
    actorTokenName: S.optional(
      LogsAuditListRequestActorTokenName.pipe(
        T.Body("actor_token_name"),
        T.DeepQuery("actor_token_name"),
      ),
    ),
    actorType: S.optional(
      LogsAuditListRequestActorType.pipe(
        T.Body("actor_type"),
        T.DeepQuery("actor_type"),
      ),
    ),
    auditLogId: S.optional(
      LogsAuditListRequestAuditLogId.pipe(
        T.Body("audit_log_id"),
        T.DeepQuery("audit_log_id"),
      ),
    ),
    cursor: S.optional(S.String.pipe(T.Query())),
    direction: S.optional(LogsAuditListRequestDirection.pipe(T.Query())),
    limit: S.optional(S.Number.pipe(T.Query())),
    productCategory: S.optional(
      LogsAuditListRequestProductCategoryList.pipe(T.Query("product_category")),
    ),
    rawCfRayId: S.optional(
      LogsAuditListRequestRawCfRayId.pipe(
        T.Body("raw_cf_ray_id"),
        T.DeepQuery("raw_cf_ray_id"),
      ),
    ),
    rawMethod: S.optional(
      LogsAuditListRequestRawMethod.pipe(
        T.Body("raw_method"),
        T.DeepQuery("raw_method"),
      ),
    ),
    rawStatusCode: S.optional(
      LogsAuditListRequestRawStatusCode.pipe(
        T.Body("raw_status_code"),
        T.DeepQuery("raw_status_code"),
      ),
    ),
    rawUri: S.optional(
      LogsAuditListRequestRawUri.pipe(
        T.Body("raw_uri"),
        T.DeepQuery("raw_uri"),
      ),
    ),
    resourceId: S.optional(
      LogsAuditListRequestResourceId.pipe(
        T.Body("resource_id"),
        T.DeepQuery("resource_id"),
      ),
    ),
    resourceProduct: S.optional(
      LogsAuditListRequestResourceProduct.pipe(
        T.Body("resource_product"),
        T.DeepQuery("resource_product"),
      ),
    ),
    resourceScope: S.optional(
      LogsAuditListRequestResourceScope.pipe(
        T.Body("resource_scope"),
        T.DeepQuery("resource_scope"),
      ),
    ),
    resourceType: S.optional(
      LogsAuditListRequestResourceType.pipe(
        T.Body("resource_type"),
        T.DeepQuery("resource_type"),
      ),
    ),
    zoneId: S.optional(
      LogsAuditListRequestZoneId.pipe(
        T.Body("zone_id"),
        T.DeepQuery("zone_id"),
      ),
    ),
    zoneName: S.optional(
      LogsAuditListRequestZoneName.pipe(
        T.Body("zone_name"),
        T.DeepQuery("zone_name"),
      ),
    ),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/logs/audit",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListLogAuditsRequest",
}) as any as S.Schema<ListLogAuditsRequest>;

export interface LogsAuditListResultItemAccount {
  /** A unique identifier for the account. */
  id?: string | null;
  /** A string that identifies the account name. */
  name?: string | null;
}
export const LogsAuditListResultItemAccount = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    name: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "LogsAuditListResultItemAccount",
}) as any as S.Schema<LogsAuditListResultItemAccount>;

export interface LogsAuditListResultItemAction {
  /** A short description of the action performed. */
  description?: string | null;
  /** The result of the action, indicating success or failure. */
  result?: string | null;
  /** A timestamp indicating when the action was logged. */
  time?: string | null;
  /** A short string that describes the action that was performed. */
  type?: string | null;
}
export const LogsAuditListResultItemAction = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    description: S.optional(S.NullOr(S.String)),
    result: S.optional(S.NullOr(S.String)),
    time: S.optional(S.NullOr(S.String)),
    type: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "LogsAuditListResultItemAction",
}) as any as S.Schema<LogsAuditListResultItemAction>;

export type LogsAuditListResultItemActorContext =
  | "api_key"
  | "api_token"
  | "dash"
  | "oauth"
  | "origin_ca_key";
export const LogsAuditListResultItemActorContext = /*@__PURE__*/ S.String;

export type LogsAuditListResultItemActorType =
  | "account"
  | "cloudflare_admin"
  | "system"
  | "user";
export const LogsAuditListResultItemActorType = /*@__PURE__*/ S.String;

export interface LogsAuditListResultItemActor {
  /** The ID of the actor who performed the action. If a user performed the action, this will be their User ID. */
  id?: string | null;
  context?: LogsAuditListResultItemActorContext | null;
  /** The email of the actor who performed the action. */
  email?: string | null;
  /** The IP address of the request that performed the action. */
  ipAddress?: string | null;
  /** The API token ID when the actor context is an api_token or oauth. */
  tokenId?: string | null;
  /** The API token name when the actor context is an api_token or oauth. */
  tokenName?: string | null;
  /** The type of actor. */
  type?: LogsAuditListResultItemActorType | null;
}
export const LogsAuditListResultItemActor = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    context: S.optional(S.NullOr(LogsAuditListResultItemActorContext)),
    email: S.optional(S.NullOr(S.String)),
    ipAddress: S.optional(S.NullOr(S.String).pipe(T.Body("ip_address"))),
    tokenId: S.optional(S.NullOr(S.String).pipe(T.Body("token_id"))),
    tokenName: S.optional(S.NullOr(S.String).pipe(T.Body("token_name"))),
    type: S.optional(S.NullOr(LogsAuditListResultItemActorType)),
  }),
).annotate({
  identifier: "LogsAuditListResultItemActor",
}) as any as S.Schema<LogsAuditListResultItemActor>;

export interface LogsAuditListResultItemRaw {
  /** The Cloudflare Ray ID for the request. */
  cfRayId?: string | null;
  /** The HTTP method of the request. */
  method?: string | null;
  /** The HTTP response status code returned by the API. */
  statusCode?: number | null;
  /** The URI of the request. */
  uri?: string | null;
  /** The client's user agent string sent with the request. */
  userAgent?: string | null;
}
export const LogsAuditListResultItemRaw = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    cfRayId: S.optional(S.NullOr(S.String).pipe(T.Body("cf_ray_id"))),
    method: S.optional(S.NullOr(S.String)),
    statusCode: S.optional(S.NullOr(S.Number).pipe(T.Body("status_code"))),
    uri: S.optional(S.NullOr(S.String)),
    userAgent: S.optional(S.NullOr(S.String).pipe(T.Body("user_agent"))),
  }),
).annotate({
  identifier: "LogsAuditListResultItemRaw",
}) as any as S.Schema<LogsAuditListResultItemRaw>;

export interface LogsAuditListResultItemResource {
  /** The unique identifier for the affected resource. */
  id?: string | null;
  /** The Cloudflare product associated with the resource. */
  product?: string | null;
  request?: unknown | null;
  response?: unknown | null;
  /** The scope of the resource. */
  scope?: unknown | null;
  /** The type of the resource. */
  type?: string | null;
}
export const LogsAuditListResultItemResource = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    product: S.optional(S.NullOr(S.String)),
    request: S.optional(S.NullOr(S.Unknown)),
    response: S.optional(S.NullOr(S.Unknown)),
    scope: S.optional(S.NullOr(S.Unknown)),
    type: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "LogsAuditListResultItemResource",
}) as any as S.Schema<LogsAuditListResultItemResource>;

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

export interface LogsAuditListResultItem {
  /** A unique identifier for the audit log entry. */
  id?: string | null;
  /** Contains account related information. */
  account?: LogsAuditListResultItemAccount | null;
  /** Provides information about the action performed. */
  action?: LogsAuditListResultItemAction | null;
  /** Provides details about the actor who performed the action. */
  actor?: LogsAuditListResultItemActor | null;
  /** Provides raw information about the request and response. */
  raw?: LogsAuditListResultItemRaw | null;
  /** Provides details about the affected resource. */
  resource?: LogsAuditListResultItemResource | null;
  /** Provides details about the zone affected by the action. */
  zone?: LogsAuditListResultItemZone | null;
}
export const LogsAuditListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    account: S.optional(S.NullOr(LogsAuditListResultItemAccount)),
    action: S.optional(S.NullOr(LogsAuditListResultItemAction)),
    actor: S.optional(S.NullOr(LogsAuditListResultItemActor)),
    raw: S.optional(S.NullOr(LogsAuditListResultItemRaw)),
    resource: S.optional(S.NullOr(LogsAuditListResultItemResource)),
    zone: S.optional(S.NullOr(LogsAuditListResultItemZone)),
  }),
).annotate({
  identifier: "LogsAuditListResultItem",
}) as any as S.Schema<LogsAuditListResultItem>;

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

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

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

export type MembersListRequestOrder =
  | "user.first_name"
  | "user.last_name"
  | "user.email"
  | "status";
export const MembersListRequestOrder = /*@__PURE__*/ S.String;

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

export interface ListMembersRequest {
  /** Account identifier tag. */
  accountId: string;
  /** Direction to order results. */
  direction?: MembersListRequestDirection | (string & {});
  /** Field to order results by. */
  order?: MembersListRequestOrder | (string & {});
  /** Page number of paginated results. */
  page?: number;
  /** Maximum number of results per page. */
  perPage?: number;
  /** A member's status in the account. */
  status?: MembersListRequestStatus | (string & {});
}
export const ListMembersRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    direction: S.optional(MembersListRequestDirection.pipe(T.Query())),
    order: S.optional(MembersListRequestOrder.pipe(T.Query())),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    status: S.optional(MembersListRequestStatus.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/members",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListMembersRequest",
}) as any as S.Schema<ListMembersRequest>;

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

export type MembersListResultItemPoliciesItemPermissionGroupsItemMeta =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;
export const MembersListResultItemPoliciesItemPermissionGroupsItemMeta =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;

export type MembersListResultItemPoliciesItemPermissionGroupsItem =
  MembersCreateResponsePoliciesItemPermissionGroupsItem;
export const MembersListResultItemPoliciesItemPermissionGroupsItem =
  MembersCreateResponsePoliciesItemPermissionGroupsItem;

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

export type MembersListResultItemPoliciesItemResourceGroupsItemScopeItemObjectsItem =
  MembersCreateResponsePoliciesItemResourceGroupsItemScopeItemObjectsItem;
export const MembersListResultItemPoliciesItemResourceGroupsItemScopeItemObjectsItem =
  MembersCreateResponsePoliciesItemResourceGroupsItemScopeItemObjectsItem;

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

export interface MembersListResultItemPoliciesItemResourceGroupsItemScopeItem {
  /** This is a combination of pre-defined resource name and identifier (like Account ID etc.) */
  key: string;
  /** A list of scope objects for additional context. */
  objects: MembersListResultItemPoliciesItemResourceGroupsItemScopeItemObjectsList;
}
export const MembersListResultItemPoliciesItemResourceGroupsItemScopeItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: S.String,
      objects:
        MembersListResultItemPoliciesItemResourceGroupsItemScopeItemObjectsList,
    }),
  ).annotate({
    identifier: "MembersListResultItemPoliciesItemResourceGroupsItemScopeItem",
  }) as any as S.Schema<MembersListResultItemPoliciesItemResourceGroupsItemScopeItem>;

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

export type MembersListResultItemPoliciesItemResourceGroupsItemMeta =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;
export const MembersListResultItemPoliciesItemResourceGroupsItemMeta =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;

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

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

export interface MembersListResultItemPoliciesItem {
  /** Policy identifier. */
  id?: string | null;
  /** Allow or deny operations against the resources. */
  access?: MembersListResultItemPoliciesItemAccess | null;
  /** A set of permission groups that are specified to the policy. */
  permissionGroups?: MembersListResultItemPoliciesItemPermissionGroupsList | null;
  /** A list of resource groups that the policy applies to. */
  resourceGroups?: MembersListResultItemPoliciesItemResourceGroupsList | null;
}
export const MembersListResultItemPoliciesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    access: S.optional(S.NullOr(MembersListResultItemPoliciesItemAccess)),
    permissionGroups: S.optional(
      S.NullOr(MembersListResultItemPoliciesItemPermissionGroupsList).pipe(
        T.Body("permission_groups"),
      ),
    ),
    resourceGroups: S.optional(
      S.NullOr(MembersListResultItemPoliciesItemResourceGroupsList).pipe(
        T.Body("resource_groups"),
      ),
    ),
  }),
).annotate({
  identifier: "MembersListResultItemPoliciesItem",
}) as any as S.Schema<MembersListResultItemPoliciesItem>;

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

export type MembersListResultItemRolesItemPermissionsAnalytics =
  MembersCreateResponseRolesItemPermissionsAnalytics;
export const MembersListResultItemRolesItemPermissionsAnalytics =
  MembersCreateResponseRolesItemPermissionsAnalytics;

export type MembersListResultItemRolesItemPermissions =
  MembersCreateResponseRolesItemPermissions;
export const MembersListResultItemRolesItemPermissions =
  MembersCreateResponseRolesItemPermissions;

export type MembersListResultItemRolesItem = MembersCreateResponseRolesItem;
export const MembersListResultItemRolesItem = MembersCreateResponseRolesItem;

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

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

export type MembersListResultItemUser = MembersCreateResponseUser;
export const MembersListResultItemUser = MembersCreateResponseUser;

export interface MembersListResultItem {
  /** Membership identifier tag. */
  id?: string | null;
  /** The contact email address of the user. */
  email?: string | null;
  /** Access policy for the membership */
  policies?: MembersListResultItemPoliciesList | null;
  /** Roles assigned to this Member. */
  roles?: MembersListResultItemRolesList | null;
  /** A member's status in the account. */
  status?: MembersListResultItemStatus | null;
  /** Details of the user associated to the membership. */
  user?: MembersCreateResponseUser | null;
}
export const MembersListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    email: S.optional(S.NullOr(S.String)),
    policies: S.optional(S.NullOr(MembersListResultItemPoliciesList)),
    roles: S.optional(S.NullOr(MembersListResultItemRolesList)),
    status: S.optional(S.NullOr(MembersListResultItemStatus)),
    user: S.optional(S.NullOr(MembersCreateResponseUser)),
  }),
).annotate({
  identifier: "MembersListResultItem",
}) as any as S.Schema<MembersListResultItem>;

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

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

export interface ListRolesRequest {
  /** Account identifier tag. */
  accountId: string;
  /** Page number of paginated results. */
  page?: number;
  /** Number of roles per page. */
  perPage?: number;
}
export const ListRolesRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
  })
    .pipe(
      T.Http({ method: "GET", uri: "/accounts/{account_id}/roles", code: 200 }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListRolesRequest",
}) as any as S.Schema<ListRolesRequest>;

export type RolesListResultItemPermissionsAnalytics =
  MembersCreateResponseRolesItemPermissionsAnalytics;
export const RolesListResultItemPermissionsAnalytics =
  MembersCreateResponseRolesItemPermissionsAnalytics;

export type RolesListResultItemPermissions =
  MembersCreateResponseRolesItemPermissions;
export const RolesListResultItemPermissions =
  MembersCreateResponseRolesItemPermissions;

export type RolesListResultItem = MembersCreateResponseRolesItem;
export const RolesListResultItem = MembersCreateResponseRolesItem;

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

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

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

export interface ListTokensRequest {
  /** Account identifier tag. */
  accountId: string;
  /** 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({
    accountId: S.String.pipe(T.Label("account_id")),
    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: "/accounts/{account_id}/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 =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;
export const TokensListResultItemPoliciesItemPermissionGroupsItemMeta =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;

export type TokensListResultItemPoliciesItemPermissionGroupsItem =
  MembersCreateResponsePoliciesItemPermissionGroupsItem;
export const TokensListResultItemPoliciesItemPermissionGroupsItem =
  MembersCreateResponsePoliciesItemPermissionGroupsItem;

export type TokensListResultItemPoliciesItemPermissionGroupsList =
  Array<MembersCreateResponsePoliciesItemPermissionGroupsItem>;
export const TokensListResultItemPoliciesItemPermissionGroupsList =
  /*@__PURE__*/ S.Array(
    MembersCreateResponsePoliciesItemPermissionGroupsItem,
  ) 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 interface ListTokensPermissionGroupsRequest {
  /** Account identifier tag. */
  accountId: string;
  /** Filter by the name of the permission group. */
  name?: string;
  /** Filter by the scope of the permission group. */
  scope?: string;
}
export const ListTokensPermissionGroupsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    name: S.optional(S.String.pipe(T.Query())),
    scope: S.optional(S.String.pipe(T.Query())),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/tokens/permission_groups",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListTokensPermissionGroupsRequest",
}) as any as S.Schema<ListTokensPermissionGroupsRequest>;

export type ListTokensPermissionGroupsResultItemCategory =
  | "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 ListTokensPermissionGroupsResultItemCategory =
  /*@__PURE__*/ S.String;

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

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

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

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

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

export interface PutTokenValueRequest {
  /** Account identifier tag. */
  accountId: string;
  /** Token identifier tag. */
  tokenId: string;
}
export const PutTokenValueRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    tokenId: S.String.pipe(T.Label("token_id")),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/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 UpdateRequestType = "standard" | "enterprise";
export const UpdateRequestType = /*@__PURE__*/ S.String;

export interface UpdateRequestManagedBy {
  /** ID of the parent Organization, if one exists */
  parentOrgId?: string;
  /** Name of the parent Organization, if one exists */
  parentOrgName?: string;
}
export const UpdateRequestManagedBy = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    parentOrgId: S.optional(S.String.pipe(T.Body("parent_org_id"))),
    parentOrgName: S.optional(S.String.pipe(T.Body("parent_org_name"))),
  }),
).annotate({
  identifier: "UpdateRequestManagedBy",
}) as any as S.Schema<UpdateRequestManagedBy>;

export interface UpdateRequestSettings {
  /** Sets an abuse contact email to notify for abuse reports. */
  abuseContactEmail?: string;
  /** Indicates whether membership in this account requires that */
  enforceTwofactor?: boolean;
}
export const UpdateRequestSettings = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    abuseContactEmail: S.optional(S.String.pipe(T.Body("abuse_contact_email"))),
    enforceTwofactor: S.optional(S.Boolean.pipe(T.Body("enforce_twofactor"))),
  }),
).annotate({
  identifier: "UpdateRequestSettings",
}) as any as S.Schema<UpdateRequestSettings>;

export interface UpdateAccountRequest {
  /** Account identifier tag. */
  accountId: string;
  /** Identifier */
  id: string;
  /** Account name */
  name: string;
  type?: UpdateRequestType | (string & {});
  /** Parent container details */
  managedBy?: UpdateRequestManagedBy;
  /** Account settings */
  settings?: UpdateRequestSettings;
}
export const UpdateAccountRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    id: S.String,
    name: S.String,
    type: S.optional(UpdateRequestType),
    managedBy: S.optional(UpdateRequestManagedBy.pipe(T.Body("managed_by"))),
    settings: S.optional(UpdateRequestSettings),
  })
    .pipe(T.Http({ method: "PUT", uri: "/accounts/{account_id}", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateAccountRequest",
}) as any as S.Schema<UpdateAccountRequest>;

export type UpdateResponseType = "standard" | "enterprise";
export const UpdateResponseType = /*@__PURE__*/ S.String;

export type UpdateResponseManagedBy = CreateResponseManagedBy;
export const UpdateResponseManagedBy = CreateResponseManagedBy;

export type UpdateResponseSettings = CreateResponseSettings;
export const UpdateResponseSettings = CreateResponseSettings;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface UpdateAccountResponse {
  /** Identifier */
  id: string;
  /** Account name */
  name: string;
  type: UpdateResponseType;
  /** Timestamp for the creation of the account */
  createdOn?: string | null;
  /** Parent container details */
  managedBy?: CreateResponseManagedBy | null;
  /** Account settings */
  settings?: CreateResponseSettings | null;
}
export const UpdateAccountResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    name: S.String,
    type: UpdateResponseType,
    createdOn: S.optional(S.NullOr(S.String).pipe(T.Body("created_on"))),
    managedBy: S.optional(
      S.NullOr(CreateResponseManagedBy).pipe(T.Body("managed_by")),
    ),
    settings: S.optional(S.NullOr(CreateResponseSettings)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateAccountResponse",
}) as any as S.Schema<UpdateAccountResponse>;

export interface UpdateAccountProfileRequest {
  accountId: string;
  businessAddress: string;
  businessEmail: string;
  businessName: string;
  businessPhone: string;
  externalMetadata: string;
}
export const UpdateAccountProfileRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    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")),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/profile",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateAccountProfileRequest",
}) as any as S.Schema<UpdateAccountProfileRequest>;

export interface UpdateAccountProfileResponse {}
export const UpdateAccountProfileResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({}).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateAccountProfileResponse",
}) as any as S.Schema<UpdateAccountProfileResponse>;

export interface MembersUpdateRequestRolesItemPermissionsAnalytics {
  read?: boolean;
  write?: boolean;
}
export const MembersUpdateRequestRolesItemPermissionsAnalytics =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      read: S.optional(S.Boolean),
      write: S.optional(S.Boolean),
    }),
  ).annotate({
    identifier: "MembersUpdateRequestRolesItemPermissionsAnalytics",
  }) as any as S.Schema<MembersUpdateRequestRolesItemPermissionsAnalytics>;

export interface MembersUpdateRequestRolesItemPermissions {
  analytics?: MembersUpdateRequestRolesItemPermissionsAnalytics;
  billing?: MembersUpdateRequestRolesItemPermissionsAnalytics;
  cachePurge?: MembersUpdateRequestRolesItemPermissionsAnalytics;
  dns?: MembersUpdateRequestRolesItemPermissionsAnalytics;
  dnsRecords?: MembersUpdateRequestRolesItemPermissionsAnalytics;
  lb?: MembersUpdateRequestRolesItemPermissionsAnalytics;
  logs?: MembersUpdateRequestRolesItemPermissionsAnalytics;
  organization?: MembersUpdateRequestRolesItemPermissionsAnalytics;
  ssl?: MembersUpdateRequestRolesItemPermissionsAnalytics;
  waf?: MembersUpdateRequestRolesItemPermissionsAnalytics;
  zoneSettings?: MembersUpdateRequestRolesItemPermissionsAnalytics;
  zones?: MembersUpdateRequestRolesItemPermissionsAnalytics;
}
export const MembersUpdateRequestRolesItemPermissions = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      analytics: S.optional(MembersUpdateRequestRolesItemPermissionsAnalytics),
      billing: S.optional(MembersUpdateRequestRolesItemPermissionsAnalytics),
      cachePurge: S.optional(
        MembersUpdateRequestRolesItemPermissionsAnalytics.pipe(
          T.Body("cache_purge"),
        ),
      ),
      dns: S.optional(MembersUpdateRequestRolesItemPermissionsAnalytics),
      dnsRecords: S.optional(
        MembersUpdateRequestRolesItemPermissionsAnalytics.pipe(
          T.Body("dns_records"),
        ),
      ),
      lb: S.optional(MembersUpdateRequestRolesItemPermissionsAnalytics),
      logs: S.optional(MembersUpdateRequestRolesItemPermissionsAnalytics),
      organization: S.optional(
        MembersUpdateRequestRolesItemPermissionsAnalytics,
      ),
      ssl: S.optional(MembersUpdateRequestRolesItemPermissionsAnalytics),
      waf: S.optional(MembersUpdateRequestRolesItemPermissionsAnalytics),
      zoneSettings: S.optional(
        MembersUpdateRequestRolesItemPermissionsAnalytics.pipe(
          T.Body("zone_settings"),
        ),
      ),
      zones: S.optional(MembersUpdateRequestRolesItemPermissionsAnalytics),
    }),
).annotate({
  identifier: "MembersUpdateRequestRolesItemPermissions",
}) as any as S.Schema<MembersUpdateRequestRolesItemPermissions>;

export interface MembersUpdateRequestRolesItem {
  /** Role identifier tag. */
  id: string;
  /** Description of role's permissions. */
  description?: string;
  /** Role name. */
  name?: string;
  permissions?: MembersUpdateRequestRolesItemPermissions;
}
export const MembersUpdateRequestRolesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    description: S.optional(S.String),
    name: S.optional(S.String),
    permissions: S.optional(MembersUpdateRequestRolesItemPermissions),
  }),
).annotate({
  identifier: "MembersUpdateRequestRolesItem",
}) as any as S.Schema<MembersUpdateRequestRolesItem>;

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

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

export interface MembersUpdateRequestUser {
  /** The contact email address of the user. */
  email: string;
  /** Identifier */
  id?: string;
  /** User's first name */
  firstName?: string;
  /** User's last name */
  lastName?: string;
  /** Indicates whether two-factor authentication is enabled for the user account. Does not apply to API authentication. */
  twoFactorAuthenticationEnabled?: boolean;
}
export const MembersUpdateRequestUser = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    email: S.String,
    id: S.optional(S.String),
    firstName: S.optional(S.String.pipe(T.Body("first_name"))),
    lastName: S.optional(S.String.pipe(T.Body("last_name"))),
    twoFactorAuthenticationEnabled: S.optional(
      S.Boolean.pipe(T.Body("two_factor_authentication_enabled")),
    ),
  }),
).annotate({
  identifier: "MembersUpdateRequestUser",
}) as any as S.Schema<MembersUpdateRequestUser>;

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

export type MembersUpdateRequestPoliciesItemPermissionGroupsItem =
  MembersCreateRequestPoliciesItemPermissionGroupsItem;
export const MembersUpdateRequestPoliciesItemPermissionGroupsItem =
  MembersCreateRequestPoliciesItemPermissionGroupsItem;

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

export type MembersUpdateRequestPoliciesItemResourceGroupsItem =
  MembersCreateRequestPoliciesItemPermissionGroupsItem;
export const MembersUpdateRequestPoliciesItemResourceGroupsItem =
  MembersCreateRequestPoliciesItemPermissionGroupsItem;

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

export interface MembersUpdateRequestPoliciesItem {
  /** Policy identifier. */
  id?: string;
  /** Allow or deny operations against the resources. */
  access: MembersUpdateRequestPoliciesItemAccess | (string & {});
  /** A set of permission groups that are specified to the policy. */
  permissionGroups: MembersUpdateRequestPoliciesItemPermissionGroupsList;
  /** A list of resource groups that the policy applies to. */
  resourceGroups: MembersUpdateRequestPoliciesItemResourceGroupsList;
}
export const MembersUpdateRequestPoliciesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.String),
    access: MembersUpdateRequestPoliciesItemAccess,
    permissionGroups: MembersUpdateRequestPoliciesItemPermissionGroupsList.pipe(
      T.Body("permission_groups"),
    ),
    resourceGroups: MembersUpdateRequestPoliciesItemResourceGroupsList.pipe(
      T.Body("resource_groups"),
    ),
  }),
).annotate({
  identifier: "MembersUpdateRequestPoliciesItem",
}) as any as S.Schema<MembersUpdateRequestPoliciesItem>;

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

export interface UpdateMemberRequest {
  /** Account identifier tag. */
  accountId: string;
  /** Membership identifier tag. */
  memberId: string;
  /** Membership identifier tag. */
  id?: string;
  /** Roles assigned to this member. */
  roles?: MembersUpdateRequestRolesList;
  /** A member's status in the account. */
  status?: MembersUpdateRequestStatus | (string & {});
  /** Details of the user associated to the membership. */
  user?: MembersUpdateRequestUser;
  /** Array of policies associated with this member. */
  policies?: MembersUpdateRequestPoliciesList;
}
export const UpdateMemberRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    memberId: S.String.pipe(T.Label("member_id")),
    id: S.optional(S.String),
    roles: S.optional(MembersUpdateRequestRolesList),
    status: S.optional(MembersUpdateRequestStatus),
    user: S.optional(MembersUpdateRequestUser),
    policies: S.optional(MembersUpdateRequestPoliciesList),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/accounts/{account_id}/members/{member_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateMemberRequest",
}) as any as S.Schema<UpdateMemberRequest>;

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

export type MembersUpdateResponsePoliciesItemPermissionGroupsItemMeta =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;
export const MembersUpdateResponsePoliciesItemPermissionGroupsItemMeta =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;

export type MembersUpdateResponsePoliciesItemPermissionGroupsItem =
  MembersCreateResponsePoliciesItemPermissionGroupsItem;
export const MembersUpdateResponsePoliciesItemPermissionGroupsItem =
  MembersCreateResponsePoliciesItemPermissionGroupsItem;

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

export type MembersUpdateResponsePoliciesItemResourceGroupsItemScopeItemObjectsItem =
  MembersCreateResponsePoliciesItemResourceGroupsItemScopeItemObjectsItem;
export const MembersUpdateResponsePoliciesItemResourceGroupsItemScopeItemObjectsItem =
  MembersCreateResponsePoliciesItemResourceGroupsItemScopeItemObjectsItem;

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

export interface MembersUpdateResponsePoliciesItemResourceGroupsItemScopeItem {
  /** This is a combination of pre-defined resource name and identifier (like Account ID etc.) */
  key: string;
  /** A list of scope objects for additional context. */
  objects: MembersUpdateResponsePoliciesItemResourceGroupsItemScopeItemObjectsList;
}
export const MembersUpdateResponsePoliciesItemResourceGroupsItemScopeItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: S.String,
      objects:
        MembersUpdateResponsePoliciesItemResourceGroupsItemScopeItemObjectsList,
    }),
  ).annotate({
    identifier: "MembersUpdateResponsePoliciesItemResourceGroupsItemScopeItem",
  }) as any as S.Schema<MembersUpdateResponsePoliciesItemResourceGroupsItemScopeItem>;

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

export type MembersUpdateResponsePoliciesItemResourceGroupsItemMeta =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;
export const MembersUpdateResponsePoliciesItemResourceGroupsItemMeta =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;

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

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

export interface MembersUpdateResponsePoliciesItem {
  /** Policy identifier. */
  id?: string | null;
  /** Allow or deny operations against the resources. */
  access?: MembersUpdateResponsePoliciesItemAccess | null;
  /** A set of permission groups that are specified to the policy. */
  permissionGroups?: MembersUpdateResponsePoliciesItemPermissionGroupsList | null;
  /** A list of resource groups that the policy applies to. */
  resourceGroups?: MembersUpdateResponsePoliciesItemResourceGroupsList | null;
}
export const MembersUpdateResponsePoliciesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    access: S.optional(S.NullOr(MembersUpdateResponsePoliciesItemAccess)),
    permissionGroups: S.optional(
      S.NullOr(MembersUpdateResponsePoliciesItemPermissionGroupsList).pipe(
        T.Body("permission_groups"),
      ),
    ),
    resourceGroups: S.optional(
      S.NullOr(MembersUpdateResponsePoliciesItemResourceGroupsList).pipe(
        T.Body("resource_groups"),
      ),
    ),
  }),
).annotate({
  identifier: "MembersUpdateResponsePoliciesItem",
}) as any as S.Schema<MembersUpdateResponsePoliciesItem>;

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

export type MembersUpdateResponseRolesItemPermissionsAnalytics =
  MembersCreateResponseRolesItemPermissionsAnalytics;
export const MembersUpdateResponseRolesItemPermissionsAnalytics =
  MembersCreateResponseRolesItemPermissionsAnalytics;

export type MembersUpdateResponseRolesItemPermissions =
  MembersCreateResponseRolesItemPermissions;
export const MembersUpdateResponseRolesItemPermissions =
  MembersCreateResponseRolesItemPermissions;

export type MembersUpdateResponseRolesItem = MembersCreateResponseRolesItem;
export const MembersUpdateResponseRolesItem = MembersCreateResponseRolesItem;

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

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

export type MembersUpdateResponseUser = MembersCreateResponseUser;
export const MembersUpdateResponseUser = MembersCreateResponseUser;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface UpdateMemberResponse {
  /** Membership identifier tag. */
  id?: string | null;
  /** The contact email address of the user. */
  email?: string | null;
  /** Access policy for the membership */
  policies?: MembersUpdateResponsePoliciesList | null;
  /** Roles assigned to this Member. */
  roles?: MembersUpdateResponseRolesList | null;
  /** A member's status in the account. */
  status?: MembersUpdateResponseStatus | null;
  /** Details of the user associated to the membership. */
  user?: MembersCreateResponseUser | null;
}
export const UpdateMemberResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    email: S.optional(S.NullOr(S.String)),
    policies: S.optional(S.NullOr(MembersUpdateResponsePoliciesList)),
    roles: S.optional(S.NullOr(MembersUpdateResponseRolesList)),
    status: S.optional(S.NullOr(MembersUpdateResponseStatus)),
    user: S.optional(S.NullOr(MembersCreateResponseUser)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateMemberResponse",
}) as any as S.Schema<UpdateMemberResponse>;

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

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

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

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

export interface SubscriptionsUpdateResponseRatePlan {
  /** The ID of the rate plan. */
  id?: SubscriptionsUpdateResponseRatePlanId | 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?: SubscriptionsUpdateResponseRatePlanSetsList | null;
}
export const SubscriptionsUpdateResponseRatePlan = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(SubscriptionsUpdateResponseRatePlanId)),
    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(SubscriptionsUpdateResponseRatePlanSetsList)),
  }),
).annotate({
  identifier: "SubscriptionsUpdateResponseRatePlan",
}) as any as S.Schema<SubscriptionsUpdateResponseRatePlan>;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface UpdateSubscriptionResponse {
  /** Subscription identifier tag. */
  id?: string | null;
  /** The monetary unit in which pricing information is displayed. */
  currency?: string | null;
  /** The end of the current period and also when the next billing is due. */
  currentPeriodEnd?: string | null;
  /** When the current billing period started. May match initial_period_start if this is the first period. */
  currentPeriodStart?: string | null;
  /** How often the subscription is renewed automatically. */
  frequency?: SubscriptionsUpdateResponseFrequency | null;
  /** The price of the subscription that will be billed, in US dollars. */
  price?: number | null;
  /** The rate plan applied to the subscription. */
  ratePlan?: SubscriptionsUpdateResponseRatePlan | null;
  /** The state that the subscription is in. */
  state?: SubscriptionsUpdateResponseState | null;
}
export const UpdateSubscriptionResponse = /*@__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(SubscriptionsUpdateResponseFrequency)),
    price: S.optional(S.NullOr(S.Number)),
    ratePlan: S.optional(
      S.NullOr(SubscriptionsUpdateResponseRatePlan).pipe(T.Body("rate_plan")),
    ),
    state: S.optional(S.NullOr(SubscriptionsUpdateResponseState)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "UpdateSubscriptionResponse",
}) as any as S.Schema<UpdateSubscriptionResponse>;

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 {
  /** Account identifier tag. */
  accountId: string;
  /** 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({
    accountId: S.String.pipe(T.Label("account_id")),
    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: "/accounts/{account_id}/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 =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;
export const TokensUpdateResponsePoliciesItemPermissionGroupsItemMeta =
  MembersCreateResponsePoliciesItemPermissionGroupsItemMeta;

export type TokensUpdateResponsePoliciesItemPermissionGroupsItem =
  MembersCreateResponsePoliciesItemPermissionGroupsItem;
export const TokensUpdateResponsePoliciesItemPermissionGroupsItem =
  MembersCreateResponsePoliciesItemPermissionGroupsItem;

export type TokensUpdateResponsePoliciesItemPermissionGroupsList =
  Array<MembersCreateResponsePoliciesItemPermissionGroupsItem>;
export const TokensUpdateResponsePoliciesItemPermissionGroupsList =
  /*@__PURE__*/ S.Array(
    MembersCreateResponsePoliciesItemPermissionGroupsItem,
  ) 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 {
  /** Account identifier tag. */
  accountId: string;
}
export const VerifyTokenRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/accounts/{account_id}/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 CreateAccountError =
  | AccountCreationForbidden
  | MissingName
  | CloudflareOpError;
/** Create an account (only available for tenant admins at this time) */
export const createAccount: API.OperationMethod<
  CreateAccountRequest,
  CreateAccountResponse,
  CreateAccountError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateAccountRequest,
  output: CreateAccountResponse,
  errors: [
    AccountCreationForbidden,
    MissingName,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateAccountOrganizationError = CloudflareOpError;
/** Move an account within an organization hierarchy or an account outside an organization. (Currently in Public Beta - see https://developers.cloudflare.com/fundamentals/organizations/) */
export const createAccountOrganization: API.OperationMethod<
  CreateAccountOrganizationRequest,
  CreateAccountOrganizationResponse,
  CreateAccountOrganizationError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateAccountOrganizationRequest,
  output: CreateAccountOrganizationResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateMemberError =
  | InvalidRoute
  | ValidationError
  | AccountMemberAlreadyExists
  | CloudflareOpError;
/** Add a user to the list of members for this account. */
export const createMember: API.OperationMethod<
  CreateMemberRequest,
  CreateMemberResponse,
  CreateMemberError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateMemberRequest,
  output: CreateMemberResponse,
  errors: [
    InvalidRoute,
    ValidationError,
    AccountMemberAlreadyExists,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateSubscriptionError =
  | JsonDecodeFailure
  | InvalidRoute
  | CloudflareOpError;
/** Creates an account subscription. */
export const createSubscription: API.OperationMethod<
  CreateSubscriptionRequest,
  CreateSubscriptionResponse,
  CreateSubscriptionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateSubscriptionRequest,
  output: CreateSubscriptionResponse,
  errors: [
    JsonDecodeFailure,
    InvalidRoute,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateTokenError =
  | InvalidRoute
  | InvalidTokenName
  | PermissionGroupNotFound
  | CloudflareOpError;
/** Create a new Account Owned API 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 DeleteAccountError =
  | InvalidRoute
  | MethodNotAllowed
  | CloudflareOpError;
/** Delete a specific account (only available for tenant admins at this time). This is a permanent operation that will delete any zones or other resources under the account */
export const deleteAccount: API.OperationMethod<
  DeleteAccountRequest,
  DeleteAccountResponse,
  DeleteAccountError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteAccountRequest,
  output: DeleteAccountResponse,
  errors: [
    InvalidRoute,
    MethodNotAllowed,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteMemberError =
  | MemberNotFound
  | InvalidRoute
  | CloudflareOpError;
/** Remove a member from an account. */
export const deleteMember: API.OperationMethod<
  DeleteMemberRequest,
  DeleteMemberResponse,
  DeleteMemberError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteMemberRequest,
  output: DeleteMemberResponse,
  errors: [
    MemberNotFound,
    InvalidRoute,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

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

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

export type GetAccountError = InvalidRoute | CloudflareOpError;
/** Get information about a specific account that you are a member of. */
export const getAccount: API.OperationMethod<
  GetAccountRequest,
  GetAccountResponse,
  GetAccountError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetAccountRequest,
  output: GetAccountResponse,
  errors: [InvalidRoute, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetAccountProfileError = CloudflareOpError;
/** Retrieves the profile information for a specific Cloudflare account, including organization details, settings, and metadata. This endpoint is commonly used to verify account access and retrieve account-level configuration. */
export const getAccountProfile: API.OperationMethod<
  GetAccountProfileRequest,
  GetAccountProfileResponse,
  GetAccountProfileError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetAccountProfileRequest,
  output: GetAccountProfileResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetMemberError = MemberNotFound | InvalidRoute | CloudflareOpError;
/** Get information about a specific member of an account. */
export const getMember: API.OperationMethod<
  GetMemberRequest,
  GetMemberResponse,
  GetMemberError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetMemberRequest,
  output: GetMemberResponse,
  errors: [
    MemberNotFound,
    InvalidRoute,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetRoleError = InvalidRoute | CloudflareOpError;
/** Get information about a specific role for an account. */
export const getRole: API.OperationMethod<
  GetRoleRequest,
  GetRoleResponse,
  GetRoleError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetRoleRequest,
  output: GetRoleResponse,
  errors: [InvalidRoute, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetSubscriptionError = CloudflareOpError;
/** Lists all of an account'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 Account Owned API 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 GetTokenPermissionGroupError = InvalidRoute | CloudflareOpError;
/** Find all available permission groups for Account Owned API Tokens */
export const getTokenPermissionGroup: API.OperationMethod<
  GetTokenPermissionGroupRequest,
  GetTokenPermissionGroupResponse,
  GetTokenPermissionGroupError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetTokenPermissionGroupRequest,
  output: GetTokenPermissionGroupResponse,
  errors: [InvalidRoute, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListAccountsError = CloudflareOpError;
/** List all accounts you have ownership or verified access to. */
export const listAccounts: API.PaginatedOperationMethod<
  ListAccountsRequest,
  ListAccountsResponse,
  ListAccountsError,
  CloudflareOpContext,
  ListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListAccountsRequest,
    output: ListAccountsResponse,
    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 ListLogAuditsError = CloudflareOpError;
/** Gets a list of audit logs for an account. */
export const listLogAudits: API.PaginatedOperationMethod<
  ListLogAuditsRequest,
  ListLogAuditsResponse,
  ListLogAuditsError,
  CloudflareOpContext,
  LogsAuditListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListLogAuditsRequest,
    output: ListLogAuditsResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "cursor",
      inputToken: "cursor",
      outputToken: "resultInfo.cursors.after",
      items: "result",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListMembersError = CloudflareOpError;
/** List all members of an account. */
export const listMembers: API.PaginatedOperationMethod<
  ListMembersRequest,
  ListMembersResponse,
  ListMembersError,
  CloudflareOpContext,
  MembersListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListMembersRequest,
    output: ListMembersResponse,
    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 ListRolesError = CloudflareOpError;
/** Get all available roles for an account. */
export const listRoles: API.PaginatedOperationMethod<
  ListRolesRequest,
  ListRolesResponse,
  ListRolesError,
  CloudflareOpContext,
  MembersCreateResponseRolesItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListRolesRequest,
    output: ListRolesResponse,
    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 ListTokensError = CloudflareOpError;
/** List all Account Owned API tokens created for this account. */
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 ListTokensPermissionGroupsError = InvalidRoute | CloudflareOpError;
/** Find all available permission groups for Account Owned API Tokens */
export const listTokensPermissionGroups: API.OperationMethod<
  ListTokensPermissionGroupsRequest,
  ListTokensPermissionGroupsResponse,
  ListTokensPermissionGroupsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListTokensPermissionGroupsRequest,
  output: ListTokensPermissionGroupsResponse,
  errors: [InvalidRoute, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PutTokenValueError =
  | InvalidRoute
  | TokenNotFound
  | CloudflareOpError;
/** Roll the Account Owned API 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 UpdateAccountError =
  | InvalidAccountName
  | AccountNameTooLong
  | UpdateAccountTypeNotSupported
  | InvalidRoute
  | MethodNotAllowed
  | CloudflareOpError;
/** Update an existing account. */
export const updateAccount: API.OperationMethod<
  UpdateAccountRequest,
  UpdateAccountResponse,
  UpdateAccountError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdateAccountRequest,
  output: UpdateAccountResponse,
  errors: [
    InvalidAccountName,
    AccountNameTooLong,
    UpdateAccountTypeNotSupported,
    InvalidRoute,
    MethodNotAllowed,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type UpdateAccountProfileError = CloudflareOpError;
/** Updates the profile information for a Cloudflare account. Allows modification of account-level settings and organizational details. Requires Account Settings Write permission. */
export const updateAccountProfile: API.OperationMethod<
  UpdateAccountProfileRequest,
  UpdateAccountProfileResponse,
  UpdateAccountProfileError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdateAccountProfileRequest,
  output: UpdateAccountProfileResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type UpdateMemberError =
  | MemberNotFound
  | InvalidRoute
  | BadRequest
  | MethodNotAllowed
  | CloudflareOpError;
/** Modify an account member. */
export const updateMember: API.OperationMethod<
  UpdateMemberRequest,
  UpdateMemberResponse,
  UpdateMemberError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdateMemberRequest,
  output: UpdateMemberResponse,
  errors: [
    MemberNotFound,
    InvalidRoute,
    BadRequest,
    MethodNotAllowed,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type UpdateSubscriptionError =
  | JsonDecodeFailure
  | InvalidRoute
  | EndpointNotFound
  | CloudflareOpError;
/** Updates an account subscription. */
export const updateSubscription: API.OperationMethod<
  UpdateSubscriptionRequest,
  UpdateSubscriptionResponse,
  UpdateSubscriptionError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: UpdateSubscriptionRequest,
  output: UpdateSubscriptionResponse,
  errors: [
    JsonDecodeFailure,
    InvalidRoute,
    EndpointNotFound,
    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 =
  | MissingAuthenticationToken
  | InvalidRoute
  | CloudflareOpError;
/** Test whether a token works. */
export const verifyToken: API.OperationMethod<
  VerifyTokenRequest,
  VerifyTokenResponse,
  VerifyTokenError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: VerifyTokenRequest,
  output: VerifyTokenResponse,
  errors: [
    MissingAuthenticationToken,
    InvalidRoute,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

// Alias of getTokenPermissionGroup (same route, alternate export name upstream).
export const listTokenPermissionGroups = getTokenPermissionGroup;
export type ListTokenPermissionGroupsRequest = GetTokenPermissionGroupRequest;
export type ListTokenPermissionGroupsResponse = GetTokenPermissionGroupResponse;
export type ListTokenPermissionGroupsError = GetTokenPermissionGroupError;