export type ClientOptions = {
    baseUrl: 'https://demo.ziti.dev/fabric/v1' | (string & {});
};
export type Pagination = {
    limit: number;
    offset: number;
    totalCount: number;
};
export type Empty = {
    meta: Meta;
    data: {
        [key: string]: unknown;
    };
};
export type Meta = {
    filterableFields?: Array<string>;
    pagination?: Pagination;
    apiEnrollmentVersion?: string;
    apiVersion?: string;
};
export type CreateEnvelope = {
    meta?: Meta;
    data?: CreateLocation;
};
export type CreateLocation = {
    _links?: Links;
    id?: string;
};
/**
 * Fields shared by all Edge API entities
 */
export type BaseEntity = {
    id: string;
    createdAt: string;
    updatedAt: string;
    _links: Links;
    tags: Tags;
};
/**
 * A link to another resource
 */
export type Link = {
    href: string;
    method?: string;
    comment?: string;
};
/**
 * A map of named links
 */
export type Links = {
    [key: string]: Link;
};
/**
 * A reference to another resource and links to interact with it
 */
export type EntityRef = {
    entity?: string;
    id?: string;
    name?: string;
    _links?: Links;
};
/**
 * 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;
export type SubTags = {
    [key: string]: {
        [key: string]: unknown;
    };
};
/**
 * Application build information
 */
export type VersionInfo = {
    version?: string;
    revision?: string;
    buildDate?: string;
    os?: string;
    arch?: string;
};
export type DatabaseSnapshotCreate = {
    path?: string;
};
export type DatabaseSnapshotCreateResultEnvelope = {
    meta: Meta;
    data: DatabaseSnapshotCreateDetails;
};
export type DatabaseSnapshotCreateDetails = {
    path: string;
};
export type DataIntegrityCheckResultEnvelope = {
    meta: Meta;
    data: DataIntegrityCheckDetails;
};
export type DataIntegrityCheckDetails = {
    inProgress: boolean;
    startTime: string;
    endTime: string;
    fixingErrors: boolean;
    error: string;
    tooManyErrors: boolean;
    results: DataIntegrityCheckDetailList;
};
export type DataIntegrityCheckDetailList = Array<DataIntegrityCheckDetail>;
export type DataIntegrityCheckDetail = {
    description: string;
    fixed: boolean;
};
export type ClusterMemberAdd = {
    address: string;
    isVoter: boolean;
};
export type ClusterMemberRemove = {
    id: string;
};
export type ClusterTransferLeadership = {
    newLeaderId?: string;
};
/**
 * A resource describing a network interface
 */
export type Interface = {
    name: string;
    hardwareAddress: string;
    mtu: number;
    index: number;
    isUp: boolean;
    isRunning: boolean;
    isLoopback: boolean;
    isBroadcast: boolean;
    isMulticast: boolean;
    addresses: Array<string>;
};
export type ApiErrorEnvelope = {
    meta: Meta;
    error: ApiError;
};
export type ApiError = {
    args?: ApiErrorArgs;
    data?: {
        [key: string]: unknown;
    };
    causeMessage?: string;
    code?: string;
    message?: string;
    requestId?: string;
    cause?: ApiErrorCause;
};
export type ApiFieldError = {
    reason?: string;
    field?: string;
    value?: string;
};
export type ApiErrorCause = ApiFieldError & ApiError;
export type ApiErrorArgs = {
    urlVars?: {
        [key: string]: string;
    };
};
export type ListServicesEnvelope = {
    meta: Meta;
    data: ServiceList;
};
export type DetailServiceEnvelope = {
    meta: Meta;
    data: ServiceDetail;
};
export type ServiceList = Array<ServiceDetail>;
export type ServiceDetail = BaseEntity & {
    name: string;
    terminatorStrategy: string;
    maxIdleTimeMillis: number;
};
export type ServiceCreate = {
    name: string;
    terminatorStrategy?: string;
    maxIdleTimeMillis?: number;
    tags?: Tags;
};
export type ServiceUpdate = {
    name: string;
    terminatorStrategy?: string;
    maxIdleTimeMillis?: number;
    tags?: Tags;
};
export type ServicePatch = {
    name?: string;
    terminatorStrategy?: string;
    maxIdleTimeMillis?: number;
    tags?: Tags;
};
export type ListRoutersEnvelope = {
    meta: Meta;
    data: RouterList;
};
export type DetailRouterEnvelope = {
    meta: Meta;
    data: RouterDetail;
};
export type RouterList = Array<RouterDetail>;
export type RouterDetail = BaseEntity & {
    name: string;
    fingerprint: string;
    connected: boolean;
    cost: number;
    noTraversal: boolean;
    disabled: boolean;
    listenerAddresses?: Array<RouterListener>;
    versionInfo?: VersionInfo;
    interfaces?: Array<Interface>;
};
export type RouterListener = {
    address: string;
    protocol: string;
};
export type RouterCreate = {
    id: string;
    name: string;
    fingerprint?: string | null;
    cost: number;
    noTraversal: boolean;
    disabled?: boolean | null;
    tags?: Tags;
};
export type RouterUpdate = {
    name: string;
    fingerprint: string;
    cost: number;
    noTraversal: boolean;
    disabled?: boolean | null;
    tags?: Tags;
};
export type RouterPatch = {
    name?: string;
    fingerprint?: string | null;
    cost?: number | null;
    noTraversal?: boolean | null;
    disabled?: boolean | null;
    tags?: Tags;
};
export type ListTerminatorsEnvelope = {
    meta: Meta;
    data: TerminatorList;
};
export type DetailTerminatorEnvelope = {
    meta: Meta;
    data: TerminatorDetail;
};
export type TerminatorList = Array<TerminatorDetail>;
export type TerminatorDetail = BaseEntity & {
    serviceId: string;
    service: EntityRef;
    routerId: string;
    router: EntityRef;
    binding: string;
    address: string;
    instanceId: string;
    cost: TerminatorCost;
    precedence: TerminatorPrecedence;
    dynamicCost: TerminatorCost;
    hostId: string;
};
export type TerminatorCreate = {
    service: string;
    router: string;
    binding: string;
    address: string;
    instanceId?: string;
    instanceSecret?: string;
    cost?: TerminatorCost;
    precedence?: TerminatorPrecedence;
    tags?: Tags;
    hostId?: string;
};
export type TerminatorUpdate = {
    service: string;
    router: string;
    binding: string;
    address: string;
    cost?: TerminatorCost;
    precedence?: TerminatorPrecedence;
    tags?: Tags;
    hostId?: string;
};
export type TerminatorPatch = {
    service?: string;
    router?: string;
    binding?: string;
    address?: string;
    cost?: TerminatorCost;
    precedence?: TerminatorPrecedence;
    tags?: Tags;
    hostId?: string;
};
export type TerminatorCost = number;
export type TerminatorPrecedence = 'default' | 'required' | 'failed';
export type TerminatorPrecedenceMap = {
    [key: string]: TerminatorPrecedence;
};
export type TerminatorCostMap = {
    [key: string]: TerminatorCost;
};
export type ListLinksEnvelope = {
    meta: Meta;
    data: LinkList;
};
export type DetailLinkEnvelope = {
    meta: Meta;
    data: LinkDetail;
};
export type LinkList = Array<LinkDetail>;
export type LinkConnection = {
    type?: string;
    source?: string;
    dest?: string;
};
export type LinkDetail = {
    id: string;
    protocol: string;
    sourceRouter: EntityRef;
    destRouter: EntityRef;
    state: string;
    down: boolean;
    staticCost: number;
    sourceLatency: number;
    destLatency: number;
    cost: number;
    iteration: number;
    connections?: Array<LinkConnection>;
};
export type LinkPatch = {
    down?: boolean;
    staticCost?: number;
};
export type ListCircuitsEnvelope = {
    meta: Meta;
    data: CircuitList;
};
export type DetailCircuitEnvelope = {
    meta: Meta;
    data: CircuitDetail;
};
export type CircuitList = Array<CircuitDetail>;
export type CircuitDetail = BaseEntity & {
    clientId?: string;
    service: EntityRef;
    terminator: EntityRef;
    path: Path;
};
export type CircuitDelete = {
    immediate?: boolean;
};
export type Path = {
    nodes?: Array<EntityRef>;
    links?: Array<EntityRef>;
};
export type InspectRequest = {
    appRegex: string;
    requestedValues: Array<string>;
};
export type InspectResponseValue = {
    appId: string;
    name: string;
    value: unknown;
};
export type InspectResponse = {
    success: boolean;
    errors?: Array<string>;
    values?: Array<InspectResponseValue>;
};
export type ClusterMemberListValue = {
    id: string;
    address: string;
    voter: boolean;
    leader: boolean;
    version: string;
    connected: boolean;
    readOnly: boolean;
};
export type ClusterMemberListResponse = {
    data?: Array<ClusterMemberListValue>;
};
export type ListServicesData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/services';
};
export type ListServicesErrors = {
    /**
     * The currently 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 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 currently 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 currently 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 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 currently 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 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 currently 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 currently 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 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 currently 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 ListServiceTerminatorsError = ListServiceTerminatorsErrors[keyof ListServiceTerminatorsErrors];
export type ListServiceTerminatorsResponses = {
    /**
     * A list of terminators
     */
    200: ListTerminatorsEnvelope;
};
export type ListServiceTerminatorsResponse = ListServiceTerminatorsResponses[keyof ListServiceTerminatorsResponses];
export type ListRoutersData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/routers';
};
export type ListRoutersErrors = {
    /**
     * The currently 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 ListRoutersError = ListRoutersErrors[keyof ListRoutersErrors];
export type ListRoutersResponses = {
    /**
     * A list of routers
     */
    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 currently 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 currently 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 currently 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 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 currently 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 currently 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 ListRouterTerminatorsData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/routers/{id}/terminators';
};
export type ListRouterTerminatorsErrors = {
    /**
     * 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 currently 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 ListRouterTerminatorsError = ListRouterTerminatorsErrors[keyof ListRouterTerminatorsErrors];
export type ListRouterTerminatorsResponses = {
    /**
     * A list of terminators
     */
    200: ListTerminatorsEnvelope;
};
export type ListRouterTerminatorsResponse = ListRouterTerminatorsResponses[keyof ListRouterTerminatorsResponses];
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 currently 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 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 currently 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 currently 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 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 currently 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 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 currently 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 currently 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 ListLinksData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/links';
};
export type ListLinksErrors = {
    /**
     * The currently 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 ListLinksError = ListLinksErrors[keyof ListLinksErrors];
export type ListLinksResponses = {
    /**
     * A list of links
     */
    200: ListLinksEnvelope;
};
export type ListLinksResponse = ListLinksResponses[keyof ListLinksResponses];
export type DeleteLinkData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/links/{id}';
};
export type DeleteLinkErrors = {
    /**
     * 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 currently 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 DeleteLinkError = DeleteLinkErrors[keyof DeleteLinkErrors];
export type DeleteLinkResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteLinkResponse = DeleteLinkResponses[keyof DeleteLinkResponses];
export type DetailLinkData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/links/{id}';
};
export type DetailLinkErrors = {
    /**
     * The currently 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 DetailLinkError = DetailLinkErrors[keyof DetailLinkErrors];
export type DetailLinkResponses = {
    /**
     * A single link
     */
    200: DetailLinkEnvelope;
};
export type DetailLinkResponse = DetailLinkResponses[keyof DetailLinkResponses];
export type PatchLinkData = {
    /**
     * A link patch object
     */
    body: LinkPatch;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/links/{id}';
};
export type PatchLinkErrors = {
    /**
     * 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 currently 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 PatchLinkError = PatchLinkErrors[keyof PatchLinkErrors];
export type PatchLinkResponses = {
    /**
     * The patch request was successful and the resource has been altered
     */
    200: Empty;
};
export type PatchLinkResponse = PatchLinkResponses[keyof PatchLinkResponses];
export type ListCircuitsData = {
    body?: never;
    path?: never;
    query?: {
        limit?: number;
        offset?: number;
        filter?: string;
    };
    url: '/circuits';
};
export type ListCircuitsErrors = {
    /**
     * The currently 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 ListCircuitsError = ListCircuitsErrors[keyof ListCircuitsErrors];
export type ListCircuitsResponses = {
    /**
     * A list of circuits
     */
    200: ListCircuitsEnvelope;
};
export type ListCircuitsResponse = ListCircuitsResponses[keyof ListCircuitsResponses];
export type DeleteCircuitData = {
    /**
     * A circuit delete object
     */
    body?: CircuitDelete;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/circuits/{id}';
};
export type DeleteCircuitErrors = {
    /**
     * 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 currently 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 DeleteCircuitError = DeleteCircuitErrors[keyof DeleteCircuitErrors];
export type DeleteCircuitResponses = {
    /**
     * The delete request was successful and the resource has been removed
     */
    200: Empty;
};
export type DeleteCircuitResponse = DeleteCircuitResponses[keyof DeleteCircuitResponses];
export type DetailCircuitData = {
    body?: never;
    path: {
        /**
         * The id of the requested resource
         */
        id: string;
    };
    query?: never;
    url: '/circuits/{id}';
};
export type DetailCircuitErrors = {
    /**
     * The currently 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 DetailCircuitError = DetailCircuitErrors[keyof DetailCircuitErrors];
export type DetailCircuitResponses = {
    /**
     * A single circuit
     */
    200: DetailCircuitEnvelope;
};
export type DetailCircuitResponse = DetailCircuitResponses[keyof DetailCircuitResponses];
export type InspectData = {
    /**
     * An inspect request
     */
    body: InspectRequest;
    path?: never;
    query?: never;
    url: '/inspections';
};
export type InspectErrors = {
    /**
     * The currently 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 InspectError = InspectErrors[keyof InspectErrors];
export type InspectResponses = {
    /**
     * A response to an inspect request
     */
    200: InspectResponse;
};
export type InspectResponse2 = InspectResponses[keyof InspectResponses];
export type CreateDatabaseSnapshotData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/database';
};
export type CreateDatabaseSnapshotErrors = {
    /**
     * The currently 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 CreateDatabaseSnapshotWithPathData = {
    /**
     * snapshot parameters
     */
    body: DatabaseSnapshotCreate;
    path?: never;
    query?: never;
    url: '/database/snapshot';
};
export type CreateDatabaseSnapshotWithPathErrors = {
    /**
     * The currently 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 CreateDatabaseSnapshotWithPathError = CreateDatabaseSnapshotWithPathErrors[keyof CreateDatabaseSnapshotWithPathErrors];
export type CreateDatabaseSnapshotWithPathResponses = {
    /**
     * The path to the created snapshot
     */
    200: DatabaseSnapshotCreateResultEnvelope;
};
export type CreateDatabaseSnapshotWithPathResponse = CreateDatabaseSnapshotWithPathResponses[keyof CreateDatabaseSnapshotWithPathResponses];
export type CheckDataIntegrityData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/database/check-data-integrity';
};
export type CheckDataIntegrityErrors = {
    /**
     * The currently 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 FixDataIntegrityData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/database/fix-data-integrity';
};
export type FixDataIntegrityErrors = {
    /**
     * The currently 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 DataIntegrityResultsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/database/data-integrity-results';
};
export type DataIntegrityResultsErrors = {
    /**
     * The currently 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 DataIntegrityResultsError = DataIntegrityResultsErrors[keyof DataIntegrityResultsErrors];
export type DataIntegrityResultsResponses = {
    /**
     * A list of data integrity issues found
     */
    200: DataIntegrityCheckResultEnvelope;
};
export type DataIntegrityResultsResponse = DataIntegrityResultsResponses[keyof DataIntegrityResultsResponses];
export type ClusterListMembersData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/cluster/list-members';
};
export type ClusterListMembersErrors = {
    /**
     * 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 currently 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 ClusterListMembersError = ClusterListMembersErrors[keyof ClusterListMembersErrors];
export type ClusterListMembersResponses = {
    /**
     * A response to a cluster list-members request
     */
    200: ClusterMemberListResponse;
};
export type ClusterListMembersResponse = ClusterListMembersResponses[keyof ClusterListMembersResponses];
export type ClusterMemberAddData = {
    /**
     * member parameters
     */
    body: ClusterMemberAdd;
    path?: never;
    query?: never;
    url: '/cluster/add-member';
};
export type ClusterMemberAddErrors = {
    /**
     * 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 currently 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 ClusterMemberAddError = ClusterMemberAddErrors[keyof ClusterMemberAddErrors];
export type ClusterMemberAddResponses = {
    /**
     * Base empty response
     */
    200: Empty;
};
export type ClusterMemberAddResponse = ClusterMemberAddResponses[keyof ClusterMemberAddResponses];
export type ClusterMemberRemoveData = {
    /**
     * member parameters
     */
    body: ClusterMemberRemove;
    path?: never;
    query?: never;
    url: '/cluster/remove-member';
};
export type ClusterMemberRemoveErrors = {
    /**
     * 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 currently 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 ClusterMemberRemoveError = ClusterMemberRemoveErrors[keyof ClusterMemberRemoveErrors];
export type ClusterMemberRemoveResponses = {
    /**
     * Base empty response
     */
    200: Empty;
};
export type ClusterMemberRemoveResponse = ClusterMemberRemoveResponses[keyof ClusterMemberRemoveResponses];
export type ClusterTransferLeadershipData = {
    /**
     * transfer operation parameters
     */
    body: ClusterTransferLeadership;
    path?: never;
    query?: never;
    url: '/cluster/transfer-leadership';
};
export type ClusterTransferLeadershipErrors = {
    /**
     * The currently 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 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
     */
    500: ApiErrorEnvelope;
    /**
     * The request could not be completed due to the server being busy or in a temporarily bad state
     */
    503: ApiErrorEnvelope;
};
export type ClusterTransferLeadershipError = ClusterTransferLeadershipErrors[keyof ClusterTransferLeadershipErrors];
export type ClusterTransferLeadershipResponses = {
    /**
     * Base empty response
     */
    200: Empty;
};
export type ClusterTransferLeadershipResponse = ClusterTransferLeadershipResponses[keyof ClusterTransferLeadershipResponses];