/**
 * Cloudflare REGISTRAR API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service registrar
 */
import * as Schema from "effect/Schema";
import type * as HttpClient from "effect/unstable/http/HttpClient";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import { type DefaultErrors } from "../errors.ts";
export interface GetDomainRequest {
    domainName: string;
    /** Identifier */
    accountId: string;
}
export declare const GetDomainRequest: Schema.Schema<GetDomainRequest>;
export type GetDomainResponse = unknown;
export declare const GetDomainResponse: Schema.Schema<GetDomainResponse>;
export type GetDomainError = DefaultErrors;
export declare const getDomain: API.OperationMethod<GetDomainRequest, GetDomainResponse, GetDomainError, Credentials | HttpClient.HttpClient>;
export interface ListDomainsRequest {
    /** Identifier */
    accountId: string;
}
export declare const ListDomainsRequest: Schema.Schema<ListDomainsRequest>;
export interface ListDomainsResponse {
    result: {
        id?: string | null;
        available?: boolean | null;
        canRegister?: boolean | null;
        createdAt?: string | null;
        currentRegistrar?: string | null;
        expiresAt?: string | null;
        locked?: boolean | null;
        registrantContact?: {
            address: string;
            city: string;
            country: string | null;
            firstName: string | null;
            lastName: string | null;
            organization: string;
            phone: string | null;
            state: string;
            zip: string | null;
            id?: string | null;
            address2?: string | null;
            email?: string | null;
            fax?: string | null;
        } | null;
        registryStatuses?: string | null;
        supportedTld?: boolean | null;
        transferIn?: {
            acceptFoa?: "needed" | "ok" | (string & {}) | null;
            approveTransfer?: "needed" | "ok" | "pending" | "trying" | "rejected" | "unknown" | (string & {}) | null;
            canCancelTransfer?: boolean | null;
            disablePrivacy?: "needed" | "ok" | "unknown" | (string & {}) | null;
            enterAuthCode?: "needed" | "ok" | "pending" | "trying" | "rejected" | (string & {}) | null;
            unlockDomain?: "needed" | "ok" | "pending" | "trying" | "unknown" | (string & {}) | null;
        } | null;
        updatedAt?: string | null;
    }[];
}
export declare const ListDomainsResponse: Schema.Schema<ListDomainsResponse>;
export type ListDomainsError = DefaultErrors;
export declare const listDomains: API.PaginatedOperationMethod<ListDomainsRequest, ListDomainsResponse, ListDomainsError, Credentials | HttpClient.HttpClient>;
export interface PutDomainRequest {
    domainName: string;
    /** Path param: Identifier */
    accountId: string;
    /** Body param: Auto-renew controls whether subscription is automatically renewed upon domain expiration. */
    autoRenew?: boolean;
    /** Body param: Shows whether a registrar lock is in place for a domain. */
    locked?: boolean;
    /** Body param: Privacy option controls redacting WHOIS information. */
    privacy?: boolean;
}
export declare const PutDomainRequest: Schema.Schema<PutDomainRequest>;
export type PutDomainResponse = unknown;
export declare const PutDomainResponse: Schema.Schema<PutDomainResponse>;
export type PutDomainError = DefaultErrors;
export declare const putDomain: API.OperationMethod<PutDomainRequest, PutDomainResponse, PutDomainError, Credentials | HttpClient.HttpClient>;
export interface CheckRegistrarRequest {
    /** Path param: Identifier */
    accountId: string;
    /** Body param: List of fully qualified domain names (FQDNs) to check for availability. Each domain must include the extension.  - Minimum: 1 domain - Maximum: 20 domains per request - Domains on unsuppor */
    domains: string[];
}
export declare const CheckRegistrarRequest: Schema.Schema<CheckRegistrarRequest>;
export interface CheckRegistrarResponse {
    /** Array of domain availability results. Domains on unsupported extensions are included with `registrable: false` and a `reason` field. Malformed domain names may be omitted. */
    domains: {
        name: string;
        registrable: boolean;
        pricing?: {
            currency: string;
            registrationCost: string;
            renewalCost: string;
        } | null;
        reason?: "extension_not_supported_via_api" | "extension_not_supported" | "extension_disallows_registration" | "domain_premium" | "domain_unavailable" | (string & {}) | null;
        tier?: "standard" | "premium" | (string & {}) | null;
    }[];
}
export declare const CheckRegistrarResponse: Schema.Schema<CheckRegistrarResponse>;
export type CheckRegistrarError = DefaultErrors;
export declare const checkRegistrar: API.OperationMethod<CheckRegistrarRequest, CheckRegistrarResponse, CheckRegistrarError, Credentials | HttpClient.HttpClient>;
export interface SearchRegistrarRequest {
    /** Path param: Identifier */
    accountId: string;
    /** Query param: The search term to find domain suggestions. Accepts keywords, phrases, or full domain names.  - Phrases: "coffee shop" returns coffeeshop.com, mycoffeeshop.net, etc. - Domain names: "exam */
    q: string;
    /** Query param: Limits results to specific domain extensions from the supported set. If not specified, returns results across all supported extensions. Extensions not in the supported set are silently ig */
    extensions?: string[];
    /** Query param: Maximum number of domain suggestions to return. Defaults to 20 if not specified. */
    limit?: number;
}
export declare const SearchRegistrarRequest: Schema.Schema<SearchRegistrarRequest>;
export interface SearchRegistrarResponse {
    /** Array of domain suggestions sorted by relevance. May be empty if no domains match the search criteria. */
    domains: {
        name: string;
        registrable: boolean;
        pricing?: {
            currency: string;
            registrationCost: string;
            renewalCost: string;
        } | null;
        reason?: "extension_not_supported_via_api" | "extension_not_supported" | "extension_disallows_registration" | "domain_premium" | "domain_unavailable" | (string & {}) | null;
        tier?: "standard" | "premium" | (string & {}) | null;
    }[];
}
export declare const SearchRegistrarResponse: Schema.Schema<SearchRegistrarResponse>;
export type SearchRegistrarError = DefaultErrors;
export declare const searchRegistrar: API.OperationMethod<SearchRegistrarRequest, SearchRegistrarResponse, SearchRegistrarError, Credentials | HttpClient.HttpClient>;
export interface GetRegistrationStatusRequest {
    domainName: string;
    /** Identifier */
    accountId: string;
}
export declare const GetRegistrationStatusRequest: Schema.Schema<GetRegistrationStatusRequest>;
export interface GetRegistrationStatusResponse {
    /** Whether the workflow has reached a terminal state. `true` when `state` is `succeeded` or `failed`. `false` for `pending`, `in_progress`, `action_required`, and `blocked`. */
    completed: boolean;
    createdAt: string;
    links: {
        self: string;
        resource?: string | null;
    };
    /** Workflow lifecycle state.  - `pending`: Workflow has been created but not yet started processing. - `in_progress`: Actively processing. Continue polling `links.self`. The workflow has an internal dead */
    state: "pending" | "in_progress" | "action_required" | "blocked" | "succeeded" | "failed" | (string & {});
    updatedAt: string;
    /** Workflow-specific data for this workflow.  The workflow subject is identified by `context.domain_name` for domain-centric workflows. */
    context?: Record<string, unknown> | null;
    /** Error details when a workflow reaches the `failed` state. The specific error codes and messages depend on the workflow type (registration, update, etc.) and the underlying registry response. These wor */
    error?: {
        code: string;
        message: string;
    } | null;
}
export declare const GetRegistrationStatusResponse: Schema.Schema<GetRegistrationStatusResponse>;
export type GetRegistrationStatusError = DefaultErrors;
export declare const getRegistrationStatus: API.OperationMethod<GetRegistrationStatusRequest, GetRegistrationStatusResponse, GetRegistrationStatusError, Credentials | HttpClient.HttpClient>;
export interface GetUpdateStatusRequest {
    domainName: string;
    /** Identifier */
    accountId: string;
}
export declare const GetUpdateStatusRequest: Schema.Schema<GetUpdateStatusRequest>;
export interface GetUpdateStatusResponse {
    /** Whether the workflow has reached a terminal state. `true` when `state` is `succeeded` or `failed`. `false` for `pending`, `in_progress`, `action_required`, and `blocked`. */
    completed: boolean;
    createdAt: string;
    links: {
        self: string;
        resource?: string | null;
    };
    /** Workflow lifecycle state.  - `pending`: Workflow has been created but not yet started processing. - `in_progress`: Actively processing. Continue polling `links.self`. The workflow has an internal dead */
    state: "pending" | "in_progress" | "action_required" | "blocked" | "succeeded" | "failed" | (string & {});
    updatedAt: string;
    /** Workflow-specific data for this workflow.  The workflow subject is identified by `context.domain_name` for domain-centric workflows. */
    context?: Record<string, unknown> | null;
    /** Error details when a workflow reaches the `failed` state. The specific error codes and messages depend on the workflow type (registration, update, etc.) and the underlying registry response. These wor */
    error?: {
        code: string;
        message: string;
    } | null;
}
export declare const GetUpdateStatusResponse: Schema.Schema<GetUpdateStatusResponse>;
export type GetUpdateStatusError = DefaultErrors;
export declare const getUpdateStatus: API.OperationMethod<GetUpdateStatusRequest, GetUpdateStatusResponse, GetUpdateStatusError, Credentials | HttpClient.HttpClient>;
//# sourceMappingURL=registrar.d.ts.map