// 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",
  apiAccessEnabled: "api_access_enabled",
  cachePurge: "cache_purge",
  createdOn: "created_on",
  dnsRecords: "dns_records",
  enforceTwofactor: "enforce_twofactor",
  managedBy: "managed_by",
  parentOrgId: "parent_org_id",
  parentOrgName: "parent_org_name",
  perPage: "per_page",
  permissionGroups: "permission_groups",
  resourceGroups: "resource_groups",
  resultInfo: "result_info",
  totalCount: "total_count",
  zoneSettings: "zone_settings",
};

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

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

export interface GetMembershipRequest {
  /** Membership identifier tag. */
  membershipId: string;
}
export const GetMembershipRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    membershipId: S.String.pipe(T.Label("membership_id")),
  })
    .pipe(
      T.Http({ method: "GET", uri: "/memberships/{membership_id}", code: 200 }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetMembershipRequest",
}) as any as S.Schema<GetMembershipRequest>;

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

export interface GetResponseAccountManagedBy {
  /** ID of the parent Organization, if one exists */
  parentOrgId?: string | null;
  /** Name of the parent Organization, if one exists */
  parentOrgName?: string | null;
}
export const GetResponseAccountManagedBy = /*@__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: "GetResponseAccountManagedBy",
}) as any as S.Schema<GetResponseAccountManagedBy>;

export interface GetResponseAccountSettings {
  /** 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 GetResponseAccountSettings = /*@__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: "GetResponseAccountSettings",
}) as any as S.Schema<GetResponseAccountSettings>;

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

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

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

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

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

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

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

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

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

export interface GetResponsePoliciesItemResourceGroupsItemScopeItem {
  /** 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: GetResponsePoliciesItemResourceGroupsItemScopeItemObjectsList;
}
export const GetResponsePoliciesItemResourceGroupsItemScopeItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: S.String,
      objects: GetResponsePoliciesItemResourceGroupsItemScopeItemObjectsList,
    }),
  ).annotate({
    identifier: "GetResponsePoliciesItemResourceGroupsItemScopeItem",
  }) as any as S.Schema<GetResponsePoliciesItemResourceGroupsItemScopeItem>;

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

export type GetResponsePoliciesItemResourceGroupsItemMeta =
  GetResponsePoliciesItemPermissionGroupsItemMeta;
export const GetResponsePoliciesItemResourceGroupsItemMeta =
  GetResponsePoliciesItemPermissionGroupsItemMeta;

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

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

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

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

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

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetMembershipResponse {
  /** Membership identifier tag. */
  id?: string | null;
  account?: GetResponseAccount | null;
  /** Enterprise only. Indicates whether or not API access is enabled specifically for this user on a given account. */
  apiAccessEnabled?: boolean | null;
  /** All access permissions for the user at the account. */
  permissions?: GetResponsePermissions | null;
  /** Access policy for the membership */
  policies?: GetResponsePoliciesList | null;
  /** List of role names the membership has for this account. */
  roles?: GetResponseRolesList | null;
  /** Status of this membership. */
  status?: GetResponseStatus | null;
}
export const GetMembershipResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    account: S.optional(S.NullOr(GetResponseAccount)),
    apiAccessEnabled: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("api_access_enabled")),
    ),
    permissions: S.optional(S.NullOr(GetResponsePermissions)),
    policies: S.optional(S.NullOr(GetResponsePoliciesList)),
    roles: S.optional(S.NullOr(GetResponseRolesList)),
    status: S.optional(S.NullOr(GetResponseStatus)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetMembershipResponse",
}) as any as S.Schema<GetMembershipResponse>;

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

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

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

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

export interface ListMembershipsRequest {
  account?: ListRequestAccount;
  /** Direction to order memberships. */
  direction?: ListRequestDirection | (string & {});
  /** Account name */
  name?: string;
  /** Field to order memberships by. */
  order?: ListRequestOrder | (string & {});
  /** Page number of paginated results. */
  page?: number;
  /** Number of memberships per page. */
  perPage?: number;
  /** Status of this membership. */
  status?: ListRequestStatus | (string & {});
}
export const ListMembershipsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    account: S.optional(ListRequestAccount.pipe(T.DeepQuery("account"))),
    direction: S.optional(ListRequestDirection.pipe(T.Query())),
    name: S.optional(S.String.pipe(T.Query())),
    order: S.optional(ListRequestOrder.pipe(T.Query())),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    status: S.optional(ListRequestStatus.pipe(T.Query())),
  })
    .pipe(T.Http({ method: "GET", uri: "/memberships", code: 200 }))
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListMembershipsRequest",
}) as any as S.Schema<ListMembershipsRequest>;

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

export type ListResultItemAccountManagedBy = GetResponseAccountManagedBy;
export const ListResultItemAccountManagedBy = GetResponseAccountManagedBy;

export type ListResultItemAccountSettings = GetResponseAccountSettings;
export const ListResultItemAccountSettings = GetResponseAccountSettings;

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

export type ListResultItemPermissionsAnalytics =
  GetResponsePermissionsAnalytics;
export const ListResultItemPermissionsAnalytics =
  GetResponsePermissionsAnalytics;

export type ListResultItemPermissions = GetResponsePermissions;
export const ListResultItemPermissions = GetResponsePermissions;

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

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

export interface ListResultItem {
  /** Membership identifier tag. */
  id?: string | null;
  account?: ListResultItemAccount | null;
  /** Enterprise only. Indicates whether or not API access is enabled specifically for this user on a given account. */
  apiAccessEnabled?: boolean | null;
  /** All access permissions for the user at the account. */
  permissions?: GetResponsePermissions | null;
  /** List of role names the membership has for this account. */
  roles?: ListResultItemRolesList | null;
  /** Status of this membership. */
  status?: ListResultItemStatus | null;
}
export const ListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    account: S.optional(S.NullOr(ListResultItemAccount)),
    apiAccessEnabled: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("api_access_enabled")),
    ),
    permissions: S.optional(S.NullOr(GetResponsePermissions)),
    roles: S.optional(S.NullOr(ListResultItemRolesList)),
    status: S.optional(S.NullOr(ListResultItemStatus)),
  }),
).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 ListMembershipsResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: ListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListMembershipsResponse = /*@__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: "ListMembershipsResponse",
}) as any as S.Schema<ListMembershipsResponse>;

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

export interface PutMembershipRequest {
  /** Membership identifier tag. */
  membershipId: string;
  /** Whether to accept or reject this account invitation. */
  status: UpdateRequestStatus | (string & {});
}
export const PutMembershipRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    membershipId: S.String.pipe(T.Label("membership_id")),
    status: UpdateRequestStatus,
  })
    .pipe(
      T.Http({ method: "PUT", uri: "/memberships/{membership_id}", code: 200 }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutMembershipRequest",
}) as any as S.Schema<PutMembershipRequest>;

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

export type UpdateResponseAccountManagedBy = GetResponseAccountManagedBy;
export const UpdateResponseAccountManagedBy = GetResponseAccountManagedBy;

export type UpdateResponseAccountSettings = GetResponseAccountSettings;
export const UpdateResponseAccountSettings = GetResponseAccountSettings;

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

export type UpdateResponsePermissionsAnalytics =
  GetResponsePermissionsAnalytics;
export const UpdateResponsePermissionsAnalytics =
  GetResponsePermissionsAnalytics;

export type UpdateResponsePermissions = GetResponsePermissions;
export const UpdateResponsePermissions = GetResponsePermissions;

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

export type UpdateResponsePoliciesItemPermissionGroupsItemMeta =
  GetResponsePoliciesItemPermissionGroupsItemMeta;
export const UpdateResponsePoliciesItemPermissionGroupsItemMeta =
  GetResponsePoliciesItemPermissionGroupsItemMeta;

export type UpdateResponsePoliciesItemPermissionGroupsItem =
  GetResponsePoliciesItemPermissionGroupsItem;
export const UpdateResponsePoliciesItemPermissionGroupsItem =
  GetResponsePoliciesItemPermissionGroupsItem;

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

export type UpdateResponsePoliciesItemResourceGroupsItemScopeItemObjectsItem =
  GetResponsePoliciesItemResourceGroupsItemScopeItemObjectsItem;
export const UpdateResponsePoliciesItemResourceGroupsItemScopeItemObjectsItem =
  GetResponsePoliciesItemResourceGroupsItemScopeItemObjectsItem;

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

export interface UpdateResponsePoliciesItemResourceGroupsItemScopeItem {
  /** 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: UpdateResponsePoliciesItemResourceGroupsItemScopeItemObjectsList;
}
export const UpdateResponsePoliciesItemResourceGroupsItemScopeItem =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      key: S.String,
      objects: UpdateResponsePoliciesItemResourceGroupsItemScopeItemObjectsList,
    }),
  ).annotate({
    identifier: "UpdateResponsePoliciesItemResourceGroupsItemScopeItem",
  }) as any as S.Schema<UpdateResponsePoliciesItemResourceGroupsItemScopeItem>;

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

export type UpdateResponsePoliciesItemResourceGroupsItemMeta =
  GetResponsePoliciesItemPermissionGroupsItemMeta;
export const UpdateResponsePoliciesItemResourceGroupsItemMeta =
  GetResponsePoliciesItemPermissionGroupsItemMeta;

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

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

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

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

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

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PutMembershipResponse {
  /** Membership identifier tag. */
  id?: string | null;
  account?: UpdateResponseAccount | null;
  /** Enterprise only. Indicates whether or not API access is enabled specifically for this user on a given account. */
  apiAccessEnabled?: boolean | null;
  /** All access permissions for the user at the account. */
  permissions?: GetResponsePermissions | null;
  /** Access policy for the membership */
  policies?: UpdateResponsePoliciesList | null;
  /** List of role names the membership has for this account. */
  roles?: UpdateResponseRolesList | null;
  /** Status of this membership. */
  status?: UpdateResponseStatus | null;
}
export const PutMembershipResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    account: S.optional(S.NullOr(UpdateResponseAccount)),
    apiAccessEnabled: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("api_access_enabled")),
    ),
    permissions: S.optional(S.NullOr(GetResponsePermissions)),
    policies: S.optional(S.NullOr(UpdateResponsePoliciesList)),
    roles: S.optional(S.NullOr(UpdateResponseRolesList)),
    status: S.optional(S.NullOr(UpdateResponseStatus)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutMembershipResponse",
}) as any as S.Schema<PutMembershipResponse>;

export type DeleteMembershipError = CloudflareOpError;
/** Remove the associated member from an account. */
export const deleteMembership: API.OperationMethod<
  DeleteMembershipRequest,
  DeleteMembershipResponse,
  DeleteMembershipError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteMembershipRequest,
  output: DeleteMembershipResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetMembershipError = CloudflareOpError;
/** Get a specific membership. */
export const getMembership: API.OperationMethod<
  GetMembershipRequest,
  GetMembershipResponse,
  GetMembershipError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetMembershipRequest,
  output: GetMembershipResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListMembershipsError = CloudflareOpError;
/** List memberships of accounts the user can access. */
export const listMemberships: API.PaginatedOperationMethod<
  ListMembershipsRequest,
  ListMembershipsResponse,
  ListMembershipsError,
  CloudflareOpContext,
  ListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListMembershipsRequest,
    output: ListMembershipsResponse,
    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 PutMembershipError = CloudflareOpError;
/** Accept or reject this account invitation. */
export const putMembership: API.OperationMethod<
  PutMembershipRequest,
  PutMembershipResponse,
  PutMembershipError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PutMembershipRequest,
  output: PutMembershipResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));