/**
 * Cloudflare HYPERDRIVE API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service hyperdrive
 */
import * as Schema from "effect/Schema";
import * as API from "../client/api.js";
import * as T from "../traits.js";
import {} from "../errors.js";
import { SensitiveString } from "../sensitive.js";
// =============================================================================
// Errors
// =============================================================================
export class HyperdriveConfigNotFound extends Schema.TaggedErrorClass()("HyperdriveConfigNotFound", { code: Schema.Number, message: Schema.String }) {
}
T.applyErrorMatchers(HyperdriveConfigNotFound, [{ code: 2006 }]);
export class InvalidHyperdriveConfig extends Schema.TaggedErrorClass()("InvalidHyperdriveConfig", { code: Schema.Number, message: Schema.String }) {
}
T.applyErrorMatchers(InvalidHyperdriveConfig, [{ code: 2007 }]);
export class InvalidObjectIdentifier extends Schema.TaggedErrorClass()("InvalidObjectIdentifier", { code: Schema.Number, message: Schema.String }) {
}
T.applyErrorMatchers(InvalidObjectIdentifier, [{ code: 7003 }]);
export class MethodNotAllowed extends Schema.TaggedErrorClass()("MethodNotAllowed", { code: Schema.Number, message: Schema.String }) {
}
T.applyErrorMatchers(MethodNotAllowed, [
    { code: 10000, message: { includes: "method not allowed" } },
    { code: 10405, message: { includes: "Method not allowed" } },
]);
export class PrivateHostNotAllowed extends Schema.TaggedErrorClass()("PrivateHostNotAllowed", { code: Schema.Number, message: Schema.String }) {
}
T.applyErrorMatchers(PrivateHostNotAllowed, [{ code: 2009 }]);
export const GetConfigRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    hyperdriveId: Schema.String.pipe(T.HttpPath("hyperdriveId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "GET",
    path: "/accounts/{account_id}/hyperdrive/configs/{hyperdriveId}",
}));
export const GetConfigResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    id: Schema.String,
    name: Schema.String,
    origin: Schema.Union([
        Schema.Struct({
            database: Schema.String,
            host: Schema.String,
            port: Schema.Number,
            scheme: Schema.Literals(["postgres", "postgresql", "mysql"]),
            user: Schema.String,
        }),
        Schema.Struct({
            accessClientId: Schema.String,
            database: Schema.String,
            host: Schema.String,
            scheme: Schema.Literals(["postgres", "postgresql", "mysql"]),
            user: Schema.String,
        }).pipe(Schema.encodeKeys({
            accessClientId: "access_client_id",
            database: "database",
            host: "host",
            scheme: "scheme",
            user: "user",
        })),
    ]),
    caching: Schema.optional(Schema.Union([
        Schema.Union([
            Schema.Struct({
                disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
            }),
            Schema.Struct({
                disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
                maxAge: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
                staleWhileRevalidate: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
            }).pipe(Schema.encodeKeys({
                disabled: "disabled",
                maxAge: "max_age",
                staleWhileRevalidate: "stale_while_revalidate",
            })),
        ]),
        Schema.Null,
    ])),
    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    mtls: Schema.optional(Schema.Union([
        Schema.Struct({
            caCertificateId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
            mtlsCertificateId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
            sslmode: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        }).pipe(Schema.encodeKeys({
            caCertificateId: "ca_certificate_id",
            mtlsCertificateId: "mtls_certificate_id",
            sslmode: "sslmode",
        })),
        Schema.Null,
    ])),
    originConnectionLimit: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
})
    .pipe(Schema.encodeKeys({
    id: "id",
    name: "name",
    origin: "origin",
    caching: "caching",
    createdOn: "created_on",
    modifiedOn: "modified_on",
    mtls: "mtls",
    originConnectionLimit: "origin_connection_limit",
}))
    .pipe(T.ResponsePath("result"));
export const getConfig = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetConfigRequest,
    output: GetConfigResponse,
    errors: [
        PrivateHostNotAllowed,
        HyperdriveConfigNotFound,
        InvalidObjectIdentifier,
    ],
}));
export const ListConfigsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({ method: "GET", path: "/accounts/{account_id}/hyperdrive/configs" }));
export const ListConfigsResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    result: Schema.Array(Schema.Struct({
        id: Schema.String,
        name: Schema.String,
        origin: Schema.Union([
            Schema.Struct({
                database: Schema.String,
                host: Schema.String,
                port: Schema.Number,
                scheme: Schema.Literals(["postgres", "postgresql", "mysql"]),
                user: Schema.String,
            }),
            Schema.Struct({
                accessClientId: Schema.String,
                database: Schema.String,
                host: Schema.String,
                scheme: Schema.Literals(["postgres", "postgresql", "mysql"]),
                user: Schema.String,
            }).pipe(Schema.encodeKeys({
                accessClientId: "access_client_id",
                database: "database",
                host: "host",
                scheme: "scheme",
                user: "user",
            })),
        ]),
        caching: Schema.optional(Schema.Union([
            Schema.Union([
                Schema.Struct({
                    disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
                }),
                Schema.Struct({
                    disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
                    maxAge: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
                    staleWhileRevalidate: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
                }).pipe(Schema.encodeKeys({
                    disabled: "disabled",
                    maxAge: "max_age",
                    staleWhileRevalidate: "stale_while_revalidate",
                })),
            ]),
            Schema.Null,
        ])),
        createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        mtls: Schema.optional(Schema.Union([
            Schema.Struct({
                caCertificateId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
                mtlsCertificateId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
                sslmode: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
            }).pipe(Schema.encodeKeys({
                caCertificateId: "ca_certificate_id",
                mtlsCertificateId: "mtls_certificate_id",
                sslmode: "sslmode",
            })),
            Schema.Null,
        ])),
        originConnectionLimit: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
    }).pipe(Schema.encodeKeys({
        id: "id",
        name: "name",
        origin: "origin",
        caching: "caching",
        createdOn: "created_on",
        modifiedOn: "modified_on",
        mtls: "mtls",
        originConnectionLimit: "origin_connection_limit",
    }))),
});
export const listConfigs = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListConfigsRequest,
    output: ListConfigsResponse,
    errors: [PrivateHostNotAllowed, InvalidObjectIdentifier],
    pagination: {
        mode: "single",
        items: "result",
    },
}));
export const CreateConfigRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    name: Schema.String,
    origin: Schema.Union([
        Schema.Struct({
            accessClientId: Schema.String,
            accessClientSecret: SensitiveString,
            database: Schema.String,
            host: Schema.String,
            password: SensitiveString,
            scheme: Schema.Literals(["postgres", "postgresql", "mysql"]),
            user: Schema.String,
        }).pipe(Schema.encodeKeys({
            accessClientId: "access_client_id",
            accessClientSecret: "access_client_secret",
            database: "database",
            host: "host",
            password: "password",
            scheme: "scheme",
            user: "user",
        })),
        Schema.Struct({
            database: Schema.String,
            host: Schema.String,
            password: SensitiveString,
            port: Schema.Number,
            scheme: Schema.Literals(["postgres", "postgresql", "mysql"]),
            user: Schema.String,
        }),
    ]),
    caching: Schema.optional(Schema.Union([
        Schema.Struct({
            disabled: Schema.optional(Schema.Boolean),
        }),
        Schema.Struct({
            disabled: Schema.optional(Schema.Boolean),
            maxAge: Schema.optional(Schema.Number),
            staleWhileRevalidate: Schema.optional(Schema.Number),
        }).pipe(Schema.encodeKeys({
            disabled: "disabled",
            maxAge: "max_age",
            staleWhileRevalidate: "stale_while_revalidate",
        })),
    ])),
    mtls: Schema.optional(Schema.Struct({
        caCertificateId: Schema.optional(Schema.String),
        mtlsCertificateId: Schema.optional(Schema.String),
        sslmode: Schema.optional(Schema.String),
    }).pipe(Schema.encodeKeys({
        caCertificateId: "ca_certificate_id",
        mtlsCertificateId: "mtls_certificate_id",
        sslmode: "sslmode",
    }))),
    originConnectionLimit: Schema.optional(Schema.Number),
}).pipe(Schema.encodeKeys({
    name: "name",
    origin: "origin",
    caching: "caching",
    mtls: "mtls",
    originConnectionLimit: "origin_connection_limit",
}), T.Http({ method: "POST", path: "/accounts/{account_id}/hyperdrive/configs" }));
export const CreateConfigResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    id: Schema.String,
    name: Schema.String,
    origin: Schema.Union([
        Schema.Struct({
            database: Schema.String,
            host: Schema.String,
            port: Schema.Number,
            scheme: Schema.Literals(["postgres", "postgresql", "mysql"]),
            user: Schema.String,
        }),
        Schema.Struct({
            accessClientId: Schema.String,
            database: Schema.String,
            host: Schema.String,
            scheme: Schema.Literals(["postgres", "postgresql", "mysql"]),
            user: Schema.String,
        }).pipe(Schema.encodeKeys({
            accessClientId: "access_client_id",
            database: "database",
            host: "host",
            scheme: "scheme",
            user: "user",
        })),
    ]),
    caching: Schema.optional(Schema.Union([
        Schema.Union([
            Schema.Struct({
                disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
            }),
            Schema.Struct({
                disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
                maxAge: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
                staleWhileRevalidate: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
            }).pipe(Schema.encodeKeys({
                disabled: "disabled",
                maxAge: "max_age",
                staleWhileRevalidate: "stale_while_revalidate",
            })),
        ]),
        Schema.Null,
    ])),
    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    mtls: Schema.optional(Schema.Union([
        Schema.Struct({
            caCertificateId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
            mtlsCertificateId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
            sslmode: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        }).pipe(Schema.encodeKeys({
            caCertificateId: "ca_certificate_id",
            mtlsCertificateId: "mtls_certificate_id",
            sslmode: "sslmode",
        })),
        Schema.Null,
    ])),
    originConnectionLimit: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
})
    .pipe(Schema.encodeKeys({
    id: "id",
    name: "name",
    origin: "origin",
    caching: "caching",
    createdOn: "created_on",
    modifiedOn: "modified_on",
    mtls: "mtls",
    originConnectionLimit: "origin_connection_limit",
}))
    .pipe(T.ResponsePath("result"));
export const createConfig = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateConfigRequest,
    output: CreateConfigResponse,
    errors: [
        PrivateHostNotAllowed,
        InvalidHyperdriveConfig,
        InvalidObjectIdentifier,
    ],
}));
export const UpdateConfigRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    hyperdriveId: Schema.String.pipe(T.HttpPath("hyperdriveId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    name: Schema.String,
    origin: Schema.Union([
        Schema.Struct({
            accessClientId: Schema.String,
            accessClientSecret: SensitiveString,
            database: Schema.String,
            host: Schema.String,
            password: SensitiveString,
            scheme: Schema.Literals(["postgres", "postgresql", "mysql"]),
            user: Schema.String,
        }).pipe(Schema.encodeKeys({
            accessClientId: "access_client_id",
            accessClientSecret: "access_client_secret",
            database: "database",
            host: "host",
            password: "password",
            scheme: "scheme",
            user: "user",
        })),
        Schema.Struct({
            database: Schema.String,
            host: Schema.String,
            password: SensitiveString,
            port: Schema.Number,
            scheme: Schema.Literals(["postgres", "postgresql", "mysql"]),
            user: Schema.String,
        }),
    ]),
    caching: Schema.optional(Schema.Union([
        Schema.Struct({
            disabled: Schema.optional(Schema.Boolean),
        }),
        Schema.Struct({
            disabled: Schema.optional(Schema.Boolean),
            maxAge: Schema.optional(Schema.Number),
            staleWhileRevalidate: Schema.optional(Schema.Number),
        }).pipe(Schema.encodeKeys({
            disabled: "disabled",
            maxAge: "max_age",
            staleWhileRevalidate: "stale_while_revalidate",
        })),
    ])),
    mtls: Schema.optional(Schema.Struct({
        caCertificateId: Schema.optional(Schema.String),
        mtlsCertificateId: Schema.optional(Schema.String),
        sslmode: Schema.optional(Schema.String),
    }).pipe(Schema.encodeKeys({
        caCertificateId: "ca_certificate_id",
        mtlsCertificateId: "mtls_certificate_id",
        sslmode: "sslmode",
    }))),
    originConnectionLimit: Schema.optional(Schema.Number),
}).pipe(Schema.encodeKeys({
    name: "name",
    origin: "origin",
    caching: "caching",
    mtls: "mtls",
    originConnectionLimit: "origin_connection_limit",
}), T.Http({
    method: "PUT",
    path: "/accounts/{account_id}/hyperdrive/configs/{hyperdriveId}",
}));
export const UpdateConfigResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    id: Schema.String,
    name: Schema.String,
    origin: Schema.Union([
        Schema.Struct({
            database: Schema.String,
            host: Schema.String,
            port: Schema.Number,
            scheme: Schema.Literals(["postgres", "postgresql", "mysql"]),
            user: Schema.String,
        }),
        Schema.Struct({
            accessClientId: Schema.String,
            database: Schema.String,
            host: Schema.String,
            scheme: Schema.Literals(["postgres", "postgresql", "mysql"]),
            user: Schema.String,
        }).pipe(Schema.encodeKeys({
            accessClientId: "access_client_id",
            database: "database",
            host: "host",
            scheme: "scheme",
            user: "user",
        })),
    ]),
    caching: Schema.optional(Schema.Union([
        Schema.Union([
            Schema.Struct({
                disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
            }),
            Schema.Struct({
                disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
                maxAge: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
                staleWhileRevalidate: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
            }).pipe(Schema.encodeKeys({
                disabled: "disabled",
                maxAge: "max_age",
                staleWhileRevalidate: "stale_while_revalidate",
            })),
        ]),
        Schema.Null,
    ])),
    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    mtls: Schema.optional(Schema.Union([
        Schema.Struct({
            caCertificateId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
            mtlsCertificateId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
            sslmode: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        }).pipe(Schema.encodeKeys({
            caCertificateId: "ca_certificate_id",
            mtlsCertificateId: "mtls_certificate_id",
            sslmode: "sslmode",
        })),
        Schema.Null,
    ])),
    originConnectionLimit: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
})
    .pipe(Schema.encodeKeys({
    id: "id",
    name: "name",
    origin: "origin",
    caching: "caching",
    createdOn: "created_on",
    modifiedOn: "modified_on",
    mtls: "mtls",
    originConnectionLimit: "origin_connection_limit",
}))
    .pipe(T.ResponsePath("result"));
export const updateConfig = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateConfigRequest,
    output: UpdateConfigResponse,
    errors: [
        PrivateHostNotAllowed,
        HyperdriveConfigNotFound,
        InvalidObjectIdentifier,
        MethodNotAllowed,
    ],
}));
export const PatchConfigRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    hyperdriveId: Schema.String.pipe(T.HttpPath("hyperdriveId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
    caching: Schema.optional(Schema.Union([
        Schema.Struct({
            disabled: Schema.optional(Schema.Boolean),
        }),
        Schema.Struct({
            disabled: Schema.optional(Schema.Boolean),
            maxAge: Schema.optional(Schema.Number),
            staleWhileRevalidate: Schema.optional(Schema.Number),
        }).pipe(Schema.encodeKeys({
            disabled: "disabled",
            maxAge: "max_age",
            staleWhileRevalidate: "stale_while_revalidate",
        })),
    ])),
    mtls: Schema.optional(Schema.Struct({
        caCertificateId: Schema.optional(Schema.String),
        mtlsCertificateId: Schema.optional(Schema.String),
        sslmode: Schema.optional(Schema.String),
    }).pipe(Schema.encodeKeys({
        caCertificateId: "ca_certificate_id",
        mtlsCertificateId: "mtls_certificate_id",
        sslmode: "sslmode",
    }))),
    name: Schema.optional(Schema.String),
    origin: Schema.optional(Schema.Union([
        Schema.Struct({
            accessClientId: Schema.String,
            accessClientSecret: SensitiveString,
            host: Schema.String,
        }).pipe(Schema.encodeKeys({
            accessClientId: "access_client_id",
            accessClientSecret: "access_client_secret",
            host: "host",
        })),
        Schema.Struct({
            host: Schema.String,
            port: Schema.Number,
        }),
        Schema.Struct({
            database: Schema.optional(Schema.String),
            password: Schema.optional(SensitiveString),
            scheme: Schema.optional(Schema.Literals(["postgres", "postgresql", "mysql"])),
            user: Schema.optional(Schema.String),
        }),
    ])),
    originConnectionLimit: Schema.optional(Schema.Number),
}).pipe(Schema.encodeKeys({
    caching: "caching",
    mtls: "mtls",
    name: "name",
    origin: "origin",
    originConnectionLimit: "origin_connection_limit",
}), T.Http({
    method: "PATCH",
    path: "/accounts/{account_id}/hyperdrive/configs/{hyperdriveId}",
}));
export const PatchConfigResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    id: Schema.String,
    name: Schema.String,
    origin: Schema.Union([
        Schema.Struct({
            database: Schema.String,
            host: Schema.String,
            port: Schema.Number,
            scheme: Schema.Literals(["postgres", "postgresql", "mysql"]),
            user: Schema.String,
        }),
        Schema.Struct({
            accessClientId: Schema.String,
            database: Schema.String,
            host: Schema.String,
            scheme: Schema.Literals(["postgres", "postgresql", "mysql"]),
            user: Schema.String,
        }).pipe(Schema.encodeKeys({
            accessClientId: "access_client_id",
            database: "database",
            host: "host",
            scheme: "scheme",
            user: "user",
        })),
    ]),
    caching: Schema.optional(Schema.Union([
        Schema.Union([
            Schema.Struct({
                disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
            }),
            Schema.Struct({
                disabled: Schema.optional(Schema.Union([Schema.Boolean, Schema.Null])),
                maxAge: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
                staleWhileRevalidate: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
            }).pipe(Schema.encodeKeys({
                disabled: "disabled",
                maxAge: "max_age",
                staleWhileRevalidate: "stale_while_revalidate",
            })),
        ]),
        Schema.Null,
    ])),
    createdOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    modifiedOn: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
    mtls: Schema.optional(Schema.Union([
        Schema.Struct({
            caCertificateId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
            mtlsCertificateId: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
            sslmode: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
        }).pipe(Schema.encodeKeys({
            caCertificateId: "ca_certificate_id",
            mtlsCertificateId: "mtls_certificate_id",
            sslmode: "sslmode",
        })),
        Schema.Null,
    ])),
    originConnectionLimit: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
})
    .pipe(Schema.encodeKeys({
    id: "id",
    name: "name",
    origin: "origin",
    caching: "caching",
    createdOn: "created_on",
    modifiedOn: "modified_on",
    mtls: "mtls",
    originConnectionLimit: "origin_connection_limit",
}))
    .pipe(T.ResponsePath("result"));
export const patchConfig = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PatchConfigRequest,
    output: PatchConfigResponse,
    errors: [
        PrivateHostNotAllowed,
        HyperdriveConfigNotFound,
        InvalidObjectIdentifier,
        MethodNotAllowed,
    ],
}));
export const DeleteConfigRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
    hyperdriveId: Schema.String.pipe(T.HttpPath("hyperdriveId")),
    accountId: Schema.String.pipe(T.HttpPath("account_id")),
}).pipe(T.Http({
    method: "DELETE",
    path: "/accounts/{account_id}/hyperdrive/configs/{hyperdriveId}",
}));
export const DeleteConfigResponse = 
/*@__PURE__*/ /*#__PURE__*/ Schema.Unknown.pipe(T.ResponsePath("result"));
export const deleteConfig = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteConfigRequest,
    output: DeleteConfigResponse,
    errors: [
        PrivateHostNotAllowed,
        HyperdriveConfigNotFound,
        InvalidObjectIdentifier,
        MethodNotAllowed,
    ],
}));
//# sourceMappingURL=hyperdrive.js.map