/**
 * Cloudflare SECRETS-STORE API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service secrets-store
 */
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";
declare const InvalidAccountId_base: Schema.Class<InvalidAccountId, Schema.TaggedStruct<"InvalidAccountId", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidAccountId extends InvalidAccountId_base {
}
declare const InvalidJsonBody_base: Schema.Class<InvalidJsonBody, Schema.TaggedStruct<"InvalidJsonBody", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidJsonBody extends InvalidJsonBody_base {
}
declare const MaximumStoresExceeded_base: Schema.Class<MaximumStoresExceeded, Schema.TaggedStruct<"MaximumStoresExceeded", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class MaximumStoresExceeded extends MaximumStoresExceeded_base {
}
declare const NotFound_base: Schema.Class<NotFound, Schema.TaggedStruct<"NotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class NotFound extends NotFound_base {
}
declare const SecretNameAlreadyExists_base: Schema.Class<SecretNameAlreadyExists, Schema.TaggedStruct<"SecretNameAlreadyExists", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class SecretNameAlreadyExists extends SecretNameAlreadyExists_base {
}
declare const SecretNameEmpty_base: Schema.Class<SecretNameEmpty, Schema.TaggedStruct<"SecretNameEmpty", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class SecretNameEmpty extends SecretNameEmpty_base {
}
declare const SecretNotFound_base: Schema.Class<SecretNotFound, Schema.TaggedStruct<"SecretNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class SecretNotFound extends SecretNotFound_base {
}
declare const SecretScopeInvalid_base: Schema.Class<SecretScopeInvalid, Schema.TaggedStruct<"SecretScopeInvalid", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class SecretScopeInvalid extends SecretScopeInvalid_base {
}
declare const SecretScopesEmpty_base: Schema.Class<SecretScopesEmpty, Schema.TaggedStruct<"SecretScopesEmpty", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class SecretScopesEmpty extends SecretScopesEmpty_base {
}
declare const StoreNotFound_base: Schema.Class<StoreNotFound, Schema.TaggedStruct<"StoreNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class StoreNotFound extends StoreNotFound_base {
}
export interface GetQuotaRequest {
    /** Account Identifier */
    accountId: string;
}
export declare const GetQuotaRequest: Schema.Schema<GetQuotaRequest>;
export interface GetQuotaResponse {
    secrets: {
        quota: number;
        usage: number;
    };
}
export declare const GetQuotaResponse: Schema.Schema<GetQuotaResponse>;
export type GetQuotaError = DefaultErrors | InvalidAccountId;
export declare const getQuota: API.OperationMethod<GetQuotaRequest, GetQuotaResponse, GetQuotaError, Credentials | HttpClient.HttpClient>;
export interface ListStoresRequest {
    /** Path param: Account Identifier */
    accountId: string;
    page?: number;
    perPage?: number;
    /** Query param: Direction to sort objects */
    direction?: "asc" | "desc";
    /** Query param: Order secrets by values in the given field */
    order?: "name" | "comment" | "created" | "modified" | "status";
}
export declare const ListStoresRequest: Schema.Schema<ListStoresRequest>;
export interface ListStoresResponse {
    result: {
        id: string;
        created: string;
        modified: string;
        name: string;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListStoresResponse: Schema.Schema<ListStoresResponse>;
export type ListStoresError = DefaultErrors | InvalidAccountId;
export declare const listStores: API.PaginatedOperationMethod<ListStoresRequest, ListStoresResponse, ListStoresError, Credentials | HttpClient.HttpClient>;
export interface CreateStoreRequest {
    /** Account identifier */
    accountId: string;
    /** The name of the store */
    name: string;
}
export declare const CreateStoreRequest: Schema.Schema<CreateStoreRequest>;
export interface CreateStoreResponse {
    /** Store identifier */
    id: string;
    /** When the store was created */
    created: string;
    /** When the store was modified */
    modified: string;
    /** The name of the store */
    name: string;
}
export declare const CreateStoreResponse: Schema.Schema<CreateStoreResponse>;
export type CreateStoreError = DefaultErrors | InvalidAccountId | MaximumStoresExceeded;
export declare const createStore: API.OperationMethod<CreateStoreRequest, CreateStoreResponse, CreateStoreError, Credentials | HttpClient.HttpClient>;
export interface DeleteStoreRequest {
    storeId: string;
    /** Account Identifier */
    accountId: string;
}
export declare const DeleteStoreRequest: Schema.Schema<DeleteStoreRequest>;
export interface DeleteStoreResponse {
    /** Store Identifier */
    id?: string | null;
    /** Whenthe secret was created. */
    created?: string | null;
    /** When the secret was modified. */
    modified?: string | null;
    /** The name of the store */
    name?: string | null;
}
export declare const DeleteStoreResponse: Schema.Schema<DeleteStoreResponse>;
export type DeleteStoreError = DefaultErrors | StoreNotFound | InvalidAccountId | NotFound;
export declare const deleteStore: API.OperationMethod<DeleteStoreRequest, DeleteStoreResponse, DeleteStoreError, Credentials | HttpClient.HttpClient>;
export interface GetStoreSecretRequest {
    storeId: string;
    secretId: string;
    /** Account Identifier */
    accountId: string;
}
export declare const GetStoreSecretRequest: Schema.Schema<GetStoreSecretRequest>;
export interface GetStoreSecretResponse {
    /** Secret identifier tag. */
    id: string;
    /** Whenthe secret was created. */
    created: string;
    /** When the secret was modified. */
    modified: string;
    /** The name of the secret */
    name: string;
    status: "pending" | "active" | "deleted";
    /** Store Identifier */
    storeId: string;
    /** Freeform text describing the secret */
    comment?: string | null;
}
export declare const GetStoreSecretResponse: Schema.Schema<GetStoreSecretResponse>;
export type GetStoreSecretError = DefaultErrors | StoreNotFound | SecretNotFound | InvalidAccountId | NotFound;
export declare const getStoreSecret: API.OperationMethod<GetStoreSecretRequest, GetStoreSecretResponse, GetStoreSecretError, Credentials | HttpClient.HttpClient>;
export interface ListStoreSecretsRequest {
    storeId: string;
    /** Path param: Account Identifier */
    accountId: string;
    page?: number;
    perPage?: number;
    /** Query param: Direction to sort objects */
    direction?: "asc" | "desc";
    /** Query param: Order secrets by values in the given field */
    order?: "name" | "comment" | "created" | "modified" | "status";
    /** Query param: Only secrets with the given scopes will be returned */
    scopes?: string[][];
    /** Query param: Search secrets using a filter string, filtering across name and comment */
    search?: string;
}
export declare const ListStoreSecretsRequest: Schema.Schema<ListStoreSecretsRequest>;
export interface ListStoreSecretsResponse {
    result: {
        id: string;
        created: string;
        modified: string;
        name: string;
        status: "pending" | "active" | "deleted";
        storeId: string;
        comment?: string | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListStoreSecretsResponse: Schema.Schema<ListStoreSecretsResponse>;
export type ListStoreSecretsError = DefaultErrors | StoreNotFound | InvalidAccountId;
export declare const listStoreSecrets: API.PaginatedOperationMethod<ListStoreSecretsRequest, ListStoreSecretsResponse, ListStoreSecretsError, Credentials | HttpClient.HttpClient>;
export interface CreateStoreSecretRequest {
    storeId: string;
    /** Path param: Account Identifier */
    accountId: string;
    /** Body param: */
    body: {
        name: string;
        scopes: string[];
        value: string;
        comment?: string;
    }[];
}
export declare const CreateStoreSecretRequest: Schema.Schema<CreateStoreSecretRequest>;
export interface CreateStoreSecretResponse {
    result: {
        id: string;
        created: string;
        modified: string;
        name: string;
        status: "pending" | "active" | "deleted";
        storeId: string;
        comment?: string | null;
    }[];
}
export declare const CreateStoreSecretResponse: Schema.Schema<CreateStoreSecretResponse>;
export type CreateStoreSecretError = DefaultErrors | StoreNotFound | InvalidAccountId | SecretNameEmpty | SecretNameAlreadyExists | SecretScopeInvalid;
export declare const createStoreSecret: API.PaginatedOperationMethod<CreateStoreSecretRequest, CreateStoreSecretResponse, CreateStoreSecretError, Credentials | HttpClient.HttpClient>;
export interface PatchStoreSecretRequest {
    storeId: string;
    secretId: string;
    /** Path param: Account Identifier */
    accountId: string;
    /** Body param: Freeform text describing the secret */
    comment?: string;
    /** Body param: The list of services that can use this secret. */
    scopes?: string[];
}
export declare const PatchStoreSecretRequest: Schema.Schema<PatchStoreSecretRequest>;
export interface PatchStoreSecretResponse {
    /** Secret identifier tag. */
    id: string;
    /** Whenthe secret was created. */
    created: string;
    /** When the secret was modified. */
    modified: string;
    /** The name of the secret */
    name: string;
    status: "pending" | "active" | "deleted";
    /** Store Identifier */
    storeId: string;
    /** Freeform text describing the secret */
    comment?: string | null;
}
export declare const PatchStoreSecretResponse: Schema.Schema<PatchStoreSecretResponse>;
export type PatchStoreSecretError = DefaultErrors | StoreNotFound | SecretNotFound | InvalidAccountId | SecretScopeInvalid;
export declare const patchStoreSecret: API.OperationMethod<PatchStoreSecretRequest, PatchStoreSecretResponse, PatchStoreSecretError, Credentials | HttpClient.HttpClient>;
export interface DeleteStoreSecretRequest {
    storeId: string;
    secretId: string;
    /** Account Identifier */
    accountId: string;
}
export declare const DeleteStoreSecretRequest: Schema.Schema<DeleteStoreSecretRequest>;
export interface DeleteStoreSecretResponse {
    /** Secret identifier tag. */
    id?: string | null;
    /** Whenthe secret was created. */
    created?: string | null;
    /** When the secret was modified. */
    modified?: string | null;
    /** The name of the secret */
    name?: string | null;
    status?: "pending" | "active" | "deleted" | null;
    /** Store Identifier */
    storeId?: string | null;
    /** Freeform text describing the secret */
    comment?: string | null;
}
export declare const DeleteStoreSecretResponse: Schema.Schema<DeleteStoreSecretResponse>;
export type DeleteStoreSecretError = DefaultErrors | StoreNotFound | SecretNotFound | InvalidAccountId | NotFound;
export declare const deleteStoreSecret: API.OperationMethod<DeleteStoreSecretRequest, DeleteStoreSecretResponse, DeleteStoreSecretError, Credentials | HttpClient.HttpClient>;
export interface BulkDeleteStoreSecretsRequest {
    storeId: string;
    /** Account Identifier */
    accountId: string;
}
export declare const BulkDeleteStoreSecretsRequest: Schema.Schema<BulkDeleteStoreSecretsRequest>;
export interface BulkDeleteStoreSecretsResponse {
    result: {
        id: string;
        created: string;
        modified: string;
        name: string;
        status: "pending" | "active" | "deleted";
        storeId: string;
        comment?: string | null;
    }[];
}
export declare const BulkDeleteStoreSecretsResponse: Schema.Schema<BulkDeleteStoreSecretsResponse>;
export type BulkDeleteStoreSecretsError = DefaultErrors | StoreNotFound | InvalidAccountId | InvalidJsonBody;
export declare const bulkDeleteStoreSecrets: API.PaginatedOperationMethod<BulkDeleteStoreSecretsRequest, BulkDeleteStoreSecretsResponse, BulkDeleteStoreSecretsError, Credentials | HttpClient.HttpClient>;
export interface DuplicateStoreSecretRequest {
    storeId: string;
    secretId: string;
    /** Path param: Account Identifier */
    accountId: string;
    /** Body param: The name of the secret */
    name: string;
    /** Body param: The list of services that can use this secret. */
    scopes: string[];
    /** Body param: Freeform text describing the secret */
    comment?: string;
}
export declare const DuplicateStoreSecretRequest: Schema.Schema<DuplicateStoreSecretRequest>;
export interface DuplicateStoreSecretResponse {
    /** Secret identifier tag. */
    id: string;
    /** Whenthe secret was created. */
    created: string;
    /** When the secret was modified. */
    modified: string;
    /** The name of the secret */
    name: string;
    status: "pending" | "active" | "deleted";
    /** Store Identifier */
    storeId: string;
    /** Freeform text describing the secret */
    comment?: string | null;
}
export declare const DuplicateStoreSecretResponse: Schema.Schema<DuplicateStoreSecretResponse>;
export type DuplicateStoreSecretError = DefaultErrors | StoreNotFound | SecretNotFound | SecretNameEmpty | SecretScopesEmpty | SecretNameAlreadyExists | InvalidAccountId | SecretScopeInvalid;
export declare const duplicateStoreSecret: API.OperationMethod<DuplicateStoreSecretRequest, DuplicateStoreSecretResponse, DuplicateStoreSecretError, Credentials | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=secrets-store.d.ts.map