@wix/domains 1.0.0 → 1.0.2

package/type-bundles/context.bundle.d.ts

@@ -1,3 +1,668 @@
+/** A `connectedDomain` object holds information about an external domain and its connection to a Wix site. */
+interface ConnectedDomain {
+    /**
+     * ID of the connected domain. Identical to the domain name including TLD.
+     * @readonly
+     */
+    _id?: string;
+    /**
+     * Domain name including TLD.
+     * Both root domains and subdomains are supported.
+     */
+    domain?: string;
+    /**
+     * How the domain is connected to the Wix site.
+     *
+     * + `"UNKNOWN_CONNECTION_TYPE"`: There is no information about the connection type.
+     * + `"POINTING"`: The domain is connected by pointing. Wix doesn't manage DNS information.
+     * + `"NAMESERVERS"`: The domain is connected by nameservers. Wix manages DNS information.
+     * + `"HIDDEN"`: The domain isn't visible to site visitors.
+     */
+    connectionType?: ConnectionType;
+    /**
+     * Information about the site to which the domain is assigned to and whether
+     * it's the primary domain or a redirect.
+     */
+    siteInfo?: SiteInfo$1;
+    /**
+     * Whether the site owner receives standard email notifications from Wix about
+     * the connected domain.
+     *
+     * Default: `false`
+     */
+    suppressNotifications?: boolean;
+    /**
+     * DNS propagation status.
+     *
+     * + `"UNKNOWN_DNS_PROPAGATION_STATUS"`: There's no information about the domain's DNS propagation status.
+     * + `"IN_PROGRESS"`: The domain's DNS propagation process has started but hasn't successfully completed yet.
+     * + `"COMPLETED"`: The domain's DNS propagation process has successfully finished.
+     * + `"FAILED"`: The domain's DNS propagation process has failed.
+     * @readonly
+     */
+    dnsPropagationStatus?: DnsPropagationStatus$1;
+}
+declare enum ConnectionType {
+    /** Used by sub domain */
+    UNKNOWN_CONNECTION_TYPE = "UNKNOWN_CONNECTION_TYPE",
+    POINTING = "POINTING",
+    NAMESERVERS = "NAMESERVERS",
+    /**
+     * internal used by photography company.
+     * when a customer creates a photo album, each album has its sub domain and this sub domain
+     * is not visible in my domains page.
+     */
+    HIDDEN = "HIDDEN"
+}
+interface SiteInfo$1 extends SiteInfoAssignmentInfoOneOf$1 {
+    /**
+     * Extra details in case assignment type is redirect.
+     * @readonly
+     */
+    redirectInfo?: RedirectAssignmentInfo$1;
+    /**
+     * ID of the site the domain is assigned to, will be taken from context.
+     * @readonly
+     */
+    _id?: string | null;
+    /**
+     * The assignment type the relationship will be based on:
+     * + `"UNKNOWN_ASSIGNMENT_TYPE"`: There is no information about the domain assignment type
+     * + `"PRIMARY"`: There can only be one primary domain per site, the result of this assignment type is that the domain will lead directly to a site.
+     * + `"REDIRECT"`: There can be multiple redirect domains. the result of this assignment type is that the redirects will lead to the primary domain
+     * Read more about [primary and redirected domains](https://support.wix.com/en/article/switching-your-primary-and-redirected-domains).
+     */
+    assignmentType?: AssignmentType$1;
+}
+/** @oneof */
+interface SiteInfoAssignmentInfoOneOf$1 {
+    /**
+     * Extra details in case assignment type is redirect.
+     * @readonly
+     */
+    redirectInfo?: RedirectAssignmentInfo$1;
+}
+declare enum AssignmentType$1 {
+    UNKNOWN_ASSIGNMENT_TYPE = "UNKNOWN_ASSIGNMENT_TYPE",
+    PRIMARY = "PRIMARY",
+    REDIRECT = "REDIRECT"
+}
+interface RedirectAssignmentInfo$1 {
+    /**
+     * Primary domain the redirect points to.
+     * @readonly
+     */
+    primaryDomain?: string;
+}
+declare enum DnsPropagationStatus$1 {
+    UNKNOWN_DNS_PROPAGATION_STATUS = "UNKNOWN_DNS_PROPAGATION_STATUS",
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS"
+}
+interface DomainRemovedEvent {
+    /**
+     * Domain name including TLD.
+     * Both root domains and subdomains are supported.
+     */
+    domain?: string;
+}
+interface CursorPaging$1 {
+    /**
+     * Number of domains to load.
+     *
+     * Min: `0`
+     * Max: `100`
+     */
+    limit?: number | null;
+    /**
+     * Pointer to the next or previous page in the list of results.
+     *
+     * You can get the relevant cursor token
+     * from the `pagingMetadata` object in the previous call's response.
+     * Not relevant for the first request.
+     */
+    cursor?: string | null;
+}
+interface ListConnectedDomainsResponse {
+    /** Metadata about the returned list of connected domains. */
+    pagingMetadata?: CursorPagingMetadata$1;
+    /** Retrieved connected domains. */
+    connectedDomains?: ConnectedDomain[];
+}
+interface CursorPagingMetadata$1 {
+    /** Number of domains returned in the response. */
+    count?: number | null;
+    /** Offset that was requested. */
+    cursors?: Cursors$1;
+    /**
+     * Indicates if there are more results after the current page.
+     * If `true`, another page of results can be retrieved.
+     * If `false`, this is the last page.
+     */
+    hasNext?: boolean | null;
+}
+interface Cursors$1 {
+    /** Cursor pointing to next page in the list of results. */
+    next?: string | null;
+    /** Cursor pointing to previous page in the list of results. */
+    prev?: string | null;
+}
+interface IdentificationData extends IdentificationDataIdOneOf {
+    /** ID of a site visitor that has not logged in to the site. */
+    anonymousVisitorId?: string;
+    /** ID of a site visitor that has logged in to the site. */
+    memberId?: string;
+    /** ID of a Wix user (site owner, contributor, etc.). */
+    wixUserId?: string;
+    /** ID of an app. */
+    appId?: string;
+    /** @readonly */
+    identityType?: WebhookIdentityType;
+}
+/** @oneof */
+interface IdentificationDataIdOneOf {
+    /** ID of a site visitor that has not logged in to the site. */
+    anonymousVisitorId?: string;
+    /** ID of a site visitor that has logged in to the site. */
+    memberId?: string;
+    /** ID of a Wix user (site owner, contributor, etc.). */
+    wixUserId?: string;
+    /** ID of an app. */
+    appId?: string;
+}
+declare enum WebhookIdentityType {
+    UNKNOWN = "UNKNOWN",
+    ANONYMOUS_VISITOR = "ANONYMOUS_VISITOR",
+    MEMBER = "MEMBER",
+    WIX_USER = "WIX_USER",
+    APP = "APP"
+}
+interface ListConnectedDomainsResponseNonNullableFields {
+    connectedDomains: {
+        _id: string;
+        domain: string;
+        connectionType: ConnectionType;
+        siteInfo?: {
+            redirectInfo?: {
+                primaryDomain: string;
+            };
+            assignmentType: AssignmentType$1;
+        };
+        suppressNotifications: boolean;
+        dnsPropagationStatus: DnsPropagationStatus$1;
+    }[];
+}
+interface BaseEventMetadata {
+    /** App instance ID. */
+    instanceId?: string | null;
+    /** Event type. */
+    eventType?: string;
+    /** The identification type and identity data. */
+    identity?: IdentificationData;
+}
+interface EventMetadata extends BaseEventMetadata {
+    /**
+     * Unique event ID.
+     * Allows clients to ignore duplicate webhooks.
+     */
+    _id?: string;
+    /**
+     * Assumes actions are also always typed to an entity_type
+     * Example: wix.stores.catalog.product, wix.bookings.session, wix.payments.transaction
+     */
+    entityFqdn?: string;
+    /**
+     * This is top level to ease client code dispatching of messages (switch on entity_fqdn+slug)
+     * This is although the created/updated/deleted notion is duplication of the oneof types
+     * Example: created/updated/deleted/started/completed/email_opened
+     */
+    slug?: string;
+    /** ID of the entity associated with the event. */
+    entityId?: string;
+    /** Event timestamp. */
+    eventTime?: Date;
+    /**
+     * Whether the event was triggered as a result of a privacy regulation application
+     * (for example, GDPR).
+     */
+    triggeredByAnonymizeRequest?: boolean | null;
+    /** If present, indicates the action that triggered the event. */
+    originatedFrom?: string | null;
+    /**
+     * A sequence number defining the order of updates to the underlying entity.
+     * For example, given that some entity was updated at 16:00 and than again at 16:01,
+     * it is guaranteed that the sequence number of the second update is strictly higher than the first.
+     * As the consumer, you can use this value to ensure that you handle messages in the correct order.
+     * To do so, you will need to persist this number on your end, and compare the sequence number from the
+     * message against the one you have stored. Given that the stored number is higher, you should ignore the message.
+     */
+    entityEventSequence?: string | null;
+}
+interface ConnectedDomainRemovedEnvelope {
+    data: DomainRemovedEvent;
+    metadata: EventMetadata;
+}
+interface ListConnectedDomainsOptions {
+    /** Cursor paging options. */
+    paging?: CursorPaging$1;
+}
+
+type RESTFunctionDescriptor<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient) => T;
+interface HttpClient {
+    request<TResponse, TData = any>(req: RequestOptionsFactory<TResponse, TData>): Promise<HttpResponse<TResponse>>;
+}
+type RequestOptionsFactory<TResponse = any, TData = any> = (context: any) => RequestOptions<TResponse, TData>;
+type HttpResponse<T = any> = {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: any;
+    request?: any;
+};
+type RequestOptions<_TResponse = any, Data = any> = {
+    method: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    url: string;
+    data?: Data;
+    params?: URLSearchParams;
+} & APIMetadata;
+type APIMetadata = {
+    methodFqn?: string;
+    entityFqdn?: string;
+    packageName?: string;
+};
+type BuildRESTFunction<T extends RESTFunctionDescriptor> = T extends RESTFunctionDescriptor<infer U> ? U : never;
+type EventDefinition<Payload = unknown, Type extends string = string> = {
+    __type: 'event-definition';
+    type: Type;
+    isDomainEvent?: boolean;
+    transformations?: unknown;
+    __payload: Payload;
+};
+declare function EventDefinition<Type extends string>(type: Type, isDomainEvent?: boolean, _transformations?: unknown): <Payload = unknown>() => EventDefinition<Payload, Type>;
+type EventHandler<T extends EventDefinition> = (payload: T['__payload']) => void | Promise<void>;
+type BuildEventDefinition<T extends EventDefinition<any, string>> = (handler: EventHandler<T>) => void;
+
+declare function createConnectedDomain$1(httpClient: HttpClient): (connectedDomain: ConnectedDomain) => Promise<ConnectedDomain & {
+    _id: string;
+    domain: string;
+    connectionType: ConnectionType;
+    siteInfo?: {
+        redirectInfo?: {
+            primaryDomain: string;
+        } | undefined;
+        assignmentType: AssignmentType$1;
+    } | undefined;
+    suppressNotifications: boolean;
+    dnsPropagationStatus: DnsPropagationStatus$1;
+}>;
+declare function getConnectedDomain$1(httpClient: HttpClient): (connectedDomainId: string) => Promise<ConnectedDomain & {
+    _id: string;
+    domain: string;
+    connectionType: ConnectionType;
+    siteInfo?: {
+        redirectInfo?: {
+            primaryDomain: string;
+        } | undefined;
+        assignmentType: AssignmentType$1;
+    } | undefined;
+    suppressNotifications: boolean;
+    dnsPropagationStatus: DnsPropagationStatus$1;
+}>;
+declare function listConnectedDomains$1(httpClient: HttpClient): (options?: ListConnectedDomainsOptions) => Promise<ListConnectedDomainsResponse & ListConnectedDomainsResponseNonNullableFields>;
+declare const onConnectedDomainRemoved$1: EventDefinition<ConnectedDomainRemovedEnvelope, "wix.premium.domains.v1.connected_domain_removed">;
+
+declare const createConnectedDomain: BuildRESTFunction<typeof createConnectedDomain$1>;
+declare const getConnectedDomain: BuildRESTFunction<typeof getConnectedDomain$1>;
+declare const listConnectedDomains: BuildRESTFunction<typeof listConnectedDomains$1>;
+declare const onConnectedDomainRemoved: BuildEventDefinition<typeof onConnectedDomainRemoved$1>;
+
+declare const context$4_createConnectedDomain: typeof createConnectedDomain;
+declare const context$4_getConnectedDomain: typeof getConnectedDomain;
+declare const context$4_listConnectedDomains: typeof listConnectedDomains;
+declare const context$4_onConnectedDomainRemoved: typeof onConnectedDomainRemoved;
+declare namespace context$4 {
+  export { context$4_createConnectedDomain as createConnectedDomain, context$4_getConnectedDomain as getConnectedDomain, context$4_listConnectedDomains as listConnectedDomains, context$4_onConnectedDomainRemoved as onConnectedDomainRemoved };
+}
+
+/**
+ * A `connectedDomainSetupInfo` object holds information the connected domain's
+ * external registrar and some DNS records. You can use this information to guide
+ * the site owner through the domain's setup process.
+ */
+interface ConnectedDomainSetupInfo extends ConnectedDomainSetupInfoDnsRecordsOneOf {
+    /**
+     * Information about domains connected using nameservers. Available only for
+     * `{"connectionType": "NAMESERVERS"}`.
+     */
+    nameserverRecord?: NameserverRecord;
+    /**
+     * Information about domains connected by pointing.  Available only for
+     * `{"connectionType": "POINTING"}`.
+     * @readonly
+     */
+    pointingRecords?: PointingRecords;
+    /**
+     * Information about subdomains.  Available only for subdomains.
+     * @readonly
+     */
+    subdomainRecords?: SubdomainRecords;
+    /** ID of the connected domain. Identical to the domain name including TLD. */
+    connectedDomainId?: string;
+    /**
+     * Information about the external domain registrar including current name
+     * servers.
+     */
+    registrar?: Registrar;
+}
+/** @oneof */
+interface ConnectedDomainSetupInfoDnsRecordsOneOf {
+    /**
+     * Information about domains connected using nameservers. Available only for
+     * `{"connectionType": "NAMESERVERS"}`.
+     */
+    nameserverRecord?: NameserverRecord;
+    /**
+     * Information about domains connected by pointing.  Available only for
+     * `{"connectionType": "POINTING"}`.
+     * @readonly
+     */
+    pointingRecords?: PointingRecords;
+    /**
+     * Information about subdomains.  Available only for subdomains.
+     * @readonly
+     */
+    subdomainRecords?: SubdomainRecords;
+}
+interface Registrar {
+    /**
+     * Name of the external domain registrar. For subdomains it's the registrar of the root domain.
+     * @readonly
+     */
+    name?: string | null;
+    /**
+     * Values of the current name server records. In case you connect an external
+     * domain using name servers, site owners must replace these current name servers
+     * with the new name servers found in `connectedDomainSetupInfo.nameserverRecord.nsRecord.values`
+     * during the initial domain setup.
+     * The replacement can't be performed through Wix APIs, you must use the
+     * infrastructure of the external domain registrar. Read more about
+     * [connecting domains using nameservers](https://dev.wix.com/api/rest/account-level-apis/connected-domains/sample-flows#account-level-apis_connected-domains_sample-flows_connect-an-external-domain-using-nameservers).
+     * @readonly
+     */
+    nameServers?: string[];
+}
+/** Information about domains connected by nameservers. */
+interface NameserverRecord {
+    /**
+     * Default [nameserver record](https://en.wikipedia.org/wiki/List_of_DNS_record_types#NS).
+     * @readonly
+     */
+    nsRecord?: NsRecord;
+}
+interface NsRecord {
+    /** Domain host name. For example `domain.com` or `mail.domain.com`. Can be a subdomain. */
+    hostName?: string;
+    /** [Time to live](https://en.wikipedia.org/wiki/Time_to_live) in seconds. */
+    ttl?: number;
+    /** DNS record values. */
+    values?: string[];
+}
+/** Information about domains connected by pointing. */
+interface PointingRecords {
+    /**
+     * [Address record](https://en.wikipedia.org/wiki/List_of_DNS_record_types#A).
+     * @readonly
+     */
+    aRecord?: ARecord;
+    /**
+     * [Canonical Name record](https://en.wikipedia.org/wiki/CNAME_record).
+     * @readonly
+     */
+    cnameRecord?: CnameRecord;
+}
+interface ARecord {
+    /** Domain host name. For example `domain.com` or `mail.domain.com`. Can be a subdomain. */
+    hostName?: string;
+    /** [Time to live](https://en.wikipedia.org/wiki/Time_to_live) in seconds. */
+    ttl?: number;
+    /** DNS record values. */
+    values?: string[];
+}
+interface CnameRecord {
+    /** Domain host name. For example `domain.com` or `mail.domain.com`. Can be a subdomain. */
+    hostName?: string;
+    /** [Time to live](https://en.wikipedia.org/wiki/Time_to_live) in seconds. */
+    ttl?: number;
+    /** DNS record value. */
+    value?: string;
+}
+/** Information about subdomains. */
+interface SubdomainRecords {
+    /**
+     * [Canonical Name records](https://en.wikipedia.org/wiki/CNAME_record).
+     * @readonly
+     */
+    cnameRecords?: CnameRecord[];
+}
+interface GetConnectedDomainSetupInfoResponse {
+    /** Retrieved setup information. */
+    connectedDomainSetupInfo?: ConnectedDomainSetupInfo;
+}
+interface GetConnectedDomainSetupInfoResponseNonNullableFields {
+    connectedDomainSetupInfo?: {
+        nameserverRecord?: {
+            nsRecord?: {
+                hostName: string;
+                ttl: number;
+                values: string[];
+            };
+        };
+        pointingRecords?: {
+            aRecord?: {
+                hostName: string;
+                ttl: number;
+                values: string[];
+            };
+            cnameRecord?: {
+                hostName: string;
+                ttl: number;
+                value: string;
+            };
+        };
+        subdomainRecords?: {
+            cnameRecords: {
+                hostName: string;
+                ttl: number;
+                value: string;
+            }[];
+        };
+        connectedDomainId: string;
+        registrar?: {
+            nameServers: string[];
+        };
+    };
+}
+
+declare function getConnectedDomainSetupInfo$1(httpClient: HttpClient): (connectedDomainId: string) => Promise<GetConnectedDomainSetupInfoResponse & GetConnectedDomainSetupInfoResponseNonNullableFields>;
+
+declare const getConnectedDomainSetupInfo: BuildRESTFunction<typeof getConnectedDomainSetupInfo$1>;
+
+declare const context$3_getConnectedDomainSetupInfo: typeof getConnectedDomainSetupInfo;
+declare namespace context$3 {
+  export { context$3_getConnectedDomainSetupInfo as getConnectedDomainSetupInfo };
+}
+
+/** DNS zones hold information about the records that map a domain's URL to an IP address. */
+interface DnsZone {
+    /** Domain name including the TLD. Both root domains and subdomains are supported. */
+    domainName?: string;
+    /**
+     * DNS records. You can only set up a single `record` object per DNS record
+     * type. If you want to specify multiple values for the same record type, you
+     * must save them in the `values` for the relevant type.
+     *
+     * Min: 2 DNS record - a DNS zone file has to have at least two required DNS records: NS and SOA records
+     * Max: 5000 DNS records
+     */
+    records?: DnsRecord[];
+    /**
+     * ID of the Dns Zone. Identical to the domain name including TLD.
+     * @readonly
+     */
+    _id?: string;
+    /**
+     * Whether [DNS Security Extensions (DNSSEC)](https://en.wikipedia.org/wiki/Domain_Name_System_Security_Extensions) are enabled.
+     *
+     * Default: `false`
+     */
+    dnssecEnabled?: boolean;
+}
+interface DnsRecord {
+    /**
+     * [DNS record type](https://en.wikipedia.org/wiki/List_of_DNS_record_types).
+     *
+     * + `UNKNOWN`: Default value. Used in case the record type isn't known. You can't set a record type to `UNKNOWN`.
+     * + `A`: Address record. Most fundamental type of DNS record that indicates the IP address of a given domain.
+     * + `AAAA`: Address record in [IPv6 format](https://en.wikipedia.org/wiki/IPv6).
+     * + `NS`: Name server record. Describes which server contains the actual DNS record.
+     * + `SOA`: [Start of authority record](https://en.wikipedia.org/wiki/SOA_record). Holds adminstrative information about the zone.
+     * + `CNAME`: [CNAME record](https://en.wikipedia.org/wiki/CNAME_record). Maps an alias name to the canonical domain name.
+     * + `MX`: MX record. Directs emails to mail servers.
+     * + `TXT`: [TXT record](https://en.wikipedia.org/wiki/TXT_record). Used by domain admins to add human readable descriptions.
+     * + `SPF`: SPF record. Used for email authentication.
+     * + `SRV`: [Service record](https://en.wikipedia.org/wiki/SRV_record). Defines the server location.
+     * + `PTR`: Pointer record. Specifies which host is supported for a given IP address.
+     * + `NAPTR`: [Name Authority Pointer record](https://en.wikipedia.org/wiki/NAPTR_record). Used by Internet telephony applications.
+     */
+    type?: RecordType;
+    /**
+     * Host name. Can be a subdomain. For example, `domain.com` or
+     * `mail.domain.com`. Equal to the domain name, except for `CNAME` records.
+     */
+    hostName?: string;
+    /** [Time to live](https://en.wikipedia.org/wiki/Time_to_live) in seconds. */
+    ttl?: number;
+    /**
+     * DNS record values. Wix limits DNS records to 50 values per type. External
+     * providers may support a different maximum number of DNS records for a
+     * specific type, Wix doesn't validate that you don't exceed these external
+     * limits.
+     *
+     * Max: 50 records
+     */
+    values?: string[];
+}
+declare enum RecordType {
+    UNKNOWN = "UNKNOWN",
+    A = "A",
+    AAAA = "AAAA",
+    NS = "NS",
+    SOA = "SOA",
+    CNAME = "CNAME",
+    MX = "MX",
+    TXT = "TXT",
+    SPF = "SPF",
+    SRV = "SRV",
+    PTR = "PTR",
+    NAPTR = "NAPTR"
+}
+interface UpdateDnsZoneResponse {
+    /** Updated DNS zone. */
+    dnsZone?: DnsZone;
+}
+interface PreviewDnsZoneResponse {
+    /**
+     * DNS zone preview.
+     *
+     * Includes calculated `A`, `CNAME`, `NS` and `SOA` records.
+     */
+    dnsZone?: DnsZone;
+}
+interface UpdateDnsZoneResponseNonNullableFields {
+    dnsZone?: {
+        domainName: string;
+        records: {
+            type: RecordType;
+            hostName: string;
+            ttl: number;
+            values: string[];
+        }[];
+        _id: string;
+        dnssecEnabled: boolean;
+    };
+}
+interface PreviewDnsZoneResponseNonNullableFields {
+    dnsZone?: {
+        domainName: string;
+        records: {
+            type: RecordType;
+            hostName: string;
+            ttl: number;
+            values: string[];
+        }[];
+        _id: string;
+        dnssecEnabled: boolean;
+    };
+}
+interface UpdateDnsZoneOptions {
+    /**
+     * DNS records to add to the DNS zone.
+     *
+     * Max: 10 additions
+     */
+    additions?: DnsRecord[];
+    /**
+     * DNS records to remove from the DNS zone.
+     *
+     * Max: 10 deletions
+     */
+    deletions?: DnsRecord[];
+    /** Whether you want to enable or disable [DNS Security Extensions (DNSSEC)](https://en.wikipedia.org/wiki/Domain_Name_System_Security_Extensions). */
+    dnssecEnabled?: boolean | null;
+}
+
+declare function createDnsZone$1(httpClient: HttpClient): (dnsZone: DnsZone) => Promise<DnsZone & {
+    domainName: string;
+    records: {
+        type: RecordType;
+        hostName: string;
+        ttl: number;
+        values: string[];
+    }[];
+    _id: string;
+    dnssecEnabled: boolean;
+}>;
+declare function getDnsZone$1(httpClient: HttpClient): (domainName: string) => Promise<DnsZone & {
+    domainName: string;
+    records: {
+        type: RecordType;
+        hostName: string;
+        ttl: number;
+        values: string[];
+    }[];
+    _id: string;
+    dnssecEnabled: boolean;
+}>;
+declare function updateDnsZone$1(httpClient: HttpClient): (domainName: string, options?: UpdateDnsZoneOptions) => Promise<UpdateDnsZoneResponse & UpdateDnsZoneResponseNonNullableFields>;
+declare function deleteDnsZone$1(httpClient: HttpClient): (domainName: string) => Promise<void>;
+declare function previewDnsZone$1(httpClient: HttpClient): (domainName: string) => Promise<PreviewDnsZoneResponse & PreviewDnsZoneResponseNonNullableFields>;
+
+declare const createDnsZone: BuildRESTFunction<typeof createDnsZone$1>;
+declare const getDnsZone: BuildRESTFunction<typeof getDnsZone$1>;
+declare const updateDnsZone: BuildRESTFunction<typeof updateDnsZone$1>;
+declare const deleteDnsZone: BuildRESTFunction<typeof deleteDnsZone$1>;
+declare const previewDnsZone: BuildRESTFunction<typeof previewDnsZone$1>;
+
+declare const context$2_createDnsZone: typeof createDnsZone;
+declare const context$2_deleteDnsZone: typeof deleteDnsZone;
+declare const context$2_getDnsZone: typeof getDnsZone;
+declare const context$2_previewDnsZone: typeof previewDnsZone;
+declare const context$2_updateDnsZone: typeof updateDnsZone;
+declare namespace context$2 {
+  export { context$2_createDnsZone as createDnsZone, context$2_deleteDnsZone as deleteDnsZone, context$2_getDnsZone as getDnsZone, context$2_previewDnsZone as previewDnsZone, context$2_updateDnsZone as updateDnsZone };
+}
+
 /**
  * A registered domain is a domain that Wix has registered on behalf of a customer
  * with an external registar.
@@ -563,31 +1228,6 @@ interface ListRegisteredDomainsOptions {
     paging?: CursorPaging;
 }
 
-type RESTFunctionDescriptor<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient) => T;
-interface HttpClient {
-    request<TResponse, TData = any>(req: RequestOptionsFactory<TResponse, TData>): Promise<HttpResponse<TResponse>>;
-}
-type RequestOptionsFactory<TResponse = any, TData = any> = (context: any) => RequestOptions<TResponse, TData>;
-type HttpResponse<T = any> = {
-    data: T;
-    status: number;
-    statusText: string;
-    headers: any;
-    request?: any;
-};
-type RequestOptions<_TResponse = any, Data = any> = {
-    method: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
-    url: string;
-    data?: Data;
-    params?: URLSearchParams;
-} & APIMetadata;
-type APIMetadata = {
-    methodFqn?: string;
-    entityFqdn?: string;
-    packageName?: string;
-};
-type BuildRESTFunction<T extends RESTFunctionDescriptor> = T extends RESTFunctionDescriptor<infer U> ? U : never;
-
 declare function createRegisteredDomain$1(httpClient: HttpClient): (registeredDomain: RegisteredDomain) => Promise<RegisteredDomain & {
     pendingRegistrationInfo?: {
         latestAttempt?: {
@@ -716,12 +1356,55 @@ declare const getRegisteredDomain: BuildRESTFunction<typeof getRegisteredDomain$
 declare const listRegisteredDomains: BuildRESTFunction<typeof listRegisteredDomains$1>;
 declare const redeemRegisteredDomain: BuildRESTFunction<typeof redeemRegisteredDomain$1>;
 
-declare const context_createRegisteredDomain: typeof createRegisteredDomain;
-declare const context_getRegisteredDomain: typeof getRegisteredDomain;
-declare const context_listRegisteredDomains: typeof listRegisteredDomains;
-declare const context_redeemRegisteredDomain: typeof redeemRegisteredDomain;
+declare const context$1_createRegisteredDomain: typeof createRegisteredDomain;
+declare const context$1_getRegisteredDomain: typeof getRegisteredDomain;
+declare const context$1_listRegisteredDomains: typeof listRegisteredDomains;
+declare const context$1_redeemRegisteredDomain: typeof redeemRegisteredDomain;
+declare namespace context$1 {
+  export { context$1_createRegisteredDomain as createRegisteredDomain, context$1_getRegisteredDomain as getRegisteredDomain, context$1_listRegisteredDomains as listRegisteredDomains, context$1_redeemRegisteredDomain as redeemRegisteredDomain };
+}
+
+interface DomainSuggestion {
+    /** Suggested domain name including TLD. */
+    domain?: string;
+}
+interface SuggestDomainsResponse {
+    /** List of suggested available domains. */
+    suggestions?: DomainSuggestion[];
+}
+interface SuggestDomainsResponseNonNullableFields {
+    suggestions: {
+        domain: string;
+    }[];
+}
+interface SuggestDomainsOptions {
+    /**
+     * [Top-level domains](https://en.wikipedia.org/wiki/Top-level_domain). Must
+     * not include the dot. For example, `com`, not `.com`. Not all TLDs can be
+     * connected to Wix sites. Supported TLDS include `com`, `net`, and `org`.
+     * Contact the [Wix B2B sales team](mailto:bizdev@wix.com) for more
+     * information.
+     *
+     * Max: 10 TLDs
+     */
+    tlds?: string[];
+    /**
+     * Number of domain suggestions to return.
+     *
+     * Min: `1`
+     * Max: `20`
+     * Default: `10`
+     */
+    limit?: number | null;
+}
+
+declare function suggestDomains$1(httpClient: HttpClient): (query: string, options?: SuggestDomainsOptions) => Promise<SuggestDomainsResponse & SuggestDomainsResponseNonNullableFields>;
+
+declare const suggestDomains: BuildRESTFunction<typeof suggestDomains$1>;
+
+declare const context_suggestDomains: typeof suggestDomains;
 declare namespace context {
-  export { context_createRegisteredDomain as createRegisteredDomain, context_getRegisteredDomain as getRegisteredDomain, context_listRegisteredDomains as listRegisteredDomains, context_redeemRegisteredDomain as redeemRegisteredDomain };
+  export { context_suggestDomains as suggestDomains };
 }
 
-export { context as registeredDomains };
+export { context$3 as connectedDomainSetupInfo, context$4 as connectedDomains, context$2 as domainDns, context as domainSuggestions, context$1 as registeredDomains };