import * as z from "zod/v4";
import { Result as SafeParseResult } from "../types/fp.js";
import { DeploymentPortalManagedDnsRecord } from "./deploymentportalmanageddnsrecord.js";
import { DomainEndpointKind } from "./domainendpointkind.js";
import { DomainEndpointOwner } from "./domainendpointowner.js";
import { DomainEndpointStatus } from "./domainendpointstatus.js";
import { SDKValidationError } from "./errors/sdkvalidationerror.js";
/**
 * Canonical error container that provides a structured way to represent errors
 *
 * @remarks
 * with rich metadata including error codes, human-readable messages, context,
 * and chaining capabilities for error propagation.
 *
 * This struct is designed to be both machine-readable and user-friendly,
 * supporting serialization for API responses and detailed error reporting
 * in distributed systems.
 */
export type DomainEndpointError = {
    /**
     * A unique identifier for the type of error.
     *
     * @remarks
     *
     * This should be a short, machine-readable string that can be used
     * by clients to programmatically handle different error types.
     * Examples: "NOT_FOUND", "VALIDATION_ERROR", "TIMEOUT"
     */
    code: string;
    /**
     * Additional diagnostic information about the error context.
     *
     * @remarks
     *
     * This optional field can contain structured data providing more details
     * about the error, such as validation errors, request parameters that
     * caused the issue, or other relevant context information.
     */
    context?: any | null | undefined;
    /**
     * Optional human-facing remediation hint.
     */
    hint?: string | null | undefined;
    /**
     * HTTP status code for this error.
     *
     * @remarks
     *
     * Used when converting the error to an HTTP response. If None, falls back to
     * the error type's default status code or 500.
     */
    httpStatusCode?: number | null | undefined;
    /**
     * Indicates if this is an internal error that should not be exposed to users.
     *
     * @remarks
     *
     * When `true`, this error contains sensitive information or implementation
     * details that should not be shown to end-users. Such errors should be
     * logged for debugging but replaced with generic error messages in responses.
     */
    internal: boolean;
    /**
     * Human-readable error message.
     *
     * @remarks
     *
     * This message should be clear and actionable for developers or end-users,
     * providing context about what went wrong and potentially how to fix it.
     */
    message: string;
    /**
     * Indicates whether the operation that caused the error should be retried.
     *
     * @remarks
     *
     * When `true`, the error is transient and the operation might succeed
     * if attempted again. When `false`, retrying the same operation is
     * unlikely to succeed without changes.
     */
    retryable: boolean;
    /**
     * The underlying error that caused this error, creating an error chain.
     *
     * @remarks
     *
     * This allows for proper error propagation and debugging by maintaining
     * the full context of how an error occurred through multiple layers
     * of an application.
     */
    source?: any | null | undefined;
};
export type DomainEndpoint = {
    /**
     * Unique identifier for the domain endpoint.
     */
    id: string;
    /**
     * Unique identifier for the workspace.
     */
    workspaceId: string;
    /**
     * Unique identifier for the domain.
     */
    domainId: string;
    kind: DomainEndpointKind;
    owner: DomainEndpointOwner;
    hostname: string;
    status: DomainEndpointStatus;
    provider?: string | null | undefined;
    providerState?: {
        [k: string]: any | null;
    } | null | undefined;
    managedDnsRecords: Array<DeploymentPortalManagedDnsRecord>;
    /**
     * Canonical error container that provides a structured way to represent errors
     *
     * @remarks
     * with rich metadata including error codes, human-readable messages, context,
     * and chaining capabilities for error propagation.
     *
     * This struct is designed to be both machine-readable and user-friendly,
     * supporting serialization for API responses and detailed error reporting
     * in distributed systems.
     */
    error?: DomainEndpointError | null | undefined;
    lockedAt?: Date | null | undefined;
    lockedBy?: string | null | undefined;
    retryAttempts: number;
    nextStepAfter?: Date | null | undefined;
    createdAt: Date;
    updatedAt: Date;
};
/** @internal */
export declare const DomainEndpointError$inboundSchema: z.ZodType<DomainEndpointError, unknown>;
export declare function domainEndpointErrorFromJSON(jsonString: string): SafeParseResult<DomainEndpointError, SDKValidationError>;
/** @internal */
export declare const DomainEndpoint$inboundSchema: z.ZodType<DomainEndpoint, unknown>;
export declare function domainEndpointFromJSON(jsonString: string): SafeParseResult<DomainEndpoint, SDKValidationError>;
//# sourceMappingURL=domainendpoint.d.ts.map