@bosunski/laravel-cloud-sdk 0.1.1

package/dist/resources/databases.js

@@ -0,0 +1,198 @@
+import { z } from 'zod';
+import { createJsonApiCollectionSchema, createJsonApiResponseSchema, JsonApiResourceSchema, } from '../types/jsonApi.js';
+const databaseAttributesSchema = z
+    .object({
+    name: z.string(),
+    type: z.string(),
+    status: z.string(),
+    region: z.string(),
+    created_at: z.string(),
+    config: z.record(z.string(), z.any()),
+    connection: z
+        .object({
+        hostname: z.string(),
+        port: z.number(),
+        protocol: z.string(),
+        driver: z.string(),
+        username: z.string(),
+        password: z.string(),
+    })
+        .passthrough(),
+})
+    .passthrough();
+const databaseResourceSchema = JsonApiResourceSchema.extend({
+    type: z.literal('databases'),
+    attributes: databaseAttributesSchema,
+});
+const databaseResponseSchema = createJsonApiResponseSchema(databaseResourceSchema);
+const databaseCollectionSchema = createJsonApiCollectionSchema(databaseResourceSchema);
+const databaseTypeFieldSchema = z
+    .object({
+    name: z.string(),
+    type: z.string(),
+    required: z.boolean(),
+    nullable: z.boolean().optional(),
+    description: z.string().optional(),
+    min: z.number().optional(),
+    max: z.number().optional(),
+    enum: z.array(z.string()).optional(),
+    example: z.string().optional(),
+})
+    .passthrough();
+const databaseTypeSchema = z
+    .object({
+    type: z.string(),
+    label: z.string(),
+    regions: z.array(z.string()),
+    config_schema: z.array(databaseTypeFieldSchema),
+})
+    .passthrough();
+const databaseTypesResponseSchema = z.object({
+    data: z.array(databaseTypeSchema),
+});
+const mapDatabase = (resource) => {
+    const parsed = databaseResourceSchema.parse(resource);
+    const { attributes } = parsed;
+    const { hostname, port, protocol, driver, username, password, ...restConnection } = attributes.connection;
+    return {
+        id: parsed.id,
+        name: attributes.name,
+        type: attributes.type,
+        status: attributes.status,
+        region: attributes.region,
+        createdAt: attributes.created_at,
+        config: attributes.config,
+        connection: {
+            hostname,
+            port,
+            protocol,
+            driver,
+            username,
+            password,
+            ...restConnection,
+        },
+        raw: parsed,
+    };
+};
+const serializeDatabaseList = (response) => ({
+    data: response.data.map(mapDatabase),
+    included: response.included,
+    meta: response.meta,
+    links: response.links,
+});
+const serializeDatabaseResponse = (response) => ({
+    data: mapDatabase(response.data),
+    included: response.included,
+    meta: response.meta,
+    links: response.links,
+});
+const createDatabaseSchema = z
+    .object({
+    type: z.string(),
+    name: z.string().min(3).max(40),
+    region: z.string(),
+    config: z.record(z.string(), z.any()),
+    clusterId: z.number().int().nullable().optional(),
+})
+    .strict();
+const mapDatabaseType = (item) => ({
+    type: item.type,
+    label: item.label,
+    regions: item.regions,
+    configSchema: item.config_schema.map((field) => ({
+        name: field.name,
+        type: field.type,
+        required: field.required,
+        nullable: field.nullable,
+        description: field.description,
+        min: field.min,
+        max: field.max,
+        enum: field.enum,
+        example: field.example,
+        raw: field,
+    })),
+    raw: item,
+});
+const mapCreatePayload = (payload) => {
+    const body = {
+        type: payload.type,
+        name: payload.name,
+        region: payload.region,
+        config: payload.config,
+    };
+    if (payload.clusterId !== undefined) {
+        body.cluster_id = payload.clusterId;
+    }
+    return body;
+};
+export class DatabasesResource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async list(options) {
+        const query = {};
+        if (options?.include?.length) {
+            query.include = options.include.join(',');
+        }
+        if (options?.filter?.type) {
+            query['filter[type]'] = options.filter.type;
+        }
+        if (options?.filter?.region) {
+            query['filter[region]'] = options.filter.region;
+        }
+        if (options?.filter?.status) {
+            query['filter[status]'] = options.filter.status;
+        }
+        if (options?.page?.number !== undefined) {
+            query['page[number]'] = options.page.number;
+        }
+        if (options?.page?.size !== undefined) {
+            query['page[size]'] = options.page.size;
+        }
+        const response = await this.client.request({
+            path: '/databases',
+            method: 'GET',
+            query,
+            schema: databaseCollectionSchema,
+        });
+        return serializeDatabaseList(response);
+    }
+    async create(payload) {
+        const parsedPayload = createDatabaseSchema.parse(payload);
+        const response = await this.client.request({
+            path: '/databases',
+            method: 'POST',
+            json: mapCreatePayload(parsedPayload),
+            schema: databaseResponseSchema,
+        });
+        return serializeDatabaseResponse(response);
+    }
+    async retrieve(databaseId, options) {
+        const query = options?.include?.length
+            ? { include: options.include.join(',') }
+            : undefined;
+        const response = await this.client.request({
+            path: `/databases/${databaseId}`,
+            method: 'GET',
+            query,
+            schema: databaseResponseSchema,
+        });
+        return serializeDatabaseResponse(response);
+    }
+    async delete(databaseId) {
+        await this.client.request({
+            path: `/databases/${databaseId}`,
+            method: 'DELETE',
+        });
+    }
+    async listTypes() {
+        const response = await this.client.request({
+            path: '/databases/types',
+            method: 'GET',
+            accept: 'application/json',
+            schema: databaseTypesResponseSchema,
+        });
+        return response.data.map(mapDatabaseType);
+    }
+}

package/dist/resources/deployments.d.ts

@@ -0,0 +1,223 @@
+import { z } from 'zod';
+import { HttpClient } from '../http/client.js';
+import { JsonApiResponse, JsonApiResource } from '../types/jsonApi.js';
+export declare const deploymentResourceSchema: z.ZodObject<{
+    id: z.ZodString;
+    relationships: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        data: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodString;
+            id: z.ZodString;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            id: z.ZodString;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, z.core.$strip>>]>>;
+        links: z.ZodOptional<z.ZodObject<{
+            related: z.ZodOptional<z.ZodObject<{
+                href: z.ZodOptional<z.ZodString>;
+                rel: z.ZodOptional<z.ZodString>;
+                describedby: z.ZodOptional<z.ZodString>;
+                title: z.ZodOptional<z.ZodString>;
+                type: z.ZodOptional<z.ZodString>;
+                hreflang: z.ZodOptional<z.ZodString>;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, z.core.$loose>>;
+            self: z.ZodOptional<z.ZodObject<{
+                href: z.ZodOptional<z.ZodString>;
+                rel: z.ZodOptional<z.ZodString>;
+                describedby: z.ZodOptional<z.ZodString>;
+                title: z.ZodOptional<z.ZodString>;
+                type: z.ZodOptional<z.ZodString>;
+                hreflang: z.ZodOptional<z.ZodString>;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, z.core.$loose>>;
+        }, z.core.$strip>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$loose>>>;
+    links: z.ZodOptional<z.ZodObject<{
+        self: z.ZodOptional<z.ZodObject<{
+            href: z.ZodOptional<z.ZodString>;
+            rel: z.ZodOptional<z.ZodString>;
+            describedby: z.ZodOptional<z.ZodString>;
+            title: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodString>;
+            hreflang: z.ZodOptional<z.ZodString>;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, z.core.$loose>>;
+    }, z.core.$strip>>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    type: z.ZodLiteral<"deployments">;
+    attributes: z.ZodObject<{
+        status: z.ZodString;
+        branch_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        commit_hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        commit_message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        commit_author: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        failure_reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        php_major_version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        build_command: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        node_version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        uses_octane: z.ZodOptional<z.ZodBoolean>;
+        uses_hibernation: z.ZodOptional<z.ZodBoolean>;
+        started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        finished_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const deploymentResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodString;
+        relationships: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            data: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, z.core.$strip>>]>>;
+            links: z.ZodOptional<z.ZodObject<{
+                related: z.ZodOptional<z.ZodObject<{
+                    href: z.ZodOptional<z.ZodString>;
+                    rel: z.ZodOptional<z.ZodString>;
+                    describedby: z.ZodOptional<z.ZodString>;
+                    title: z.ZodOptional<z.ZodString>;
+                    type: z.ZodOptional<z.ZodString>;
+                    hreflang: z.ZodOptional<z.ZodString>;
+                    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                }, z.core.$loose>>;
+                self: z.ZodOptional<z.ZodObject<{
+                    href: z.ZodOptional<z.ZodString>;
+                    rel: z.ZodOptional<z.ZodString>;
+                    describedby: z.ZodOptional<z.ZodString>;
+                    title: z.ZodOptional<z.ZodString>;
+                    type: z.ZodOptional<z.ZodString>;
+                    hreflang: z.ZodOptional<z.ZodString>;
+                    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                }, z.core.$loose>>;
+            }, z.core.$strip>>;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, z.core.$loose>>>;
+        links: z.ZodOptional<z.ZodObject<{
+            self: z.ZodOptional<z.ZodObject<{
+                href: z.ZodOptional<z.ZodString>;
+                rel: z.ZodOptional<z.ZodString>;
+                describedby: z.ZodOptional<z.ZodString>;
+                title: z.ZodOptional<z.ZodString>;
+                type: z.ZodOptional<z.ZodString>;
+                hreflang: z.ZodOptional<z.ZodString>;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, z.core.$loose>>;
+        }, z.core.$strip>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        type: z.ZodLiteral<"deployments">;
+        attributes: z.ZodObject<{
+            status: z.ZodString;
+            branch_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            commit_hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            commit_message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            commit_author: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            failure_reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            php_major_version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            build_command: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            node_version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            uses_octane: z.ZodOptional<z.ZodBoolean>;
+            uses_hibernation: z.ZodOptional<z.ZodBoolean>;
+            started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            finished_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+    included: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        relationships: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            data: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, z.core.$strip>>]>>;
+            links: z.ZodOptional<z.ZodObject<{
+                related: z.ZodOptional<z.ZodObject<{
+                    href: z.ZodOptional<z.ZodString>;
+                    rel: z.ZodOptional<z.ZodString>;
+                    describedby: z.ZodOptional<z.ZodString>;
+                    title: z.ZodOptional<z.ZodString>;
+                    type: z.ZodOptional<z.ZodString>;
+                    hreflang: z.ZodOptional<z.ZodString>;
+                    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                }, z.core.$loose>>;
+                self: z.ZodOptional<z.ZodObject<{
+                    href: z.ZodOptional<z.ZodString>;
+                    rel: z.ZodOptional<z.ZodString>;
+                    describedby: z.ZodOptional<z.ZodString>;
+                    title: z.ZodOptional<z.ZodString>;
+                    type: z.ZodOptional<z.ZodString>;
+                    hreflang: z.ZodOptional<z.ZodString>;
+                    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                }, z.core.$loose>>;
+            }, z.core.$strip>>;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, z.core.$loose>>>;
+        links: z.ZodOptional<z.ZodObject<{
+            self: z.ZodOptional<z.ZodObject<{
+                href: z.ZodOptional<z.ZodString>;
+                rel: z.ZodOptional<z.ZodString>;
+                describedby: z.ZodOptional<z.ZodString>;
+                title: z.ZodOptional<z.ZodString>;
+                type: z.ZodOptional<z.ZodString>;
+                hreflang: z.ZodOptional<z.ZodString>;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, z.core.$loose>>;
+        }, z.core.$strip>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$loose>>>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    links: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>;
+export interface Deployment {
+    id: string;
+    status: string;
+    branchName?: string | null;
+    commitHash?: string | null;
+    commitMessage?: string | null;
+    commitAuthor?: string | null;
+    failureReason?: string | null;
+    phpMajorVersion?: string | null;
+    buildCommand?: string | null;
+    nodeVersion?: string | null;
+    usesOctane?: boolean;
+    usesHibernation?: boolean;
+    startedAt?: string | null;
+    finishedAt?: string | null;
+    raw: JsonApiResource;
+}
+export interface ListDeploymentsOptions {
+    include?: Array<'environment' | 'initiator'>;
+    filter?: {
+        status?: string;
+        branchName?: string;
+        commitHash?: string;
+    };
+    page?: {
+        number?: number;
+        size?: number;
+    };
+}
+export interface DeploymentListResponse extends JsonApiResponse<Deployment[]> {
+}
+export interface DeploymentResponse extends JsonApiResponse<Deployment> {
+}
+export declare const serializeDeploymentResponse: (response: z.infer<typeof deploymentResponseSchema>) => DeploymentResponse;
+export declare class DeploymentsResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    list(environmentId: string, options?: ListDeploymentsOptions): Promise<DeploymentListResponse>;
+    retrieve(deploymentId: string, options?: Pick<ListDeploymentsOptions, 'include'>): Promise<DeploymentResponse>;
+    initiate(environmentId: string): Promise<DeploymentResponse>;
+}

package/dist/resources/deployments.js

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+import { createJsonApiCollectionSchema, createJsonApiResponseSchema, JsonApiResourceSchema, } from '../types/jsonApi.js';
+const deploymentAttributesSchema = z
+    .object({
+    status: z.string(),
+    branch_name: z.string().nullable().optional(),
+    commit_hash: z.string().nullable().optional(),
+    commit_message: z.string().nullable().optional(),
+    commit_author: z.string().nullable().optional(),
+    failure_reason: z.string().nullable().optional(),
+    php_major_version: z.string().nullable().optional(),
+    build_command: z.string().nullable().optional(),
+    node_version: z.string().nullable().optional(),
+    uses_octane: z.boolean().optional(),
+    uses_hibernation: z.boolean().optional(),
+    started_at: z.string().nullable().optional(),
+    finished_at: z.string().nullable().optional(),
+})
+    .passthrough();
+export const deploymentResourceSchema = JsonApiResourceSchema.extend({
+    type: z.literal('deployments'),
+    attributes: deploymentAttributesSchema,
+});
+export const deploymentResponseSchema = createJsonApiResponseSchema(deploymentResourceSchema);
+const deploymentCollectionSchema = createJsonApiCollectionSchema(deploymentResourceSchema);
+const mapDeployment = (resource) => {
+    const parsed = deploymentResourceSchema.parse(resource);
+    const { attributes } = parsed;
+    return {
+        id: parsed.id,
+        status: attributes.status,
+        branchName: attributes.branch_name ?? null,
+        commitHash: attributes.commit_hash ?? null,
+        commitMessage: attributes.commit_message ?? null,
+        commitAuthor: attributes.commit_author ?? null,
+        failureReason: attributes.failure_reason ?? null,
+        phpMajorVersion: attributes.php_major_version ?? null,
+        buildCommand: attributes.build_command ?? null,
+        nodeVersion: attributes.node_version ?? null,
+        usesOctane: attributes.uses_octane,
+        usesHibernation: attributes.uses_hibernation,
+        startedAt: attributes.started_at ?? null,
+        finishedAt: attributes.finished_at ?? null,
+        raw: parsed,
+    };
+};
+const serializeDeploymentList = (response) => ({
+    data: response.data.map(mapDeployment),
+    included: response.included,
+    meta: response.meta,
+    links: response.links,
+});
+export const serializeDeploymentResponse = (response) => ({
+    data: mapDeployment(response.data),
+    included: response.included,
+    meta: response.meta,
+    links: response.links,
+});
+export class DeploymentsResource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async list(environmentId, options) {
+        const query = {};
+        if (options?.include?.length) {
+            query.include = options.include.join(',');
+        }
+        if (options?.filter?.status) {
+            query['filter[status]'] = options.filter.status;
+        }
+        if (options?.filter?.branchName) {
+            query['filter[branch_name]'] = options.filter.branchName;
+        }
+        if (options?.filter?.commitHash) {
+            query['filter[commit_hash]'] = options.filter.commitHash;
+        }
+        if (options?.page?.number !== undefined) {
+            query['page[number]'] = options.page.number;
+        }
+        if (options?.page?.size !== undefined) {
+            query['page[size]'] = options.page.size;
+        }
+        const response = await this.client.request({
+            path: `/environments/${environmentId}/deployments`,
+            method: 'GET',
+            query,
+            schema: deploymentCollectionSchema,
+        });
+        return serializeDeploymentList(response);
+    }
+    async retrieve(deploymentId, options) {
+        const query = options?.include?.length
+            ? { include: options.include.join(',') }
+            : undefined;
+        const response = await this.client.request({
+            path: `/deployments/${deploymentId}`,
+            method: 'GET',
+            query,
+            schema: deploymentResponseSchema,
+        });
+        return serializeDeploymentResponse(response);
+    }
+    async initiate(environmentId) {
+        const response = await this.client.request({
+            path: `/environments/${environmentId}/deployments`,
+            method: 'POST',
+            schema: deploymentResponseSchema,
+        });
+        return serializeDeploymentResponse(response);
+    }
+}

package/dist/resources/domains.d.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { HttpClient } from '../http/client.js';
+import { JsonApiResponse, JsonApiResource } from '../types/jsonApi.js';
+declare const domainVerificationMethodSchema: z.ZodEnum<{
+    pre_verification: "pre_verification";
+    real_time: "real_time";
+}>;
+declare const domainRedirectSchema: z.ZodEnum<{
+    root_to_www: "root_to_www";
+    www_to_root: "www_to_root";
+}>;
+export interface Domain {
+    id: string;
+    name: string;
+    type: string;
+    hostnameStatus: string;
+    sslStatus: string;
+    originStatus: string;
+    redirect?: string | null;
+    lastVerifiedAt?: string | null;
+    createdAt: string;
+    dnsRecords?: Record<string, unknown>;
+    wildcard?: Record<string, unknown>;
+    www?: Record<string, unknown>;
+    raw: JsonApiResource;
+}
+export interface ListDomainsOptions {
+    include?: Array<'environment'>;
+    filter?: {
+        name?: string;
+        hostnameStatus?: string;
+        sslStatus?: string;
+        originStatus?: string;
+    };
+    page?: {
+        number?: number;
+        size?: number;
+    };
+}
+export interface CreateDomainPayload {
+    name: string;
+    wwwRedirect?: z.infer<typeof domainRedirectSchema> | null;
+    wildcardEnabled?: boolean;
+    verificationMethod?: z.infer<typeof domainVerificationMethodSchema>;
+}
+export interface UpdateDomainPayload {
+    verificationMethod?: z.infer<typeof domainVerificationMethodSchema>;
+}
+export interface DomainListResponse extends JsonApiResponse<Domain[]> {
+}
+export interface DomainResponse extends JsonApiResponse<Domain> {
+}
+export declare class DomainsResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    list(environmentId: string, options?: ListDomainsOptions): Promise<DomainListResponse>;
+    create(environmentId: string, payload: CreateDomainPayload): Promise<DomainResponse>;
+    retrieve(domainId: string, options?: {
+        include?: Array<'environment'>;
+        verify?: boolean;
+    }): Promise<DomainResponse>;
+    update(domainId: string, payload: UpdateDomainPayload): Promise<DomainResponse>;
+    verify(domainId: string): Promise<DomainResponse>;
+    delete(domainId: string): Promise<void>;
+}
+export {};