/**
 * Cloudflare USER API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service user
 */
import * as Schema from "effect/Schema";
import type * as HttpClient from "effect/unstable/http/HttpClient";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import { type DefaultErrors } from "../errors.ts";
declare const InvalidRoute_base: Schema.Class<InvalidRoute, Schema.TaggedStruct<"InvalidRoute", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidRoute extends InvalidRoute_base {
}
declare const InvalidTokenName_base: Schema.Class<InvalidTokenName, Schema.TaggedStruct<"InvalidTokenName", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidTokenName extends InvalidTokenName_base {
}
declare const MethodNotAllowed_base: Schema.Class<MethodNotAllowed, Schema.TaggedStruct<"MethodNotAllowed", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class MethodNotAllowed extends MethodNotAllowed_base {
}
declare const PermissionGroupNotFound_base: Schema.Class<PermissionGroupNotFound, Schema.TaggedStruct<"PermissionGroupNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class PermissionGroupNotFound extends PermissionGroupNotFound_base {
}
declare const TokenNotFound_base: Schema.Class<TokenNotFound, Schema.TaggedStruct<"TokenNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class TokenNotFound extends TokenNotFound_base {
}
export interface ListAuditLogsRequest {
}
export declare const ListAuditLogsRequest: Schema.Schema<ListAuditLogsRequest>;
export interface ListAuditLogsResponse {
    result: {
        id?: string | null;
        action?: {
            result?: boolean | null;
            type?: string | null;
        } | null;
        actor?: {
            id?: string | null;
            email?: string | null;
            ip?: string | null;
            type?: "user" | "admin" | "Cloudflare" | null;
        } | null;
        interface?: string | null;
        metadata?: unknown | null;
        newValue?: string | null;
        oldValue?: string | null;
        owner?: {
            id?: string | null;
        } | null;
        resource?: {
            id?: string | null;
            type?: string | null;
        } | null;
        when?: string | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListAuditLogsResponse: Schema.Schema<ListAuditLogsResponse>;
export type ListAuditLogsError = DefaultErrors;
export declare const listAuditLogs: API.PaginatedOperationMethod<ListAuditLogsRequest, ListAuditLogsResponse, ListAuditLogsError, Credentials | HttpClient.HttpClient>;
export interface ListBillingHistoriesRequest {
}
export declare const ListBillingHistoriesRequest: Schema.Schema<ListBillingHistoriesRequest>;
export interface ListBillingHistoriesResponse {
    result: {
        id: string;
        action: string;
        amount: number;
        currency: string;
        description: string;
        occurredAt: string;
        type: string;
        zone: {
            name?: string | null;
        };
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListBillingHistoriesResponse: Schema.Schema<ListBillingHistoriesResponse>;
export type ListBillingHistoriesError = DefaultErrors;
export declare const listBillingHistories: API.PaginatedOperationMethod<ListBillingHistoriesRequest, ListBillingHistoriesResponse, ListBillingHistoriesError, Credentials | HttpClient.HttpClient>;
export interface GetBillingProfileRequest {
}
export declare const GetBillingProfileRequest: Schema.Schema<GetBillingProfileRequest>;
export interface GetBillingProfileResponse {
    /** Billing item identifier tag. */
    id?: string | null;
    accountType?: string | null;
    address?: string | null;
    address2?: string | null;
    balance?: string | null;
    cardExpiryMonth?: number | null;
    cardExpiryYear?: number | null;
    cardNumber?: string | null;
    city?: string | null;
    company?: string | null;
    country?: string | null;
    createdOn?: string | null;
    deviceData?: string | null;
    editedOn?: string | null;
    enterpriseBillingEmail?: string | null;
    enterprisePrimaryEmail?: string | null;
    firstName?: string | null;
    isPartner?: boolean | null;
    lastName?: string | null;
    nextBillDate?: string | null;
    paymentAddress?: string | null;
    paymentAddress2?: string | null;
    paymentCity?: string | null;
    paymentCountry?: string | null;
    paymentEmail?: string | null;
    paymentFirstName?: string | null;
    paymentGateway?: string | null;
    paymentLastName?: string | null;
    paymentNonce?: string | null;
    paymentState?: string | null;
    paymentZipcode?: string | null;
    primaryEmail?: string | null;
    state?: string | null;
    taxIdType?: string | null;
    telephone?: string | null;
    useLegacy?: boolean | null;
    validationCode?: string | null;
    vat?: string | null;
    zipcode?: string | null;
}
export declare const GetBillingProfileResponse: Schema.Schema<GetBillingProfileResponse>;
export type GetBillingProfileError = DefaultErrors;
export declare const getBillingProfile: API.OperationMethod<GetBillingProfileRequest, GetBillingProfileResponse, GetBillingProfileError, Credentials | HttpClient.HttpClient>;
export interface GetInviteRequest {
    inviteId: string;
}
export declare const GetInviteRequest: Schema.Schema<GetInviteRequest>;
export interface GetInviteResponse {
    /** ID of the user to add to the organization. */
    invitedMemberId: string | null;
    /** ID of the organization the user will be added to. */
    organizationId: string;
    /** Invite identifier tag. */
    id?: string | null;
    /** When the invite is no longer active. */
    expiresOn?: string | null;
    /** The email address of the user who created the invite. */
    invitedBy?: string | null;
    /** Email address of the user to add to the organization. */
    invitedMemberEmail?: string | null;
    /** When the invite was sent. */
    invitedOn?: string | null;
    organizationIsEnforcingTwofactor?: boolean | null;
    /** Organization name. */
    organizationName?: string | null;
    /** List of role names the membership has for this account. */
    roles?: string[] | null;
    /** Current status of the invitation. */
    status?: "pending" | "accepted" | "rejected" | "expired" | null;
}
export declare const GetInviteResponse: Schema.Schema<GetInviteResponse>;
export type GetInviteError = DefaultErrors;
export declare const getInvite: API.OperationMethod<GetInviteRequest, GetInviteResponse, GetInviteError, Credentials | HttpClient.HttpClient>;
export interface ListInvitesRequest {
}
export declare const ListInvitesRequest: Schema.Schema<ListInvitesRequest>;
export interface ListInvitesResponse {
    result: {
        invitedMemberId: string | null;
        organizationId: string;
        id?: string | null;
        expiresOn?: string | null;
        invitedBy?: string | null;
        invitedMemberEmail?: string | null;
        invitedOn?: string | null;
        organizationIsEnforcingTwofactor?: boolean | null;
        organizationName?: string | null;
        roles?: string[] | null;
        status?: "pending" | "accepted" | "rejected" | "expired" | null;
    }[];
}
export declare const ListInvitesResponse: Schema.Schema<ListInvitesResponse>;
export type ListInvitesError = DefaultErrors;
export declare const listInvites: API.PaginatedOperationMethod<ListInvitesRequest, ListInvitesResponse, ListInvitesError, Credentials | HttpClient.HttpClient>;
export interface PatchInviteRequest {
    inviteId: string;
    /** Status of your response to the invitation (rejected or accepted). */
    status: "accepted" | "rejected";
}
export declare const PatchInviteRequest: Schema.Schema<PatchInviteRequest>;
export interface PatchInviteResponse {
    /** ID of the user to add to the organization. */
    invitedMemberId: string | null;
    /** ID of the organization the user will be added to. */
    organizationId: string;
    /** Invite identifier tag. */
    id?: string | null;
    /** When the invite is no longer active. */
    expiresOn?: string | null;
    /** The email address of the user who created the invite. */
    invitedBy?: string | null;
    /** Email address of the user to add to the organization. */
    invitedMemberEmail?: string | null;
    /** When the invite was sent. */
    invitedOn?: string | null;
    organizationIsEnforcingTwofactor?: boolean | null;
    /** Organization name. */
    organizationName?: string | null;
    /** List of role names the membership has for this account. */
    roles?: string[] | null;
    /** Current status of the invitation. */
    status?: "pending" | "accepted" | "rejected" | "expired" | null;
}
export declare const PatchInviteResponse: Schema.Schema<PatchInviteResponse>;
export type PatchInviteError = DefaultErrors;
export declare const patchInvite: API.OperationMethod<PatchInviteRequest, PatchInviteResponse, PatchInviteError, Credentials | HttpClient.HttpClient>;
export interface GetOrganizationRequest {
    organizationId: string;
}
export declare const GetOrganizationRequest: Schema.Schema<GetOrganizationRequest>;
export type GetOrganizationResponse = unknown;
export declare const GetOrganizationResponse: Schema.Schema<GetOrganizationResponse>;
export type GetOrganizationError = DefaultErrors;
export declare const getOrganization: API.OperationMethod<GetOrganizationRequest, GetOrganizationResponse, GetOrganizationError, Credentials | HttpClient.HttpClient>;
export interface ListOrganizationsRequest {
}
export declare const ListOrganizationsRequest: Schema.Schema<ListOrganizationsRequest>;
export interface ListOrganizationsResponse {
    result: {
        id?: string | null;
        name?: string | null;
        permissions?: string[] | null;
        roles?: string[] | null;
        status?: "member" | "invited" | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListOrganizationsResponse: Schema.Schema<ListOrganizationsResponse>;
export type ListOrganizationsError = DefaultErrors;
export declare const listOrganizations: API.PaginatedOperationMethod<ListOrganizationsRequest, ListOrganizationsResponse, ListOrganizationsError, Credentials | HttpClient.HttpClient>;
export interface DeleteOrganizationRequest {
    organizationId: string;
}
export declare const DeleteOrganizationRequest: Schema.Schema<DeleteOrganizationRequest>;
export interface DeleteOrganizationResponse {
    /** Identifier */
    id?: string | null;
}
export declare const DeleteOrganizationResponse: Schema.Schema<DeleteOrganizationResponse>;
export type DeleteOrganizationError = DefaultErrors;
export declare const deleteOrganization: API.OperationMethod<DeleteOrganizationRequest, DeleteOrganizationResponse, DeleteOrganizationError, Credentials | HttpClient.HttpClient>;
export interface GetSubscriptionRequest {
}
export declare const GetSubscriptionRequest: Schema.Schema<GetSubscriptionRequest>;
export interface GetSubscriptionResponse {
    result: {
        id?: string | null;
        currency?: string | null;
        currentPeriodEnd?: string | null;
        currentPeriodStart?: string | null;
        frequency?: "weekly" | "monthly" | "quarterly" | "yearly" | null;
        price?: number | null;
        ratePlan?: {
            id?: "free" | "lite" | "pro" | "pro_plus" | "business" | "enterprise" | "partners_free" | "partners_pro" | "partners_business" | "partners_enterprise" | null;
            currency?: string | null;
            externallyManaged?: boolean | null;
            isContract?: boolean | null;
            publicName?: string | null;
            scope?: string | null;
            sets?: string[] | null;
        } | null;
        state?: "Trial" | "Provisioned" | "Paid" | "AwaitingPayment" | "Cancelled" | "Failed" | "Expired" | null;
    }[];
}
export declare const GetSubscriptionResponse: Schema.Schema<GetSubscriptionResponse>;
export type GetSubscriptionError = DefaultErrors;
export declare const getSubscription: API.PaginatedOperationMethod<GetSubscriptionRequest, GetSubscriptionResponse, GetSubscriptionError, Credentials | HttpClient.HttpClient>;
export interface PutSubscriptionRequest {
    identifier: string;
    /** How often the subscription is renewed automatically. */
    frequency?: "weekly" | "monthly" | "quarterly" | "yearly";
    /** The rate plan applied to the subscription. */
    ratePlan?: {
        id?: "free" | "lite" | "pro" | "pro_plus" | "business" | "enterprise" | "partners_free" | "partners_pro" | "partners_business" | "partners_enterprise";
        currency?: string;
        externallyManaged?: boolean;
        isContract?: boolean;
        publicName?: string;
        scope?: string;
        sets?: string[];
    };
}
export declare const PutSubscriptionRequest: Schema.Schema<PutSubscriptionRequest>;
export type PutSubscriptionResponse = string | null;
export declare const PutSubscriptionResponse: Schema.Schema<PutSubscriptionResponse>;
export type PutSubscriptionError = DefaultErrors;
export declare const putSubscription: API.OperationMethod<PutSubscriptionRequest, PutSubscriptionResponse, PutSubscriptionError, Credentials | HttpClient.HttpClient>;
export interface DeleteSubscriptionRequest {
    identifier: string;
}
export declare const DeleteSubscriptionRequest: Schema.Schema<DeleteSubscriptionRequest>;
export interface DeleteSubscriptionResponse {
    /** Subscription identifier tag. */
    subscriptionId?: string | null;
}
export declare const DeleteSubscriptionResponse: Schema.Schema<DeleteSubscriptionResponse>;
export type DeleteSubscriptionError = DefaultErrors;
export declare const deleteSubscription: API.OperationMethod<DeleteSubscriptionRequest, DeleteSubscriptionResponse, DeleteSubscriptionError, Credentials | HttpClient.HttpClient>;
export interface GetTokenRequest {
    tokenId: string;
}
export declare const GetTokenRequest: Schema.Schema<GetTokenRequest>;
export interface GetTokenResponse {
    /** Token identifier tag. */
    id?: string | null;
    condition?: {
        requestIp?: {
            in?: string[] | null;
            notIn?: string[] | null;
        } | null;
    } | null;
    /** The expiration time on or after which the JWT MUST NOT be accepted for processing. */
    expiresOn?: string | null;
    /** The time on which the token was created. */
    issuedOn?: string | null;
    /** Last time the token was used. */
    lastUsedOn?: string | null;
    /** Last time the token was modified. */
    modifiedOn?: string | null;
    /** Token name. */
    name?: string | null;
    /** The time before which the token MUST NOT be accepted for processing. */
    notBefore?: string | null;
    /** List of access policies assigned to the token. */
    policies?: {
        id: string;
        effect: "allow" | "deny";
        permissionGroups: {
            id: string;
            meta?: {
                key?: string | null;
                value?: string | null;
            } | null;
            name?: string | null;
        }[];
        resources: Record<string, unknown>;
    }[] | null;
    /** Status of the token. */
    status?: "active" | "disabled" | "expired" | null;
}
export declare const GetTokenResponse: Schema.Schema<GetTokenResponse>;
export type GetTokenError = DefaultErrors | InvalidRoute | TokenNotFound;
export declare const getToken: API.OperationMethod<GetTokenRequest, GetTokenResponse, GetTokenError, Credentials | HttpClient.HttpClient>;
export interface ListTokensRequest {
}
export declare const ListTokensRequest: Schema.Schema<ListTokensRequest>;
export interface ListTokensResponse {
    result: {
        id?: string | null;
        condition?: {
            requestIp?: {
                in?: string[] | null;
                notIn?: string[] | null;
            } | null;
        } | null;
        expiresOn?: string | null;
        issuedOn?: string | null;
        lastUsedOn?: string | null;
        modifiedOn?: string | null;
        name?: string | null;
        notBefore?: string | null;
        policies?: {
            id: string;
            effect: "allow" | "deny";
            permissionGroups: {
                id: string;
                meta?: {
                    key?: string | null;
                    value?: string | null;
                } | null;
                name?: string | null;
            }[];
            resources: Record<string, unknown>;
        }[] | null;
        status?: "active" | "disabled" | "expired" | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListTokensResponse: Schema.Schema<ListTokensResponse>;
export type ListTokensError = DefaultErrors;
export declare const listTokens: API.PaginatedOperationMethod<ListTokensRequest, ListTokensResponse, ListTokensError, Credentials | HttpClient.HttpClient>;
export interface CreateTokenRequest {
    /** Token name. */
    name: string;
    /** List of access policies assigned to the token. */
    policies: {
        effect: "allow" | "deny";
        permissionGroups: {
            id: string;
            meta?: {
                key?: string;
                value?: string;
            };
        }[];
        resources: Record<string, unknown>;
    }[];
    condition?: {
        requestIp?: {
            in?: string[];
            notIn?: string[];
        };
    };
    /** 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 declare const CreateTokenRequest: Schema.Schema<CreateTokenRequest>;
export interface CreateTokenResponse {
    /** Token identifier tag. */
    id?: string | null;
    condition?: {
        requestIp?: {
            in?: string[] | null;
            notIn?: string[] | null;
        } | null;
    } | null;
    /** The expiration time on or after which the JWT MUST NOT be accepted for processing. */
    expiresOn?: string | null;
    /** The time on which the token was created. */
    issuedOn?: string | null;
    /** Last time the token was used. */
    lastUsedOn?: string | null;
    /** Last time the token was modified. */
    modifiedOn?: string | null;
    /** Token name. */
    name?: string | null;
    /** The time before which the token MUST NOT be accepted for processing. */
    notBefore?: string | null;
    /** List of access policies assigned to the token. */
    policies?: {
        id: string;
        effect: "allow" | "deny";
        permissionGroups: {
            id: string;
            meta?: {
                key?: string | null;
                value?: string | null;
            } | null;
            name?: string | null;
        }[];
        resources: Record<string, unknown>;
    }[] | null;
    /** Status of the token. */
    status?: "active" | "disabled" | "expired" | null;
    /** The token value. */
    value?: string | null;
}
export declare const CreateTokenResponse: Schema.Schema<CreateTokenResponse>;
export type CreateTokenError = DefaultErrors | InvalidRoute | InvalidTokenName | PermissionGroupNotFound;
export declare const createToken: API.OperationMethod<CreateTokenRequest, CreateTokenResponse, CreateTokenError, Credentials | HttpClient.HttpClient>;
export interface UpdateTokenRequest {
    tokenId: string;
    /** Token name. */
    name: string;
    /** List of access policies assigned to the token. */
    policies: {
        effect: "allow" | "deny";
        permissionGroups: {
            id: string;
            meta?: {
                key?: string;
                value?: string;
            };
        }[];
        resources: Record<string, unknown>;
    }[];
    condition?: {
        requestIp?: {
            in?: string[];
            notIn?: string[];
        };
    };
    /** 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?: "active" | "disabled" | "expired";
}
export declare const UpdateTokenRequest: Schema.Schema<UpdateTokenRequest>;
export interface UpdateTokenResponse {
    /** Token identifier tag. */
    id?: string | null;
    condition?: {
        requestIp?: {
            in?: string[] | null;
            notIn?: string[] | null;
        } | null;
    } | null;
    /** The expiration time on or after which the JWT MUST NOT be accepted for processing. */
    expiresOn?: string | null;
    /** The time on which the token was created. */
    issuedOn?: string | null;
    /** Last time the token was used. */
    lastUsedOn?: string | null;
    /** Last time the token was modified. */
    modifiedOn?: string | null;
    /** Token name. */
    name?: string | null;
    /** The time before which the token MUST NOT be accepted for processing. */
    notBefore?: string | null;
    /** List of access policies assigned to the token. */
    policies?: {
        id: string;
        effect: "allow" | "deny";
        permissionGroups: {
            id: string;
            meta?: {
                key?: string | null;
                value?: string | null;
            } | null;
            name?: string | null;
        }[];
        resources: Record<string, unknown>;
    }[] | null;
    /** Status of the token. */
    status?: "active" | "disabled" | "expired" | null;
}
export declare const UpdateTokenResponse: Schema.Schema<UpdateTokenResponse>;
export type UpdateTokenError = DefaultErrors | InvalidRoute | MethodNotAllowed | TokenNotFound | PermissionGroupNotFound;
export declare const updateToken: API.OperationMethod<UpdateTokenRequest, UpdateTokenResponse, UpdateTokenError, Credentials | HttpClient.HttpClient>;
export interface DeleteTokenRequest {
    tokenId: string;
}
export declare const DeleteTokenRequest: Schema.Schema<DeleteTokenRequest>;
export interface DeleteTokenResponse {
    /** Identifier */
    id: string;
}
export declare const DeleteTokenResponse: Schema.Schema<DeleteTokenResponse>;
export type DeleteTokenError = DefaultErrors | InvalidRoute | MethodNotAllowed | TokenNotFound;
export declare const deleteToken: API.OperationMethod<DeleteTokenRequest, DeleteTokenResponse, DeleteTokenError, Credentials | HttpClient.HttpClient>;
export interface VerifyTokenRequest {
}
export declare const VerifyTokenRequest: Schema.Schema<VerifyTokenRequest>;
export interface VerifyTokenResponse {
    /** Token identifier tag. */
    id: string;
    /** Status of the token. */
    status: "active" | "disabled" | "expired";
    /** The expiration time on or after which the JWT MUST NOT be accepted for processing. */
    expiresOn?: string | null;
    /** The time before which the token MUST NOT be accepted for processing. */
    notBefore?: string | null;
}
export declare const VerifyTokenResponse: Schema.Schema<VerifyTokenResponse>;
export type VerifyTokenError = DefaultErrors;
export declare const verifyToken: API.OperationMethod<VerifyTokenRequest, VerifyTokenResponse, VerifyTokenError, Credentials | HttpClient.HttpClient>;
export interface ListTokenPermissionGroupsRequest {
}
export declare const ListTokenPermissionGroupsRequest: Schema.Schema<ListTokenPermissionGroupsRequest>;
export interface ListTokenPermissionGroupsResponse {
    result: {
        id?: string | null;
        name?: string | null;
        scopes?: ("com.cloudflare.api.account" | "com.cloudflare.api.account.zone" | "com.cloudflare.api.user" | "com.cloudflare.edge.r2.bucket")[] | null;
    }[];
}
export declare const ListTokenPermissionGroupsResponse: Schema.Schema<ListTokenPermissionGroupsResponse>;
export type ListTokenPermissionGroupsError = DefaultErrors;
export declare const listTokenPermissionGroups: API.PaginatedOperationMethod<ListTokenPermissionGroupsRequest, ListTokenPermissionGroupsResponse, ListTokenPermissionGroupsError, Credentials | HttpClient.HttpClient>;
export interface PutTokenValueRequest {
    tokenId: string;
}
export declare const PutTokenValueRequest: Schema.Schema<PutTokenValueRequest>;
export type PutTokenValueResponse = string;
export declare const PutTokenValueResponse: Schema.Schema<PutTokenValueResponse>;
export type PutTokenValueError = DefaultErrors | InvalidRoute | TokenNotFound;
export declare const putTokenValue: API.OperationMethod<PutTokenValueRequest, PutTokenValueResponse, PutTokenValueError, Credentials | HttpClient.HttpClient>;
export interface GetUserRequest {
}
export declare const GetUserRequest: Schema.Schema<GetUserRequest>;
export interface GetUserResponse {
    /** Identifier of the user. */
    id?: string | null;
    /** Lists the betas that the user is participating in. */
    betas?: string[] | null;
    /** The country in which the user lives. */
    country?: string | null;
    /** User's first name */
    firstName?: string | null;
    /** Indicates whether user has any business zones */
    hasBusinessZones?: boolean | null;
    /** Indicates whether user has any enterprise zones */
    hasEnterpriseZones?: boolean | null;
    /** Indicates whether user has any pro zones */
    hasProZones?: boolean | null;
    /** User's last name */
    lastName?: string | null;
    organizations?: {
        id?: string | null;
        name?: string | null;
        permissions?: string[] | null;
        roles?: string[] | null;
        status?: "member" | "invited" | null;
    }[] | null;
    /** Indicates whether user has been suspended */
    suspended?: boolean | null;
    /** User's telephone number */
    telephone?: string | null;
    /** Indicates whether two-factor authentication is enabled for the user account. Does not apply to API authentication. */
    twoFactorAuthenticationEnabled?: boolean | null;
    /** Indicates whether two-factor authentication is required by one of the accounts that the user is a member of. */
    twoFactorAuthenticationLocked?: boolean | null;
    /** The zipcode or postal code where the user lives. */
    zipcode?: string | null;
}
export declare const GetUserResponse: Schema.Schema<GetUserResponse>;
export type GetUserError = DefaultErrors;
export declare const getUser: API.OperationMethod<GetUserRequest, GetUserResponse, GetUserError, Credentials | HttpClient.HttpClient>;
export interface PatchUserRequest {
    /** The country in which the user lives. */
    country?: string | null;
    /** User's first name */
    firstName?: string | null;
    /** User's last name */
    lastName?: string | null;
    /** User's telephone number */
    telephone?: string | null;
    /** The zipcode or postal code where the user lives. */
    zipcode?: string | null;
}
export declare const PatchUserRequest: Schema.Schema<PatchUserRequest>;
export interface PatchUserResponse {
    /** Identifier of the user. */
    id?: string | null;
    /** Lists the betas that the user is participating in. */
    betas?: string[] | null;
    /** The country in which the user lives. */
    country?: string | null;
    /** User's first name */
    firstName?: string | null;
    /** Indicates whether user has any business zones */
    hasBusinessZones?: boolean | null;
    /** Indicates whether user has any enterprise zones */
    hasEnterpriseZones?: boolean | null;
    /** Indicates whether user has any pro zones */
    hasProZones?: boolean | null;
    /** User's last name */
    lastName?: string | null;
    organizations?: {
        id?: string | null;
        name?: string | null;
        permissions?: string[] | null;
        roles?: string[] | null;
        status?: "member" | "invited" | null;
    }[] | null;
    /** Indicates whether user has been suspended */
    suspended?: boolean | null;
    /** User's telephone number */
    telephone?: string | null;
    /** Indicates whether two-factor authentication is enabled for the user account. Does not apply to API authentication. */
    twoFactorAuthenticationEnabled?: boolean | null;
    /** Indicates whether two-factor authentication is required by one of the accounts that the user is a member of. */
    twoFactorAuthenticationLocked?: boolean | null;
    /** The zipcode or postal code where the user lives. */
    zipcode?: string | null;
}
export declare const PatchUserResponse: Schema.Schema<PatchUserResponse>;
export type PatchUserError = DefaultErrors;
export declare const patchUser: API.OperationMethod<PatchUserRequest, PatchUserResponse, PatchUserError, Credentials | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=user.d.ts.map