export type ClientOptions = {
    baseUrl: 'https://demo.ziti.dev/edge/management/v1' | (string & {});
};
export type ApiAddress = {
    url?: string;
    version?: string;
};
export type ApiAddressArray = Array<ApiAddress>;
export type ApiAddressList = {
    [key: string]: ApiAddressArray;
};
export type ApiError = {
    args?: ApiErrorArgs;
    cause?: ApiErrorCause;
    causeMessage?: string;
    code?: string;
    data?: {
        [key: string]: unknown;
    };
    message?: string;
    requestId?: string;
};
export type ApiErrorArgs = {
    urlVars?: {
        [key: string]: string;
    };
};
export type ApiErrorCause = ApiFieldError & ApiError;
export type ApiErrorEnvelope = {
    error: ApiError;
    meta: Meta;
};
export type ApiFieldError = {
    field?: string;
    reason?: string;
    /**
     * can be any value - string, number, boolean, array or object
     */
    value?: unknown;
};
/**
 * An API Session object
 */
export type ApiSessionDetail = BaseEntity & {
    authQueries: AuthQueryList;
    authenticatorId: string;
    cachedLastActivityAt?: string;
    configTypes: Array<string>;
    identity: EntityRef;
    identityId: string;
    improperClientCertChain?: boolean;
    ipAddress: string;
    isCertExtendRequested?: boolean;
    isCertExtendable: boolean;
    isCertKeyRollRequested?: boolean;
    isMfaComplete: boolean;
    isMfaRequired: boolean;
    lastActivityAt?: string;
    token: string;
};
export type ApiSessionList = Array<ApiSessionDetail>;
export type ApiSessionPostureData = {
    endpointState?: PostureDataEndpointState;
    mfa: PostureDataMfa;
    sdkInfo?: SdkInfo;
};
export type ApiVersion = {
    apiBaseUrls?: Array<string>;
    path: string;
    version?: string;
};
/**
 * A set of strings used to loosely couple this resource to policies
 */
export type Attributes = Array<string> | null;
/**
 * A Auth Policy resource
 */
export type AuthPolicyCreate = {
    name: string;
    primary: AuthPolicyPrimary;
    secondary: AuthPolicySecondary;
    tags?: Tags;
};
/**
 * A Auth Policy resource
 */
export type AuthPolicyDetail = BaseEntity & {
    name: string;
    primary: AuthPolicyPrimary;
    secondary: AuthPolicySecondary;
};
/**
 * An array of Auth Policies resources
 */
export type AuthPolicyList = Array<AuthPolicyDetail>;
/**
 * A Auth Policy resource
 */
export type AuthPolicyPatch = {
    name?: string | null;
    primary?: AuthPolicyPrimaryPatch;
    secondary?: AuthPolicySecondaryPatch;
    tags?: Tags;
};
export type AuthPolicyPrimary = {
    cert: AuthPolicyPrimaryCert;
    extJwt: AuthPolicyPrimaryExtJwt;
    updb: AuthPolicyPrimaryUpdb;
};
export type AuthPolicyPrimaryCert = {
    allowExpiredCerts: boolean;
    allowed: boolean;
};
export type AuthPolicyPrimaryCertPatch = {
    allowExpiredCerts?: boolean | null;
    allowed?: boolean | null;
} | null;
export type AuthPolicyPrimaryExtJwt = {
    allowed: boolean;
    allowedSigners: Array<string>;
};
export type AuthPolicyPrimaryExtJwtPatch = {
    allowed?: boolean | null;
    allowedSigners?: Array<string> | null;
} | null;
export type AuthPolicyPrimaryPatch = {
    cert?: AuthPolicyPrimaryCertPatch;
    extJwt?: AuthPolicyPrimaryExtJwtPatch;
    updb?: AuthPolicyPrimaryUpdbPatch;
};
export type AuthPolicyPrimaryUpdb = {
    allowed: boolean;
    lockoutDurationMinutes: number;
    maxAttempts: number;
    minPasswordLength: number;
    requireMixedCase: boolean;
    requireNumberChar: boolean;
    requireSpecialChar: boolean;
};
export type AuthPolicyPrimaryUpdbPatch = {
    allowed?: boolean | null;
    lockoutDurationMinutes?: number | null;
    maxAttempts?: number | null;
    minPasswordLength?: number | null;
    requireMixedCase?: boolean | null;
    requireNumberChar?: boolean | null;
    requireSpecialChar?: boolean | null;
} | null;
export type AuthPolicySecondary = {
    requireExtJwtSigner?: string | null;
    requireTotp: boolean;
};
export type AuthPolicySecondaryPatch = {
    requireExtJwtSigner?: string | null;
    requireTotp?: boolean | null;
} | null;
export type AuthPolicyUpdate = AuthPolicyCreate;
export type AuthQueryDetail = {
    clientId?: string;
    format?: MfaFormats;
    httpMethod?: string;
    httpUrl?: string;
    id?: string;
    isTotpEnrolled?: boolean;
    maxLength?: number;
    minLength?: number;
    provider: MfaProviders;
    scopes?: Array<string>;
    typeId?: AuthQueryType;
};
export type AuthQueryList = Array<AuthQueryDetail>;
export type AuthQueryType = 'MFA' | 'TOTP' | 'EXT-JWT';
/**
 * A generic authenticate object meant for use with the /authenticate path. Required fields depend on authentication method.
 */
export type Authenticate = {
    configTypes?: ConfigTypes;
    envInfo?: EnvInfo;
    password?: Password;
    sdkInfo?: SdkInfo;
    username?: Username;
};
/**
 * Creates an authenticator for a specific identity which can be used for API authentication
 */
export type AuthenticatorCreate = {
    /**
     * The client certificate the identity will login with. Used only for method='cert'
     */
    certPem?: string;
    /**
     * The id of an existing identity that will be assigned this authenticator
     */
    identityId: string;
    /**
     * The type of authenticator to create; which will dictate which properties on this object are required.
     */
    method: string;
    /**
     * The password the identity will login with. Used only for method='updb'
     */
    password?: string;
    tags?: Tags;
    /**
     * The username that the identity will login with. Used only for method='updb'
     */
    username?: string;
};
/**
 * A singular authenticator resource
 */
export type AuthenticatorDetail = BaseEntity & {
    certPem?: string;
    extendRequestedAt?: string | null;
    fingerprint?: string;
    identity: EntityRef;
    identityId: string;
    isExtendRequested?: boolean;
    isIssuedByNetwork?: boolean;
    isKeyRollRequested?: boolean;
    lastAuthResolvedToRoot?: boolean;
    lastExtendRolledKeys?: boolean;
    method: string;
    username?: string;
};
/**
 * An array of authenticator resources
 */
export type AuthenticatorList = Array<AuthenticatorDetail>;
/**
 * All of the fields on an authenticator that may be updated
 */
export type AuthenticatorPatch = {
    password?: PasswordNullable;
    tags?: Tags;
    username?: UsernameNullable;
};
/**
 * All of the fields on an authenticator that may be updated
 */
export type AuthenticatorPatchWithCurrent = AuthenticatorPatch & {
    currentPassword: Password;
};
/**
 * All of the fields on an authenticator that will be updated
 */
export type AuthenticatorUpdate = {
    password: Password;
    tags?: Tags;
    username: Username;
};
/**
 * All of the fields on an authenticator that will be updated
 */
export type AuthenticatorUpdateWithCurrent = AuthenticatorUpdate & {
    currentPassword: Password;
};
/**
 * Fields shared by all Edge API entities
 */
export type BaseEntity = {
    _links: Links;
    createdAt: string;
    id: string;
    tags?: Tags;
    updatedAt: string;
};
/**
 * A create Certificate Authority (CA) object
 */
export type CaCreate = {
    certPem: string;
    externalIdClaim?: ExternalIdClaim;
    identityNameFormat?: string;
    identityRoles: Roles;
    isAuthEnabled: boolean;
    isAutoCaEnrollmentEnabled: boolean;
    isOttCaEnrollmentEnabled: boolean;
    name: string;
    tags?: Tags;
};
/**
 * A Certificate Authority (CA) resource
 */
export type CaDetail = BaseEntity & {
    certPem: string;
    externalIdClaim?: ExternalIdClaim;
    fingerprint: string;
    identityNameFormat: string;
    identityRoles: Roles;
    isAuthEnabled: boolean;
    isAutoCaEnrollmentEnabled: boolean;
    isOttCaEnrollmentEnabled: boolean;
    isVerified: boolean;
    name: string;
    verificationToken?: string;
};
/**
 * An array of Certificate Authority (CA) resources
 */
export type CaList = Array<CaDetail>;
export type CaPatch = {
    externalIdClaim?: ExternalIdClaimPatch;
    identityNameFormat?: string | null;
    identityRoles?: Roles;
    isAuthEnabled?: boolean | null;
    isAutoCaEnrollmentEnabled?: boolean | null;
    isOttCaEnrollmentEnabled?: boolean | null;
    name?: string | null;
    tags?: Tags;
};
export type CaUpdate = {
    externalIdClaim?: ExternalIdClaim;
    identityNameFormat: string;
    identityRoles: Roles;
    isAuthEnabled: boolean;
    isAutoCaEnrollmentEnabled: boolean;
    isOttCaEnrollmentEnabled: boolean;
    name: string;
    tags?: Tags;
};
export type Capabilities = 'OIDC_AUTH' | 'HA_CONTROLLER';
export type CommonEdgeRouterProperties = {
    appData?: Tags;
    cost: number | null;
    disabled: boolean;
    hostname: string;
    isOnline: boolean;
    name: string;
    noTraversal: boolean | null;
    supportedProtocols: {
        [key: string]: string;
    };
    syncStatus: string;
};
/**
 * A config create object
 */
export type ConfigCreate = {
    /**
     * The id of a config-type that the data section will match
     */
    configTypeId: string;
    /**
     * Data payload is defined by the schema of the config-type defined in the type parameter
     */
    data: {
        [key: string]: unknown;
    };
    name: string;
    tags?: Tags;
};
/**
 * A config resource
 */
export type ConfigDetail = BaseEntity & {
    configType: EntityRef;
    configTypeId: string;
    /**
     * The data section of a config is based on the schema of its type
     */
    data: {
        [key: string]: unknown;
    };
    name: string;
};
/**
 * An array of config resources
 */
export type ConfigList = Array<ConfigDetail>;
/**
 * A config patch object
 */
export type ConfigPatch = {
    /**
     * Data payload is defined by the schema of the config-type defined in the type parameter
     */
    data?: {
        [key: string]: unknown;
    };
    name?: string;
    tags?: Tags;
};
/**
 * A config-type create object
 */
export type ConfigTypeCreate = {
    name: string;
    /**
     * A JSON schema to enforce configuration against
     */
    schema?: {
        [key: string]: unknown;
    };
    tags?: Tags;
};
/**
 * A config-type resource
 */
export type ConfigTypeDetail = BaseEntity & {
    name: string;
    /**
     * A JSON schema to enforce configuration against
     */
    schema: {
        [key: string]: unknown;
    };
};
/**
 * An array of config-type resources
 */
export type ConfigTypeList = Array<ConfigTypeDetail>;
/**
 * A config-type patch object
 */
export type ConfigTypePatch = {
    name?: string;
    /**
     * A JSON schema to enforce configuration against
     */
    schema?: {
        [key: string]: unknown;
    };
    tags?: Tags;
};
/**
 * A config-type update object
 */
export type ConfigTypeUpdate = {
    name: string;
    /**
     * A JSON schema to enforce configuration against
     */
    schema?: {
        [key: string]: unknown;
    };
    tags?: Tags;
};
/**
 * Specific configuration types that should be returned
 */
export type ConfigTypes = Array<string>;
/**
 * A config update object
 */
export type ConfigUpdate = {
    /**
     * Data payload is defined by the schema of the config-type defined in the type parameter
     */
    data: {
        [key: string]: unknown;
    };
    name: string;
    tags?: Tags;
};
/**
 * A controller resource
 */
export type ControllerDetail = BaseEntity & {
    apiAddresses?: ApiAddressList;
    certPem: string;
    ctrlAddress?: string | null;
    fingerprint: string;
    isOnline: boolean;
    lastJoinedAt: string;
    name: string;
};
export type ControllerSettingCreate = ControllerSettings & {
    controllerId: string;
    tags?: Tags;
};
export type ControllerSettingDetail = BaseEntity & ControllerSettings;
export type ControllerSettingEffective = BaseEntity & {
    effective?: ControllerSettings;
    instance?: ControllerSettings;
};
export type ControllerSettingPatch = ControllerSettings & {
    tags?: Tags;
};
export type ControllerSettingUpdate = ControllerSettings & {
    tags?: Tags;
};
export type ControllerSettings = {
    oidc?: {
        postLogoutUris?: Array<string>;
        redirectUris?: Array<string>;
    };
};
export type ControllerSettingsList = Array<unknown>;
/**
 * An array of controller resources
 */
export type ControllersList = Array<ControllerDetail>;
export type CreateEnvelope = {
    data?: CreateLocation;
    meta?: Meta;
};
export type CreateLocation = {
    _links?: Links;
    id?: string;
};
/**
 * An API Session object for the current API session
 */
export type CurrentApiSessionDetail = ApiSessionDetail & {
    expirationSeconds: number;
    expiresAt: string;
};
export type CurrentApiSessionDetailEnvelope = {
    data: CurrentApiSessionDetail;
    meta: Meta;
};
export type CurrentIdentityDetailEnvelope = {
    data: IdentityDetail;
    meta: Meta;
};
export type DataIntegrityCheckDetail = {
    description: string;
    fixed: boolean;
};
export type DataIntegrityCheckDetailList = Array<DataIntegrityCheckDetail>;
export type DataIntegrityCheckDetails = {
    endTime: string;
    error: string;
    fixingErrors: boolean;
    inProgress: boolean;
    results: DataIntegrityCheckDetailList;
    startTime: string;
    tooManyErrors: boolean;
};
export type DataIntegrityCheckResultEnvelope = {
    data: DataIntegrityCheckDetails;
    meta: Meta;
};
export type DetailApiSessionEnvelope = {
    data: ApiSessionDetail;
    meta: Meta;
};
export type DetailAuthPolicyEnvelope = {
    data: AuthPolicyDetail;
    meta: Meta;
};
export type DetailAuthenticatorEnvelope = {
    data: AuthenticatorDetail;
    meta: Meta;
};
export type DetailCaEnvelope = {
    data: CaDetail;
    meta: Meta;
};
export type DetailConfigEnvelope = {
    data: ConfigDetail;
    meta: Meta;
};
export type DetailConfigTypeEnvelope = {
    data: ConfigTypeDetail;
    meta: Meta;
};
export type DetailControllerSettingEffectiveEnvelope = {
    data: ControllerSettingEffective;
    meta: Meta;
};
export type DetailControllerSettingEnvelope = {
    data: ControllerSettingDetail;
    meta: Meta;
};
export type DetailEdgeRouterPolicyEnvelope = {
    data: EdgeRouterPolicyDetail;
    meta: Meta;
};
export type DetailEnrollmentEnvelope = {
    data: EnrollmentDetail;
    meta: Meta;
};
export type DetailExternalJwtSignerEnvelope = {
    data: ExternalJwtSignerDetail;
    meta: Meta;
};
export type DetailIdentityEnvelope = {
    data: IdentityDetail;
    meta: Meta;
};
export type DetailIdentityTypeEnvelope = {
    data: IdentityTypeDetail;
    meta: Meta;
};
export type DetailMfa = BaseEntity & {
    isVerified: boolean;
    /**
     * Not provided if MFA verification has been completed
     */
    provisioningUrl?: string;
    /**
     * Not provided if MFA verification has been completed
     */
    recoveryCodes?: Array<string>;
};
export type DetailMfaEnvelope = {
    data: DetailMfa;
    meta: Meta;
};
export type DetailMfaRecoveryCodes = BaseEntity & {
    recoveryCodes: Array<string>;
};
export type DetailMfaRecoveryCodesEnvelope = {
    data: DetailMfaRecoveryCodes;
    meta: Meta;
};
export type DetailPostureCheckEnvelope = {
    data: PostureCheckDetail;
    meta: Meta;
};
export type DetailPostureCheckTypeEnvelope = {
    data: PostureCheckTypeDetail;
    meta: Meta;
};
export type DetailRouterEnvelope = {
    data: RouterDetail;
    meta: Meta;
};
export type DetailServiceEdgePolicyEnvelope = {
    data: ServiceEdgeRouterPolicyDetail;
    meta: Meta;
};
export type DetailServiceEnvelope = {
    data: ServiceDetail;
    meta: Meta;
};
export type DetailServicePolicyEnvelop = {
    data: ServicePolicyDetail;
    meta: Meta;
};
export type DetailSessionManagementEnvelope = {
    data: SessionManagementDetail;
    meta: Meta;
};
export type DetailSessionRoutePathEnvelope = {
    data: SessionRoutePathDetail;
    meta: Meta;
};
export type DetailSpecBodyEnvelope = {
    data: SpecBodyDetail;
    meta: Meta;
};
export type DetailSpecEnvelope = {
    data: SpecDetail;
    meta: Meta;
};
export type DetailTerminatorEnvelope = {
    data: TerminatorDetail;
    meta: Meta;
};
export type DetailedEdgeRouterEnvelope = {
    data: EdgeRouterDetail;
    meta: Meta;
};
export type DialBind = 'Dial' | 'Bind' | 'Invalid';
export type DialBindArray = Array<DialBind>;
export type DisableParams = {
    durationMinutes: number;
};
/**
 * An edge router create object
 */
export type EdgeRouterCreate = {
    appData?: Tags;
    cost?: number | null;
    disabled?: boolean | null;
    isTunnelerEnabled?: boolean;
    name: string;
    noTraversal?: boolean | null;
    roleAttributes?: Attributes;
    tags?: Tags;
};
/**
 * A detail edge router resource
 */
export type EdgeRouterDetail = BaseEntity & CommonEdgeRouterProperties & {
    certPem?: string | null;
    enrollmentCreatedAt?: string | null;
    enrollmentExpiresAt?: string | null;
    enrollmentJwt?: string | null;
    enrollmentToken?: string | null;
    fingerprint?: string;
    interfaces?: Array<Interface>;
    isTunnelerEnabled: boolean;
    isVerified: boolean;
    roleAttributes: Attributes;
    unverifiedCertPem?: string | null;
    unverifiedFingerprint?: string | null;
    versionInfo?: VersionInfo;
};
/**
 * A list of edge router resources
 */
export type EdgeRouterList = Array<EdgeRouterDetail>;
/**
 * An edge router patch object
 */
export type EdgeRouterPatch = {
    appData?: Tags;
    cost?: number | null;
    disabled?: boolean | null;
    isTunnelerEnabled?: boolean;
    name?: string | null;
    noTraversal?: boolean | null;
    roleAttributes?: Attributes;
    tags?: Tags;
};
export type EdgeRouterPolicyCreate = {
    edgeRouterRoles?: Roles;
    identityRoles?: Roles;
    name: string;
    semantic: Semantic;
    tags?: Tags;
};
export type EdgeRouterPolicyDetail = BaseEntity & {
    edgeRouterRoles: Roles;
    edgeRouterRolesDisplay: NamedRoles;
    identityRoles: Roles;
    identityRolesDisplay: NamedRoles;
    isSystem: boolean;
    name: string;
    semantic: Semantic;
};
export type EdgeRouterPolicyList = Array<EdgeRouterPolicyDetail>;
export type EdgeRouterPolicyPatch = {
    edgeRouterRoles?: Roles;
    identityRoles?: Roles;
    name?: string;
    semantic?: Semantic;
    tags?: Tags;
};
export type EdgeRouterPolicyUpdate = {
    edgeRouterRoles?: Roles;
    identityRoles?: Roles;
    name: string;
    semantic: Semantic;
    tags?: Tags;
};
/**
 * An edge router update object
 */
export type EdgeRouterUpdate = {
    appData?: Tags;
    cost?: number | null;
    disabled?: boolean | null;
    isTunnelerEnabled?: boolean;
    name: string;
    noTraversal?: boolean | null;
    roleAttributes?: Attributes;
    tags?: Tags;
};
export type Empty = {
    data: {
        [key: string]: unknown;
    };
    meta: Meta;
};
export type EnrollmentCreate = {
    caId?: string | null;
    expiresAt: string;
    identityId: string;
    method: 'ott' | 'ottca' | 'updb';
    username?: string | null;
};
/**
 * An enrollment object. Enrollments are tied to identities and potentially a CA. Depending on the
 * method, different fields are utilized. For example ottca enrollments use the `ca` field and updb enrollments
 * use the username field, but not vice versa.
 *
 */
export type EnrollmentDetail = BaseEntity & {
    caId?: string | null;
    edgeRouter?: EntityRef;
    edgeRouterId?: string;
    expiresAt: string;
    identity?: EntityRef;
    identityId?: string;
    jwt?: string;
    method: string;
    token: string;
    transitRouter?: EntityRef;
    transitRouterId?: string;
    username?: string;
};
/**
 * An array of enrollment resources
 */
export type EnrollmentList = Array<EnrollmentDetail>;
export type EnrollmentRefresh = {
    expiresAt: string;
};
/**
 * A reference to another resource and links to interact with it
 */
export type EntityRef = {
    _links?: Links;
    entity?: string;
    id?: string;
    name?: string;
};
/**
 * Environment information an authenticating client may provide
 */
export type EnvInfo = {
    arch?: string;
    domain?: string;
    hostname?: string;
    os?: string;
    osRelease?: string;
    osVersion?: string;
};
export type ExternalIdClaim = {
    index: number | null;
    location: 'COMMON_NAME' | 'SAN_URI' | 'SAN_EMAIL';
    matcher: 'ALL' | 'PREFIX' | 'SUFFIX' | 'SCHEME';
    matcherCriteria: string | null;
    parser: 'NONE' | 'SPLIT';
    parserCriteria: string | null;
};
export type ExternalIdClaimPatch = {
    index?: number | null;
    location?: 'COMMON_NAME' | 'SAN_URI' | 'SAN_EMAIL';
    matcher?: 'ALL' | 'PREFIX' | 'SUFFIX' | 'SCHEME';
    matcherCriteria?: string | null;
    parser?: 'NONE' | 'SPLIT';
    parserCriteria?: string | null;
};
/**
 * A create Certificate Authority (CA) object
 */
export type ExternalJwtSignerCreate = {
    audience: string | null;
    certPem?: string | null;
    claimsProperty?: string | null;
    clientId?: string | null;
    enabled: boolean;
    enrollAttributeClaimsSelector?: string;
    enrollAuthPolicyId?: string;
    enrollNameClaimsSelector?: string;
    enrollToCertEnabled?: boolean;
    enrollToTokenEnabled?: boolean;
    externalAuthUrl?: string | null;
    issuer: string;
    jwksEndpoint?: string | null;
    kid?: string | null;
    name: string;
    scopes?: Array<string> | null;
    tags?: Tags;
    targetToken?: TargetToken;
    useExternalId?: boolean | null;
};
/**
 * A External JWT Signer resource
 */
export type ExternalJwtSignerDetail = BaseEntity & {
    audience: string;
    certPem: string | null;
    claimsProperty: string;
    clientId: string;
    commonName: string;
    enabled: boolean;
    enrollAttributeClaimsSelector?: string;
    enrollAuthPolicyId?: string;
    enrollNameClaimsSelector?: string;
    enrollToCertEnabled?: boolean;
    enrollToTokenEnabled?: boolean;
    externalAuthUrl: string;
    fingerprint: string;
    issuer: string;
    jwksEndpoint: string | null;
    kid: string;
    name: string;
    notAfter: string;
    notBefore: string;
    scopes: Array<string>;
    targetToken: TargetToken;
    useExternalId: boolean;
};
/**
 * An array of External JWT Signers resources
 */
export type ExternalJwtSignerList = Array<ExternalJwtSignerDetail>;
export type ExternalJwtSignerPatch = {
    audience?: string | null;
    certPem?: string | null;
    claimsProperty?: string | null;
    clientId?: string | null;
    enabled?: boolean | null;
    enrollAttributeClaimsSelector?: string | null;
    enrollAuthPolicyId?: string | null;
    enrollNameClaimsSelector?: string | null;
    enrollToCertEnabled?: boolean | null;
    enrollToTokenEnabled?: boolean | null;
    externalAuthUrl?: string | null;
    issuer?: string | null;
    jwksEndpoint?: string | null;
    kid?: string | null;
    name?: string | null;
    scopes?: Array<string>;
    tags?: Tags;
    targetToken?: TargetToken;
    useExternalId?: boolean | null;
};
export type ExternalJwtSignerUpdate = {
    audience: string | null;
    certPem?: string | null;
    claimsProperty?: string | null;
    clientId?: string | null;
    enabled: boolean;
    enrollAttributeClaimsSelector?: string | null;
    enrollAuthPolicyId?: string | null;
    enrollNameClaimsSelector?: string | null;
    enrollToCertEnabled?: boolean | null;
    enrollToTokenEnabled?: boolean | null;
    externalAuthUrl?: string | null;
    issuer: string;
    jwksEndpoint?: string | null;
    kid?: string | null;
    name: string;
    scopes?: Array<string> | null;
    tags?: Tags;
    targetToken?: TargetToken;
    useExternalId?: boolean | null;
};
export type FailedServiceRequest = {
    apiSessionId?: string;
    policyFailures?: Array<PolicyFailure>;
    serviceId?: string;
    serviceName?: string;
    sessionType?: DialBind;
    when?: string;
};
export type FailedServiceRequestEnvelope = {
    data: FailedServiceRequestList;
    meta: Meta;
};
export type FailedServiceRequestList = Array<FailedServiceRequest>;
export type GetIdentityPolicyAdviceEnvelope = {
    data: PolicyAdvice;
    meta: Meta;
};
export type IdentityAuthenticators = {
    cert?: {
        fingerprint?: string;
        id?: string;
    };
    updb?: {
        id?: string;
        username?: string;
    };
};
/**
 * An identity to create
 */
export type IdentityCreate = {
    appData?: Tags;
    authPolicyId?: string | null;
    defaultHostingCost?: TerminatorCost;
    defaultHostingPrecedence?: TerminatorPrecedence;
    enrollment?: {
        ott?: boolean;
        ottca?: string;
        updb?: string;
    };
    externalId?: string | null;
    isAdmin: boolean;
    name: string;
    permissions?: Permissions;
    roleAttributes?: Attributes;
    serviceHostingCosts?: TerminatorCostMap;
    serviceHostingPrecedences?: TerminatorPrecedenceMap;
    tags?: Tags;
    type: IdentityType;
};
/**
 * Detail of a specific identity
 */
export type IdentityDetail = BaseEntity & {
    appData?: Tags;
    authPolicy: EntityRef;
    authPolicyId: string;
    authenticators: IdentityAuthenticators;
    defaultHostingCost: TerminatorCost;
    defaultHostingPrecedence?: TerminatorPrecedence;
    disabled: boolean;
    disabledAt?: string | null;
    disabledUntil?: string | null;
    edgeRouterConnectionStatus: 'online' | 'offline' | 'unknown';
    enrollment: IdentityEnrollments;
    envInfo: EnvInfo;
    externalId: string | null;
    hasApiSession: boolean;
    hasEdgeRouterConnection: boolean;
    interfaces?: Array<Interface>;
    isAdmin: boolean;
    isDefaultAdmin: boolean;
    isMfaEnabled: boolean;
    name: string;
    permissions: Permissions;
    roleAttributes: Attributes;
    sdkInfo: SdkInfo;
    serviceHostingCosts: TerminatorCostMap;
    serviceHostingPrecedences: TerminatorPrecedenceMap;
    type: EntityRef;
    typeId: string;
};
export type IdentityEnrollments = {
    ott?: {
        expiresAt?: string;
        id?: string;
        jwt?: string;
        token?: string;
    };
    ottca?: {
        ca?: EntityRef;
        caId?: string;
        expiresAt?: string;
        id?: string;
        jwt?: string;
        token?: string;
    };
    updb?: {
        expiresAt?: string;
        id?: string;
        jwt?: string;
        token?: string;
    };
};
export type IdentityExtendCerts = {
    /**
     * A PEM encoded set of CA certificates
     */
    ca?: string;
    /**
     * A PEM encoded client certificate
     */
    clientCert?: string;
};
export type IdentityExtendEnrollmentEnvelope = {
    data?: IdentityExtendCerts;
    meta?: Meta;
};
export type IdentityExtendEnrollmentRequest = {
    clientCertCsr: string;
};
export type IdentityExtendValidateEnrollmentRequest = {
    /**
     * A PEM encoded client certificate previously returned after an extension request
     */
    clientCert: string;
};
/**
 * A list of identities
 */
export type IdentityList = Array<IdentityDetail>;
export type IdentityPatch = {
    appData?: Tags;
    authPolicyId?: string | null;
    defaultHostingCost?: TerminatorCost;
    defaultHostingPrecedence?: TerminatorPrecedence;
    externalId?: string | null;
    isAdmin?: boolean | null;
    name?: string | null;
    permissions?: Permissions;
    roleAttributes?: Attributes;
    serviceHostingCosts?: TerminatorCostMap;
    serviceHostingPrecedences?: TerminatorPrecedenceMap;
    tags?: Tags;
    type?: IdentityType;
};
export type IdentityType = 'User' | 'Device' | 'Service' | 'Router' | 'Default';
export type IdentityTypeDetail = BaseEntity & {
    name?: string;
};
export type IdentityTypeList = Array<IdentityTypeDetail>;
export type IdentityUpdate = {
    appData?: Tags;
    authPolicyId?: string | null;
    defaultHostingCost?: TerminatorCost;
    defaultHostingPrecedence?: TerminatorPrecedence;
    externalId?: string | null;
    isAdmin: boolean;
    name: string;
    permissions?: Permissions;
    roleAttributes?: Attributes;
    serviceHostingCosts?: TerminatorCostMap;
    serviceHostingPrecedences?: TerminatorPrecedenceMap;
    tags?: Tags;
    type: IdentityType;
};
/**
 * A resource describing a network interface
 */
export type Interface = {
    addresses?: Array<string>;
    hardwareAddress: string;
    index: number;
    isBroadcast: boolean;
    isLoopback: boolean;
    isMulticast: boolean;
    isRunning: boolean;
    isUp: boolean;
    mtu: number;
    name: string;
};
/**
 * A link to another resource
 */
export type Link = {
    comment?: string;
    href: string;
    method?: string;
};
/**
 * A map of named links
 */
export type Links = {
    [key: string]: Link;
};
export type ListApiSessionsEnvelope = {
    data: ApiSessionList;
    meta: Meta;
};
export type ListAuthPoliciesEnvelope = {
    data: AuthPolicyList;
    meta: Meta;
};
export type ListAuthenticatorsEnvelope = {
    data?: AuthenticatorList;
    meta?: Meta;
};
export type ListCasEnvelope = {
    data: CaList;
    meta: Meta;
};
export type ListConfigTypesEnvelope = {
    data: ConfigTypeList;
    meta: Meta;
};
export type ListConfigsEnvelope = {
    data: ConfigList;
    meta: Meta;
};
export type ListControllerSettingEnvelope = {
    data: ControllerSettingsList;
    meta: Meta;
};
export type ListControllersEnvelope = {
    data: ControllersList;
    meta: Meta;
};
export type ListEdgeRouterPoliciesEnvelope = {
    data: EdgeRouterPolicyList;
    meta: Meta;
};
export type ListEdgeRoutersEnvelope = {
    data: EdgeRouterList;
    meta: Meta;
};
export type ListEnrollmentsEnvelope = {
    data: EnrollmentList;
    meta: Meta;
};
export type ListEnumeratedCapabilitiesEnvelope = {
    data: Array<Capabilities>;
    meta: Meta;
};
export type ListExternalJwtSignersEnvelope = {
    data: ExternalJwtSignerList;
    meta: Meta;
};
export type ListIdentitiesEnvelope = {
    data: IdentityList;
    meta: Meta;
};
export type ListIdentityTypesEnvelope = {
    data: IdentityTypeList;
    meta: Meta;
};
export type ListNetworkJwtsEnvelope = {
    data: NetworkJwtList;
    meta: Meta;
};
export type ListPostureCheckEnvelope = {
    data: Array<PostureCheckDetail>;
    meta: Meta;
};
export type ListPostureCheckTypesEnvelope = {
    data: PostureCheckTypeList;
    meta: Meta;
};
export type ListRoleAttributesEnvelope = {
    data: RoleAttributesList;
    meta: Meta;
};
export type ListRoutersEnvelope = {
    data: RouterList;
    meta: Meta;
};
export type ListServiceConfigsEnvelope = {
    data: ServiceConfigList;
    meta: Meta;
};
export type ListServiceEdgeRouterPoliciesEnvelope = {
    data: ServiceEdgeRouterPolicyList;
    meta: Meta;
};
export type ListServicePoliciesEnvelope = {
    data: ServicePolicyList;
    meta: Meta;
};
export type ListServicesEnvelope = {
    data: ServiceList;
    meta: Meta;
};
export type ListSessionsManagementEnvelope = {
    data: SessionManagementList;
    meta: Meta;
};
export type ListSpecsEnvelope = {
    data: SpecList;
    meta: Meta;
};
export type ListSummaryCounts = {
    [key: string]: number;
};
export type ListSummaryCountsEnvelope = {
    data: ListSummaryCounts;
    meta: Meta;
};
export type ListTerminatorsEnvelope = {
    data: TerminatorList;
    meta: Meta;
};
export type ListVersionEnvelope = {
    data: Version;
    meta: Meta;
};
export type Meta = {
    apiEnrollmentVersion?: string;
    apiVersion?: string;
    filterableFields?: Array<string>;
    pagination?: Pagination;
};
export type MfaCode = {
    code: string;
};
export type MfaFormats = 'numeric' | 'alpha' | 'alphaNumeric';
export type MfaProviders = 'ziti' | 'url';
export type NamedRole = {
    name?: string;
    role?: string;
};
export type NamedRoles = Array<NamedRole>;
/**
 * A network JWT
 */
export type NetworkJwt = {
    name: string;
    token: string;
};
/**
 * An array of network JWTs
 */
export type NetworkJwtList = Array<NetworkJwt>;
export type OperatingSystem = {
    type: OsType;
    versions: Array<string>;
};
export type OsType = 'Windows' | 'WindowsServer' | 'Android' | 'iOS' | 'Linux' | 'macOS';
export type Pagination = {
    limit: number;
    offset: number;
    totalCount: number;
};
export type Password = string;
export type PasswordNullable = string | null;
/**
 * A set of strings used to define which types of resources this resource can acccess
 */
export type Permissions = Array<'admin_readonly' | 'auth-policy' | 'auth-policy.read' | 'auth-policy.create' | 'auth-policy.update' | 'auth-policy.delete' | 'ca' | 'ca.read' | 'ca.create' | 'ca.update' | 'ca.delete' | 'config' | 'config.read' | 'config.create' | 'config.update' | 'config.delete' | 'config-type' | 'config-type.read' | 'config-type.create' | 'config-type.update' | 'config-type.delete' | 'edge-router-policy' | 'edge-router-policy.read' | 'edge-router-policy.create' | 'edge-router-policy.update' | 'edge-router-policy.delete' | 'enrollment' | 'enrollment.read' | 'enrollment.create' | 'enrollment.update' | 'enrollment.delete' | 'external-jwt-signer' | 'external-jwt-signer.read' | 'external-jwt-signer.create' | 'external-jwt-signer.update' | 'external-jwt-signer.delete' | 'identity' | 'identity.read' | 'identity.create' | 'identity.update' | 'identity.delete' | 'ops' | 'ops.read' | 'ops.update' | 'ops.delete' | 'posture-check' | 'posture-check.read' | 'posture-check.create' | 'posture-check.update' | 'posture-check.delete' | 'router' | 'router.read' | 'router.create' | 'router.update' | 'router.delete' | 'service' | 'service.read' | 'service.create' | 'service.update' | 'service.delete' | 'service-edge-router-policy' | 'service-edge-router-policy.read' | 'service-edge-router-policy.create' | 'service-edge-router-policy.update' | 'service-edge-router-policy.delete' | 'service-policy' | 'service-policy.read' | 'service-policy.create' | 'service-policy.update' | 'service-policy.delete' | 'terminator' | 'terminator.read' | 'terminator.create' | 'terminator.update' | 'terminator.delete'> | null;
export type PolicyAdvice = {
    commonRouters?: Array<RouterEntityRef>;
    identity?: EntityRef;
    identityId?: string;
    identityRouterCount?: number;
    isBindAllowed?: boolean;
    isDialAllowed?: boolean;
    service?: EntityRef;
    serviceId?: string;
    serviceRouterCount?: number;
};
export type PolicyFailure = {
    checks?: Array<PostureCheckFailure>;
    policyId?: string;
    policyName?: string;
};
export type PostureCheckCreate = {
    name: string;
    roleAttributes?: Attributes;
    tags?: Tags;
    typeId: PostureCheckType;
};
export type PostureCheckDetail = {
    _links: Links;
    createdAt: string;
    id: string;
    name: string;
    roleAttributes: Attributes;
    tags: Tags;
    typeId: string;
    updatedAt: string;
    version: number;
};
export type PostureCheckDomainCreate = PostureCheckCreate & {
    typeId: 'postureCheckDomainCreate';
} & {
    domains: Array<string>;
};
export type PostureCheckDomainDetail = PostureCheckDetail & {
    typeId: 'postureCheckDomainDetail';
} & {
    domains: Array<string>;
};
export type PostureCheckDomainPatch = PostureCheckPatch & {
    typeId: 'postureCheckDomainPatch';
} & {
    domains?: Array<string>;
};
export type PostureCheckDomainUpdate = PostureCheckUpdate & {
    typeId?: 'postureCheckDomainUpdate';
} & {
    domains: Array<string>;
};
export type PostureCheckFailure = {
    postureCheckId: string;
    postureCheckName: string;
    postureCheckType: string;
};
export type PostureCheckFailureDomain = PostureCheckFailure & {
    postureCheckType: 'postureCheckFailureDomain';
} & {
    actualValue: string;
    expectedValue: Array<string>;
};
export type PostureCheckFailureMacAddress = PostureCheckFailure & {
    postureCheckType: 'postureCheckFailureMacAddress';
} & {
    actualValue: Array<string>;
    expectedValue: Array<string>;
};
export type PostureCheckFailureMfa = PostureCheckFailure & {
    postureCheckType: 'postureCheckFailureMfa';
} & {
    actualValue: PostureChecksFailureMfaValues;
    criteria: PostureChecksFailureMfaCriteria;
    expectedValue: PostureChecksFailureMfaValues;
};
export type PostureCheckFailureOperatingSystem = PostureCheckFailure & {
    postureCheckType: 'postureCheckFailureOperatingSystem';
} & {
    actualValue: PostureCheckFailureOperatingSystemActual;
    expectedValue: Array<OperatingSystem>;
};
export type PostureCheckFailureOperatingSystemActual = {
    type: string;
    version: string;
};
export type PostureCheckFailureProcess = PostureCheckFailure & {
    postureCheckType: 'postureCheckFailureProcess';
} & {
    actualValue: PostureCheckFailureProcessActual;
    expectedValue: Process;
};
export type PostureCheckFailureProcessActual = {
    hash: string;
    isRunning: boolean;
    osType?: OsType;
    path?: string;
    signerFingerprints: Array<string>;
};
export type PostureCheckFailureProcessMulti = PostureCheckFailure & {
    postureCheckType: 'postureCheckFailureProcessMulti';
} & {
    actualValue: Array<PostureCheckFailureProcessActual>;
    expectedValue: Array<ProcessMulti>;
    semantic: Semantic;
};
export type PostureCheckMacAddressCreate = PostureCheckCreate & {
    typeId: 'postureCheckMacAddressCreate';
} & {
    macAddresses: Array<string>;
};
export type PostureCheckMacAddressDetail = PostureCheckDetail & {
    typeId: 'postureCheckMacAddressDetail';
} & {
    macAddresses: Array<string>;
};
export type PostureCheckMacAddressPatch = PostureCheckPatch & {
    typeId: 'postureCheckMacAddressPatch';
} & {
    macAddresses?: Array<string>;
};
export type PostureCheckMacAddressUpdate = PostureCheckUpdate & {
    typeId?: 'postureCheckMacAddressUpdate';
} & {
    macAddresses: Array<string>;
};
export type PostureCheckMfaCreate = PostureCheckCreate & {
    typeId: 'postureCheckMfaCreate';
} & PostureCheckMfaProperties;
export type PostureCheckMfaDetail = PostureCheckDetail & {
    typeId: 'postureCheckMfaDetail';
} & PostureCheckMfaProperties;
export type PostureCheckMfaPatch = PostureCheckPatch & {
    typeId: 'postureCheckMfaPatch';
} & PostureCheckMfaPropertiesPatch;
export type PostureCheckMfaProperties = {
    ignoreLegacyEndpoints?: boolean;
    promptOnUnlock?: boolean;
    promptOnWake?: boolean;
    timeoutSeconds?: number;
};
export type PostureCheckMfaPropertiesPatch = {
    ignoreLegacyEndpoints?: boolean | null;
    promptOnUnlock?: boolean | null;
    promptOnWake?: boolean | null;
    timeoutSeconds?: number | null;
};
export type PostureCheckMfaUpdate = PostureCheckUpdate & {
    typeId?: 'postureCheckMfaUpdate';
} & PostureCheckMfaProperties;
export type PostureCheckOperatingSystemCreate = PostureCheckCreate & {
    typeId: 'postureCheckOperatingSystemCreate';
} & {
    operatingSystems: Array<OperatingSystem>;
};
export type PostureCheckOperatingSystemDetail = PostureCheckDetail & {
    typeId: 'postureCheckOperatingSystemDetail';
} & {
    operatingSystems: Array<OperatingSystem>;
};
export type PostureCheckOperatingSystemPatch = PostureCheckPatch & {
    typeId: 'postureCheckOperatingSystemPatch';
} & {
    operatingSystems?: Array<OperatingSystem>;
};
export type PostureCheckOperatingSystemUpdate = PostureCheckUpdate & {
    typeId?: 'postureCheckOperatingSystemUpdate';
} & {
    operatingSystems: Array<OperatingSystem>;
};
export type PostureCheckPatch = {
    name?: string;
    roleAttributes?: Attributes;
    tags?: Tags;
    typeId: PostureCheckType;
};
export type PostureCheckProcessCreate = PostureCheckCreate & {
    typeId: 'postureCheckProcessCreate';
} & {
    process: Process;
};
export type PostureCheckProcessDetail = PostureCheckDetail & {
    typeId: 'postureCheckProcessDetail';
} & {
    process: Process;
};
export type PostureCheckProcessMultiCreate = PostureCheckCreate & {
    typeId: 'postureCheckProcessMultiCreate';
} & {
    processes: Array<ProcessMulti>;
    semantic: Semantic;
};
export type PostureCheckProcessMultiDetail = PostureCheckDetail & {
    typeId: 'postureCheckProcessMultiDetail';
} & {
    processes: Array<ProcessMulti>;
    semantic: Semantic;
};
export type PostureCheckProcessMultiPatch = PostureCheckPatch & {
    typeId: 'postureCheckProcessMultiPatch';
} & {
    processes?: Array<ProcessMulti>;
    semantic?: Semantic;
};
export type PostureCheckProcessMultiUpdate = PostureCheckUpdate & {
    typeId?: 'postureCheckProcessMultiUpdate';
} & {
    processes: Array<ProcessMulti>;
    semantic: Semantic;
};
export type PostureCheckProcessPatch = PostureCheckPatch & {
    typeId: 'postureCheckProcessPatch';
} & {
    process?: Process;
};
export type PostureCheckProcessUpdate = PostureCheckUpdate & {
    typeId?: 'postureCheckProcessUpdate';
} & {
    process: Process;
};
export type PostureCheckType = 'OS' | 'PROCESS' | 'DOMAIN' | 'MAC' | 'MFA' | 'PROCESS_MULTI';
export type PostureCheckTypeDetail = BaseEntity & {
    name: string;
    operatingSystems: Array<OperatingSystem>;
    version: string;
};
export type PostureCheckTypeList = Array<PostureCheckTypeDetail>;
export type PostureCheckUpdate = {
    name: string;
    roleAttributes?: Attributes;
    tags?: Tags;
    typeId?: PostureCheckType;
};
export type PostureChecksFailureMfaCriteria = {
    passedMfaAt: string;
    timeoutRemainingSeconds: number;
    timeoutSeconds: number;
    unlockedAt: string;
    wokenAt: string;
};
export type PostureChecksFailureMfaValues = {
    passedMfa?: boolean;
    passedOnUnlock?: boolean;
    passedOnWake?: boolean;
    timedOut?: boolean;
};
export type PostureData = {
    apiSessionPostureData: {
        [key: string]: ApiSessionPostureData;
    };
    domain: PostureDataDomain;
    mac: PostureDataMac;
    os: PostureDataOs;
    processes: Array<PostureDataProcess>;
};
export type PostureDataBase = {
    lastUpdatedAt: string;
    postureCheckId: string;
    timedOut: boolean;
};
export type PostureDataDomain = PostureDataBase & {
    domain: string;
};
export type PostureDataEndpointState = {
    unlockedAt: string;
    wokenAt: string;
};
export type PostureDataEnvelope = {
    data: PostureData;
    meta: Meta;
};
export type PostureDataMac = PostureDataBase & {
    addresses: Array<string>;
};
export type PostureDataMfa = {
    apiSessionId: string;
    passedAt: string;
    passedMfa: boolean;
    passedOnUnlock: boolean;
    passedOnWake: boolean;
};
export type PostureDataOs = PostureDataBase & {
    build: string;
    type: string;
    version: string;
};
export type PostureDataProcess = PostureDataBase & {
    binaryHash?: string;
    isRunning?: boolean;
    signerFingerprints?: Array<string>;
};
export type PostureQueries = {
    isPassing: boolean;
    policyId: string;
    policyType?: DialBind;
    postureQueries: Array<PostureQuery>;
};
export type PostureQuery = BaseEntity & {
    isPassing: boolean;
    process?: PostureQueryProcess;
    processes?: Array<PostureQueryProcess>;
    promptGracePeriodSeconds?: number;
    promptOnUnlock?: boolean;
    promptOnWake?: boolean;
    queryType: PostureCheckType;
    timeout: number;
    timeoutAt?: string | null;
    timeoutRemaining: number;
};
export type PostureQueryProcess = {
    osType?: OsType;
    path?: string;
};
export type Process = {
    hashes?: Array<string>;
    osType: OsType;
    path: string;
    signerFingerprint?: string;
};
export type ProcessMulti = {
    hashes?: Array<string>;
    osType: OsType;
    path: string;
    signerFingerprints?: Array<string>;
};
export type ReEnroll = {
    expiresAt: string;
};
export type RequestExtendAuthenticator = {
    rollKeys?: boolean;
};
/**
 * An array of role attributes
 */
export type RoleAttributesList = Array<string>;
export type Roles = Array<string>;
export type RouterCreate = {
    cost?: number | null;
    disabled?: boolean | null;
    name: string;
    noTraversal?: boolean | null;
    tags?: Tags;
};
export type RouterDetail = BaseEntity & {
    cost: number;
    disabled: boolean;
    enrollmentCreatedAt?: string | null;
    enrollmentExpiresAt?: string | null;
    enrollmentJwt?: string | null;
    enrollmentToken?: string | null;
    fingerprint: string;
    interfaces?: Array<Interface>;
    isOnline: boolean;
    isVerified: boolean;
    name: string;
    noTraversal: boolean;
    unverifiedCertPem?: string | null;
    unverifiedFingerprint?: string | null;
};
export type RouterEntityRef = EntityRef & {
    isOnline: boolean;
};
export type RouterList = Array<RouterDetail>;
export type RouterPatch = {
    cost?: number | null;
    disabled?: boolean | null;
    name?: string;
    noTraversal?: boolean | null;
    tags?: Tags;
};
export type RouterUpdate = {
    cost?: number | null;
    disabled?: boolean | null;
    name: string;
    noTraversal?: boolean | null;
    tags?: Tags;
};
/**
 * SDK information an authenticating client may provide
 */
export type SdkInfo = {
    appId?: string;
    appVersion?: string;
    branch?: string;
    revision?: string;
    type?: string;
    version?: string;
};
export type Semantic = 'AllOf' | 'AnyOf';
export type ServiceConfigAssign = {
    configId: string;
    serviceId: string;
};
export type ServiceConfigDetail = {
    config: EntityRef;
    configId: string;
    service: EntityRef;
    serviceId: string;
};
export type ServiceConfigList = Array<ServiceConfigDetail>;
export type ServiceConfigsAssignList = Array<ServiceConfigAssign>;
export type ServiceCreate = {
    configs?: Array<string>;
    /**
     * Describes whether connections must support end-to-end encryption on both sides of the connection.
     */
    encryptionRequired: boolean;
    maxIdleTimeMillis?: number;
    name: string;
    roleAttributes?: Array<string>;
    tags?: Tags;
    terminatorStrategy?: string;
};
export type ServiceDetail = BaseEntity & {
    /**
     * map of config data for this service keyed by the config type name. Only configs of the types requested will be returned.
     */
    config: {
        [key: string]: {
            [key: string]: {
                [key: string]: unknown;
            };
        };
    };
    configs: Array<string>;
    /**
     * Describes whether connections must support end-to-end encryption on both sides of the connection. Read-only property, set at create.
     */
    encryptionRequired: boolean;
    maxIdleTimeMillis: number;
    name: string;
    permissions: DialBindArray;
    postureQueries: Array<PostureQueries>;
    roleAttributes: Attributes;
    terminatorStrategy: string;
};
export type ServiceEdgeRouterPolicyCreate = {
    edgeRouterRoles?: Roles;
    name: string;
    semantic: Semantic;
    serviceRoles?: Roles;
    tags?: Tags;
};
export type ServiceEdgeRouterPolicyDetail = BaseEntity & {
    edgeRouterRoles: Roles;
    edgeRouterRolesDisplay: NamedRoles;
    name: string;
    semantic: Semantic;
    serviceRoles: Roles;
    serviceRolesDisplay: NamedRoles;
};
export type ServiceEdgeRouterPolicyList = Array<ServiceEdgeRouterPolicyDetail>;
export type ServiceEdgeRouterPolicyPatch = {
    edgeRouterRoles?: Roles;
    name?: string;
    semantic?: Semantic;
    serviceRoles?: Roles;
    tags?: Tags;
};
export type ServiceEdgeRouterPolicyUpdate = {
    edgeRouterRoles?: Roles;
    name: string;
    semantic: Semantic;
    serviceRoles?: Roles;
    tags?: Tags;
};
export type ServiceList = Array<ServiceDetail>;
export type ServicePatch = {
    configs?: Array<string>;
    /**
     * Describes whether connections must support end-to-end encryption on both sides of the connection. Read-only property, set at create.
     */
    encryptionRequired?: boolean;
    maxIdleTimeMillis?: number;
    name?: string;
    roleAttributes?: Array<string>;
    tags?: Tags;
    terminatorStrategy?: string;
};
export type ServicePolicyCreate = {
    identityRoles?: Roles;
    name: string;
    postureCheckRoles?: Roles;
    semantic: Semantic;
    serviceRoles?: Roles;
    tags?: Tags;
    type: DialBind;
};
export type ServicePolicyDetail = BaseEntity & {
    identityRoles: Roles;
    identityRolesDisplay: NamedRoles;
    name: string;
    postureCheckRoles: Roles;
    postureCheckRolesDisplay: NamedRoles;
    semantic: Semantic;
    serviceRoles: Roles;
    serviceRolesDisplay: NamedRoles;
    type: DialBind;
};
export type ServicePolicyList = Array<ServicePolicyDetail>;
export type ServicePolicyPatch = {
    identityRoles?: Roles;
    name?: string;
    postureCheckRoles?: Roles;
    semantic?: Semantic;
    serviceRoles?: Roles;
    tags?: Tags;
    type?: DialBind;
};
export type ServicePolicyUpdate = {
    identityRoles?: Roles;
    name: string;
    postureCheckRoles?: Roles;
    semantic: Semantic;
    serviceRoles?: Roles;
    tags?: Tags;
    type: DialBind;
};
export type ServiceUpdate = {
    configs?: Array<string>;
    /**
     * Describes whether connections must support end-to-end encryption on both sides of the connection. Read-only property, set at create.
     */
    encryptionRequired?: boolean;
    maxIdleTimeMillis?: number;
    name: string;
    roleAttributes?: Array<string>;
    tags?: Tags;
    terminatorStrategy?: string;
};
export type SessionDetail = BaseEntity & {
    apiSession: EntityRef;
    apiSessionId: string;
    edgeRouters: Array<SessionEdgeRouter>;
    identityId: string;
    service: EntityRef;
    serviceId: string;
    token: string;
    type: DialBind;
};
export type SessionEdgeRouter = CommonEdgeRouterProperties & {
    urls: {
        [key: string]: string;
    };
};
export type SessionManagementDetail = SessionDetail & {
    servicePolicies?: Array<EntityRef>;
};
export type SessionManagementList = Array<SessionManagementDetail>;
export type SessionRoutePathDetail = {
    routePath?: Array<string>;
};
export type SpecBodyDetail = string;
export type SpecDetail = BaseEntity & {
    name: string;
};
export type SpecList = Array<SpecDetail>;
export type SubTags = {
    [key: string]: {
        [key: string]: unknown;
    };
};
/**
 * A map of user defined fields and values. The values are limited to the following types/values: null, string, boolean
 */
export type Tags = SubTags | null;
/**
 * Defines the target token type
 */
export type TargetToken = 'ACCESS' | 'ID';
export type TerminatorCost = number;
export type TerminatorCostMap = {
    [key: string]: TerminatorCost;
};
export type TerminatorCreate = {
    address: string;
    binding: string;
    cost?: TerminatorCost;
    identity?: string;
    identitySecret?: string;
    precedence?: TerminatorPrecedence;
    router: string;
    service: string;
    tags?: Tags;
};
export type TerminatorDetail = BaseEntity & {
    address: string;
    binding: string;
    cost: TerminatorCost;
    dynamicCost: TerminatorCost;
    identity: string;
    precedence: TerminatorPrecedence;
    router: EntityRef;
    routerId: string;
    service: EntityRef;
    serviceId: string;
};
export type TerminatorList = Array<TerminatorDetail>;
export type TerminatorPatch = {
    address?: string;
    binding?: string;
    cost?: TerminatorCost;
    precedence?: TerminatorPrecedence;
    router?: string;
    service?: string;
    tags?: Tags;
};
export type TerminatorPrecedence = 'default' | 'required' | 'failed';
export type TerminatorPrecedenceMap = {
    [key: string]: TerminatorPrecedence;
};
export type TerminatorUpdate = {
    address: string;
    binding: string;
    cost?: TerminatorCost;
    precedence?: TerminatorPrecedence;
    router: string;
    service: string;
    tags?: Tags;
};
export type TotpToken = {
    issuedAt: string;
    token: string;
};
export type TotpTokenEnvelope = {
    data: TotpToken;
    meta: Meta;
};
export type TraceDetail = {
    enabled?: boolean;
    traceId?: string;
    until?: string;
};
export type TraceDetailEnvelope = {
    data: TraceDetail;
    meta: Meta;
};
export type TraceSpec = {
    channels?: Array<string>;
    duration?: string;
    enabled?: boolean;
    traceId?: string;
};
export type Username = string;
export type UsernameNullable = string | null;
export type Version = {
    apiVersions?: {
        [key: string]: {
            [key: string]: ApiVersion;
        };
    };
    buildDate?: string;
    capabilities?: Array<string>;
    revision?: string;
    runtimeVersion?: string;
    version?: string;
};
export type VersionInfo = {
    arch: string;
    buildDate: string;
    os: string;
    revision: string;
    version: string;
};
export type ListRootData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/';
};
export type ListRootResponses = {
    /**
     * Version information for the controller
     */
    200: ListVersionEnvelope;
};
export type ListRootResponse = ListRootResponses[keyof ListRootResponses];
export type ListWellKnownCasData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/.well-known/est/cacerts';
};
export type ListWellKnownCasResponses = {
    /**
     * A base64 encoded PKCS7 store
     */
    200: string;
};
export type ListWellKnownCasResponse = ListWellKnownCasResponses[keyof ListWellKnownCasResponses];
export type ListApiSessionsData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/api-sessions';
};
export type ListApiSessionsErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListApiSessionsError = ListApiSessionsErrors[keyof ListApiSessionsErrors];
export type ListApiSessionsResponses = {
    /**
     * A list of active API Sessions
     */
    200: ListApiSessionsEnvelope;
};
export type ListApiSessionsResponse = ListApiSessionsResponses[keyof ListApiSessionsResponses];
export type DeleteApiSessionsData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/api-sessions/{id}';
};
export type DeleteApiSessionsErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    403: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DeleteApiSessionsError = DeleteApiSessionsErrors[keyof DeleteApiSessionsErrors];
export type DeleteApiSessionsResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteApiSessionsResponse = DeleteApiSessionsResponses[keyof DeleteApiSessionsResponses];
export type DetailApiSessionsData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/api-sessions/{id}';
};
export type DetailApiSessionsErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailApiSessionsError = DetailApiSessionsErrors[keyof DetailApiSessionsErrors];
export type DetailApiSessionsResponses = {
    /**
     * Retrieves a singular API Session by id
     */
    200: DetailApiSessionEnvelope;
};
export type DetailApiSessionsResponse = DetailApiSessionsResponses[keyof DetailApiSessionsResponses];
export type ListAuthPoliciesData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/auth-policies';
};
export type ListAuthPoliciesErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListAuthPoliciesError = ListAuthPoliciesErrors[keyof ListAuthPoliciesErrors];
export type ListAuthPoliciesResponses = {
    /**
     * A list of Auth Policies
     */
    200: ListAuthPoliciesEnvelope;
};
export type ListAuthPoliciesResponse = ListAuthPoliciesResponses[keyof ListAuthPoliciesResponses];
export type CreateAuthPolicyData = {
    /**
     * An Auth Policy to create
     */
    body: AuthPolicyCreate;
    path?: never;
    query?: never;
    url: '/auth-policies';
};
export type CreateAuthPolicyErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type CreateAuthPolicyError = CreateAuthPolicyErrors[keyof CreateAuthPolicyErrors];
export type CreateAuthPolicyResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type CreateAuthPolicyResponse = CreateAuthPolicyResponses[keyof CreateAuthPolicyResponses];
export type DeleteAuthPolicyData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/auth-policies/{id}';
};
export type DeleteAuthPolicyErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DeleteAuthPolicyError = DeleteAuthPolicyErrors[keyof DeleteAuthPolicyErrors];
export type DeleteAuthPolicyResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteAuthPolicyResponse = DeleteAuthPolicyResponses[keyof DeleteAuthPolicyResponses];
export type DetailAuthPolicyData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/auth-policies/{id}';
};
export type DetailAuthPolicyErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailAuthPolicyError = DetailAuthPolicyErrors[keyof DetailAuthPolicyErrors];
export type DetailAuthPolicyResponses = {
    /**
     * A singular Auth Policy resource
     */
    200: DetailAuthPolicyEnvelope;
};
export type DetailAuthPolicyResponse = DetailAuthPolicyResponses[keyof DetailAuthPolicyResponses];
export type PatchAuthPolicyData = {
    /**
     * An Auth Policy patch object
     */
    body: AuthPolicyPatch;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/auth-policies/{id}';
};
export type PatchAuthPolicyErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type PatchAuthPolicyError = PatchAuthPolicyErrors[keyof PatchAuthPolicyErrors];
export type PatchAuthPolicyResponses = {
    /**
     * The patch request was successful and the resource has been altered
     */
    200: Empty;
};
export type PatchAuthPolicyResponse = PatchAuthPolicyResponses[keyof PatchAuthPolicyResponses];
export type UpdateAuthPolicyData = {
    /**
     * An Auth Policy update object
     */
    body: AuthPolicyCreate;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/auth-policies/{id}';
};
export type UpdateAuthPolicyErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type UpdateAuthPolicyError = UpdateAuthPolicyErrors[keyof UpdateAuthPolicyErrors];
export type UpdateAuthPolicyResponses = {
    /**
     * The update request was successful and the resource has been altered
     */
    200: Empty;
};
export type UpdateAuthPolicyResponse = UpdateAuthPolicyResponses[keyof UpdateAuthPolicyResponses];
export type AuthenticateData = {
    body?: Authenticate;
    path?: never;
    query: {
        method: 'password' | 'cert' | 'ext-jwt';
    };
    url: '/authenticate';
};
export type AuthenticateErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The authentication request could not be processed as the credentials are invalid
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
};
export type AuthenticateError = AuthenticateErrors[keyof AuthenticateErrors];
export type AuthenticateResponses = {
    /**
     * The API session associated with the session used to issue the request
     */
    200: CurrentApiSessionDetailEnvelope;
};
export type AuthenticateResponse = AuthenticateResponses[keyof AuthenticateResponses];
export type AuthenticateMfaData = {
    /**
     * An MFA validation request
     */
    body: MfaCode;
    path?: never;
    query?: never;
    url: '/authenticate/mfa';
};
export type AuthenticateMfaErrors = {
    /**
     * Base empty response
     */
    401: Empty;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
};
export type AuthenticateMfaError = AuthenticateMfaErrors[keyof AuthenticateMfaErrors];
export type AuthenticateMfaResponses = {
    /**
     * Base empty response
     */
    200: Empty;
};
export type AuthenticateMfaResponse = AuthenticateMfaResponses[keyof AuthenticateMfaResponses];
export type ListAuthenticatorsData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/authenticators';
};
export type ListAuthenticatorsErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListAuthenticatorsError = ListAuthenticatorsErrors[keyof ListAuthenticatorsErrors];
export type ListAuthenticatorsResponses = {
    /**
     * A list of authenticators
     */
    200: ListAuthenticatorsEnvelope;
};
export type ListAuthenticatorsResponse = ListAuthenticatorsResponses[keyof ListAuthenticatorsResponses];
export type CreateAuthenticatorData = {
    /**
     * A Authenticator create object
     */
    body: AuthenticatorCreate;
    path?: never;
    query?: never;
    url: '/authenticators';
};
export type CreateAuthenticatorErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type CreateAuthenticatorError = CreateAuthenticatorErrors[keyof CreateAuthenticatorErrors];
export type CreateAuthenticatorResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type CreateAuthenticatorResponse = CreateAuthenticatorResponses[keyof CreateAuthenticatorResponses];
export type DeleteAuthenticatorData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/authenticators/{id}';
};
export type DeleteAuthenticatorErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DeleteAuthenticatorError = DeleteAuthenticatorErrors[keyof DeleteAuthenticatorErrors];
export type DeleteAuthenticatorResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteAuthenticatorResponse = DeleteAuthenticatorResponses[keyof DeleteAuthenticatorResponses];
export type DetailAuthenticatorData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/authenticators/{id}';
};
export type DetailAuthenticatorErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailAuthenticatorError = DetailAuthenticatorErrors[keyof DetailAuthenticatorErrors];
export type DetailAuthenticatorResponses = {
    /**
     * A singular authenticator resource
     */
    200: DetailAuthenticatorEnvelope;
};
export type DetailAuthenticatorResponse = DetailAuthenticatorResponses[keyof DetailAuthenticatorResponses];
export type PatchAuthenticatorData = {
    /**
     * An authenticator patch object
     */
    body: AuthenticatorPatch;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/authenticators/{id}';
};
export type PatchAuthenticatorErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type PatchAuthenticatorError = PatchAuthenticatorErrors[keyof PatchAuthenticatorErrors];
export type PatchAuthenticatorResponses = {
    /**
     * The patch request was successful and the resource has been altered
     */
    200: Empty;
};
export type PatchAuthenticatorResponse = PatchAuthenticatorResponses[keyof PatchAuthenticatorResponses];
export type UpdateAuthenticatorData = {
    /**
     * An authenticator put object
     */
    body: AuthenticatorUpdate;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/authenticators/{id}';
};
export type UpdateAuthenticatorErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type UpdateAuthenticatorError = UpdateAuthenticatorErrors[keyof UpdateAuthenticatorErrors];
export type UpdateAuthenticatorResponses = {
    /**
     * The update request was successful and the resource has been altered
     */
    200: Empty;
};
export type UpdateAuthenticatorResponse = UpdateAuthenticatorResponses[keyof UpdateAuthenticatorResponses];
export type ReEnrollAuthenticatorData = {
    /**
     * A reEnrollment request
     */
    body: ReEnroll;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/authenticators/{id}/re-enroll';
};
export type ReEnrollAuthenticatorErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ReEnrollAuthenticatorError = ReEnrollAuthenticatorErrors[keyof ReEnrollAuthenticatorErrors];
export type ReEnrollAuthenticatorResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type ReEnrollAuthenticatorResponse = ReEnrollAuthenticatorResponses[keyof ReEnrollAuthenticatorResponses];
export type RequestExtendAuthenticatorData = {
    /**
     * A request to flag a certificate authenticator for early extension/key rolling.
     */
    body: RequestExtendAuthenticator;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/authenticators/{id}/request-extend';
};
export type RequestExtendAuthenticatorErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The request could not be completed and will never complete due to unchangeable state or conflicts.
     */
    403: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type RequestExtendAuthenticatorError = RequestExtendAuthenticatorErrors[keyof RequestExtendAuthenticatorErrors];
export type RequestExtendAuthenticatorResponses = {
    /**
     * Base empty response
     */
    200: Empty;
};
export type RequestExtendAuthenticatorResponse = RequestExtendAuthenticatorResponses[keyof RequestExtendAuthenticatorResponses];
export type ListCasData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/cas';
};
export type ListCasErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListCasError = ListCasErrors[keyof ListCasErrors];
export type ListCasResponses = {
    /**
     * A list of Certificate Authorities (CAs)
     */
    200: ListCasEnvelope;
};
export type ListCasResponse = ListCasResponses[keyof ListCasResponses];
export type CreateCaData = {
    /**
     * A CA to create
     */
    body: CaCreate;
    path?: never;
    query?: never;
    url: '/cas';
};
export type CreateCaErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type CreateCaError = CreateCaErrors[keyof CreateCaErrors];
export type CreateCaResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type CreateCaResponse = CreateCaResponses[keyof CreateCaResponses];
export type DeleteCaData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/cas/{id}';
};
export type DeleteCaErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DeleteCaError = DeleteCaErrors[keyof DeleteCaErrors];
export type DeleteCaResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteCaResponse = DeleteCaResponses[keyof DeleteCaResponses];
export type DetailCaData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/cas/{id}';
};
export type DetailCaErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailCaError = DetailCaErrors[keyof DetailCaErrors];
export type DetailCaResponses = {
    /**
     * A singular Certificate Authority (CA) resource
     */
    200: DetailCaEnvelope;
};
export type DetailCaResponse = DetailCaResponses[keyof DetailCaResponses];
export type PatchCaData = {
    /**
     * A CA patch object
     */
    body: CaPatch;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/cas/{id}';
};
export type PatchCaErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type PatchCaError = PatchCaErrors[keyof PatchCaErrors];
export type PatchCaResponses = {
    /**
     * The patch request was successful and the resource has been altered
     */
    200: Empty;
};
export type PatchCaResponse = PatchCaResponses[keyof PatchCaResponses];
export type UpdateCaData = {
    /**
     * A CA update object
     */
    body: CaUpdate;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/cas/{id}';
};
export type UpdateCaErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type UpdateCaError = UpdateCaErrors[keyof UpdateCaErrors];
export type UpdateCaResponses = {
    /**
     * The update request was successful and the resource has been altered
     */
    200: Empty;
};
export type UpdateCaResponse = UpdateCaResponses[keyof UpdateCaResponses];
export type GetCaJwtData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/cas/{id}/jwt';
};
export type GetCaJwtErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type GetCaJwtError = GetCaJwtErrors[keyof GetCaJwtErrors];
export type GetCaJwtResponses = {
    /**
     * The result is the JWT text to validate the CA
     */
    200: string;
};
export type GetCaJwtResponse = GetCaJwtResponses[keyof GetCaJwtResponses];
export type VerifyCaData = {
    /**
     * A PEM formatted certificate signed by the target CA with the common name matching the CA's validationToken
     */
    body: string;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/cas/{id}/verify';
};
export type VerifyCaErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type VerifyCaError = VerifyCaErrors[keyof VerifyCaErrors];
export type VerifyCaResponses = {
    /**
     * Base empty response
     */
    200: Empty;
};
export type VerifyCaResponse = VerifyCaResponses[keyof VerifyCaResponses];
export type ListConfigTypesData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/config-types';
};
export type ListConfigTypesErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListConfigTypesError = ListConfigTypesErrors[keyof ListConfigTypesErrors];
export type ListConfigTypesResponses = {
    /**
     * A list of config-types
     */
    200: ListConfigTypesEnvelope;
};
export type ListConfigTypesResponse = ListConfigTypesResponses[keyof ListConfigTypesResponses];
export type CreateConfigTypeData = {
    /**
     * A config-type to create
     */
    body: ConfigTypeCreate;
    path?: never;
    query?: never;
    url: '/config-types';
};
export type CreateConfigTypeErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type CreateConfigTypeError = CreateConfigTypeErrors[keyof CreateConfigTypeErrors];
export type CreateConfigTypeResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type CreateConfigTypeResponse = CreateConfigTypeResponses[keyof CreateConfigTypeResponses];
export type DeleteConfigTypeData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/config-types/{id}';
};
export type DeleteConfigTypeErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested to be removed/altered cannot be as it is referenced by another object.
     */
    409: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DeleteConfigTypeError = DeleteConfigTypeErrors[keyof DeleteConfigTypeErrors];
export type DeleteConfigTypeResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteConfigTypeResponse = DeleteConfigTypeResponses[keyof DeleteConfigTypeResponses];
export type DetailConfigTypeData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/config-types/{id}';
};
export type DetailConfigTypeErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailConfigTypeError = DetailConfigTypeErrors[keyof DetailConfigTypeErrors];
export type DetailConfigTypeResponses = {
    /**
     * A singular config-type resource
     */
    200: DetailConfigTypeEnvelope;
};
export type DetailConfigTypeResponse = DetailConfigTypeResponses[keyof DetailConfigTypeResponses];
export type PatchConfigTypeData = {
    /**
     * A config-type patch object
     */
    body: ConfigTypePatch;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/config-types/{id}';
};
export type PatchConfigTypeErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type PatchConfigTypeError = PatchConfigTypeErrors[keyof PatchConfigTypeErrors];
export type PatchConfigTypeResponses = {
    /**
     * The patch request was successful and the resource has been altered
     */
    200: Empty;
};
export type PatchConfigTypeResponse = PatchConfigTypeResponses[keyof PatchConfigTypeResponses];
export type UpdateConfigTypeData = {
    /**
     * A config-type update object
     */
    body: ConfigTypeUpdate;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/config-types/{id}';
};
export type UpdateConfigTypeErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type UpdateConfigTypeError = UpdateConfigTypeErrors[keyof UpdateConfigTypeErrors];
export type UpdateConfigTypeResponses = {
    /**
     * The update request was successful and the resource has been altered
     */
    200: Empty;
};
export type UpdateConfigTypeResponse = UpdateConfigTypeResponses[keyof UpdateConfigTypeResponses];
export type ListConfigsForConfigTypeData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/config-types/{id}/configs';
};
export type ListConfigsForConfigTypeErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListConfigsForConfigTypeError = ListConfigsForConfigTypeErrors[keyof ListConfigsForConfigTypeErrors];
export type ListConfigsForConfigTypeResponses = {
    /**
     * A list of configs
     */
    200: ListConfigsEnvelope;
};
export type ListConfigsForConfigTypeResponse = ListConfigsForConfigTypeResponses[keyof ListConfigsForConfigTypeResponses];
export type ListConfigsData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/configs';
};
export type ListConfigsErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListConfigsError = ListConfigsErrors[keyof ListConfigsErrors];
export type ListConfigsResponses = {
    /**
     * A list of configs
     */
    200: ListConfigsEnvelope;
};
export type ListConfigsResponse = ListConfigsResponses[keyof ListConfigsResponses];
export type CreateConfigData = {
    /**
     * A config to create
     */
    body: ConfigCreate;
    path?: never;
    query?: never;
    url: '/configs';
};
export type CreateConfigErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type CreateConfigError = CreateConfigErrors[keyof CreateConfigErrors];
export type CreateConfigResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type CreateConfigResponse = CreateConfigResponses[keyof CreateConfigResponses];
export type DeleteConfigData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/configs/{id}';
};
export type DeleteConfigErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested to be removed/altered cannot be as it is referenced by another object.
     */
    409: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DeleteConfigError = DeleteConfigErrors[keyof DeleteConfigErrors];
export type DeleteConfigResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteConfigResponse = DeleteConfigResponses[keyof DeleteConfigResponses];
export type DetailConfigData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/configs/{id}';
};
export type DetailConfigErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailConfigError = DetailConfigErrors[keyof DetailConfigErrors];
export type DetailConfigResponses = {
    /**
     * A singular config resource
     */
    200: DetailConfigEnvelope;
};
export type DetailConfigResponse = DetailConfigResponses[keyof DetailConfigResponses];
export type PatchConfigData = {
    /**
     * A config patch object
     */
    body: ConfigPatch;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/configs/{id}';
};
export type PatchConfigErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type PatchConfigError = PatchConfigErrors[keyof PatchConfigErrors];
export type PatchConfigResponses = {
    /**
     * The patch request was successful and the resource has been altered
     */
    200: Empty;
};
export type PatchConfigResponse = PatchConfigResponses[keyof PatchConfigResponses];
export type UpdateConfigData = {
    /**
     * A config update object
     */
    body: ConfigUpdate;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/configs/{id}';
};
export type UpdateConfigErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type UpdateConfigError = UpdateConfigErrors[keyof UpdateConfigErrors];
export type UpdateConfigResponses = {
    /**
     * The update request was successful and the resource has been altered
     */
    200: Empty;
};
export type UpdateConfigResponse = UpdateConfigResponses[keyof UpdateConfigResponses];
export type ListConfigServicesData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/configs/{id}/services';
};
export type ListConfigServicesErrors = {
    /**
     * The requested resource does not exist
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListConfigServicesError = ListConfigServicesErrors[keyof ListConfigServicesErrors];
export type ListConfigServicesResponses = {
    /**
     * A list of services
     */
    200: ListServicesEnvelope;
};
export type ListConfigServicesResponse = ListConfigServicesResponses[keyof ListConfigServicesResponses];
export type ListControllerSettingsData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/controller-settings';
};
export type ListControllerSettingsErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
};
export type ListControllerSettingsError = ListControllerSettingsErrors[keyof ListControllerSettingsErrors];
export type ListControllerSettingsResponses = {
    /**
     * A list of controller setting objects
     */
    200: ListControllerSettingEnvelope;
};
export type ListControllerSettingsResponse = ListControllerSettingsResponses[keyof ListControllerSettingsResponses];
export type CreateControllerSettingData = {
    /**
     * A controller settings object to create
     */
    body: ControllerSettingCreate;
    path?: never;
    query?: never;
    url: '/controller-settings';
};
export type CreateControllerSettingErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
};
export type CreateControllerSettingError = CreateControllerSettingErrors[keyof CreateControllerSettingErrors];
export type CreateControllerSettingResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type CreateControllerSettingResponse = CreateControllerSettingResponses[keyof CreateControllerSettingResponses];
export type DetailControllerSettingData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/controller-settings/{id}';
};
export type DetailControllerSettingErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
};
export type DetailControllerSettingError = DetailControllerSettingErrors[keyof DetailControllerSettingErrors];
export type DetailControllerSettingResponses = {
    /**
     * A singular controller setting object
     */
    200: DetailControllerSettingEnvelope;
};
export type DetailControllerSettingResponse = DetailControllerSettingResponses[keyof DetailControllerSettingResponses];
export type DeleteControllerSettingData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/controller-settings/{id}/effective';
};
export type DeleteControllerSettingErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested to be removed/altered cannot be as it is referenced by another object.
     */
    409: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
};
export type DeleteControllerSettingError = DeleteControllerSettingErrors[keyof DeleteControllerSettingErrors];
export type DeleteControllerSettingResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteControllerSettingResponse = DeleteControllerSettingResponses[keyof DeleteControllerSettingResponses];
export type DetailControllerSettingEffectiveData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/controller-settings/{id}/effective';
};
export type DetailControllerSettingEffectiveErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
};
export type DetailControllerSettingEffectiveError = DetailControllerSettingEffectiveErrors[keyof DetailControllerSettingEffectiveErrors];
export type DetailControllerSettingEffectiveResponses = {
    /**
     * A singular controller's effective setting object
     */
    200: DetailControllerSettingEffectiveEnvelope;
};
export type DetailControllerSettingEffectiveResponse = DetailControllerSettingEffectiveResponses[keyof DetailControllerSettingEffectiveResponses];
export type PatchControllerSettingData = {
    /**
     * A controller setting object patch object
     */
    body: ControllerSettingPatch;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/controller-settings/{id}/effective';
};
export type PatchControllerSettingErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
};
export type PatchControllerSettingError = PatchControllerSettingErrors[keyof PatchControllerSettingErrors];
export type PatchControllerSettingResponses = {
    /**
     * The patch request was successful and the resource has been altered
     */
    200: Empty;
};
export type PatchControllerSettingResponse = PatchControllerSettingResponses[keyof PatchControllerSettingResponses];
export type UpdateControllerSettingData = {
    /**
     * A controller setting update object
     */
    body: ControllerSettingUpdate;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/controller-settings/{id}/effective';
};
export type UpdateControllerSettingErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
};
export type UpdateControllerSettingError = UpdateControllerSettingErrors[keyof UpdateControllerSettingErrors];
export type UpdateControllerSettingResponses = {
    /**
     * The update request was successful and the resource has been altered
     */
    200: Empty;
};
export type UpdateControllerSettingResponse = UpdateControllerSettingResponses[keyof UpdateControllerSettingResponses];
export type ListControllersData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/controllers';
};
export type ListControllersErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
};
export type ListControllersError = ListControllersErrors[keyof ListControllersErrors];
export type ListControllersResponses = {
    /**
     * A list of controllers
     */
    200: ListControllersEnvelope;
};
export type ListControllersResponse = ListControllersResponses[keyof ListControllersResponses];
export type DeleteCurrentApiSessionData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/current-api-session';
};
export type DeleteCurrentApiSessionErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
};
export type DeleteCurrentApiSessionError = DeleteCurrentApiSessionErrors[keyof DeleteCurrentApiSessionErrors];
export type DeleteCurrentApiSessionResponses = {
    /**
     * Base empty response
     */
    200: Empty;
};
export type DeleteCurrentApiSessionResponse = DeleteCurrentApiSessionResponses[keyof DeleteCurrentApiSessionResponses];
export type GetCurrentApiSessionData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/current-api-session';
};
export type GetCurrentApiSessionErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
};
export type GetCurrentApiSessionError = GetCurrentApiSessionErrors[keyof GetCurrentApiSessionErrors];
export type GetCurrentApiSessionResponses = {
    /**
     * The API session associated with the session used to issue the request
     */
    200: CurrentApiSessionDetailEnvelope;
};
export type GetCurrentApiSessionResponse = GetCurrentApiSessionResponses[keyof GetCurrentApiSessionResponses];
export type CreateTotpTokenData = {
    /**
     * An MFA TOTP validation request
     */
    body: MfaCode;
    path?: never;
    query?: never;
    url: '/current-api-session/totp-token';
};
export type CreateTotpTokenErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
};
export type CreateTotpTokenError = CreateTotpTokenErrors[keyof CreateTotpTokenErrors];
export type CreateTotpTokenResponses = {
    /**
     * A TOTP token create response, contains a token used to satisfy posture checks
     */
    200: TotpTokenEnvelope;
};
export type CreateTotpTokenResponse = CreateTotpTokenResponses[keyof CreateTotpTokenResponses];
export type GetCurrentIdentityData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/current-identity';
};
export type GetCurrentIdentityErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
};
export type GetCurrentIdentityError = GetCurrentIdentityErrors[keyof GetCurrentIdentityErrors];
export type GetCurrentIdentityResponses = {
    /**
     * The identity associated with the API Session used to issue the request
     */
    200: CurrentIdentityDetailEnvelope;
};
export type GetCurrentIdentityResponse = GetCurrentIdentityResponses[keyof GetCurrentIdentityResponses];
export type ListCurrentIdentityAuthenticatorsData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/current-identity/authenticators';
};
export type ListCurrentIdentityAuthenticatorsErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
};
export type ListCurrentIdentityAuthenticatorsError = ListCurrentIdentityAuthenticatorsErrors[keyof ListCurrentIdentityAuthenticatorsErrors];
export type ListCurrentIdentityAuthenticatorsResponses = {
    /**
     * A list of authenticators
     */
    200: ListAuthenticatorsEnvelope;
};
export type ListCurrentIdentityAuthenticatorsResponse = ListCurrentIdentityAuthenticatorsResponses[keyof ListCurrentIdentityAuthenticatorsResponses];
export type DetailCurrentIdentityAuthenticatorData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/current-identity/authenticators/{id}';
};
export type DetailCurrentIdentityAuthenticatorErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
};
export type DetailCurrentIdentityAuthenticatorError = DetailCurrentIdentityAuthenticatorErrors[keyof DetailCurrentIdentityAuthenticatorErrors];
export type DetailCurrentIdentityAuthenticatorResponses = {
    /**
     * A singular authenticator resource
     */
    200: DetailAuthenticatorEnvelope;
};
export type DetailCurrentIdentityAuthenticatorResponse = DetailCurrentIdentityAuthenticatorResponses[keyof DetailCurrentIdentityAuthenticatorResponses];
export type PatchCurrentIdentityAuthenticatorData = {
    /**
     * An authenticator patch object
     */
    body: AuthenticatorPatchWithCurrent;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/current-identity/authenticators/{id}';
};
export type PatchCurrentIdentityAuthenticatorErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
};
export type PatchCurrentIdentityAuthenticatorError = PatchCurrentIdentityAuthenticatorErrors[keyof PatchCurrentIdentityAuthenticatorErrors];
export type PatchCurrentIdentityAuthenticatorResponses = {
    /**
     * The patch request was successful and the resource has been altered
     */
    200: Empty;
};
export type PatchCurrentIdentityAuthenticatorResponse = PatchCurrentIdentityAuthenticatorResponses[keyof PatchCurrentIdentityAuthenticatorResponses];
export type UpdateCurrentIdentityAuthenticatorData = {
    /**
     * An authenticator put object
     */
    body: AuthenticatorUpdateWithCurrent;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/current-identity/authenticators/{id}';
};
export type UpdateCurrentIdentityAuthenticatorErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
};
export type UpdateCurrentIdentityAuthenticatorError = UpdateCurrentIdentityAuthenticatorErrors[keyof UpdateCurrentIdentityAuthenticatorErrors];
export type UpdateCurrentIdentityAuthenticatorResponses = {
    /**
     * The update request was successful and the resource has been altered
     */
    200: Empty;
};
export type UpdateCurrentIdentityAuthenticatorResponse = UpdateCurrentIdentityAuthenticatorResponses[keyof UpdateCurrentIdentityAuthenticatorResponses];
export type ExtendCurrentIdentityAuthenticatorData = {
    body: IdentityExtendEnrollmentRequest;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/current-identity/authenticators/{id}/extend';
};
export type ExtendCurrentIdentityAuthenticatorErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
};
export type ExtendCurrentIdentityAuthenticatorError = ExtendCurrentIdentityAuthenticatorErrors[keyof ExtendCurrentIdentityAuthenticatorErrors];
export type ExtendCurrentIdentityAuthenticatorResponses = {
    /**
     * A response containg the identity's new certificate
     */
    200: IdentityExtendEnrollmentEnvelope;
};
export type ExtendCurrentIdentityAuthenticatorResponse = ExtendCurrentIdentityAuthenticatorResponses[keyof ExtendCurrentIdentityAuthenticatorResponses];
export type ExtendVerifyCurrentIdentityAuthenticatorData = {
    body: IdentityExtendValidateEnrollmentRequest;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/current-identity/authenticators/{id}/extend-verify';
};
export type ExtendVerifyCurrentIdentityAuthenticatorErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
};
export type ExtendVerifyCurrentIdentityAuthenticatorError = ExtendVerifyCurrentIdentityAuthenticatorErrors[keyof ExtendVerifyCurrentIdentityAuthenticatorErrors];
export type ExtendVerifyCurrentIdentityAuthenticatorResponses = {
    /**
     * Base empty response
     */
    200: Empty;
};
export type ExtendVerifyCurrentIdentityAuthenticatorResponse = ExtendVerifyCurrentIdentityAuthenticatorResponses[keyof ExtendVerifyCurrentIdentityAuthenticatorResponses];
export type DeleteMfaData = {
    body?: never;
    headers?: {
        'mfa-validation-code'?: string;
    };
    path?: never;
    query?: never;
    url: '/current-identity/mfa';
};
export type DeleteMfaErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
};
export type DeleteMfaError = DeleteMfaErrors[keyof DeleteMfaErrors];
export type DeleteMfaResponses = {
    /**
     * Base empty response
     */
    200: Empty;
};
export type DeleteMfaResponse = DeleteMfaResponses[keyof DeleteMfaResponses];
export type DetailMfaData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/current-identity/mfa';
};
export type DetailMfaErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
};
export type DetailMfaError = DetailMfaErrors[keyof DetailMfaErrors];
export type DetailMfaResponses = {
    /**
     * The details of an MFA enrollment
     */
    200: DetailMfaEnvelope;
};
export type DetailMfaResponse = DetailMfaResponses[keyof DetailMfaResponses];
export type EnrollMfaData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/current-identity/mfa';
};
export type EnrollMfaErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The identity is already enrolled in MFA
     */
    409: ApiErrorEnvelope;
};
export type EnrollMfaError = EnrollMfaErrors[keyof EnrollMfaErrors];
export type EnrollMfaResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type EnrollMfaResponse = EnrollMfaResponses[keyof EnrollMfaResponses];
export type DetailMfaQrCodeData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/current-identity/mfa/qr-code';
};
export type DetailMfaQrCodeErrors = {
    /**
     * No MFA enrollment or MFA enrollment is completed
     */
    404: unknown;
};
export type DetailMfaQrCodeResponses = {
    /**
     * OK
     */
    200: unknown;
};
export type DetailMfaRecoveryCodesData = {
    /**
     * An MFA validation request
     */
    body?: MfaCode;
    headers?: {
        'mfa-validation-code'?: string;
    };
    path?: never;
    query?: never;
    url: '/current-identity/mfa/recovery-codes';
};
export type DetailMfaRecoveryCodesErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
};
export type DetailMfaRecoveryCodesError = DetailMfaRecoveryCodesErrors[keyof DetailMfaRecoveryCodesErrors];
export type DetailMfaRecoveryCodesResponses = {
    /**
     * The recovery codes of an MFA enrollment
     */
    200: DetailMfaRecoveryCodesEnvelope;
};
export type DetailMfaRecoveryCodesResponse = DetailMfaRecoveryCodesResponses[keyof DetailMfaRecoveryCodesResponses];
export type CreateMfaRecoveryCodesData = {
    /**
     * An MFA validation request
     */
    body: MfaCode;
    path?: never;
    query?: never;
    url: '/current-identity/mfa/recovery-codes';
};
export type CreateMfaRecoveryCodesErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
};
export type CreateMfaRecoveryCodesError = CreateMfaRecoveryCodesErrors[keyof CreateMfaRecoveryCodesErrors];
export type CreateMfaRecoveryCodesResponses = {
    /**
     * Base empty response
     */
    200: Empty;
};
export type CreateMfaRecoveryCodesResponse = CreateMfaRecoveryCodesResponses[keyof CreateMfaRecoveryCodesResponses];
export type VerifyMfaData = {
    /**
     * An MFA validation request
     */
    body: MfaCode;
    path?: never;
    query?: never;
    url: '/current-identity/mfa/verify';
};
export type VerifyMfaErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
};
export type VerifyMfaError = VerifyMfaErrors[keyof VerifyMfaErrors];
export type VerifyMfaResponses = {
    /**
     * Base empty response
     */
    200: Empty;
};
export type VerifyMfaResponse = VerifyMfaResponses[keyof VerifyMfaResponses];
export type CheckDataIntegrityData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/database/check-data-integrity';
};
export type CheckDataIntegrityErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
};
export type CheckDataIntegrityError = CheckDataIntegrityErrors[keyof CheckDataIntegrityErrors];
export type CheckDataIntegrityResponses = {
    /**
     * Base empty response
     */
    202: Empty;
};
export type CheckDataIntegrityResponse = CheckDataIntegrityResponses[keyof CheckDataIntegrityResponses];
export type DataIntegrityResultsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/database/data-integrity-results';
};
export type DataIntegrityResultsErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DataIntegrityResultsError = DataIntegrityResultsErrors[keyof DataIntegrityResultsErrors];
export type DataIntegrityResultsResponses = {
    /**
     * A list of data integrity issues found
     */
    200: DataIntegrityCheckResultEnvelope;
};
export type DataIntegrityResultsResponse = DataIntegrityResultsResponses[keyof DataIntegrityResultsResponses];
export type FixDataIntegrityData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/database/fix-data-integrity';
};
export type FixDataIntegrityErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
};
export type FixDataIntegrityError = FixDataIntegrityErrors[keyof FixDataIntegrityErrors];
export type FixDataIntegrityResponses = {
    /**
     * Base empty response
     */
    202: Empty;
};
export type FixDataIntegrityResponse = FixDataIntegrityResponses[keyof FixDataIntegrityResponses];
export type CreateDatabaseSnapshotData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/database/snapshot';
};
export type CreateDatabaseSnapshotErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
};
export type CreateDatabaseSnapshotError = CreateDatabaseSnapshotErrors[keyof CreateDatabaseSnapshotErrors];
export type CreateDatabaseSnapshotResponses = {
    /**
     * Base empty response
     */
    200: Empty;
};
export type CreateDatabaseSnapshotResponse = CreateDatabaseSnapshotResponses[keyof CreateDatabaseSnapshotResponses];
export type ListEdgeRouterPoliciesData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/edge-router-policies';
};
export type ListEdgeRouterPoliciesErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListEdgeRouterPoliciesError = ListEdgeRouterPoliciesErrors[keyof ListEdgeRouterPoliciesErrors];
export type ListEdgeRouterPoliciesResponses = {
    /**
     * A list of edge router policies
     */
    200: ListEdgeRouterPoliciesEnvelope;
};
export type ListEdgeRouterPoliciesResponse = ListEdgeRouterPoliciesResponses[keyof ListEdgeRouterPoliciesResponses];
export type CreateEdgeRouterPolicyData = {
    /**
     * An edge router policy to create
     */
    body: EdgeRouterPolicyCreate;
    path?: never;
    query?: never;
    url: '/edge-router-policies';
};
export type CreateEdgeRouterPolicyErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type CreateEdgeRouterPolicyError = CreateEdgeRouterPolicyErrors[keyof CreateEdgeRouterPolicyErrors];
export type CreateEdgeRouterPolicyResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type CreateEdgeRouterPolicyResponse = CreateEdgeRouterPolicyResponses[keyof CreateEdgeRouterPolicyResponses];
export type DeleteEdgeRouterPolicyData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/edge-router-policies/{id}';
};
export type DeleteEdgeRouterPolicyErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested to be removed/altered cannot be as it is referenced by another object.
     */
    409: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DeleteEdgeRouterPolicyError = DeleteEdgeRouterPolicyErrors[keyof DeleteEdgeRouterPolicyErrors];
export type DeleteEdgeRouterPolicyResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteEdgeRouterPolicyResponse = DeleteEdgeRouterPolicyResponses[keyof DeleteEdgeRouterPolicyResponses];
export type DetailEdgeRouterPolicyData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/edge-router-policies/{id}';
};
export type DetailEdgeRouterPolicyErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailEdgeRouterPolicyError = DetailEdgeRouterPolicyErrors[keyof DetailEdgeRouterPolicyErrors];
export type DetailEdgeRouterPolicyResponses = {
    /**
     * A single edge router policy
     */
    200: DetailEdgeRouterPolicyEnvelope;
};
export type DetailEdgeRouterPolicyResponse = DetailEdgeRouterPolicyResponses[keyof DetailEdgeRouterPolicyResponses];
export type PatchEdgeRouterPolicyData = {
    /**
     * An edge router policy patch object
     */
    body: EdgeRouterPolicyPatch;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/edge-router-policies/{id}';
};
export type PatchEdgeRouterPolicyErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type PatchEdgeRouterPolicyError = PatchEdgeRouterPolicyErrors[keyof PatchEdgeRouterPolicyErrors];
export type PatchEdgeRouterPolicyResponses = {
    /**
     * The patch request was successful and the resource has been altered
     */
    200: Empty;
};
export type PatchEdgeRouterPolicyResponse = PatchEdgeRouterPolicyResponses[keyof PatchEdgeRouterPolicyResponses];
export type UpdateEdgeRouterPolicyData = {
    /**
     * An edge router policy update object
     */
    body: EdgeRouterPolicyUpdate;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/edge-router-policies/{id}';
};
export type UpdateEdgeRouterPolicyErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type UpdateEdgeRouterPolicyError = UpdateEdgeRouterPolicyErrors[keyof UpdateEdgeRouterPolicyErrors];
export type UpdateEdgeRouterPolicyResponses = {
    /**
     * The update request was successful and the resource has been altered
     */
    200: Empty;
};
export type UpdateEdgeRouterPolicyResponse = UpdateEdgeRouterPolicyResponses[keyof UpdateEdgeRouterPolicyResponses];
export type ListEdgeRouterPolicyEdgeRoutersData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/edge-router-policies/{id}/edge-routers';
};
export type ListEdgeRouterPolicyEdgeRoutersErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListEdgeRouterPolicyEdgeRoutersError = ListEdgeRouterPolicyEdgeRoutersErrors[keyof ListEdgeRouterPolicyEdgeRoutersErrors];
export type ListEdgeRouterPolicyEdgeRoutersResponses = {
    /**
     * A list of edge routers
     */
    200: ListEdgeRoutersEnvelope;
};
export type ListEdgeRouterPolicyEdgeRoutersResponse = ListEdgeRouterPolicyEdgeRoutersResponses[keyof ListEdgeRouterPolicyEdgeRoutersResponses];
export type ListEdgeRouterPolicyIdentitiesData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/edge-router-policies/{id}/identities';
};
export type ListEdgeRouterPolicyIdentitiesErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListEdgeRouterPolicyIdentitiesError = ListEdgeRouterPolicyIdentitiesErrors[keyof ListEdgeRouterPolicyIdentitiesErrors];
export type ListEdgeRouterPolicyIdentitiesResponses = {
    /**
     * A list of identities
     */
    200: ListIdentitiesEnvelope;
};
export type ListEdgeRouterPolicyIdentitiesResponse = ListEdgeRouterPolicyIdentitiesResponses[keyof ListEdgeRouterPolicyIdentitiesResponses];
export type ListEdgeRouterRoleAttributesData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/edge-router-role-attributes';
};
export type ListEdgeRouterRoleAttributesErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListEdgeRouterRoleAttributesError = ListEdgeRouterRoleAttributesErrors[keyof ListEdgeRouterRoleAttributesErrors];
export type ListEdgeRouterRoleAttributesResponses = {
    /**
     * A list of role attributes
     */
    200: ListRoleAttributesEnvelope;
};
export type ListEdgeRouterRoleAttributesResponse = ListEdgeRouterRoleAttributesResponses[keyof ListEdgeRouterRoleAttributesResponses];
export type ListEdgeRoutersData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
        roleFilter?: Array<string>;
        roleSemantic?: string;
    };
    url: '/edge-routers';
};
export type ListEdgeRoutersErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListEdgeRoutersError = ListEdgeRoutersErrors[keyof ListEdgeRoutersErrors];
export type ListEdgeRoutersResponses = {
    /**
     * A list of edge routers
     */
    200: ListEdgeRoutersEnvelope;
};
export type ListEdgeRoutersResponse = ListEdgeRoutersResponses[keyof ListEdgeRoutersResponses];
export type CreateEdgeRouterData = {
    /**
     * A edge router to create
     */
    body: EdgeRouterCreate;
    path?: never;
    query?: never;
    url: '/edge-routers';
};
export type CreateEdgeRouterErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type CreateEdgeRouterError = CreateEdgeRouterErrors[keyof CreateEdgeRouterErrors];
export type CreateEdgeRouterResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type CreateEdgeRouterResponse = CreateEdgeRouterResponses[keyof CreateEdgeRouterResponses];
export type DeleteEdgeRouterData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/edge-routers/{id}';
};
export type DeleteEdgeRouterErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested to be removed/altered cannot be as it is referenced by another object.
     */
    409: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DeleteEdgeRouterError = DeleteEdgeRouterErrors[keyof DeleteEdgeRouterErrors];
export type DeleteEdgeRouterResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteEdgeRouterResponse = DeleteEdgeRouterResponses[keyof DeleteEdgeRouterResponses];
export type DetailEdgeRouterData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/edge-routers/{id}';
};
export type DetailEdgeRouterErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailEdgeRouterError = DetailEdgeRouterErrors[keyof DetailEdgeRouterErrors];
export type DetailEdgeRouterResponses = {
    /**
     * A singular edge router resource
     */
    200: DetailedEdgeRouterEnvelope;
};
export type DetailEdgeRouterResponse = DetailEdgeRouterResponses[keyof DetailEdgeRouterResponses];
export type PatchEdgeRouterData = {
    /**
     * An edge router patch object
     */
    body: EdgeRouterPatch;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/edge-routers/{id}';
};
export type PatchEdgeRouterErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type PatchEdgeRouterError = PatchEdgeRouterErrors[keyof PatchEdgeRouterErrors];
export type PatchEdgeRouterResponses = {
    /**
     * The patch request was successful and the resource has been altered
     */
    200: Empty;
};
export type PatchEdgeRouterResponse = PatchEdgeRouterResponses[keyof PatchEdgeRouterResponses];
export type UpdateEdgeRouterData = {
    /**
     * An edge router update object
     */
    body: EdgeRouterUpdate;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/edge-routers/{id}';
};
export type UpdateEdgeRouterErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type UpdateEdgeRouterError = UpdateEdgeRouterErrors[keyof UpdateEdgeRouterErrors];
export type UpdateEdgeRouterResponses = {
    /**
     * The update request was successful and the resource has been altered
     */
    200: Empty;
};
export type UpdateEdgeRouterResponse = UpdateEdgeRouterResponses[keyof UpdateEdgeRouterResponses];
export type ListEdgeRouterEdgeRouterPoliciesData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/edge-routers/{id}/edge-router-policies';
};
export type ListEdgeRouterEdgeRouterPoliciesErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListEdgeRouterEdgeRouterPoliciesError = ListEdgeRouterEdgeRouterPoliciesErrors[keyof ListEdgeRouterEdgeRouterPoliciesErrors];
export type ListEdgeRouterEdgeRouterPoliciesResponses = {
    /**
     * A list of edge router policies
     */
    200: ListEdgeRouterPoliciesEnvelope;
};
export type ListEdgeRouterEdgeRouterPoliciesResponse = ListEdgeRouterEdgeRouterPoliciesResponses[keyof ListEdgeRouterEdgeRouterPoliciesResponses];
export type ListEdgeRouterIdentitiesData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/edge-routers/{id}/identities';
};
export type ListEdgeRouterIdentitiesErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListEdgeRouterIdentitiesError = ListEdgeRouterIdentitiesErrors[keyof ListEdgeRouterIdentitiesErrors];
export type ListEdgeRouterIdentitiesResponses = {
    /**
     * A list of identities
     */
    200: ListIdentitiesEnvelope;
};
export type ListEdgeRouterIdentitiesResponse = ListEdgeRouterIdentitiesResponses[keyof ListEdgeRouterIdentitiesResponses];
export type ReEnrollEdgeRouterData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/edge-routers/{id}/re-enroll';
};
export type ReEnrollEdgeRouterErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ReEnrollEdgeRouterError = ReEnrollEdgeRouterErrors[keyof ReEnrollEdgeRouterErrors];
export type ReEnrollEdgeRouterResponses = {
    /**
     * Base empty response
     */
    200: Empty;
};
export type ReEnrollEdgeRouterResponse = ReEnrollEdgeRouterResponses[keyof ReEnrollEdgeRouterResponses];
export type ListEdgeRouterServiceEdgeRouterPoliciesData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/edge-routers/{id}/service-edge-router-policies';
};
export type ListEdgeRouterServiceEdgeRouterPoliciesErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListEdgeRouterServiceEdgeRouterPoliciesError = ListEdgeRouterServiceEdgeRouterPoliciesErrors[keyof ListEdgeRouterServiceEdgeRouterPoliciesErrors];
export type ListEdgeRouterServiceEdgeRouterPoliciesResponses = {
    /**
     * A list of service policies
     */
    200: ListServicePoliciesEnvelope;
};
export type ListEdgeRouterServiceEdgeRouterPoliciesResponse = ListEdgeRouterServiceEdgeRouterPoliciesResponses[keyof ListEdgeRouterServiceEdgeRouterPoliciesResponses];
export type ListEdgeRouterServicesData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/edge-routers/{id}/services';
};
export type ListEdgeRouterServicesErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListEdgeRouterServicesError = ListEdgeRouterServicesErrors[keyof ListEdgeRouterServicesErrors];
export type ListEdgeRouterServicesResponses = {
    /**
     * A list of services
     */
    200: ListServicesEnvelope;
};
export type ListEdgeRouterServicesResponse = ListEdgeRouterServicesResponses[keyof ListEdgeRouterServicesResponses];
export type ListEnrollmentsData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/enrollments';
};
export type ListEnrollmentsErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListEnrollmentsError = ListEnrollmentsErrors[keyof ListEnrollmentsErrors];
export type ListEnrollmentsResponses = {
    /**
     * A list of enrollments
     */
    200: ListEnrollmentsEnvelope;
};
export type ListEnrollmentsResponse = ListEnrollmentsResponses[keyof ListEnrollmentsResponses];
export type CreateEnrollmentData = {
    /**
     * An enrollment to create
     */
    body: EnrollmentCreate;
    path?: never;
    query?: never;
    url: '/enrollments';
};
export type CreateEnrollmentErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The request could not be completed due to a conflict of configuration or state
     */
    409: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type CreateEnrollmentError = CreateEnrollmentErrors[keyof CreateEnrollmentErrors];
export type CreateEnrollmentResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type CreateEnrollmentResponse = CreateEnrollmentResponses[keyof CreateEnrollmentResponses];
export type DeleteEnrollmentData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/enrollments/{id}';
};
export type DeleteEnrollmentErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DeleteEnrollmentError = DeleteEnrollmentErrors[keyof DeleteEnrollmentErrors];
export type DeleteEnrollmentResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteEnrollmentResponse = DeleteEnrollmentResponses[keyof DeleteEnrollmentResponses];
export type DetailEnrollmentData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/enrollments/{id}';
};
export type DetailEnrollmentErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailEnrollmentError = DetailEnrollmentErrors[keyof DetailEnrollmentErrors];
export type DetailEnrollmentResponses = {
    /**
     * A singular enrollment resource
     */
    200: DetailEnrollmentEnvelope;
};
export type DetailEnrollmentResponse = DetailEnrollmentResponses[keyof DetailEnrollmentResponses];
export type RefreshEnrollmentData = {
    /**
     * An enrollment refresh request
     */
    body: EnrollmentRefresh;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/enrollments/{id}/refresh';
};
export type RefreshEnrollmentErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type RefreshEnrollmentError = RefreshEnrollmentErrors[keyof RefreshEnrollmentErrors];
export type RefreshEnrollmentResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    200: CreateEnvelope;
};
export type RefreshEnrollmentResponse = RefreshEnrollmentResponses[keyof RefreshEnrollmentResponses];
export type ListEnumeratedCapabilitiesData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/enumerated-capabilities';
};
export type ListEnumeratedCapabilitiesResponses = {
    /**
     * A typed and enumerated list of capabilities
     */
    200: ListEnumeratedCapabilitiesEnvelope;
};
export type ListEnumeratedCapabilitiesResponse = ListEnumeratedCapabilitiesResponses[keyof ListEnumeratedCapabilitiesResponses];
export type ListExternalJwtSignersData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/external-jwt-signers';
};
export type ListExternalJwtSignersErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListExternalJwtSignersError = ListExternalJwtSignersErrors[keyof ListExternalJwtSignersErrors];
export type ListExternalJwtSignersResponses = {
    /**
     * A list of External JWT Signers
     */
    200: ListExternalJwtSignersEnvelope;
};
export type ListExternalJwtSignersResponse = ListExternalJwtSignersResponses[keyof ListExternalJwtSignersResponses];
export type CreateExternalJwtSignerData = {
    /**
     * An External JWT Signer to create
     */
    body: ExternalJwtSignerCreate;
    path?: never;
    query?: never;
    url: '/external-jwt-signers';
};
export type CreateExternalJwtSignerErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type CreateExternalJwtSignerError = CreateExternalJwtSignerErrors[keyof CreateExternalJwtSignerErrors];
export type CreateExternalJwtSignerResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type CreateExternalJwtSignerResponse = CreateExternalJwtSignerResponses[keyof CreateExternalJwtSignerResponses];
export type DeleteExternalJwtSignerData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/external-jwt-signers/{id}';
};
export type DeleteExternalJwtSignerErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DeleteExternalJwtSignerError = DeleteExternalJwtSignerErrors[keyof DeleteExternalJwtSignerErrors];
export type DeleteExternalJwtSignerResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteExternalJwtSignerResponse = DeleteExternalJwtSignerResponses[keyof DeleteExternalJwtSignerResponses];
export type DetailExternalJwtSignerData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/external-jwt-signers/{id}';
};
export type DetailExternalJwtSignerErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailExternalJwtSignerError = DetailExternalJwtSignerErrors[keyof DetailExternalJwtSignerErrors];
export type DetailExternalJwtSignerResponses = {
    /**
     * A singular External JWT Signer resource
     */
    200: DetailExternalJwtSignerEnvelope;
};
export type DetailExternalJwtSignerResponse = DetailExternalJwtSignerResponses[keyof DetailExternalJwtSignerResponses];
export type PatchExternalJwtSignerData = {
    /**
     * An External JWT Signer patch object
     */
    body: ExternalJwtSignerPatch;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/external-jwt-signers/{id}';
};
export type PatchExternalJwtSignerErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type PatchExternalJwtSignerError = PatchExternalJwtSignerErrors[keyof PatchExternalJwtSignerErrors];
export type PatchExternalJwtSignerResponses = {
    /**
     * The patch request was successful and the resource has been altered
     */
    200: Empty;
};
export type PatchExternalJwtSignerResponse = PatchExternalJwtSignerResponses[keyof PatchExternalJwtSignerResponses];
export type UpdateExternalJwtSignerData = {
    /**
     * An External JWT Signer update object
     */
    body: ExternalJwtSignerUpdate;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/external-jwt-signers/{id}';
};
export type UpdateExternalJwtSignerErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type UpdateExternalJwtSignerError = UpdateExternalJwtSignerErrors[keyof UpdateExternalJwtSignerErrors];
export type UpdateExternalJwtSignerResponses = {
    /**
     * The update request was successful and the resource has been altered
     */
    200: Empty;
};
export type UpdateExternalJwtSignerResponse = UpdateExternalJwtSignerResponses[keyof UpdateExternalJwtSignerResponses];
export type ListIdentitiesData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
        roleFilter?: Array<string>;
        roleSemantic?: string;
    };
    url: '/identities';
};
export type ListIdentitiesErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListIdentitiesError = ListIdentitiesErrors[keyof ListIdentitiesErrors];
export type ListIdentitiesResponses = {
    /**
     * A list of identities
     */
    200: ListIdentitiesEnvelope;
};
export type ListIdentitiesResponse = ListIdentitiesResponses[keyof ListIdentitiesResponses];
export type CreateIdentityData = {
    /**
     * An identity to create
     */
    body: IdentityCreate;
    path?: never;
    query?: never;
    url: '/identities';
};
export type CreateIdentityErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type CreateIdentityError = CreateIdentityErrors[keyof CreateIdentityErrors];
export type CreateIdentityResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type CreateIdentityResponse = CreateIdentityResponses[keyof CreateIdentityResponses];
export type DeleteIdentityData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identities/{id}';
};
export type DeleteIdentityErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested to be removed/altered cannot be as it is referenced by another object.
     */
    409: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DeleteIdentityError = DeleteIdentityErrors[keyof DeleteIdentityErrors];
export type DeleteIdentityResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteIdentityResponse = DeleteIdentityResponses[keyof DeleteIdentityResponses];
export type DetailIdentityData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identities/{id}';
};
export type DetailIdentityErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailIdentityError = DetailIdentityErrors[keyof DetailIdentityErrors];
export type DetailIdentityResponses = {
    /**
     * A single identity
     */
    200: DetailIdentityEnvelope;
};
export type DetailIdentityResponse = DetailIdentityResponses[keyof DetailIdentityResponses];
export type PatchIdentityData = {
    /**
     * An identity patch object
     */
    body: IdentityPatch;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identities/{id}';
};
export type PatchIdentityErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type PatchIdentityError = PatchIdentityErrors[keyof PatchIdentityErrors];
export type PatchIdentityResponses = {
    /**
     * The patch request was successful and the resource has been altered
     */
    200: Empty;
};
export type PatchIdentityResponse = PatchIdentityResponses[keyof PatchIdentityResponses];
export type UpdateIdentityData = {
    /**
     * An identity update object
     */
    body: IdentityUpdate;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identities/{id}';
};
export type UpdateIdentityErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type UpdateIdentityError = UpdateIdentityErrors[keyof UpdateIdentityErrors];
export type UpdateIdentityResponses = {
    /**
     * The update request was successful and the resource has been altered
     */
    200: Empty;
};
export type UpdateIdentityResponse = UpdateIdentityResponses[keyof UpdateIdentityResponses];
export type GetIdentityAuthenticatorsData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identities/{id}/authenticators';
};
export type GetIdentityAuthenticatorsErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type GetIdentityAuthenticatorsError = GetIdentityAuthenticatorsErrors[keyof GetIdentityAuthenticatorsErrors];
export type GetIdentityAuthenticatorsResponses = {
    /**
     * A list of authenticators
     */
    200: ListAuthenticatorsEnvelope;
};
export type GetIdentityAuthenticatorsResponse = GetIdentityAuthenticatorsResponses[keyof GetIdentityAuthenticatorsResponses];
export type DisableIdentityData = {
    /**
     * Disable parameters
     */
    body: DisableParams;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identities/{id}/disable';
};
export type DisableIdentityErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DisableIdentityError = DisableIdentityErrors[keyof DisableIdentityErrors];
export type DisableIdentityResponses = {
    /**
     * Base empty response
     */
    200: Empty;
};
export type DisableIdentityResponse = DisableIdentityResponses[keyof DisableIdentityResponses];
export type ListIdentitysEdgeRouterPoliciesData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identities/{id}/edge-router-policies';
};
export type ListIdentitysEdgeRouterPoliciesErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListIdentitysEdgeRouterPoliciesError = ListIdentitysEdgeRouterPoliciesErrors[keyof ListIdentitysEdgeRouterPoliciesErrors];
export type ListIdentitysEdgeRouterPoliciesResponses = {
    /**
     * A list of edge router policies
     */
    200: ListEdgeRouterPoliciesEnvelope;
};
export type ListIdentitysEdgeRouterPoliciesResponse = ListIdentitysEdgeRouterPoliciesResponses[keyof ListIdentitysEdgeRouterPoliciesResponses];
export type ListIdentityEdgeRoutersData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identities/{id}/edge-routers';
};
export type ListIdentityEdgeRoutersErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListIdentityEdgeRoutersError = ListIdentityEdgeRoutersErrors[keyof ListIdentityEdgeRoutersErrors];
export type ListIdentityEdgeRoutersResponses = {
    /**
     * A list of edge routers
     */
    200: ListEdgeRoutersEnvelope;
};
export type ListIdentityEdgeRoutersResponse = ListIdentityEdgeRoutersResponses[keyof ListIdentityEdgeRoutersResponses];
export type EnableIdentityData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identities/{id}/enable';
};
export type EnableIdentityErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type EnableIdentityError = EnableIdentityErrors[keyof EnableIdentityErrors];
export type EnableIdentityResponses = {
    /**
     * Base empty response
     */
    200: Empty;
};
export type EnableIdentityResponse = EnableIdentityResponses[keyof EnableIdentityResponses];
export type GetIdentityEnrollmentsData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identities/{id}/enrollments';
};
export type GetIdentityEnrollmentsErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type GetIdentityEnrollmentsError = GetIdentityEnrollmentsErrors[keyof GetIdentityEnrollmentsErrors];
export type GetIdentityEnrollmentsResponses = {
    /**
     * A list of enrollments
     */
    200: ListEnrollmentsEnvelope;
};
export type GetIdentityEnrollmentsResponse = GetIdentityEnrollmentsResponses[keyof GetIdentityEnrollmentsResponses];
export type GetIdentityFailedServiceRequestsData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identities/{id}/failed-service-requests';
};
export type GetIdentityFailedServiceRequestsErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type GetIdentityFailedServiceRequestsError = GetIdentityFailedServiceRequestsErrors[keyof GetIdentityFailedServiceRequestsErrors];
export type GetIdentityFailedServiceRequestsResponses = {
    /**
     * Returns a list of service request failures
     */
    200: FailedServiceRequestEnvelope;
};
export type GetIdentityFailedServiceRequestsResponse = GetIdentityFailedServiceRequestsResponses[keyof GetIdentityFailedServiceRequestsResponses];
export type RemoveIdentityMfaData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identities/{id}/mfa';
};
export type RemoveIdentityMfaErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type RemoveIdentityMfaError = RemoveIdentityMfaErrors[keyof RemoveIdentityMfaErrors];
export type RemoveIdentityMfaResponses = {
    /**
     * Base empty response
     */
    200: Empty;
};
export type RemoveIdentityMfaResponse = RemoveIdentityMfaResponses[keyof RemoveIdentityMfaResponses];
export type GetIdentityPolicyAdviceData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
        /**
         * The id of a service
         */
        serviceId: string;
    };
    query?: never;
    url: '/identities/{id}/policy-advice/{serviceId}';
};
export type GetIdentityPolicyAdviceErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type GetIdentityPolicyAdviceError = GetIdentityPolicyAdviceErrors[keyof GetIdentityPolicyAdviceErrors];
export type GetIdentityPolicyAdviceResponses = {
    /**
     * Returns the document that represents the policy advice
     */
    200: GetIdentityPolicyAdviceEnvelope;
};
export type GetIdentityPolicyAdviceResponse = GetIdentityPolicyAdviceResponses[keyof GetIdentityPolicyAdviceResponses];
export type GetIdentityPostureDataData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identities/{id}/posture-data';
};
export type GetIdentityPostureDataErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type GetIdentityPostureDataError = GetIdentityPostureDataErrors[keyof GetIdentityPostureDataErrors];
export type GetIdentityPostureDataResponses = {
    /**
     * Returns the document that represents posture data
     */
    200: PostureDataEnvelope;
};
export type GetIdentityPostureDataResponse = GetIdentityPostureDataResponses[keyof GetIdentityPostureDataResponses];
export type RequestExtendAllCertAuthenticatorsData = {
    /**
     * A request to flag a certificate authenticator for early extension/key rolling.
     */
    body: RequestExtendAuthenticator;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identities/{id}/request-extend';
};
export type RequestExtendAllCertAuthenticatorsErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The request could not be completed and will never complete due to unchangeable state or conflicts.
     */
    403: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type RequestExtendAllCertAuthenticatorsError = RequestExtendAllCertAuthenticatorsErrors[keyof RequestExtendAllCertAuthenticatorsErrors];
export type RequestExtendAllCertAuthenticatorsResponses = {
    /**
     * Base empty response
     */
    200: Empty;
};
export type RequestExtendAllCertAuthenticatorsResponse = RequestExtendAllCertAuthenticatorsResponses[keyof RequestExtendAllCertAuthenticatorsResponses];
export type DisassociateIdentitysServiceConfigsData = {
    /**
     * An array of service and config id pairs to remove
     */
    body?: ServiceConfigsAssignList;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identities/{id}/service-configs';
};
export type DisassociateIdentitysServiceConfigsErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DisassociateIdentitysServiceConfigsError = DisassociateIdentitysServiceConfigsErrors[keyof DisassociateIdentitysServiceConfigsErrors];
export type DisassociateIdentitysServiceConfigsResponses = {
    /**
     * Base empty response
     */
    200: Empty;
};
export type DisassociateIdentitysServiceConfigsResponse = DisassociateIdentitysServiceConfigsResponses[keyof DisassociateIdentitysServiceConfigsResponses];
export type ListIdentitysServiceConfigsData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identities/{id}/service-configs';
};
export type ListIdentitysServiceConfigsErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListIdentitysServiceConfigsError = ListIdentitysServiceConfigsErrors[keyof ListIdentitysServiceConfigsErrors];
export type ListIdentitysServiceConfigsResponses = {
    /**
     * A list of service configs
     */
    200: ListServiceConfigsEnvelope;
};
export type ListIdentitysServiceConfigsResponse = ListIdentitysServiceConfigsResponses[keyof ListIdentitysServiceConfigsResponses];
export type AssociateIdentitysServiceConfigsData = {
    /**
     * A service config patch object
     */
    body: ServiceConfigsAssignList;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identities/{id}/service-configs';
};
export type AssociateIdentitysServiceConfigsErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type AssociateIdentitysServiceConfigsError = AssociateIdentitysServiceConfigsErrors[keyof AssociateIdentitysServiceConfigsErrors];
export type AssociateIdentitysServiceConfigsResponses = {
    /**
     * Base empty response
     */
    200: Empty;
};
export type AssociateIdentitysServiceConfigsResponse = AssociateIdentitysServiceConfigsResponses[keyof AssociateIdentitysServiceConfigsResponses];
export type ListIdentityServicePoliciesData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identities/{id}/service-policies';
};
export type ListIdentityServicePoliciesErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListIdentityServicePoliciesError = ListIdentityServicePoliciesErrors[keyof ListIdentityServicePoliciesErrors];
export type ListIdentityServicePoliciesResponses = {
    /**
     * A list of service policies
     */
    200: ListServicePoliciesEnvelope;
};
export type ListIdentityServicePoliciesResponse = ListIdentityServicePoliciesResponses[keyof ListIdentityServicePoliciesResponses];
export type ListIdentityServicesData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: {
        filter?: string;
        policyType?: 'dial' | 'bind';
    };
    url: '/identities/{id}/services';
};
export type ListIdentityServicesErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListIdentityServicesError = ListIdentityServicesErrors[keyof ListIdentityServicesErrors];
export type ListIdentityServicesResponses = {
    /**
     * A list of services
     */
    200: ListServicesEnvelope;
};
export type ListIdentityServicesResponse = ListIdentityServicesResponses[keyof ListIdentityServicesResponses];
export type UpdateIdentityTracingData = {
    /**
     * A traceSpec object
     */
    body: TraceSpec;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identities/{id}/trace';
};
export type UpdateIdentityTracingErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type UpdateIdentityTracingError = UpdateIdentityTracingErrors[keyof UpdateIdentityTracingErrors];
export type UpdateIdentityTracingResponses = {
    /**
     * Returns the document that represents the trace state
     */
    200: TraceDetailEnvelope;
};
export type UpdateIdentityTracingResponse = UpdateIdentityTracingResponses[keyof UpdateIdentityTracingResponses];
export type ListIdentityRoleAttributesData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/identity-role-attributes';
};
export type ListIdentityRoleAttributesErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListIdentityRoleAttributesError = ListIdentityRoleAttributesErrors[keyof ListIdentityRoleAttributesErrors];
export type ListIdentityRoleAttributesResponses = {
    /**
     * A list of role attributes
     */
    200: ListRoleAttributesEnvelope;
};
export type ListIdentityRoleAttributesResponse = ListIdentityRoleAttributesResponses[keyof ListIdentityRoleAttributesResponses];
export type ListIdentityTypesData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/identity-types';
};
export type ListIdentityTypesErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListIdentityTypesError = ListIdentityTypesErrors[keyof ListIdentityTypesErrors];
export type ListIdentityTypesResponses = {
    /**
     * A list of identity types
     */
    200: ListIdentityTypesEnvelope;
};
export type ListIdentityTypesResponse = ListIdentityTypesResponses[keyof ListIdentityTypesResponses];
export type DetailIdentityTypeData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/identity-types/{id}';
};
export type DetailIdentityTypeErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailIdentityTypeError = DetailIdentityTypeErrors[keyof DetailIdentityTypeErrors];
export type DetailIdentityTypeResponses = {
    /**
     * A single identity type
     */
    200: DetailIdentityTypeEnvelope;
};
export type DetailIdentityTypeResponse = DetailIdentityTypeResponses[keyof DetailIdentityTypeResponses];
export type ListNetworkJwtsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/network-jwts';
};
export type ListNetworkJwtsErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
};
export type ListNetworkJwtsError = ListNetworkJwtsErrors[keyof ListNetworkJwtsErrors];
export type ListNetworkJwtsResponses = {
    /**
     * A list of network JWTs
     */
    200: ListNetworkJwtsEnvelope;
};
export type ListNetworkJwtsResponse = ListNetworkJwtsResponses[keyof ListNetworkJwtsResponses];
export type ListPostureCheckRoleAttributesData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/posture-check-role-attributes';
};
export type ListPostureCheckRoleAttributesErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListPostureCheckRoleAttributesError = ListPostureCheckRoleAttributesErrors[keyof ListPostureCheckRoleAttributesErrors];
export type ListPostureCheckRoleAttributesResponses = {
    /**
     * A list of role attributes
     */
    200: ListRoleAttributesEnvelope;
};
export type ListPostureCheckRoleAttributesResponse = ListPostureCheckRoleAttributesResponses[keyof ListPostureCheckRoleAttributesResponses];
export type ListPostureCheckTypesData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/posture-check-types';
};
export type ListPostureCheckTypesErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListPostureCheckTypesError = ListPostureCheckTypesErrors[keyof ListPostureCheckTypesErrors];
export type ListPostureCheckTypesResponses = {
    /**
     * A list of posture check types
     */
    200: ListPostureCheckTypesEnvelope;
};
export type ListPostureCheckTypesResponse = ListPostureCheckTypesResponses[keyof ListPostureCheckTypesResponses];
export type DetailPostureCheckTypeData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/posture-check-types/{id}';
};
export type DetailPostureCheckTypeErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailPostureCheckTypeError = DetailPostureCheckTypeErrors[keyof DetailPostureCheckTypeErrors];
export type DetailPostureCheckTypeResponses = {
    /**
     * Retrieves a singular posture check type by id
     */
    200: DetailPostureCheckTypeEnvelope;
};
export type DetailPostureCheckTypeResponse = DetailPostureCheckTypeResponses[keyof DetailPostureCheckTypeResponses];
export type ListPostureChecksData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
        roleFilter?: Array<string>;
        roleSemantic?: string;
    };
    url: '/posture-checks';
};
export type ListPostureChecksErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListPostureChecksError = ListPostureChecksErrors[keyof ListPostureChecksErrors];
export type ListPostureChecksResponses = {
    /**
     * A list of posture checks
     */
    200: ListPostureCheckEnvelope;
};
export type ListPostureChecksResponse = ListPostureChecksResponses[keyof ListPostureChecksResponses];
export type CreatePostureCheckData = {
    /**
     * A Posture Check to create
     */
    body: PostureCheckCreate;
    path?: never;
    query?: never;
    url: '/posture-checks';
};
export type CreatePostureCheckErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type CreatePostureCheckError = CreatePostureCheckErrors[keyof CreatePostureCheckErrors];
export type CreatePostureCheckResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type CreatePostureCheckResponse = CreatePostureCheckResponses[keyof CreatePostureCheckResponses];
export type DeletePostureCheckData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/posture-checks/{id}';
};
export type DeletePostureCheckErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    403: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DeletePostureCheckError = DeletePostureCheckErrors[keyof DeletePostureCheckErrors];
export type DeletePostureCheckResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeletePostureCheckResponse = DeletePostureCheckResponses[keyof DeletePostureCheckResponses];
export type DetailPostureCheckData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/posture-checks/{id}';
};
export type DetailPostureCheckErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailPostureCheckError = DetailPostureCheckErrors[keyof DetailPostureCheckErrors];
export type DetailPostureCheckResponses = {
    /**
     * Retrieves a singular posture check by id
     */
    200: DetailPostureCheckEnvelope;
};
export type DetailPostureCheckResponse = DetailPostureCheckResponses[keyof DetailPostureCheckResponses];
export type PatchPostureCheckData = {
    /**
     * A Posture Check patch object
     */
    body: PostureCheckPatch;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/posture-checks/{id}';
};
export type PatchPostureCheckErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type PatchPostureCheckError = PatchPostureCheckErrors[keyof PatchPostureCheckErrors];
export type PatchPostureCheckResponses = {
    /**
     * The patch request was successful and the resource has been altered
     */
    200: Empty;
};
export type PatchPostureCheckResponse = PatchPostureCheckResponses[keyof PatchPostureCheckResponses];
export type UpdatePostureCheckData = {
    /**
     * A Posture Check update object
     */
    body: PostureCheckUpdate;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/posture-checks/{id}';
};
export type UpdatePostureCheckErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type UpdatePostureCheckError = UpdatePostureCheckErrors[keyof UpdatePostureCheckErrors];
export type UpdatePostureCheckResponses = {
    /**
     * The update request was successful and the resource has been altered
     */
    200: Empty;
};
export type UpdatePostureCheckResponse = UpdatePostureCheckResponses[keyof UpdatePostureCheckResponses];
export type ListRoutersData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/routers';
};
export type ListRoutersErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListRoutersError = ListRoutersErrors[keyof ListRoutersErrors];
export type ListRoutersResponses = {
    /**
     * A list of specifications
     */
    200: ListRoutersEnvelope;
};
export type ListRoutersResponse = ListRoutersResponses[keyof ListRoutersResponses];
export type CreateRouterData = {
    /**
     * A router to create
     */
    body: RouterCreate;
    path?: never;
    query?: never;
    url: '/routers';
};
export type CreateRouterErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type CreateRouterError = CreateRouterErrors[keyof CreateRouterErrors];
export type CreateRouterResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type CreateRouterResponse = CreateRouterResponses[keyof CreateRouterResponses];
export type DeleteRouterData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/routers/{id}';
};
export type DeleteRouterErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested to be removed/altered cannot be as it is referenced by another object.
     */
    409: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DeleteRouterError = DeleteRouterErrors[keyof DeleteRouterErrors];
export type DeleteRouterResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteRouterResponse = DeleteRouterResponses[keyof DeleteRouterResponses];
export type DetailRouterData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/routers/{id}';
};
export type DetailRouterErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailRouterError = DetailRouterErrors[keyof DetailRouterErrors];
export type DetailRouterResponses = {
    /**
     * A single router
     */
    200: DetailRouterEnvelope;
};
export type DetailRouterResponse = DetailRouterResponses[keyof DetailRouterResponses];
export type PatchRouterData = {
    /**
     * A router patch object
     */
    body: RouterPatch;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/routers/{id}';
};
export type PatchRouterErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type PatchRouterError = PatchRouterErrors[keyof PatchRouterErrors];
export type PatchRouterResponses = {
    /**
     * The patch request was successful and the resource has been altered
     */
    200: Empty;
};
export type PatchRouterResponse = PatchRouterResponses[keyof PatchRouterResponses];
export type UpdateRouterData = {
    /**
     * A router update object
     */
    body: RouterUpdate;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/routers/{id}';
};
export type UpdateRouterErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type UpdateRouterError = UpdateRouterErrors[keyof UpdateRouterErrors];
export type UpdateRouterResponses = {
    /**
     * The update request was successful and the resource has been altered
     */
    200: Empty;
};
export type UpdateRouterResponse = UpdateRouterResponses[keyof UpdateRouterResponses];
export type ListServiceEdgeRouterPoliciesData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/service-edge-router-policies';
};
export type ListServiceEdgeRouterPoliciesErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListServiceEdgeRouterPoliciesError = ListServiceEdgeRouterPoliciesErrors[keyof ListServiceEdgeRouterPoliciesErrors];
export type ListServiceEdgeRouterPoliciesResponses = {
    /**
     * A list of service edge router policies
     */
    200: ListServiceEdgeRouterPoliciesEnvelope;
};
export type ListServiceEdgeRouterPoliciesResponse = ListServiceEdgeRouterPoliciesResponses[keyof ListServiceEdgeRouterPoliciesResponses];
export type CreateServiceEdgeRouterPolicyData = {
    /**
     * A service edge router policy to create
     */
    body: ServiceEdgeRouterPolicyCreate;
    path?: never;
    query?: never;
    url: '/service-edge-router-policies';
};
export type CreateServiceEdgeRouterPolicyErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type CreateServiceEdgeRouterPolicyError = CreateServiceEdgeRouterPolicyErrors[keyof CreateServiceEdgeRouterPolicyErrors];
export type CreateServiceEdgeRouterPolicyResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type CreateServiceEdgeRouterPolicyResponse = CreateServiceEdgeRouterPolicyResponses[keyof CreateServiceEdgeRouterPolicyResponses];
export type DeleteServiceEdgeRouterPolicyData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/service-edge-router-policies/{id}';
};
export type DeleteServiceEdgeRouterPolicyErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested to be removed/altered cannot be as it is referenced by another object.
     */
    409: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DeleteServiceEdgeRouterPolicyError = DeleteServiceEdgeRouterPolicyErrors[keyof DeleteServiceEdgeRouterPolicyErrors];
export type DeleteServiceEdgeRouterPolicyResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteServiceEdgeRouterPolicyResponse = DeleteServiceEdgeRouterPolicyResponses[keyof DeleteServiceEdgeRouterPolicyResponses];
export type DetailServiceEdgeRouterPolicyData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/service-edge-router-policies/{id}';
};
export type DetailServiceEdgeRouterPolicyErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailServiceEdgeRouterPolicyError = DetailServiceEdgeRouterPolicyErrors[keyof DetailServiceEdgeRouterPolicyErrors];
export type DetailServiceEdgeRouterPolicyResponses = {
    /**
     * A single service edge router policy
     */
    200: DetailServiceEdgePolicyEnvelope;
};
export type DetailServiceEdgeRouterPolicyResponse = DetailServiceEdgeRouterPolicyResponses[keyof DetailServiceEdgeRouterPolicyResponses];
export type PatchServiceEdgeRouterPolicyData = {
    /**
     * A service edge router policy patch object
     */
    body: ServiceEdgeRouterPolicyPatch;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/service-edge-router-policies/{id}';
};
export type PatchServiceEdgeRouterPolicyErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type PatchServiceEdgeRouterPolicyError = PatchServiceEdgeRouterPolicyErrors[keyof PatchServiceEdgeRouterPolicyErrors];
export type PatchServiceEdgeRouterPolicyResponses = {
    /**
     * The patch request was successful and the resource has been altered
     */
    200: Empty;
};
export type PatchServiceEdgeRouterPolicyResponse = PatchServiceEdgeRouterPolicyResponses[keyof PatchServiceEdgeRouterPolicyResponses];
export type UpdateServiceEdgeRouterPolicyData = {
    /**
     * A service edge router policy update object
     */
    body: ServiceEdgeRouterPolicyUpdate;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/service-edge-router-policies/{id}';
};
export type UpdateServiceEdgeRouterPolicyErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type UpdateServiceEdgeRouterPolicyError = UpdateServiceEdgeRouterPolicyErrors[keyof UpdateServiceEdgeRouterPolicyErrors];
export type UpdateServiceEdgeRouterPolicyResponses = {
    /**
     * The update request was successful and the resource has been altered
     */
    200: Empty;
};
export type UpdateServiceEdgeRouterPolicyResponse = UpdateServiceEdgeRouterPolicyResponses[keyof UpdateServiceEdgeRouterPolicyResponses];
export type ListServiceEdgeRouterPolicyEdgeRoutersData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/service-edge-router-policies/{id}/edge-routers';
};
export type ListServiceEdgeRouterPolicyEdgeRoutersErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListServiceEdgeRouterPolicyEdgeRoutersError = ListServiceEdgeRouterPolicyEdgeRoutersErrors[keyof ListServiceEdgeRouterPolicyEdgeRoutersErrors];
export type ListServiceEdgeRouterPolicyEdgeRoutersResponses = {
    /**
     * A list of edge routers
     */
    200: ListEdgeRoutersEnvelope;
};
export type ListServiceEdgeRouterPolicyEdgeRoutersResponse = ListServiceEdgeRouterPolicyEdgeRoutersResponses[keyof ListServiceEdgeRouterPolicyEdgeRoutersResponses];
export type ListServiceEdgeRouterPolicyServicesData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/service-edge-router-policies/{id}/services';
};
export type ListServiceEdgeRouterPolicyServicesErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListServiceEdgeRouterPolicyServicesError = ListServiceEdgeRouterPolicyServicesErrors[keyof ListServiceEdgeRouterPolicyServicesErrors];
export type ListServiceEdgeRouterPolicyServicesResponses = {
    /**
     * A list of services
     */
    200: ListServicesEnvelope;
};
export type ListServiceEdgeRouterPolicyServicesResponse = ListServiceEdgeRouterPolicyServicesResponses[keyof ListServiceEdgeRouterPolicyServicesResponses];
export type ListServicePoliciesData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/service-policies';
};
export type ListServicePoliciesErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListServicePoliciesError = ListServicePoliciesErrors[keyof ListServicePoliciesErrors];
export type ListServicePoliciesResponses = {
    /**
     * A list of service policies
     */
    200: ListServicePoliciesEnvelope;
};
export type ListServicePoliciesResponse = ListServicePoliciesResponses[keyof ListServicePoliciesResponses];
export type CreateServicePolicyData = {
    /**
     * A service policy to create
     */
    body: ServicePolicyCreate;
    path?: never;
    query?: never;
    url: '/service-policies';
};
export type CreateServicePolicyErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type CreateServicePolicyError = CreateServicePolicyErrors[keyof CreateServicePolicyErrors];
export type CreateServicePolicyResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type CreateServicePolicyResponse = CreateServicePolicyResponses[keyof CreateServicePolicyResponses];
export type DeleteServicePolicyData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/service-policies/{id}';
};
export type DeleteServicePolicyErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested to be removed/altered cannot be as it is referenced by another object.
     */
    409: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DeleteServicePolicyError = DeleteServicePolicyErrors[keyof DeleteServicePolicyErrors];
export type DeleteServicePolicyResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteServicePolicyResponse = DeleteServicePolicyResponses[keyof DeleteServicePolicyResponses];
export type DetailServicePolicyData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/service-policies/{id}';
};
export type DetailServicePolicyErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailServicePolicyError = DetailServicePolicyErrors[keyof DetailServicePolicyErrors];
export type DetailServicePolicyResponses = {
    /**
     * A single service policy
     */
    200: DetailServicePolicyEnvelop;
};
export type DetailServicePolicyResponse = DetailServicePolicyResponses[keyof DetailServicePolicyResponses];
export type PatchServicePolicyData = {
    /**
     * A service policy patch object
     */
    body: ServicePolicyPatch;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/service-policies/{id}';
};
export type PatchServicePolicyErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type PatchServicePolicyError = PatchServicePolicyErrors[keyof PatchServicePolicyErrors];
export type PatchServicePolicyResponses = {
    /**
     * The patch request was successful and the resource has been altered
     */
    200: Empty;
};
export type PatchServicePolicyResponse = PatchServicePolicyResponses[keyof PatchServicePolicyResponses];
export type UpdateServicePolicyData = {
    /**
     * A service policy update object
     */
    body: ServicePolicyUpdate;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/service-policies/{id}';
};
export type UpdateServicePolicyErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type UpdateServicePolicyError = UpdateServicePolicyErrors[keyof UpdateServicePolicyErrors];
export type UpdateServicePolicyResponses = {
    /**
     * The update request was successful and the resource has been altered
     */
    200: Empty;
};
export type UpdateServicePolicyResponse = UpdateServicePolicyResponses[keyof UpdateServicePolicyResponses];
export type ListServicePolicyIdentitiesData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/service-policies/{id}/identities';
};
export type ListServicePolicyIdentitiesErrors = {
    /**
     * The requested resource does not exist
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListServicePolicyIdentitiesError = ListServicePolicyIdentitiesErrors[keyof ListServicePolicyIdentitiesErrors];
export type ListServicePolicyIdentitiesResponses = {
    /**
     * A list of identities
     */
    200: ListIdentitiesEnvelope;
};
export type ListServicePolicyIdentitiesResponse = ListServicePolicyIdentitiesResponses[keyof ListServicePolicyIdentitiesResponses];
export type ListServicePolicyPostureChecksData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/service-policies/{id}/posture-checks';
};
export type ListServicePolicyPostureChecksErrors = {
    /**
     * The requested resource does not exist
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListServicePolicyPostureChecksError = ListServicePolicyPostureChecksErrors[keyof ListServicePolicyPostureChecksErrors];
export type ListServicePolicyPostureChecksResponses = {
    /**
     * A list of posture checks
     */
    200: ListPostureCheckEnvelope;
};
export type ListServicePolicyPostureChecksResponse = ListServicePolicyPostureChecksResponses[keyof ListServicePolicyPostureChecksResponses];
export type ListServicePolicyServicesData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/service-policies/{id}/services';
};
export type ListServicePolicyServicesErrors = {
    /**
     * The requested resource does not exist
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListServicePolicyServicesError = ListServicePolicyServicesErrors[keyof ListServicePolicyServicesErrors];
export type ListServicePolicyServicesResponses = {
    /**
     * A list of services
     */
    200: ListServicesEnvelope;
};
export type ListServicePolicyServicesResponse = ListServicePolicyServicesResponses[keyof ListServicePolicyServicesResponses];
export type ListServiceRoleAttributesData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/service-role-attributes';
};
export type ListServiceRoleAttributesErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListServiceRoleAttributesError = ListServiceRoleAttributesErrors[keyof ListServiceRoleAttributesErrors];
export type ListServiceRoleAttributesResponses = {
    /**
     * A list of role attributes
     */
    200: ListRoleAttributesEnvelope;
};
export type ListServiceRoleAttributesResponse = ListServiceRoleAttributesResponses[keyof ListServiceRoleAttributesResponses];
export type ListServicesData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
        configTypes?: Array<string>;
        roleFilter?: Array<string>;
        roleSemantic?: string;
    };
    url: '/services';
};
export type ListServicesErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListServicesError = ListServicesErrors[keyof ListServicesErrors];
export type ListServicesResponses = {
    /**
     * A list of services
     */
    200: ListServicesEnvelope;
};
export type ListServicesResponse = ListServicesResponses[keyof ListServicesResponses];
export type CreateServiceData = {
    /**
     * A service to create
     */
    body: ServiceCreate;
    path?: never;
    query?: never;
    url: '/services';
};
export type CreateServiceErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type CreateServiceError = CreateServiceErrors[keyof CreateServiceErrors];
export type CreateServiceResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type CreateServiceResponse = CreateServiceResponses[keyof CreateServiceResponses];
export type DeleteServiceData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/services/{id}';
};
export type DeleteServiceErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested to be removed/altered cannot be as it is referenced by another object.
     */
    409: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DeleteServiceError = DeleteServiceErrors[keyof DeleteServiceErrors];
export type DeleteServiceResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteServiceResponse = DeleteServiceResponses[keyof DeleteServiceResponses];
export type DetailServiceData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/services/{id}';
};
export type DetailServiceErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailServiceError = DetailServiceErrors[keyof DetailServiceErrors];
export type DetailServiceResponses = {
    /**
     * A single service
     */
    200: DetailServiceEnvelope;
};
export type DetailServiceResponse = DetailServiceResponses[keyof DetailServiceResponses];
export type PatchServiceData = {
    /**
     * A service patch object
     */
    body: ServicePatch;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/services/{id}';
};
export type PatchServiceErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type PatchServiceError = PatchServiceErrors[keyof PatchServiceErrors];
export type PatchServiceResponses = {
    /**
     * The patch request was successful and the resource has been altered
     */
    200: Empty;
};
export type PatchServiceResponse = PatchServiceResponses[keyof PatchServiceResponses];
export type UpdateServiceData = {
    /**
     * A service update object
     */
    body: ServiceUpdate;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/services/{id}';
};
export type UpdateServiceErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type UpdateServiceError = UpdateServiceErrors[keyof UpdateServiceErrors];
export type UpdateServiceResponses = {
    /**
     * The update request was successful and the resource has been altered
     */
    200: Empty;
};
export type UpdateServiceResponse = UpdateServiceResponses[keyof UpdateServiceResponses];
export type ListServiceConfigData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/services/{id}/configs';
};
export type ListServiceConfigErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListServiceConfigError = ListServiceConfigErrors[keyof ListServiceConfigErrors];
export type ListServiceConfigResponses = {
    /**
     * A list of configs
     */
    200: ListConfigsEnvelope;
};
export type ListServiceConfigResponse = ListServiceConfigResponses[keyof ListServiceConfigResponses];
export type ListServiceEdgeRoutersData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/services/{id}/edge-routers';
};
export type ListServiceEdgeRoutersErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListServiceEdgeRoutersError = ListServiceEdgeRoutersErrors[keyof ListServiceEdgeRoutersErrors];
export type ListServiceEdgeRoutersResponses = {
    /**
     * A list of edge routers
     */
    200: ListEdgeRoutersEnvelope;
};
export type ListServiceEdgeRoutersResponse = ListServiceEdgeRoutersResponses[keyof ListServiceEdgeRoutersResponses];
export type ListServiceIdentitiesData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
        policyType?: 'dial' | 'bind';
    };
    url: '/services/{id}/identities';
};
export type ListServiceIdentitiesErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListServiceIdentitiesError = ListServiceIdentitiesErrors[keyof ListServiceIdentitiesErrors];
export type ListServiceIdentitiesResponses = {
    /**
     * A list of identities
     */
    200: ListIdentitiesEnvelope;
};
export type ListServiceIdentitiesResponse = ListServiceIdentitiesResponses[keyof ListServiceIdentitiesResponses];
export type ListServiceServiceEdgeRouterPoliciesData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/services/{id}/service-edge-router-policies';
};
export type ListServiceServiceEdgeRouterPoliciesErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListServiceServiceEdgeRouterPoliciesError = ListServiceServiceEdgeRouterPoliciesErrors[keyof ListServiceServiceEdgeRouterPoliciesErrors];
export type ListServiceServiceEdgeRouterPoliciesResponses = {
    /**
     * A list of service edge router policies
     */
    200: ListServiceEdgeRouterPoliciesEnvelope;
};
export type ListServiceServiceEdgeRouterPoliciesResponse = ListServiceServiceEdgeRouterPoliciesResponses[keyof ListServiceServiceEdgeRouterPoliciesResponses];
export type ListServiceServicePoliciesData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/services/{id}/service-policies';
};
export type ListServiceServicePoliciesErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListServiceServicePoliciesError = ListServiceServicePoliciesErrors[keyof ListServiceServicePoliciesErrors];
export type ListServiceServicePoliciesResponses = {
    /**
     * A list of service policies
     */
    200: ListServicePoliciesEnvelope;
};
export type ListServiceServicePoliciesResponse = ListServiceServicePoliciesResponses[keyof ListServiceServicePoliciesResponses];
export type ListServiceTerminatorsData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/services/{id}/terminators';
};
export type ListServiceTerminatorsErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListServiceTerminatorsError = ListServiceTerminatorsErrors[keyof ListServiceTerminatorsErrors];
export type ListServiceTerminatorsResponses = {
    /**
     * A list of terminators
     */
    200: ListTerminatorsEnvelope;
};
export type ListServiceTerminatorsResponse = ListServiceTerminatorsResponses[keyof ListServiceTerminatorsResponses];
export type ListSessionsData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/sessions';
};
export type ListSessionsErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListSessionsError = ListSessionsErrors[keyof ListSessionsErrors];
export type ListSessionsResponses = {
    /**
     * A list of sessions
     */
    200: ListSessionsManagementEnvelope;
};
export type ListSessionsResponse = ListSessionsResponses[keyof ListSessionsResponses];
export type DeleteSessionData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/sessions/{id}';
};
export type DeleteSessionErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested to be removed/altered cannot be as it is referenced by another object.
     */
    409: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DeleteSessionError = DeleteSessionErrors[keyof DeleteSessionErrors];
export type DeleteSessionResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteSessionResponse = DeleteSessionResponses[keyof DeleteSessionResponses];
export type DetailSessionData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/sessions/{id}';
};
export type DetailSessionErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailSessionError = DetailSessionErrors[keyof DetailSessionErrors];
export type DetailSessionResponses = {
    /**
     * A single session
     */
    200: DetailSessionManagementEnvelope;
};
export type DetailSessionResponse = DetailSessionResponses[keyof DetailSessionResponses];
export type DetailSessionRoutePathData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/sessions/{id}/route-path';
};
export type DetailSessionRoutePathErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailSessionRoutePathError = DetailSessionRoutePathErrors[keyof DetailSessionRoutePathErrors];
export type DetailSessionRoutePathResponses = {
    /**
     * A single session's route path
     */
    200: DetailSessionRoutePathEnvelope;
};
export type DetailSessionRoutePathResponse = DetailSessionRoutePathResponses[keyof DetailSessionRoutePathResponses];
export type ListSpecsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/specs';
};
export type ListSpecsResponses = {
    /**
     * A list of specifications
     */
    200: ListSpecsEnvelope;
};
export type ListSpecsResponse = ListSpecsResponses[keyof ListSpecsResponses];
export type DetailSpecData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/specs/{id}';
};
export type DetailSpecResponses = {
    /**
     * A single specification
     */
    200: DetailSpecEnvelope;
};
export type DetailSpecResponse = DetailSpecResponses[keyof DetailSpecResponses];
export type DetailSpecBodyData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/specs/{id}/spec';
};
export type DetailSpecBodyResponses = {
    /**
     * Returns the document that represents the specification
     */
    200: DetailSpecBodyEnvelope;
};
export type DetailSpecBodyResponse = DetailSpecBodyResponses[keyof DetailSpecBodyResponses];
export type ListSummaryData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/summary';
};
export type ListSummaryErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListSummaryError = ListSummaryErrors[keyof ListSummaryErrors];
export type ListSummaryResponses = {
    /**
     * Entity counts scopped to the current identitie's access
     */
    200: ListSummaryCountsEnvelope;
};
export type ListSummaryResponse = ListSummaryResponses[keyof ListSummaryResponses];
export type ListTerminatorsData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/terminators';
};
export type ListTerminatorsErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListTerminatorsError = ListTerminatorsErrors[keyof ListTerminatorsErrors];
export type ListTerminatorsResponses = {
    /**
     * A list of terminators
     */
    200: ListTerminatorsEnvelope;
};
export type ListTerminatorsResponse = ListTerminatorsResponses[keyof ListTerminatorsResponses];
export type CreateTerminatorData = {
    /**
     * A terminator to create
     */
    body: TerminatorCreate;
    path?: never;
    query?: never;
    url: '/terminators';
};
export type CreateTerminatorErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type CreateTerminatorError = CreateTerminatorErrors[keyof CreateTerminatorErrors];
export type CreateTerminatorResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type CreateTerminatorResponse = CreateTerminatorResponses[keyof CreateTerminatorResponses];
export type DeleteTerminatorData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/terminators/{id}';
};
export type DeleteTerminatorErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested to be removed/altered cannot be as it is referenced by another object.
     */
    409: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DeleteTerminatorError = DeleteTerminatorErrors[keyof DeleteTerminatorErrors];
export type DeleteTerminatorResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteTerminatorResponse = DeleteTerminatorResponses[keyof DeleteTerminatorResponses];
export type DetailTerminatorData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/terminators/{id}';
};
export type DetailTerminatorErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailTerminatorError = DetailTerminatorErrors[keyof DetailTerminatorErrors];
export type DetailTerminatorResponses = {
    /**
     * A single terminator
     */
    200: DetailTerminatorEnvelope;
};
export type DetailTerminatorResponse = DetailTerminatorResponses[keyof DetailTerminatorResponses];
export type PatchTerminatorData = {
    /**
     * A terminator patch object
     */
    body: TerminatorPatch;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/terminators/{id}';
};
export type PatchTerminatorErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type PatchTerminatorError = PatchTerminatorErrors[keyof PatchTerminatorErrors];
export type PatchTerminatorResponses = {
    /**
     * The patch request was successful and the resource has been altered
     */
    200: Empty;
};
export type PatchTerminatorResponse = PatchTerminatorResponses[keyof PatchTerminatorResponses];
export type UpdateTerminatorData = {
    /**
     * A terminator update object
     */
    body: TerminatorUpdate;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/terminators/{id}';
};
export type UpdateTerminatorErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type UpdateTerminatorError = UpdateTerminatorErrors[keyof UpdateTerminatorErrors];
export type UpdateTerminatorResponses = {
    /**
     * The update request was successful and the resource has been altered
     */
    200: Empty;
};
export type UpdateTerminatorResponse = UpdateTerminatorResponses[keyof UpdateTerminatorResponses];
export type ListTransitRoutersData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/transit-routers';
};
export type ListTransitRoutersErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ListTransitRoutersError = ListTransitRoutersErrors[keyof ListTransitRoutersErrors];
export type ListTransitRoutersResponses = {
    /**
     * A list of specifications
     */
    200: ListRoutersEnvelope;
};
export type ListTransitRoutersResponse = ListTransitRoutersResponses[keyof ListTransitRoutersResponses];
export type CreateTransitRouterData = {
    /**
     * A router to create
     */
    body: RouterCreate;
    path?: never;
    query?: never;
    url: '/transit-routers';
};
export type CreateTransitRouterErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type CreateTransitRouterError = CreateTransitRouterErrors[keyof CreateTransitRouterErrors];
export type CreateTransitRouterResponses = {
    /**
     * The create request was successful and the resource has been added at the following location
     */
    201: CreateEnvelope;
};
export type CreateTransitRouterResponse = CreateTransitRouterResponses[keyof CreateTransitRouterResponses];
export type DeleteTransitRouterData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/transit-routers/{id}';
};
export type DeleteTransitRouterErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested to be removed/altered cannot be as it is referenced by another object.
     */
    409: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DeleteTransitRouterError = DeleteTransitRouterErrors[keyof DeleteTransitRouterErrors];
export type DeleteTransitRouterResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteTransitRouterResponse = DeleteTransitRouterResponses[keyof DeleteTransitRouterResponses];
export type DetailTransitRouterData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/transit-routers/{id}';
};
export type DetailTransitRouterErrors = {
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type DetailTransitRouterError = DetailTransitRouterErrors[keyof DetailTransitRouterErrors];
export type DetailTransitRouterResponses = {
    /**
     * A single router
     */
    200: DetailRouterEnvelope;
};
export type DetailTransitRouterResponse = DetailTransitRouterResponses[keyof DetailTransitRouterResponses];
export type PatchTransitRouterData = {
    /**
     * A router patch object
     */
    body: RouterPatch;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/transit-routers/{id}';
};
export type PatchTransitRouterErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type PatchTransitRouterError = PatchTransitRouterErrors[keyof PatchTransitRouterErrors];
export type PatchTransitRouterResponses = {
    /**
     * The patch request was successful and the resource has been altered
     */
    200: Empty;
};
export type PatchTransitRouterResponse = PatchTransitRouterResponses[keyof PatchTransitRouterResponses];
export type UpdateTransitRouterData = {
    /**
     * A router update object
     */
    body: RouterUpdate;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/transit-routers/{id}';
};
export type UpdateTransitRouterErrors = {
    /**
     * The supplied request contains invalid fields or could not be parsed (json and non-json bodies). The error's code, message, and cause fields can be inspected for further information
     */
    400: ApiErrorEnvelope;
    /**
     * The supplied session does not have the correct access rights to request this resource
     */
    401: ApiErrorEnvelope;
    /**
     * The requested resource does not exist
     */
    404: ApiErrorEnvelope;
    /**
     * The resource requested is rate limited and the rate limit has been exceeded
     */
    429: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type UpdateTransitRouterError = UpdateTransitRouterErrors[keyof UpdateTransitRouterErrors];
export type UpdateTransitRouterResponses = {
    /**
     * The update request was successful and the resource has been altered
     */
    200: Empty;
};
export type UpdateTransitRouterResponse = UpdateTransitRouterResponses[keyof UpdateTransitRouterResponses];
export type ListVersionData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/version';
};
export type ListVersionResponses = {
    /**
     * Version information for the controller
     */
    200: ListVersionEnvelope;
};
export type ListVersionResponse = ListVersionResponses[keyof ListVersionResponses];