@distilled.cloud/ovh 0.0.0 → 1.0.0-rc.9

package/lib/services/ldp.d.ts

@@ -0,0 +1,2492 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import { type OvhOpError, type OvhOpContext } from "../protocol.ts";
+export type { OvhOpError, OvhOpContext };
+declare const Conflict_base: S.Class<Conflict, S.TaggedStruct<"Conflict", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
+export declare class Conflict extends /*@__PURE__*/ Conflict_base {
+}
+declare const Forbidden_base: S.Class<Forbidden, S.TaggedStruct<"Forbidden", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        AuthError: true;
+    };
+});
+export declare class Forbidden extends /*@__PURE__*/ Forbidden_base {
+}
+declare const NotFound_base: S.Class<NotFound, S.TaggedStruct<"NotFound", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class NotFound extends /*@__PURE__*/ NotFound_base {
+}
+export interface CreateDbaasLogChangeContactRequest {
+    /** Service name */
+    serviceName: string;
+    /** The contact to set as admin contact */
+    contactAdmin?: string;
+    /** The contact to set as billing contact */
+    contactBilling?: string;
+    /** The contact to set as tech contact */
+    contactTech?: string;
+}
+export declare const CreateDbaasLogChangeContactRequest: S.Schema<CreateDbaasLogChangeContactRequest>;
+export type CreateDbaasLogChangeContactResponseBodyList = Array<number>;
+export declare const CreateDbaasLogChangeContactResponseBodyList: S.Schema<CreateDbaasLogChangeContactResponseBodyList>;
+export type CreateDbaasLogChangeContactResponse = CreateDbaasLogChangeContactResponseBodyList;
+export declare const CreateDbaasLogChangeContactResponse: S.Schema<CreateDbaasLogChangeContactResponse>;
+export interface CreateDbaasLogEncryptionKeyRequest {
+    /** Service name */
+    serviceName: string;
+    /** Encryption Key content */
+    content: string;
+    /** Encryption Key fingerprint */
+    fingerprint: string;
+    /** Encryption Key title */
+    title: string;
+}
+export declare const CreateDbaasLogEncryptionKeyRequest: S.Schema<CreateDbaasLogEncryptionKeyRequest>;
+/** Possible values for OperationStateEnum */
+export type DbaasLogsOperationStateEnum = "FAILURE" | "PENDING" | "RECEIVED" | "RETRY" | "REVOKED" | "RUNNING" | "STARTED" | "SUCCESS";
+export declare const DbaasLogsOperationStateEnum: any;
+/** Asynchronous operation */
+export interface DbaasLogsOperation {
+    /** Alias used */
+    aliasId?: string | null;
+    /** Operation creation */
+    createdAt?: string;
+    /** Dashboard used */
+    dashboardId?: string | null;
+    /** Encryption key used */
+    encryptionKeyId?: string | null;
+    /** Index used */
+    indexId?: string | null;
+    /** Input used */
+    inputId?: string | null;
+    /** Operation ID */
+    operationId?: string;
+    /** OpenSearch Dashboards used */
+    osdId?: string | null;
+    /** Role used */
+    roleId?: string | null;
+    /** Service name */
+    serviceName?: string;
+    /** Operation status */
+    state?: DbaasLogsOperationStateEnum;
+    /** Stream used */
+    streamId?: string | null;
+    /** Subscription used */
+    subscriptionId?: string | null;
+    /** Metrics tenant used */
+    tenantId?: string | null;
+    /** Token used */
+    tokenId?: string | null;
+    /** Operation last update */
+    updatedAt?: string | null;
+}
+export declare const DbaasLogsOperation: S.Schema<DbaasLogsOperation>;
+/** IP blocks */
+export type CreateDbaasLogInputRequestAllowedNetworksList = Array<string>;
+export declare const CreateDbaasLogInputRequestAllowedNetworksList: S.Schema<CreateDbaasLogInputRequestAllowedNetworksList>;
+export interface CreateDbaasLogInputRequest {
+    /** Service name */
+    serviceName: string;
+    /** IP blocks */
+    allowedNetworks?: CreateDbaasLogInputRequestAllowedNetworksList | null;
+    /** Whether the workload is auto-scaled */
+    autoscale?: boolean | null;
+    /** Description */
+    description: string;
+    /** Engine ID */
+    engineId: string;
+    /** Exposed port */
+    exposedPort?: string | null;
+    /** Maximum number of instances in auto-scaled mode */
+    maxScaleInstance?: number | null;
+    /** Minimum number of instances in auto-scaled mode */
+    minScaleInstance?: number | null;
+    /** Number of instance running */
+    nbInstance?: number | null;
+    /** If set, notify when scaling happens */
+    scalingNotifyEnabled?: boolean | null;
+    /** Stream ID */
+    streamId: string;
+    /** Title */
+    title: string;
+}
+export declare const CreateDbaasLogInputRequest: S.Schema<CreateDbaasLogInputRequest>;
+export interface CreateDbaasLogInputConfigtestRequest {
+    /** Service name */
+    serviceName: string;
+    /** Input ID */
+    inputId: string;
+}
+export declare const CreateDbaasLogInputConfigtestRequest: S.Schema<CreateDbaasLogInputConfigtestRequest>;
+export interface CreateDbaasLogInputEndRequest {
+    /** Service name */
+    serviceName: string;
+    /** Input ID */
+    inputId: string;
+}
+export declare const CreateDbaasLogInputEndRequest: S.Schema<CreateDbaasLogInputEndRequest>;
+export interface CreateDbaasLogInputLogUrlRequest {
+    /** Service name */
+    serviceName: string;
+    /** Input ID */
+    inputId: string;
+}
+export declare const CreateDbaasLogInputLogUrlRequest: S.Schema<CreateDbaasLogInputLogUrlRequest>;
+/** Temporary url information */
+export interface DbaasLogsTemporaryLogsLink {
+    /** Temporary url expiration date */
+    expirationDate?: string;
+    /** Temporary url */
+    url?: string;
+}
+export declare const DbaasLogsTemporaryLogsLink: S.Schema<DbaasLogsTemporaryLogsLink>;
+export interface CreateDbaasLogOutputGraylogDashboardRequest {
+    /** Service name */
+    serviceName: string;
+    /** Description */
+    description: string;
+    /** Title */
+    title: string;
+}
+export declare const CreateDbaasLogOutputGraylogDashboardRequest: S.Schema<CreateDbaasLogOutputGraylogDashboardRequest>;
+/** Possible values for StreamColdStorageCompressionEnum */
+export type DbaasLogsStreamColdStorageCompressionEnum = "DEFLATED" | "GZIP" | "LZMA" | "ZSTD";
+export declare const DbaasLogsStreamColdStorageCompressionEnum: any;
+/** Possible values for StreamColdStorageContentEnum */
+export type DbaasLogsStreamColdStorageContentEnum = "ALL" | "GELF" | "PLAIN";
+export declare const DbaasLogsStreamColdStorageContentEnum: any;
+/** Encryption keys used to encrypt stream archives */
+export type CreateDbaasLogOutputGraylogStreamRequestEncryptionKeysIdsList = Array<string>;
+export declare const CreateDbaasLogOutputGraylogStreamRequestEncryptionKeysIdsList: S.Schema<CreateDbaasLogOutputGraylogStreamRequestEncryptionKeysIdsList>;
+export interface CreateDbaasLogOutputGraylogStreamRequest {
+    /** Service name */
+    serviceName: string;
+    /** Cold storage compression */
+    coldStorageCompression?: DbaasLogsStreamColdStorageCompressionEnum | (string & {}) | null;
+    /** Cold storage archive content */
+    coldStorageContent?: DbaasLogsStreamColdStorageContentEnum | (string & {}) | null;
+    /** Cold storage enabled */
+    coldStorageEnabled?: boolean | null;
+    /** Cold storage notify enabled */
+    coldStorageNotifyEnabled?: boolean | null;
+    /** Cold storage retention time */
+    coldStorageRetention?: number | null;
+    /** Description */
+    description: string;
+    /** Encryption keys used to encrypt stream archives */
+    encryptionKeysIds?: CreateDbaasLogOutputGraylogStreamRequestEncryptionKeysIdsList | null;
+    /** ES indexing enabled */
+    indexingEnabled?: boolean | null;
+    /** Maximum indexing size (in GB) */
+    indexingMaxSize?: number | null;
+    /** If set, notify when size is near 80, 90 or 100 % of the maximum configured setting */
+    indexingNotifyEnabled?: boolean | null;
+    /** Parent stream ID */
+    parentStreamId?: string | null;
+    /** If set, pause indexing when maximum size is reach */
+    pauseIndexingOnMaxSize?: boolean | null;
+    /** Retention ID */
+    retentionId?: string | null;
+    /** Title */
+    title: string;
+    /** Web Socket enabled */
+    webSocketEnabled?: boolean | null;
+}
+export declare const CreateDbaasLogOutputGraylogStreamRequest: S.Schema<CreateDbaasLogOutputGraylogStreamRequest>;
+/** Possible values for StreamAlertConditionConditionTypeEnum */
+export type DbaasLogsStreamAlertConditionConditionTypeEnum = "FIELD_CONTENT_VALUE" | "FIELD_VALUE" | "MESSAGE_COUNT";
+export declare const DbaasLogsStreamAlertConditionConditionTypeEnum: any;
+/** Possible values for StreamAlertConditionConstraintTypeEnum */
+export type DbaasLogsStreamAlertConditionConstraintTypeEnum = "MAX" | "MEAN" | "MIN" | "STDLABEU" | "SUM";
+export declare const DbaasLogsStreamAlertConditionConstraintTypeEnum: any;
+/** Possible values for StreamAlertConditionThresholdTypeEnum */
+export type DbaasLogsStreamAlertConditionThresholdTypeEnum = "EQ" | "GT" | "GTE" | "LT" | "LTE";
+export declare const DbaasLogsStreamAlertConditionThresholdTypeEnum: any;
+export interface CreateDbaasLogOutputGraylogStreamAlertRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+    /** Backlog */
+    backlog: number;
+    /** Condition type */
+    conditionType?: DbaasLogsStreamAlertConditionConditionTypeEnum | (string & {}) | null;
+    /** Constraint type */
+    constraintType?: DbaasLogsStreamAlertConditionConstraintTypeEnum | (string & {}) | null;
+    /** Field */
+    field?: string | null;
+    /** Grace period */
+    grace: number;
+    /** Query filter */
+    queryFilter?: string | null;
+    /** Repeat notifications enabled */
+    repeatNotificationsEnabled?: boolean | null;
+    /** Threshold */
+    threshold?: number | null;
+    /** Threshold type */
+    thresholdType?: DbaasLogsStreamAlertConditionThresholdTypeEnum | (string & {}) | null;
+    /** Time */
+    time?: number | null;
+    /** Title */
+    title: string;
+    /** Value */
+    value?: string | null;
+}
+export declare const CreateDbaasLogOutputGraylogStreamAlertRequest: S.Schema<CreateDbaasLogOutputGraylogStreamAlertRequest>;
+export interface CreateDbaasLogOutputGraylogStreamArchiveUrlRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+    /** Archive ID */
+    archiveId: string;
+}
+export declare const CreateDbaasLogOutputGraylogStreamArchiveUrlRequest: S.Schema<CreateDbaasLogOutputGraylogStreamArchiveUrlRequest>;
+/** Stream archive url */
+export interface DbaasLogsArchiveUrl {
+    /** Temporary URL expiration date */
+    expirationDate?: string;
+    /** Temporary URL to get archive */
+    url?: string;
+}
+export declare const DbaasLogsArchiveUrl: S.Schema<DbaasLogsArchiveUrl>;
+/** Possible values for StreamRuleOperatorEnum */
+export type DbaasLogsStreamRuleOperatorEnum = "FIELD_PRESENCE" | "GREATER_THAN" | "MATCH_EXACTLY" | "SMALLER_THAN";
+export declare const DbaasLogsStreamRuleOperatorEnum: any;
+export interface CreateDbaasLogOutputGraylogStreamRuleRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+    /** Field name */
+    field: string;
+    /** Invert condition */
+    isInverted?: boolean | null;
+    /** Field operator */
+    operator: DbaasLogsStreamRuleOperatorEnum | (string & {});
+    /** Field value */
+    value: string;
+}
+export declare const CreateDbaasLogOutputGraylogStreamRuleRequest: S.Schema<CreateDbaasLogOutputGraylogStreamRuleRequest>;
+export interface CreateDbaasLogOutputMetricTenantRequest {
+    /** Service name */
+    serviceName: string;
+    /** Metric tenant description */
+    description: string;
+    /** Maximum number of time series inside the tenant */
+    maxSeries?: number;
+    /** Delete samples older than the specified retention period. */
+    retentionId: string;
+    /** Metric tenant title */
+    title: string;
+}
+export declare const CreateDbaasLogOutputMetricTenantRequest: S.Schema<CreateDbaasLogOutputMetricTenantRequest>;
+export interface CreateDbaasLogOutputOpensearchAliasRequest {
+    /** Service name */
+    serviceName: string;
+    /** Description */
+    description: string;
+    /** Suffix */
+    suffix: string;
+}
+export declare const CreateDbaasLogOutputOpensearchAliasRequest: S.Schema<CreateDbaasLogOutputOpensearchAliasRequest>;
+export interface CreateDbaasLogOutputOpensearchAliasIndexRequest {
+    /** Service name */
+    serviceName: string;
+    /** Alias ID */
+    aliasId: string;
+    /** Index ID */
+    indexId: string;
+}
+export declare const CreateDbaasLogOutputOpensearchAliasIndexRequest: S.Schema<CreateDbaasLogOutputOpensearchAliasIndexRequest>;
+export interface CreateDbaasLogOutputOpensearchAliasStreamRequest {
+    /** Service name */
+    serviceName: string;
+    /** Alias ID */
+    aliasId: string;
+    /** Stream ID */
+    streamId: string;
+}
+export declare const CreateDbaasLogOutputOpensearchAliasStreamRequest: S.Schema<CreateDbaasLogOutputOpensearchAliasStreamRequest>;
+export interface CreateDbaasLogOutputOpensearchIndexRequest {
+    /** Service name */
+    serviceName: string;
+    /** If set, notify when size is near 80, 90 or 100 % of its maximum capacity */
+    alertNotifyEnabled?: boolean | null;
+    /** Description */
+    description: string;
+    /** Number of shard */
+    nbShard?: number | null;
+    /** Suffix */
+    suffix: string;
+}
+export declare const CreateDbaasLogOutputOpensearchIndexRequest: S.Schema<CreateDbaasLogOutputOpensearchIndexRequest>;
+export interface CreateDbaasLogOutputOpensearchOsdRequest {
+    /** Service name */
+    serviceName: string;
+    /** Description */
+    description: string;
+}
+export declare const CreateDbaasLogOutputOpensearchOsdRequest: S.Schema<CreateDbaasLogOutputOpensearchOsdRequest>;
+export interface CreateDbaasLogRoleRequest {
+    /** Service name */
+    serviceName: string;
+    /** Description */
+    description: string;
+    /** Name */
+    name: string;
+}
+export declare const CreateDbaasLogRoleRequest: S.Schema<CreateDbaasLogRoleRequest>;
+export interface CreateDbaasLogRoleMemberRequest {
+    /** Service name */
+    serviceName: string;
+    /** Role ID */
+    roleId: string;
+    /** Custom note */
+    note?: string | null;
+    /** Username */
+    username: string;
+}
+export declare const CreateDbaasLogRoleMemberRequest: S.Schema<CreateDbaasLogRoleMemberRequest>;
+export interface CreateDbaasLogRolePermissionAliasRequest {
+    /** Service name */
+    serviceName: string;
+    /** Role ID */
+    roleId: string;
+    /** Alias ID */
+    aliasId: string;
+}
+export declare const CreateDbaasLogRolePermissionAliasRequest: S.Schema<CreateDbaasLogRolePermissionAliasRequest>;
+/** Possible values for PermissionTypeEnum */
+export type DbaasLogsPermissionTypeEnum = "READ_ONLY" | "READ_WRITE";
+export declare const DbaasLogsPermissionTypeEnum: any;
+export interface CreateDbaasLogRolePermissionDashboardRequest {
+    /** Service name */
+    serviceName: string;
+    /** Role ID */
+    roleId: string;
+    /** Dashboard ID */
+    dashboardId: string;
+    /** Permission type */
+    permissionType?: DbaasLogsPermissionTypeEnum | (string & {}) | null;
+}
+export declare const CreateDbaasLogRolePermissionDashboardRequest: S.Schema<CreateDbaasLogRolePermissionDashboardRequest>;
+export interface CreateDbaasLogRolePermissionIndexRequest {
+    /** Service name */
+    serviceName: string;
+    /** Role ID */
+    roleId: string;
+    /** Index ID */
+    indexId: string;
+    /** Permission type */
+    permissionType?: DbaasLogsPermissionTypeEnum | (string & {}) | null;
+}
+export declare const CreateDbaasLogRolePermissionIndexRequest: S.Schema<CreateDbaasLogRolePermissionIndexRequest>;
+export interface CreateDbaasLogRolePermissionOsdRequest {
+    /** Service name */
+    serviceName: string;
+    /** Role ID */
+    roleId: string;
+    /** Osd ID */
+    osdId: string;
+    /** Permission type */
+    permissionType?: DbaasLogsPermissionTypeEnum | (string & {}) | null;
+}
+export declare const CreateDbaasLogRolePermissionOsdRequest: S.Schema<CreateDbaasLogRolePermissionOsdRequest>;
+export interface CreateDbaasLogRolePermissionStreamRequest {
+    /** Service name */
+    serviceName: string;
+    /** Role ID */
+    roleId: string;
+    /** Stream ID */
+    streamId: string;
+}
+export declare const CreateDbaasLogRolePermissionStreamRequest: S.Schema<CreateDbaasLogRolePermissionStreamRequest>;
+export interface CreateDbaasLogTokenRequest {
+    /** Service name */
+    serviceName: string;
+    /** Cluster ID */
+    clusterId?: string | null;
+    /** Token name */
+    name: string;
+}
+export declare const CreateDbaasLogTokenRequest: S.Schema<CreateDbaasLogTokenRequest>;
+export interface CreateDbaasLogUserChangePasswordRequest {
+    /** Service name */
+    serviceName: string;
+    /** Password must be at least 12 characters long contain a number, an uppercase, a lowercase and a special letter */
+    password: string | Redacted.Redacted<string>;
+}
+export declare const CreateDbaasLogUserChangePasswordRequest: S.Schema<CreateDbaasLogUserChangePasswordRequest>;
+export interface DeleteDbaasLogEncryptionKeyRequest {
+    /** Service name */
+    serviceName: string;
+    /** Encryption key ID */
+    encryptionKeyId: string;
+}
+export declare const DeleteDbaasLogEncryptionKeyRequest: S.Schema<DeleteDbaasLogEncryptionKeyRequest>;
+export interface DeleteDbaasLogInputRequest {
+    /** Service name */
+    serviceName: string;
+    /** Input ID */
+    inputId: string;
+}
+export declare const DeleteDbaasLogInputRequest: S.Schema<DeleteDbaasLogInputRequest>;
+export interface DeleteDbaasLogOutputGraylogDashboardRequest {
+    /** Service name */
+    serviceName: string;
+    /** Dashboard ID */
+    dashboardId: string;
+}
+export declare const DeleteDbaasLogOutputGraylogDashboardRequest: S.Schema<DeleteDbaasLogOutputGraylogDashboardRequest>;
+export interface DeleteDbaasLogOutputGraylogStreamRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+}
+export declare const DeleteDbaasLogOutputGraylogStreamRequest: S.Schema<DeleteDbaasLogOutputGraylogStreamRequest>;
+export interface DeleteDbaasLogOutputGraylogStreamAlertRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+    /** Alert ID */
+    alertId: string;
+}
+export declare const DeleteDbaasLogOutputGraylogStreamAlertRequest: S.Schema<DeleteDbaasLogOutputGraylogStreamAlertRequest>;
+export interface DeleteDbaasLogOutputGraylogStreamRuleRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+    /** Rule ID */
+    ruleId: string;
+}
+export declare const DeleteDbaasLogOutputGraylogStreamRuleRequest: S.Schema<DeleteDbaasLogOutputGraylogStreamRuleRequest>;
+export interface DeleteDbaasLogOutputGraylogStreamSubscriptionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+    /** Subscription ID */
+    subscriptionId: string;
+}
+export declare const DeleteDbaasLogOutputGraylogStreamSubscriptionRequest: S.Schema<DeleteDbaasLogOutputGraylogStreamSubscriptionRequest>;
+export interface DeleteDbaasLogOutputMetricTenantRequest {
+    /** Service name */
+    serviceName: string;
+    /** Tenant ID */
+    tenantId: string;
+}
+export declare const DeleteDbaasLogOutputMetricTenantRequest: S.Schema<DeleteDbaasLogOutputMetricTenantRequest>;
+export interface DeleteDbaasLogOutputMetricTenantSubscriptionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Tenant ID */
+    tenantId: string;
+    /** Subscription ID */
+    subscriptionId: string;
+}
+export declare const DeleteDbaasLogOutputMetricTenantSubscriptionRequest: S.Schema<DeleteDbaasLogOutputMetricTenantSubscriptionRequest>;
+export interface DeleteDbaasLogOutputOpensearchAliasRequest {
+    /** Service name */
+    serviceName: string;
+    /** Alias ID */
+    aliasId: string;
+}
+export declare const DeleteDbaasLogOutputOpensearchAliasRequest: S.Schema<DeleteDbaasLogOutputOpensearchAliasRequest>;
+export interface DeleteDbaasLogOutputOpensearchAliasIndexRequest {
+    /** Service name */
+    serviceName: string;
+    /** Alias ID */
+    aliasId: string;
+    /** Index ID */
+    indexId: string;
+}
+export declare const DeleteDbaasLogOutputOpensearchAliasIndexRequest: S.Schema<DeleteDbaasLogOutputOpensearchAliasIndexRequest>;
+export interface DeleteDbaasLogOutputOpensearchAliasStreamRequest {
+    /** Service name */
+    serviceName: string;
+    /** Alias ID */
+    aliasId: string;
+    /** Stream ID */
+    streamId: string;
+}
+export declare const DeleteDbaasLogOutputOpensearchAliasStreamRequest: S.Schema<DeleteDbaasLogOutputOpensearchAliasStreamRequest>;
+export interface DeleteDbaasLogOutputOpensearchIndexRequest {
+    /** Service name */
+    serviceName: string;
+    /** Index ID */
+    indexId: string;
+}
+export declare const DeleteDbaasLogOutputOpensearchIndexRequest: S.Schema<DeleteDbaasLogOutputOpensearchIndexRequest>;
+export interface DeleteDbaasLogOutputOpensearchOsdRequest {
+    /** Service name */
+    serviceName: string;
+    /** Osd ID */
+    osdId: string;
+}
+export declare const DeleteDbaasLogOutputOpensearchOsdRequest: S.Schema<DeleteDbaasLogOutputOpensearchOsdRequest>;
+export interface DeleteDbaasLogRoleRequest {
+    /** Service name */
+    serviceName: string;
+    /** Role ID */
+    roleId: string;
+}
+export declare const DeleteDbaasLogRoleRequest: S.Schema<DeleteDbaasLogRoleRequest>;
+export interface DeleteDbaasLogRoleMemberRequest {
+    /** Service name */
+    serviceName: string;
+    /** Role ID */
+    roleId: string;
+    /** Username */
+    username: string;
+}
+export declare const DeleteDbaasLogRoleMemberRequest: S.Schema<DeleteDbaasLogRoleMemberRequest>;
+export interface DeleteDbaasLogRolePermissionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Role ID */
+    roleId: string;
+    /** Permission ID */
+    permissionId: string;
+}
+export declare const DeleteDbaasLogRolePermissionRequest: S.Schema<DeleteDbaasLogRolePermissionRequest>;
+export interface DeleteDbaasLogTokenRequest {
+    /** Service name */
+    serviceName: string;
+    /** Token ID */
+    tokenId: string;
+}
+export declare const DeleteDbaasLogTokenRequest: S.Schema<DeleteDbaasLogTokenRequest>;
+export interface DuplicateDbaasLogsOutputGraylogDashboardRequest {
+    /** Service name */
+    serviceName: string;
+    /** Dashboard ID */
+    dashboardId: string;
+    /** Description */
+    description: string;
+    /** Stream ID */
+    streamId?: string | null;
+    /** Title */
+    title: string;
+}
+export declare const DuplicateDbaasLogsOutputGraylogDashboardRequest: S.Schema<DuplicateDbaasLogsOutputGraylogDashboardRequest>;
+export interface GetDbaasLogRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetDbaasLogRequest: S.Schema<GetDbaasLogRequest>;
+/** Resource tags. Tags that were internally computed are prefixed with ovh: */
+export type IamResourceMetadataTagsMap = {
+    [key: string]: string | undefined;
+};
+export declare const IamResourceMetadataTagsMap: S.Schema<IamResourceMetadataTagsMap>;
+/** IAM resource metadata embedded in services models */
+export interface IamResourceMetadata {
+    /** Resource display name */
+    displayName?: string | null;
+    /** Unique identifier of the resource */
+    id?: string;
+    /** Resource tags. Tags that were internally computed are prefixed with ovh: */
+    tags?: IamResourceMetadataTagsMap | null;
+    /** Unique resource name used in policies */
+    urn?: string;
+}
+export declare const IamResourceMetadata: S.Schema<IamResourceMetadata>;
+/** Possible values for ServicePlanEnum */
+export type DbaasLogsServicePlanEnum = "ENTERPRISE" | "STANDARD";
+export declare const DbaasLogsServicePlanEnum: any;
+/** Possible values for ServiceStateEnum */
+export type DbaasLogsServiceStateEnum = "DISABLED" | "ENABLED" | "INIT" | "TO_CONFIG";
+export declare const DbaasLogsServiceStateEnum: any;
+/** Service */
+export interface DbaasLogsServiceWithIAM {
+    /** Service creation */
+    createdAt?: string;
+    /** Service custom name */
+    displayName?: string | null;
+    /** IAM resource metadata */
+    iam?: IamResourceMetadata | null;
+    /** If set, can perform extra action on cluster */
+    isClusterOwner?: boolean;
+    /** Is IAM enabled for this service? */
+    isIamEnabled?: boolean;
+    /** Service plan */
+    plan?: DbaasLogsServicePlanEnum;
+    /** Service name */
+    serviceName?: string;
+    /** Service state */
+    state?: DbaasLogsServiceStateEnum;
+    /** Service last update */
+    updatedAt?: string | null;
+    /** Username on DBaaS Logs */
+    username?: string;
+}
+export declare const DbaasLogsServiceWithIAM: S.Schema<DbaasLogsServiceWithIAM>;
+export interface GetDbaasLogClusterRequest {
+    /** Service name */
+    serviceName: string;
+    /** Cluster ID */
+    clusterId: string;
+}
+export declare const GetDbaasLogClusterRequest: S.Schema<GetDbaasLogClusterRequest>;
+/** Allowed networks for ARCHIVE flow type */
+export type DbaasLogsClusterArchiveAllowedNetworksList = Array<string>;
+export declare const DbaasLogsClusterArchiveAllowedNetworksList: S.Schema<DbaasLogsClusterArchiveAllowedNetworksList>;
+/** Possible values for CertificationLevelEnum */
+export type DbaasLogsCertificationLevelEnum = "HDS" | "PCI_DSS" | "SNC" | "SOC2" | "STANDARD" | "TRUSTED_ZONE";
+export declare const DbaasLogsCertificationLevelEnum: any;
+/** Possible values for ClusterClusterTypeEnum */
+export type DbaasLogsClusterClusterTypeEnum = "DEDICATED" | "SHARED";
+export declare const DbaasLogsClusterClusterTypeEnum: any;
+/** Allowed networks for DIRECT_INPUT flow type */
+export type DbaasLogsClusterDirectInputAllowedNetworksList = Array<string>;
+export declare const DbaasLogsClusterDirectInputAllowedNetworksList: S.Schema<DbaasLogsClusterDirectInputAllowedNetworksList>;
+/** Allowed networks for QUERY flow type */
+export type DbaasLogsClusterQueryAllowedNetworksList = Array<string>;
+export declare const DbaasLogsClusterQueryAllowedNetworksList: S.Schema<DbaasLogsClusterQueryAllowedNetworksList>;
+/** Possible values for ClusterRegionEnum */
+export type DbaasLogsClusterRegionEnum = "BHS" | "GRA" | "P-19" | "RBX" | "SBG";
+export declare const DbaasLogsClusterRegionEnum: any;
+/** Cluster */
+export interface DbaasLogsCluster {
+    /** Allowed networks for ARCHIVE flow type */
+    archiveAllowedNetworks?: DbaasLogsClusterArchiveAllowedNetworksList;
+    /** Certification level of the given cluster */
+    certificationLevel?: DbaasLogsCertificationLevelEnum;
+    /** Cluster ID */
+    clusterId?: string;
+    /** Cluster type */
+    clusterType?: DbaasLogsClusterClusterTypeEnum;
+    /** PEM for dedicated inputs */
+    dedicatedInputPEM?: string;
+    /** Retention ID used by default when none is given on new stream */
+    defaultRetentionId?: string;
+    /** Allowed networks for DIRECT_INPUT flow type */
+    directInputAllowedNetworks?: DbaasLogsClusterDirectInputAllowedNetworksList;
+    /** PEM for direct inputs */
+    directInputPEM?: string;
+    /** Hostname */
+    hostname?: string;
+    /** All content generated by given service will be placed on this cluster */
+    isDefault?: boolean;
+    /** Allow given service to perform advanced operations on cluster */
+    isUnlocked?: boolean;
+    /** Allowed networks for QUERY flow type */
+    queryAllowedNetworks?: DbaasLogsClusterQueryAllowedNetworksList;
+    /** Data center localization */
+    region?: DbaasLogsClusterRegionEnum;
+}
+export declare const DbaasLogsCluster: S.Schema<DbaasLogsCluster>;
+export interface GetDbaasLogClusterRetentionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Cluster ID */
+    clusterId: string;
+    /** Retention ID */
+    retentionId: string;
+}
+export declare const GetDbaasLogClusterRetentionRequest: S.Schema<GetDbaasLogClusterRetentionRequest>;
+/** Possible values for RetentionTypeEnum */
+export type DbaasLogsRetentionTypeEnum = "LOGS_COLD_STORAGE" | "LOGS_INDEXING" | "METRICS_TENANT";
+export declare const DbaasLogsRetentionTypeEnum: any;
+/** Cluster retention */
+export interface DbaasLogsClusterRetention {
+    /** Indexed duration expressed in ISO-8601 format */
+    duration?: string | null;
+    /** Indicates if a new stream can use it */
+    isSupported?: boolean;
+    /** Retention ID */
+    retentionId?: string;
+    /** Retention type */
+    retentionType?: DbaasLogsRetentionTypeEnum;
+}
+export declare const DbaasLogsClusterRetention: S.Schema<DbaasLogsClusterRetention>;
+export interface GetDbaasLogEncryptionKeyRequest {
+    /** Service name */
+    serviceName: string;
+    /** Encryption key ID */
+    encryptionKeyId: string;
+}
+export declare const GetDbaasLogEncryptionKeyRequest: S.Schema<GetDbaasLogEncryptionKeyRequest>;
+/** Possible values for EncryptionKeyAlgorithmEnum */
+export type DbaasLogsEncryptionKeyAlgorithmEnum = "ECC25519" | "RSA4096";
+export declare const DbaasLogsEncryptionKeyAlgorithmEnum: any;
+/** Encryption key */
+export interface DbaasLogsEncryptionKey {
+    /** Encryption Key algorithm */
+    algorithm?: DbaasLogsEncryptionKeyAlgorithmEnum;
+    /** Encryption Key content */
+    content: string;
+    /** Encryption Key creation date */
+    createdAt?: string;
+    /** Encryption Key ID */
+    encryptionKeyId?: string;
+    /** Encryption Key fingerprint */
+    fingerprint: string;
+    /** Indicates if you are allowed to edit entry */
+    isEditable?: boolean;
+    /** Number of archives encrypted with this Encryption Key */
+    nbArchive?: number | null;
+    /** Encryption Key title */
+    title: string;
+    /** Encryption Key user ID */
+    uid?: string;
+}
+export declare const DbaasLogsEncryptionKey: S.Schema<DbaasLogsEncryptionKey>;
+export interface GetDbaasLogInputRequest {
+    /** Service name */
+    serviceName: string;
+    /** Input ID */
+    inputId: string;
+}
+export declare const GetDbaasLogInputRequest: S.Schema<GetDbaasLogInputRequest>;
+/** IP blocks */
+export type DbaasLogsInputAllowedNetworksList = Array<string>;
+export declare const DbaasLogsInputAllowedNetworksList: S.Schema<DbaasLogsInputAllowedNetworksList>;
+/** Possible values for InputStatusEnum */
+export type DbaasLogsInputStatusEnum = "INIT" | "PENDING" | "PROCESSING" | "RUNNING";
+export declare const DbaasLogsInputStatusEnum: any;
+/** Input */
+export interface DbaasLogsInput {
+    /** IP blocks */
+    allowedNetworks?: DbaasLogsInputAllowedNetworksList | null;
+    /** Whether the workload is auto-scaled */
+    autoscale?: boolean | null;
+    /** Input creation */
+    createdAt?: string;
+    /** Input description */
+    description?: string;
+    /** Input engine ID */
+    engineId?: string;
+    /** Port */
+    exposedPort?: string | null;
+    /** Hostname */
+    hostname?: string;
+    /** Input ID */
+    inputId?: string;
+    /** Indicate if input need to be restarted */
+    isRestartRequired?: boolean;
+    /** Maximum number of instances in auto-scaled mode */
+    maxScaleInstance?: number | null;
+    /** Minimum number of instances in auto-scaled mode */
+    minScaleInstance?: number | null;
+    /** Number of instance running */
+    nbInstance?: number | null;
+    /** Input IP address */
+    publicAddress?: string;
+    /** If set, notify when scaling happens */
+    scalingNotifyEnabled?: boolean | null;
+    /** Input SSL certificate */
+    sslCertificate?: string;
+    /** init: configuration required, pending: ready to start, running: available */
+    status?: DbaasLogsInputStatusEnum;
+    /** Associated Graylog stream */
+    streamId?: string;
+    /** Input title */
+    title?: string;
+    /** Input last update */
+    updatedAt?: string | null;
+}
+export declare const DbaasLogsInput: S.Schema<DbaasLogsInput>;
+export interface GetDbaasLogInputConfigtestResultRequest {
+    /** Service name */
+    serviceName: string;
+    /** Input ID */
+    inputId: string;
+}
+export declare const GetDbaasLogInputConfigtestResultRequest: S.Schema<GetDbaasLogInputConfigtestResultRequest>;
+/** Config test results */
+export interface DbaasLogsTestResult {
+    /** Whether the given configuration pass the syntax test */
+    isValid?: boolean;
+    /** Standard error */
+    stderr?: string | null;
+    /** Standard output */
+    stdout?: string | null;
+    /** Last config test update */
+    updatedAt?: string | null;
+}
+export declare const DbaasLogsTestResult: S.Schema<DbaasLogsTestResult>;
+export interface GetDbaasLogInputConfigurationFlowggerRequest {
+    /** Service name */
+    serviceName: string;
+    /** Input ID */
+    inputId: string;
+}
+export declare const GetDbaasLogInputConfigurationFlowggerRequest: S.Schema<GetDbaasLogInputConfigurationFlowggerRequest>;
+/** Possible values for FlowggerConfigurationLogFormatEnum */
+export type DbaasLogsFlowggerConfigurationLogFormatEnum = "CAPNP" | "GELF" | "LTSV" | "RFC5424";
+export declare const DbaasLogsFlowggerConfigurationLogFormatEnum: any;
+/** Possible values for FlowggerConfigurationLogFramingEnum */
+export type DbaasLogsFlowggerConfigurationLogFramingEnum = "CAPNP" | "LINE" | "NUL" | "SYSLEN";
+export declare const DbaasLogsFlowggerConfigurationLogFramingEnum: any;
+/** Flowgger configuration */
+export interface DbaasLogsFlowggerConfiguration {
+    /** Type of format to decode */
+    logFormat?: DbaasLogsFlowggerConfigurationLogFormatEnum;
+    /** Indicates how messages are delimited */
+    logFraming?: DbaasLogsFlowggerConfigurationLogFramingEnum;
+}
+export declare const DbaasLogsFlowggerConfiguration: S.Schema<DbaasLogsFlowggerConfiguration>;
+export interface GetDbaasLogInputConfigurationLogstashRequest {
+    /** Service name */
+    serviceName: string;
+    /** Input ID */
+    inputId: string;
+}
+export declare const GetDbaasLogInputConfigurationLogstashRequest: S.Schema<GetDbaasLogInputConfigurationLogstashRequest>;
+/** Logstash configuration */
+export interface DbaasLogsLogstashConfiguration {
+    /** The filter section of logstash.conf */
+    filterSection?: string | null;
+    /** The filter section of logstash.conf */
+    inputSection?: string;
+    /** The list of customs Grok patterns */
+    patternSection?: string | null;
+}
+export declare const DbaasLogsLogstashConfiguration: S.Schema<DbaasLogsLogstashConfiguration>;
+export interface GetDbaasLogInputEngineRequest {
+    /** Service name */
+    serviceName: string;
+    /** Engine ID */
+    engineId: string;
+}
+export declare const GetDbaasLogInputEngineRequest: S.Schema<GetDbaasLogInputEngineRequest>;
+/** Possible values for EngineNameEnum */
+export type DbaasLogsEngineNameEnum = "FLOWGGER" | "LOGSTASH" | "TEST";
+export declare const DbaasLogsEngineNameEnum: any;
+/** Input engine */
+export interface DbaasLogsEngine {
+    /** Input engine ID */
+    engineId?: string;
+    /** Indicates if engine will soon not be supported */
+    isDeprecated?: boolean;
+    /** Software name */
+    name?: DbaasLogsEngineNameEnum;
+    /** Software version */
+    version?: string;
+}
+export declare const DbaasLogsEngine: S.Schema<DbaasLogsEngine>;
+export interface GetDbaasLogInputEngineHelperRequest {
+    /** Service name */
+    serviceName: string;
+    /** Engine ID */
+    engineId: string;
+    /** Helper ID */
+    helperId: string;
+}
+export declare const GetDbaasLogInputEngineHelperRequest: S.Schema<GetDbaasLogInputEngineHelperRequest>;
+/** Possible values for HelperSectionName */
+export type DbaasLogsHelperSectionNameEnum = "LOGSTASH_FILTER" | "LOGSTASH_INPUT" | "LOGSTASH_PATTERN";
+export declare const DbaasLogsHelperSectionNameEnum: any;
+/** Helper section */
+export interface DbaasLogsHelperSection {
+    /** Section content */
+    content?: string;
+    /** Section name */
+    name?: DbaasLogsHelperSectionNameEnum;
+}
+export declare const DbaasLogsHelperSection: S.Schema<DbaasLogsHelperSection>;
+/** Helper sections */
+export type DbaasLogsHelperSectionsList = Array<DbaasLogsHelperSection>;
+export declare const DbaasLogsHelperSectionsList: S.Schema<DbaasLogsHelperSectionsList>;
+/** Helper */
+export interface DbaasLogsHelper {
+    /** Helper description */
+    description?: string;
+    /** Input engine UUID */
+    engineId?: string;
+    /** Helper UUID */
+    helperId?: string;
+    /** Helper sections */
+    sections?: DbaasLogsHelperSectionsList;
+    /** Helper title */
+    title?: string;
+}
+export declare const DbaasLogsHelper: S.Schema<DbaasLogsHelper>;
+export interface GetDbaasLogMetricsRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetDbaasLogMetricsRequest: S.Schema<GetDbaasLogMetricsRequest>;
+/** Metrics access */
+export interface DbaasLogsServiceMetric {
+    /** Metrics server url */
+    host?: string;
+    /** Metrics credentials */
+    token?: string;
+}
+export declare const DbaasLogsServiceMetric: S.Schema<DbaasLogsServiceMetric>;
+export interface GetDbaasLogOperationRequest {
+    /** Service name */
+    serviceName: string;
+    /** Operation ID */
+    operationId: string;
+}
+export declare const GetDbaasLogOperationRequest: S.Schema<GetDbaasLogOperationRequest>;
+export interface GetDbaasLogOutputGraylogDashboardRequest {
+    /** Service name */
+    serviceName: string;
+    /** Dashboard ID */
+    dashboardId: string;
+}
+export declare const GetDbaasLogOutputGraylogDashboardRequest: S.Schema<GetDbaasLogOutputGraylogDashboardRequest>;
+/** Graylog dashboard */
+export interface DbaasLogsDashboard {
+    /** Dashboard creation */
+    createdAt?: string;
+    /** Dashboard ID */
+    dashboardId?: string;
+    /** Dashboard description */
+    description?: string;
+    /** Indicates if you are allowed to edit entry */
+    isEditable?: boolean;
+    /** Dashboard description */
+    title?: string;
+    /** Dashboard last update */
+    updatedAt?: string | null;
+}
+export declare const DbaasLogsDashboard: S.Schema<DbaasLogsDashboard>;
+export interface GetDbaasLogOutputGraylogStreamRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+}
+export declare const GetDbaasLogOutputGraylogStreamRequest: S.Schema<GetDbaasLogOutputGraylogStreamRequest>;
+/** Encryption keys used to encrypt stream archives */
+export type DbaasLogsStreamEncryptionKeysIdsList = Array<string>;
+export declare const DbaasLogsStreamEncryptionKeysIdsList: S.Schema<DbaasLogsStreamEncryptionKeysIdsList>;
+/** Graylog stream */
+export interface DbaasLogsStream {
+    /** Indicates if the current user can create alert on the stream */
+    canAlert?: boolean;
+    /** Cluster ID */
+    clusterId?: string;
+    /** Cold storage compression method */
+    coldStorageCompression?: DbaasLogsStreamColdStorageCompressionEnum | null;
+    /** ColdStorage content */
+    coldStorageContent?: DbaasLogsStreamColdStorageContentEnum | null;
+    /** Is Cold storage enabled? */
+    coldStorageEnabled?: boolean | null;
+    /** Notify on new Cold storage archive */
+    coldStorageNotifyEnabled?: boolean | null;
+    /** Cold storage retention in year */
+    coldStorageRetention?: number | null;
+    /** Stream creation */
+    createdAt?: string;
+    /** Stream description */
+    description?: string;
+    /** Encryption keys used to encrypt stream archives */
+    encryptionKeysIds?: DbaasLogsStreamEncryptionKeysIdsList | null;
+    /** Indexing current size (in bytes) */
+    indexingCurrentSize?: number | null;
+    /** Enable ES indexing */
+    indexingEnabled?: boolean | null;
+    /** Maximum indexing size (in GB) */
+    indexingMaxSize?: number | null;
+    /** If set, notify when size is near 80, 90 or 100 % of the maximum configured setting */
+    indexingNotifyEnabled?: boolean | null;
+    /** Indicates if you are allowed to edit entry */
+    isEditable?: boolean;
+    /** Number of alert condition */
+    nbAlertCondition?: number;
+    /** Number of coldstored archives */
+    nbArchive?: number;
+    /** Number of subscriptions targeting this stream */
+    nbSubscription?: number;
+    /** Parent stream ID */
+    parentStreamId?: string | null;
+    /** If set, pause indexing when maximum size is reach */
+    pauseIndexingOnMaxSize?: boolean | null;
+    /** Retention ID */
+    retentionId?: string;
+    /** Stream ID */
+    streamId?: string;
+    /** Stream description */
+    title?: string;
+    /** Stream last update */
+    updatedAt?: string | null;
+    /** Enable Websocket */
+    webSocketEnabled?: boolean | null;
+}
+export declare const DbaasLogsStream: S.Schema<DbaasLogsStream>;
+export interface GetDbaasLogOutputGraylogStreamAlertRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+    /** Alert ID */
+    alertId: string;
+}
+export declare const GetDbaasLogOutputGraylogStreamAlertRequest: S.Schema<GetDbaasLogOutputGraylogStreamAlertRequest>;
+/** Alert condition */
+export interface DbaasLogsStreamAlertCondition {
+    /** Stream alert condition ID */
+    alertId?: string;
+    /** Backlog size */
+    backlog?: number;
+    /** Alert condition type */
+    conditionType?: DbaasLogsStreamAlertConditionConditionTypeEnum | null;
+    /** Constraint type */
+    constraintType?: DbaasLogsStreamAlertConditionConstraintTypeEnum | null;
+    /** Field name */
+    field?: string | null;
+    /** Grace period in minutes */
+    grace?: number;
+    /** Query filter */
+    queryFilter?: string | null;
+    /** Repeat notifications */
+    repeatNotificationsEnabled?: boolean | null;
+    /** Threshold */
+    threshold?: number | null;
+    /** Threshold condition */
+    thresholdType?: DbaasLogsStreamAlertConditionThresholdTypeEnum | null;
+    /** Time lapse in minutes */
+    time?: number | null;
+    /** Condition label */
+    title?: string;
+    /** Field value */
+    value?: string | null;
+}
+export declare const DbaasLogsStreamAlertCondition: S.Schema<DbaasLogsStreamAlertCondition>;
+export interface GetDbaasLogOutputGraylogStreamArchiveRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+    /** Archive ID */
+    archiveId: string;
+}
+export declare const GetDbaasLogOutputGraylogStreamArchiveRequest: S.Schema<GetDbaasLogOutputGraylogStreamArchiveRequest>;
+/** Possible values for ArchiveRetrievalStateEnum */
+export type DbaasLogsArchiveRetrievalStateEnum = "sealed" | "unsealed" | "unsealing";
+export declare const DbaasLogsArchiveRetrievalStateEnum: any;
+/** Stream archive */
+export interface DbaasLogsArchive {
+    /** Archive ID */
+    archiveId?: string;
+    /** Create date */
+    createdAt?: string | null;
+    /** Filename */
+    filename?: string;
+    /** MD5 checksum */
+    md5?: string;
+    /** Retrieval delay */
+    retrievalDelay?: number;
+    /** Retrieval state */
+    retrievalState?: DbaasLogsArchiveRetrievalStateEnum;
+    /** sha256 checksum */
+    sha256?: string;
+    /** File size in bytes */
+    size?: number;
+}
+export declare const DbaasLogsArchive: S.Schema<DbaasLogsArchive>;
+export interface GetDbaasLogOutputGraylogStreamRuleRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+    /** Rule ID */
+    ruleId: string;
+}
+export declare const GetDbaasLogOutputGraylogStreamRuleRequest: S.Schema<GetDbaasLogOutputGraylogStreamRuleRequest>;
+/** Stream rule */
+export interface DbaasLogsStreamRule {
+    /** Field name */
+    field?: string;
+    /** Invert condition */
+    isInverted?: boolean | null;
+    /** Field operator */
+    operator?: DbaasLogsStreamRuleOperatorEnum | null;
+    /** Stream rule ID */
+    ruleId?: string;
+    /** Field value */
+    value?: string;
+}
+export declare const DbaasLogsStreamRule: S.Schema<DbaasLogsStreamRule>;
+export interface GetDbaasLogOutputGraylogStreamSubscriptionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+    /** Subscription ID */
+    subscriptionId: string;
+}
+export declare const GetDbaasLogOutputGraylogStreamSubscriptionRequest: S.Schema<GetDbaasLogOutputGraylogStreamSubscriptionRequest>;
+/** Log subscription resource */
+export interface DbaasLogsLogSubscriptionResource {
+    /** Name of subscribed resource */
+    name?: string;
+    /** Type of subscribed resource */
+    type?: string;
+}
+export declare const DbaasLogsLogSubscriptionResource: S.Schema<DbaasLogsLogSubscriptionResource>;
+/** Log subscription */
+export interface DbaasLogsLogSubscription {
+    /** Creation date of the subscription */
+    createdAt?: string;
+    /** Log kind name of this subscription */
+    kind?: string;
+    /** Subscribed resource, where the logs come from */
+    resource?: DbaasLogsLogSubscriptionResource;
+    /** Name of the destination log service */
+    serviceName?: string;
+    /** Id of the destination log stream */
+    streamId?: string;
+    /** Subscription ID */
+    subscriptionId?: string;
+    /** Last update date of the subscription */
+    updatedAt?: string;
+}
+export declare const DbaasLogsLogSubscription: S.Schema<DbaasLogsLogSubscription>;
+export interface GetDbaasLogOutputMetricTenantRequest {
+    /** Service name */
+    serviceName: string;
+    /** Tenant ID */
+    tenantId: string;
+}
+export declare const GetDbaasLogOutputMetricTenantRequest: S.Schema<GetDbaasLogOutputMetricTenantRequest>;
+/** Possible values for DeliveryStatusEnum */
+export type DbaasLogsDeliveryStatusEnum = "DELETING" | "DELIVERING" | "READY" | "UPDATING";
+export declare const DbaasLogsDeliveryStatusEnum: any;
+/** Metric Tenant */
+export interface DbaasLogsMetricTenant {
+    /** Metric tenant creation */
+    createdAt?: string;
+    /** Status of the delivering process */
+    deliveryStatus?: DbaasLogsDeliveryStatusEnum;
+    /** Metric tenant description */
+    description?: string;
+    /** Maximum number of time series inside the tenant */
+    maxSeries?: number;
+    /** Delete samples older than the specified retention period. */
+    retentionId?: string;
+    /** The Id of the metric tenant */
+    tenantId?: string;
+    /** Metric tenant title */
+    title?: string;
+    /** Metric tenant last update */
+    updatedAt?: string | null;
+}
+export declare const DbaasLogsMetricTenant: S.Schema<DbaasLogsMetricTenant>;
+export interface GetDbaasLogOutputMetricTenantSubscriptionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Tenant ID */
+    tenantId: string;
+    /** Subscription ID */
+    subscriptionId: string;
+}
+export declare const GetDbaasLogOutputMetricTenantSubscriptionRequest: S.Schema<GetDbaasLogOutputMetricTenantSubscriptionRequest>;
+/** Metrics subscription */
+export interface DbaasLogsMetricSubscription {
+    /** Creation date of the subscription */
+    createdAt?: string;
+    /** Metric kind name of this subscription */
+    kind?: string;
+    /** Subscribed resource, where the metrics come from */
+    resource?: DbaasLogsLogSubscriptionResource;
+    /** Name of the destination /dbaas/logs service */
+    serviceName?: string;
+    /** Subscription ID */
+    subscriptionId?: string;
+    /** Id of the destination metric tenant */
+    tenantId?: string;
+    /** Last update date of the subscription */
+    updatedAt?: string;
+}
+export declare const DbaasLogsMetricSubscription: S.Schema<DbaasLogsMetricSubscription>;
+export interface GetDbaasLogOutputOpensearchAliasRequest {
+    /** Service name */
+    serviceName: string;
+    /** Alias ID */
+    aliasId: string;
+}
+export declare const GetDbaasLogOutputOpensearchAliasRequest: S.Schema<GetDbaasLogOutputOpensearchAliasRequest>;
+/** Alias */
+export interface DbaasLogsAlias {
+    /** Alias ID */
+    aliasId?: string;
+    /** Input creation */
+    createdAt?: string;
+    /** Alias description */
+    description?: string | null;
+    /** Indicates if you are allowed to edit entry */
+    isEditable?: boolean;
+    /** Alias name */
+    name?: string;
+    /** Number of indices linked */
+    nbIndex?: number;
+    /** Number of streams linked */
+    nbStream?: number;
+    /** Input last update */
+    updatedAt?: string | null;
+}
+export declare const DbaasLogsAlias: S.Schema<DbaasLogsAlias>;
+export interface GetDbaasLogOutputOpensearchIndexRequest {
+    /** Service name */
+    serviceName: string;
+    /** Index ID */
+    indexId: string;
+}
+export declare const GetDbaasLogOutputOpensearchIndexRequest: S.Schema<GetDbaasLogOutputOpensearchIndexRequest>;
+/** Index */
+export interface DbaasLogsIndex {
+    /** If set, notify when size is near 80, 90 or 100 % of its maximum capacity */
+    alertNotifyEnabled?: boolean | null;
+    /** Index creation */
+    createdAt?: string;
+    /** Current index size (in bytes) */
+    currentSize?: number | null;
+    /** Index description */
+    description?: string | null;
+    /** Index ID */
+    indexId?: string;
+    /** Indicates if you are allowed to edit entry */
+    isEditable?: boolean;
+    /** Maximum index size (in bytes) */
+    maxSize?: number;
+    /** Index name */
+    name?: string;
+    /** Number of shard */
+    nbShard?: number | null;
+    /** Index last update */
+    updatedAt?: string | null;
+}
+export declare const DbaasLogsIndex: S.Schema<DbaasLogsIndex>;
+export interface GetDbaasLogOutputOpensearchOsdRequest {
+    /** Service name */
+    serviceName: string;
+    /** Osd ID */
+    osdId: string;
+}
+export declare const GetDbaasLogOutputOpensearchOsdRequest: S.Schema<GetDbaasLogOutputOpensearchOsdRequest>;
+/** OpenSearch Dashboards instance */
+export interface DbaasLogsOsd {
+    /** OpenSearch Dashboards creation */
+    createdAt?: string;
+    /** Status of the delivering process */
+    deliveryStatus?: DbaasLogsDeliveryStatusEnum;
+    /** OpenSearch Dashboards description */
+    description?: string;
+    /** Indicates if you are allowed to edit entry */
+    isEditable?: boolean;
+    /** OpenSearch Dashboards name */
+    name?: string;
+    /** OpenSearch Dashboards ID */
+    osdId?: string;
+    /** OpenSearch Dashboards last update */
+    updatedAt?: string | null;
+}
+export declare const DbaasLogsOsd: S.Schema<DbaasLogsOsd>;
+export interface GetDbaasLogRoleRequest {
+    /** Service name */
+    serviceName: string;
+    /** Role ID */
+    roleId: string;
+}
+export declare const GetDbaasLogRoleRequest: S.Schema<GetDbaasLogRoleRequest>;
+/** Role */
+export interface DbaasLogsRole {
+    /** Role creation */
+    createdAt?: string;
+    /** Role description */
+    description?: string;
+    /** Role name */
+    name?: string;
+    /** Number of members */
+    nbMember?: number;
+    /** Number of permissions */
+    nbPermission?: number;
+    /** Role ID */
+    roleId?: string;
+    /** Role last update */
+    updatedAt?: string | null;
+}
+export declare const DbaasLogsRole: S.Schema<DbaasLogsRole>;
+export interface GetDbaasLogRoleMemberRequest {
+    /** Service name */
+    serviceName: string;
+    /** Role ID */
+    roleId: string;
+    /** Username */
+    username: string;
+}
+export declare const GetDbaasLogRoleMemberRequest: S.Schema<GetDbaasLogRoleMemberRequest>;
+/** Member */
+export interface DbaasLogsMember {
+    /** Membership creation */
+    createdAt?: string;
+    /** Custom note */
+    note?: string | null;
+    /** Username on DBaaS Logs */
+    username?: string;
+}
+export declare const DbaasLogsMember: S.Schema<DbaasLogsMember>;
+export interface GetDbaasLogRolePermissionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Role ID */
+    roleId: string;
+    /** Permission ID */
+    permissionId: string;
+}
+export declare const GetDbaasLogRolePermissionRequest: S.Schema<GetDbaasLogRolePermissionRequest>;
+/** Role permission */
+export interface DbaasLogsPermission {
+    /** Associated Elasticsearch alias */
+    aliasId?: string | null;
+    /** Associated Graylog dashboard */
+    dashboardId?: string | null;
+    /** Associated Elasticsearch index */
+    indexId?: string | null;
+    /** Associated OpenSearch Dashboards instance */
+    osdId?: string | null;
+    /** Permission ID */
+    permissionId?: string;
+    /** Permission type */
+    permissionType?: DbaasLogsPermissionTypeEnum | null;
+    /** Associated Graylog stream */
+    streamId?: string | null;
+}
+export declare const DbaasLogsPermission: S.Schema<DbaasLogsPermission>;
+export interface GetDbaasLogServiceInfosRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const GetDbaasLogServiceInfosRequest: S.Schema<GetDbaasLogServiceInfosRequest>;
+/** All the possible renew period of your service in month */
+export type ServicesServicePossibleRenewPeriodList = Array<number>;
+export declare const ServicesServicePossibleRenewPeriodList: S.Schema<ServicesServicePossibleRenewPeriodList>;
+/** Map a possible renew for a specific service */
+export interface ServiceRenewType {
+    /** The service is automatically renewed */
+    automatic?: boolean;
+    /** The service will be deleted at expiration */
+    deleteAtExpiration?: boolean;
+    /** The service forced to be renewed */
+    forced?: boolean;
+    /** The service needs to be manually renewed and paid */
+    manualPayment?: boolean | null;
+    /** period of renew in month */
+    period?: number | null;
+}
+export declare const ServiceRenewType: S.Schema<ServiceRenewType>;
+/** Detailed renewal type of a service */
+export type ServiceRenewalTypeEnum = "automaticForcedProduct" | "automaticV2012" | "automaticV2014" | "automaticV2016" | "manual" | "oneShot" | "option";
+export declare const ServiceRenewalTypeEnum: any;
+/** service.StateEnum */
+export type ServiceStateEnum = "autorenewInProgress" | "expired" | "inCreation" | "ok" | "pendingDebt" | "unPaid";
+export declare const ServiceStateEnum: any;
+/** Details about a Service */
+export interface ServicesService {
+    /** Indicates that the service can be set up to be deleted at expiration */
+    canDeleteAtExpiration?: boolean;
+    contactAdmin?: string;
+    contactBilling?: string;
+    contactTech?: string;
+    creation?: string;
+    domain?: string;
+    engagedUpTo?: string | null;
+    expiration?: string;
+    /** All the possible renew period of your service in month */
+    possibleRenewPeriod?: ServicesServicePossibleRenewPeriodList | null;
+    /** Way of handling the renew */
+    renew?: ServiceRenewType | null;
+    renewalType?: ServiceRenewalTypeEnum;
+    serviceId?: number;
+    status?: ServiceStateEnum;
+}
+export declare const ServicesService: S.Schema<ServicesService>;
+export interface GetDbaasLogTokenRequest {
+    /** Service name */
+    serviceName: string;
+    /** Token ID */
+    tokenId: string;
+}
+export declare const GetDbaasLogTokenRequest: S.Schema<GetDbaasLogTokenRequest>;
+/** Token */
+export interface DbaasLogsToken {
+    /** Cluster ID */
+    clusterId?: string | null;
+    /** Token creation */
+    createdAt?: string;
+    /** Token name */
+    name?: string;
+    /** Token ID */
+    tokenId?: string;
+    /** Token last update */
+    updatedAt?: string | null;
+    /** Token value */
+    value?: string;
+}
+export declare const DbaasLogsToken: S.Schema<DbaasLogsToken>;
+export interface ListDbaasLogClusterRequest {
+    /** Service name */
+    serviceName: string;
+    /** Filter by name (like) */
+    namePattern?: string;
+}
+export declare const ListDbaasLogClusterRequest: S.Schema<ListDbaasLogClusterRequest>;
+export type ListDbaasLogClusterResponseBodyList = Array<string>;
+export declare const ListDbaasLogClusterResponseBodyList: S.Schema<ListDbaasLogClusterResponseBodyList>;
+export type ListDbaasLogClusterResponse = ListDbaasLogClusterResponseBodyList;
+export declare const ListDbaasLogClusterResponse: S.Schema<ListDbaasLogClusterResponse>;
+export interface ListDbaasLogClusterRetentionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Cluster ID */
+    clusterId: string;
+}
+export declare const ListDbaasLogClusterRetentionRequest: S.Schema<ListDbaasLogClusterRetentionRequest>;
+export type ListDbaasLogClusterRetentionResponseBodyList = Array<string>;
+export declare const ListDbaasLogClusterRetentionResponseBodyList: S.Schema<ListDbaasLogClusterRetentionResponseBodyList>;
+export type ListDbaasLogClusterRetentionResponse = ListDbaasLogClusterRetentionResponseBodyList;
+export declare const ListDbaasLogClusterRetentionResponse: S.Schema<ListDbaasLogClusterRetentionResponse>;
+export interface ListDbaasLogEncryptionKeyRequest {
+    /** Service name */
+    serviceName: string;
+    /** Filter by title (like) */
+    titlePattern?: string;
+}
+export declare const ListDbaasLogEncryptionKeyRequest: S.Schema<ListDbaasLogEncryptionKeyRequest>;
+export type ListDbaasLogEncryptionKeyResponseBodyList = Array<string>;
+export declare const ListDbaasLogEncryptionKeyResponseBodyList: S.Schema<ListDbaasLogEncryptionKeyResponseBodyList>;
+export type ListDbaasLogEncryptionKeyResponse = ListDbaasLogEncryptionKeyResponseBodyList;
+export declare const ListDbaasLogEncryptionKeyResponse: S.Schema<ListDbaasLogEncryptionKeyResponse>;
+export interface ListDbaasLogInputRequest {
+    /** Service name */
+    serviceName: string;
+    /** Filter by title (like) */
+    titlePattern?: string;
+}
+export declare const ListDbaasLogInputRequest: S.Schema<ListDbaasLogInputRequest>;
+export type ListDbaasLogInputResponseBodyList = Array<string>;
+export declare const ListDbaasLogInputResponseBodyList: S.Schema<ListDbaasLogInputResponseBodyList>;
+export type ListDbaasLogInputResponse = ListDbaasLogInputResponseBodyList;
+export declare const ListDbaasLogInputResponse: S.Schema<ListDbaasLogInputResponse>;
+export interface ListDbaasLogInputActionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Input ID */
+    inputId: string;
+}
+export declare const ListDbaasLogInputActionRequest: S.Schema<ListDbaasLogInputActionRequest>;
+/** Possible values for InputActionTypeEnum */
+export type DbaasLogsInputActionTypeEnum = "DESTROY" | "END" | "LOG" | "RESTART" | "START" | "TEST";
+export declare const DbaasLogsInputActionTypeEnum: any;
+/** Action on input */
+export interface DbaasLogsInputAction {
+    /** Indicates if action is allowed */
+    isAllowed?: boolean;
+    /** Action type */
+    type?: DbaasLogsInputActionTypeEnum;
+}
+export declare const DbaasLogsInputAction: S.Schema<DbaasLogsInputAction>;
+export type ListDbaasLogInputActionResponseBodyList = Array<DbaasLogsInputAction>;
+export declare const ListDbaasLogInputActionResponseBodyList: S.Schema<ListDbaasLogInputActionResponseBodyList>;
+export type ListDbaasLogInputActionResponse = ListDbaasLogInputActionResponseBodyList;
+export declare const ListDbaasLogInputActionResponse: S.Schema<ListDbaasLogInputActionResponse>;
+export interface ListDbaasLogInputEngineRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListDbaasLogInputEngineRequest: S.Schema<ListDbaasLogInputEngineRequest>;
+export type ListDbaasLogInputEngineResponseBodyList = Array<string>;
+export declare const ListDbaasLogInputEngineResponseBodyList: S.Schema<ListDbaasLogInputEngineResponseBodyList>;
+export type ListDbaasLogInputEngineResponse = ListDbaasLogInputEngineResponseBodyList;
+export declare const ListDbaasLogInputEngineResponse: S.Schema<ListDbaasLogInputEngineResponse>;
+export interface ListDbaasLogInputEngineHelperRequest {
+    /** Service name */
+    serviceName: string;
+    /** Engine ID */
+    engineId: string;
+}
+export declare const ListDbaasLogInputEngineHelperRequest: S.Schema<ListDbaasLogInputEngineHelperRequest>;
+export type ListDbaasLogInputEngineHelperResponseBodyList = Array<string>;
+export declare const ListDbaasLogInputEngineHelperResponseBodyList: S.Schema<ListDbaasLogInputEngineHelperResponseBodyList>;
+export type ListDbaasLogInputEngineHelperResponse = ListDbaasLogInputEngineHelperResponseBodyList;
+export declare const ListDbaasLogInputEngineHelperResponse: S.Schema<ListDbaasLogInputEngineHelperResponse>;
+export interface ListDbaasLogInputUrlRequest {
+    /** Service name */
+    serviceName: string;
+    /** Input ID */
+    inputId: string;
+}
+export declare const ListDbaasLogInputUrlRequest: S.Schema<ListDbaasLogInputUrlRequest>;
+/** Possible values for UrlTypeEnum */
+export type DbaasLogsUrlTypeEnum = "CONSOLE" | "ELASTICSEARCH_API" | "GRAYLOG_API" | "GRAYLOG_WEBUI" | "HTTP_GELF" | "HTTP_TLS_GELF" | "KIBANA_WEBUI" | "OPENSEARCH_API" | "OSD_WEBUI" | "PROMETHEUS_API" | "SERVICE_DOMAIN" | "TCP_BEATS" | "TCP_CAP_N_PROTO" | "TCP_GELF" | "TCP_LTSV_LINE" | "TCP_LTSV_NUL" | "TCP_RFC5424" | "TCP_TLS_BEATS" | "TCP_TLS_CAP_N_PROTO" | "TCP_TLS_GELF" | "TCP_TLS_LTSV_LINE" | "TCP_TLS_LTSV_NUL" | "TCP_TLS_RFC5424" | "UDP_CAP_N_PROTO" | "UDP_GELF" | "UDP_LTSV_LINE" | "UDP_LTSV_NUL" | "UDP_RFC5424" | "WEB_SOCKET";
+export declare const DbaasLogsUrlTypeEnum: any;
+/** Web address */
+export interface DbaasLogsUrl {
+    /** Web URI */
+    address?: string;
+    /** Service type */
+    type?: DbaasLogsUrlTypeEnum;
+}
+export declare const DbaasLogsUrl: S.Schema<DbaasLogsUrl>;
+export type ListDbaasLogInputUrlResponseBodyList = Array<DbaasLogsUrl>;
+export declare const ListDbaasLogInputUrlResponseBodyList: S.Schema<ListDbaasLogInputUrlResponseBodyList>;
+export type ListDbaasLogInputUrlResponse = ListDbaasLogInputUrlResponseBodyList;
+export declare const ListDbaasLogInputUrlResponse: S.Schema<ListDbaasLogInputUrlResponse>;
+export interface ListDbaasLogOperationRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListDbaasLogOperationRequest: S.Schema<ListDbaasLogOperationRequest>;
+export type ListDbaasLogOperationResponseBodyList = Array<string>;
+export declare const ListDbaasLogOperationResponseBodyList: S.Schema<ListDbaasLogOperationResponseBodyList>;
+export type ListDbaasLogOperationResponse = ListDbaasLogOperationResponseBodyList;
+export declare const ListDbaasLogOperationResponse: S.Schema<ListDbaasLogOperationResponse>;
+export interface ListDbaasLogOutputGraylogDashboardRequest {
+    /** Service name */
+    serviceName: string;
+    /** Filter by title (like) */
+    titlePattern?: string;
+}
+export declare const ListDbaasLogOutputGraylogDashboardRequest: S.Schema<ListDbaasLogOutputGraylogDashboardRequest>;
+export type ListDbaasLogOutputGraylogDashboardResponseBodyList = Array<string>;
+export declare const ListDbaasLogOutputGraylogDashboardResponseBodyList: S.Schema<ListDbaasLogOutputGraylogDashboardResponseBodyList>;
+export type ListDbaasLogOutputGraylogDashboardResponse = ListDbaasLogOutputGraylogDashboardResponseBodyList;
+export declare const ListDbaasLogOutputGraylogDashboardResponse: S.Schema<ListDbaasLogOutputGraylogDashboardResponse>;
+export interface ListDbaasLogOutputGraylogDashboardUrlRequest {
+    /** Service name */
+    serviceName: string;
+    /** Dashboard ID */
+    dashboardId: string;
+}
+export declare const ListDbaasLogOutputGraylogDashboardUrlRequest: S.Schema<ListDbaasLogOutputGraylogDashboardUrlRequest>;
+export type ListDbaasLogOutputGraylogDashboardUrlResponseBodyList = Array<DbaasLogsUrl>;
+export declare const ListDbaasLogOutputGraylogDashboardUrlResponseBodyList: S.Schema<ListDbaasLogOutputGraylogDashboardUrlResponseBodyList>;
+export type ListDbaasLogOutputGraylogDashboardUrlResponse = ListDbaasLogOutputGraylogDashboardUrlResponseBodyList;
+export declare const ListDbaasLogOutputGraylogDashboardUrlResponse: S.Schema<ListDbaasLogOutputGraylogDashboardUrlResponse>;
+export interface ListDbaasLogOutputGraylogStreamRequest {
+    /** Service name */
+    serviceName: string;
+    /** Filter by title (like) */
+    titlePattern?: string;
+}
+export declare const ListDbaasLogOutputGraylogStreamRequest: S.Schema<ListDbaasLogOutputGraylogStreamRequest>;
+export type ListDbaasLogOutputGraylogStreamResponseBodyList = Array<string>;
+export declare const ListDbaasLogOutputGraylogStreamResponseBodyList: S.Schema<ListDbaasLogOutputGraylogStreamResponseBodyList>;
+export type ListDbaasLogOutputGraylogStreamResponse = ListDbaasLogOutputGraylogStreamResponseBodyList;
+export declare const ListDbaasLogOutputGraylogStreamResponse: S.Schema<ListDbaasLogOutputGraylogStreamResponse>;
+export interface ListDbaasLogOutputGraylogStreamAlertRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+}
+export declare const ListDbaasLogOutputGraylogStreamAlertRequest: S.Schema<ListDbaasLogOutputGraylogStreamAlertRequest>;
+export type ListDbaasLogOutputGraylogStreamAlertResponseBodyList = Array<string>;
+export declare const ListDbaasLogOutputGraylogStreamAlertResponseBodyList: S.Schema<ListDbaasLogOutputGraylogStreamAlertResponseBodyList>;
+export type ListDbaasLogOutputGraylogStreamAlertResponse = ListDbaasLogOutputGraylogStreamAlertResponseBodyList;
+export declare const ListDbaasLogOutputGraylogStreamAlertResponse: S.Schema<ListDbaasLogOutputGraylogStreamAlertResponse>;
+export interface ListDbaasLogOutputGraylogStreamArchiveRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+}
+export declare const ListDbaasLogOutputGraylogStreamArchiveRequest: S.Schema<ListDbaasLogOutputGraylogStreamArchiveRequest>;
+export type ListDbaasLogOutputGraylogStreamArchiveResponseBodyList = Array<string>;
+export declare const ListDbaasLogOutputGraylogStreamArchiveResponseBodyList: S.Schema<ListDbaasLogOutputGraylogStreamArchiveResponseBodyList>;
+export type ListDbaasLogOutputGraylogStreamArchiveResponse = ListDbaasLogOutputGraylogStreamArchiveResponseBodyList;
+export declare const ListDbaasLogOutputGraylogStreamArchiveResponse: S.Schema<ListDbaasLogOutputGraylogStreamArchiveResponse>;
+export interface ListDbaasLogOutputGraylogStreamArchiveEncryptionKeyRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+    /** Archive ID */
+    archiveId: string;
+}
+export declare const ListDbaasLogOutputGraylogStreamArchiveEncryptionKeyRequest: S.Schema<ListDbaasLogOutputGraylogStreamArchiveEncryptionKeyRequest>;
+export type ListDbaasLogOutputGraylogStreamArchiveEncryptionKeyResponseBodyList = Array<string>;
+export declare const ListDbaasLogOutputGraylogStreamArchiveEncryptionKeyResponseBodyList: S.Schema<ListDbaasLogOutputGraylogStreamArchiveEncryptionKeyResponseBodyList>;
+export type ListDbaasLogOutputGraylogStreamArchiveEncryptionKeyResponse = ListDbaasLogOutputGraylogStreamArchiveEncryptionKeyResponseBodyList;
+export declare const ListDbaasLogOutputGraylogStreamArchiveEncryptionKeyResponse: S.Schema<ListDbaasLogOutputGraylogStreamArchiveEncryptionKeyResponse>;
+export interface ListDbaasLogOutputGraylogStreamRuleRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+}
+export declare const ListDbaasLogOutputGraylogStreamRuleRequest: S.Schema<ListDbaasLogOutputGraylogStreamRuleRequest>;
+export type ListDbaasLogOutputGraylogStreamRuleResponseBodyList = Array<string>;
+export declare const ListDbaasLogOutputGraylogStreamRuleResponseBodyList: S.Schema<ListDbaasLogOutputGraylogStreamRuleResponseBodyList>;
+export type ListDbaasLogOutputGraylogStreamRuleResponse = ListDbaasLogOutputGraylogStreamRuleResponseBodyList;
+export declare const ListDbaasLogOutputGraylogStreamRuleResponse: S.Schema<ListDbaasLogOutputGraylogStreamRuleResponse>;
+export interface ListDbaasLogOutputGraylogStreamSubscriptionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+    /** Filter by resource name (like) */
+    resourceName?: string;
+    /** Filter by resource type (like) */
+    resourceType?: string;
+}
+export declare const ListDbaasLogOutputGraylogStreamSubscriptionRequest: S.Schema<ListDbaasLogOutputGraylogStreamSubscriptionRequest>;
+export type ListDbaasLogOutputGraylogStreamSubscriptionResponseBodyList = Array<string>;
+export declare const ListDbaasLogOutputGraylogStreamSubscriptionResponseBodyList: S.Schema<ListDbaasLogOutputGraylogStreamSubscriptionResponseBodyList>;
+export type ListDbaasLogOutputGraylogStreamSubscriptionResponse = ListDbaasLogOutputGraylogStreamSubscriptionResponseBodyList;
+export declare const ListDbaasLogOutputGraylogStreamSubscriptionResponse: S.Schema<ListDbaasLogOutputGraylogStreamSubscriptionResponse>;
+export interface ListDbaasLogOutputGraylogStreamUrlRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+}
+export declare const ListDbaasLogOutputGraylogStreamUrlRequest: S.Schema<ListDbaasLogOutputGraylogStreamUrlRequest>;
+export type ListDbaasLogOutputGraylogStreamUrlResponseBodyList = Array<DbaasLogsUrl>;
+export declare const ListDbaasLogOutputGraylogStreamUrlResponseBodyList: S.Schema<ListDbaasLogOutputGraylogStreamUrlResponseBodyList>;
+export type ListDbaasLogOutputGraylogStreamUrlResponse = ListDbaasLogOutputGraylogStreamUrlResponseBodyList;
+export declare const ListDbaasLogOutputGraylogStreamUrlResponse: S.Schema<ListDbaasLogOutputGraylogStreamUrlResponse>;
+export interface ListDbaasLogOutputMetricTenantRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListDbaasLogOutputMetricTenantRequest: S.Schema<ListDbaasLogOutputMetricTenantRequest>;
+export type ListDbaasLogOutputMetricTenantResponseBodyList = Array<string>;
+export declare const ListDbaasLogOutputMetricTenantResponseBodyList: S.Schema<ListDbaasLogOutputMetricTenantResponseBodyList>;
+export type ListDbaasLogOutputMetricTenantResponse = ListDbaasLogOutputMetricTenantResponseBodyList;
+export declare const ListDbaasLogOutputMetricTenantResponse: S.Schema<ListDbaasLogOutputMetricTenantResponse>;
+export interface ListDbaasLogOutputMetricTenantSubscriptionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Tenant ID */
+    tenantId: string;
+    /** Filter by resource name (like) */
+    resourceName?: string;
+    /** Filter by resource type (like) */
+    resourceType?: string;
+}
+export declare const ListDbaasLogOutputMetricTenantSubscriptionRequest: S.Schema<ListDbaasLogOutputMetricTenantSubscriptionRequest>;
+export type ListDbaasLogOutputMetricTenantSubscriptionResponseBodyList = Array<string>;
+export declare const ListDbaasLogOutputMetricTenantSubscriptionResponseBodyList: S.Schema<ListDbaasLogOutputMetricTenantSubscriptionResponseBodyList>;
+export type ListDbaasLogOutputMetricTenantSubscriptionResponse = ListDbaasLogOutputMetricTenantSubscriptionResponseBodyList;
+export declare const ListDbaasLogOutputMetricTenantSubscriptionResponse: S.Schema<ListDbaasLogOutputMetricTenantSubscriptionResponse>;
+export interface ListDbaasLogOutputMetricTenantUrlRequest {
+    /** Service name */
+    serviceName: string;
+    /** Tenant ID */
+    tenantId: string;
+}
+export declare const ListDbaasLogOutputMetricTenantUrlRequest: S.Schema<ListDbaasLogOutputMetricTenantUrlRequest>;
+export type ListDbaasLogOutputMetricTenantUrlResponseBodyList = Array<DbaasLogsUrl>;
+export declare const ListDbaasLogOutputMetricTenantUrlResponseBodyList: S.Schema<ListDbaasLogOutputMetricTenantUrlResponseBodyList>;
+export type ListDbaasLogOutputMetricTenantUrlResponse = ListDbaasLogOutputMetricTenantUrlResponseBodyList;
+export declare const ListDbaasLogOutputMetricTenantUrlResponse: S.Schema<ListDbaasLogOutputMetricTenantUrlResponse>;
+export interface ListDbaasLogOutputOpensearchAliasRequest {
+    /** Service name */
+    serviceName: string;
+    /** Filter by name (like) */
+    namePattern?: string;
+}
+export declare const ListDbaasLogOutputOpensearchAliasRequest: S.Schema<ListDbaasLogOutputOpensearchAliasRequest>;
+export type ListDbaasLogOutputOpensearchAliasResponseBodyList = Array<string>;
+export declare const ListDbaasLogOutputOpensearchAliasResponseBodyList: S.Schema<ListDbaasLogOutputOpensearchAliasResponseBodyList>;
+export type ListDbaasLogOutputOpensearchAliasResponse = ListDbaasLogOutputOpensearchAliasResponseBodyList;
+export declare const ListDbaasLogOutputOpensearchAliasResponse: S.Schema<ListDbaasLogOutputOpensearchAliasResponse>;
+export interface ListDbaasLogOutputOpensearchAliasIndexRequest {
+    /** Service name */
+    serviceName: string;
+    /** Alias ID */
+    aliasId: string;
+}
+export declare const ListDbaasLogOutputOpensearchAliasIndexRequest: S.Schema<ListDbaasLogOutputOpensearchAliasIndexRequest>;
+export type ListDbaasLogOutputOpensearchAliasIndexResponseBodyList = Array<string>;
+export declare const ListDbaasLogOutputOpensearchAliasIndexResponseBodyList: S.Schema<ListDbaasLogOutputOpensearchAliasIndexResponseBodyList>;
+export type ListDbaasLogOutputOpensearchAliasIndexResponse = ListDbaasLogOutputOpensearchAliasIndexResponseBodyList;
+export declare const ListDbaasLogOutputOpensearchAliasIndexResponse: S.Schema<ListDbaasLogOutputOpensearchAliasIndexResponse>;
+export interface ListDbaasLogOutputOpensearchAliasStreamRequest {
+    /** Service name */
+    serviceName: string;
+    /** Alias ID */
+    aliasId: string;
+}
+export declare const ListDbaasLogOutputOpensearchAliasStreamRequest: S.Schema<ListDbaasLogOutputOpensearchAliasStreamRequest>;
+export type ListDbaasLogOutputOpensearchAliasStreamResponseBodyList = Array<string>;
+export declare const ListDbaasLogOutputOpensearchAliasStreamResponseBodyList: S.Schema<ListDbaasLogOutputOpensearchAliasStreamResponseBodyList>;
+export type ListDbaasLogOutputOpensearchAliasStreamResponse = ListDbaasLogOutputOpensearchAliasStreamResponseBodyList;
+export declare const ListDbaasLogOutputOpensearchAliasStreamResponse: S.Schema<ListDbaasLogOutputOpensearchAliasStreamResponse>;
+export interface ListDbaasLogOutputOpensearchAliasUrlRequest {
+    /** Service name */
+    serviceName: string;
+    /** Alias ID */
+    aliasId: string;
+}
+export declare const ListDbaasLogOutputOpensearchAliasUrlRequest: S.Schema<ListDbaasLogOutputOpensearchAliasUrlRequest>;
+export type ListDbaasLogOutputOpensearchAliasUrlResponseBodyList = Array<DbaasLogsUrl>;
+export declare const ListDbaasLogOutputOpensearchAliasUrlResponseBodyList: S.Schema<ListDbaasLogOutputOpensearchAliasUrlResponseBodyList>;
+export type ListDbaasLogOutputOpensearchAliasUrlResponse = ListDbaasLogOutputOpensearchAliasUrlResponseBodyList;
+export declare const ListDbaasLogOutputOpensearchAliasUrlResponse: S.Schema<ListDbaasLogOutputOpensearchAliasUrlResponse>;
+export interface ListDbaasLogOutputOpensearchIndexRequest {
+    /** Service name */
+    serviceName: string;
+    /** Filter by name (like) */
+    namePattern?: string;
+}
+export declare const ListDbaasLogOutputOpensearchIndexRequest: S.Schema<ListDbaasLogOutputOpensearchIndexRequest>;
+export type ListDbaasLogOutputOpensearchIndexResponseBodyList = Array<string>;
+export declare const ListDbaasLogOutputOpensearchIndexResponseBodyList: S.Schema<ListDbaasLogOutputOpensearchIndexResponseBodyList>;
+export type ListDbaasLogOutputOpensearchIndexResponse = ListDbaasLogOutputOpensearchIndexResponseBodyList;
+export declare const ListDbaasLogOutputOpensearchIndexResponse: S.Schema<ListDbaasLogOutputOpensearchIndexResponse>;
+export interface ListDbaasLogOutputOpensearchIndexUrlRequest {
+    /** Service name */
+    serviceName: string;
+    /** Index ID */
+    indexId: string;
+}
+export declare const ListDbaasLogOutputOpensearchIndexUrlRequest: S.Schema<ListDbaasLogOutputOpensearchIndexUrlRequest>;
+export type ListDbaasLogOutputOpensearchIndexUrlResponseBodyList = Array<DbaasLogsUrl>;
+export declare const ListDbaasLogOutputOpensearchIndexUrlResponseBodyList: S.Schema<ListDbaasLogOutputOpensearchIndexUrlResponseBodyList>;
+export type ListDbaasLogOutputOpensearchIndexUrlResponse = ListDbaasLogOutputOpensearchIndexUrlResponseBodyList;
+export declare const ListDbaasLogOutputOpensearchIndexUrlResponse: S.Schema<ListDbaasLogOutputOpensearchIndexUrlResponse>;
+export interface ListDbaasLogOutputOpensearchOsdRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListDbaasLogOutputOpensearchOsdRequest: S.Schema<ListDbaasLogOutputOpensearchOsdRequest>;
+export type ListDbaasLogOutputOpensearchOsdResponseBodyList = Array<string>;
+export declare const ListDbaasLogOutputOpensearchOsdResponseBodyList: S.Schema<ListDbaasLogOutputOpensearchOsdResponseBodyList>;
+export type ListDbaasLogOutputOpensearchOsdResponse = ListDbaasLogOutputOpensearchOsdResponseBodyList;
+export declare const ListDbaasLogOutputOpensearchOsdResponse: S.Schema<ListDbaasLogOutputOpensearchOsdResponse>;
+export interface ListDbaasLogOutputOpensearchOsdUrlRequest {
+    /** Service name */
+    serviceName: string;
+    /** Osd ID */
+    osdId: string;
+}
+export declare const ListDbaasLogOutputOpensearchOsdUrlRequest: S.Schema<ListDbaasLogOutputOpensearchOsdUrlRequest>;
+export type ListDbaasLogOutputOpensearchOsdUrlResponseBodyList = Array<DbaasLogsUrl>;
+export declare const ListDbaasLogOutputOpensearchOsdUrlResponseBodyList: S.Schema<ListDbaasLogOutputOpensearchOsdUrlResponseBodyList>;
+export type ListDbaasLogOutputOpensearchOsdUrlResponse = ListDbaasLogOutputOpensearchOsdUrlResponseBodyList;
+export declare const ListDbaasLogOutputOpensearchOsdUrlResponse: S.Schema<ListDbaasLogOutputOpensearchOsdUrlResponse>;
+export interface ListDbaasLogRoleRequest {
+    /** Service name */
+    serviceName: string;
+    /** Filter by name (like) */
+    namePattern?: string;
+}
+export declare const ListDbaasLogRoleRequest: S.Schema<ListDbaasLogRoleRequest>;
+export type ListDbaasLogRoleResponseBodyList = Array<string>;
+export declare const ListDbaasLogRoleResponseBodyList: S.Schema<ListDbaasLogRoleResponseBodyList>;
+export type ListDbaasLogRoleResponse = ListDbaasLogRoleResponseBodyList;
+export declare const ListDbaasLogRoleResponse: S.Schema<ListDbaasLogRoleResponse>;
+export interface ListDbaasLogRoleMemberRequest {
+    /** Service name */
+    serviceName: string;
+    /** Role ID */
+    roleId: string;
+}
+export declare const ListDbaasLogRoleMemberRequest: S.Schema<ListDbaasLogRoleMemberRequest>;
+export type ListDbaasLogRoleMemberResponseBodyList = Array<string>;
+export declare const ListDbaasLogRoleMemberResponseBodyList: S.Schema<ListDbaasLogRoleMemberResponseBodyList>;
+export type ListDbaasLogRoleMemberResponse = ListDbaasLogRoleMemberResponseBodyList;
+export declare const ListDbaasLogRoleMemberResponse: S.Schema<ListDbaasLogRoleMemberResponse>;
+export interface ListDbaasLogRolePermissionRequest {
+    /** Service name */
+    serviceName: string;
+    /** Role ID */
+    roleId: string;
+}
+export declare const ListDbaasLogRolePermissionRequest: S.Schema<ListDbaasLogRolePermissionRequest>;
+export type ListDbaasLogRolePermissionResponseBodyList = Array<string>;
+export declare const ListDbaasLogRolePermissionResponseBodyList: S.Schema<ListDbaasLogRolePermissionResponseBodyList>;
+export type ListDbaasLogRolePermissionResponse = ListDbaasLogRolePermissionResponseBodyList;
+export declare const ListDbaasLogRolePermissionResponse: S.Schema<ListDbaasLogRolePermissionResponse>;
+/** Resource tag filter */
+export interface IamResourceTagFilterInput {
+}
+export declare const IamResourceTagFilterInput: S.Schema<IamResourceTagFilterInput>;
+export type ListDbaasLogsRequestIamTagsValueList = Array<IamResourceTagFilterInput>;
+export declare const ListDbaasLogsRequestIamTagsValueList: S.Schema<ListDbaasLogsRequestIamTagsValueList>;
+export type ListDbaasLogsRequestIamTagsMap = {
+    [key: string]: ListDbaasLogsRequestIamTagsValueList | undefined;
+};
+export declare const ListDbaasLogsRequestIamTagsMap: S.Schema<ListDbaasLogsRequestIamTagsMap>;
+export interface ListDbaasLogsRequest {
+    /** Filter resources on IAM tags */
+    iamTags?: ListDbaasLogsRequestIamTagsMap;
+}
+export declare const ListDbaasLogsRequest: S.Schema<ListDbaasLogsRequest>;
+export type ListDbaasLogsResponseBodyList = Array<string>;
+export declare const ListDbaasLogsResponseBodyList: S.Schema<ListDbaasLogsResponseBodyList>;
+export type ListDbaasLogsResponse = ListDbaasLogsResponseBodyList;
+export declare const ListDbaasLogsResponse: S.Schema<ListDbaasLogsResponse>;
+export interface ListDbaasLogTokenRequest {
+    /** Service name */
+    serviceName: string;
+    /** Filter by name (like) */
+    namePattern?: string;
+}
+export declare const ListDbaasLogTokenRequest: S.Schema<ListDbaasLogTokenRequest>;
+export type ListDbaasLogTokenResponseBodyList = Array<string>;
+export declare const ListDbaasLogTokenResponseBodyList: S.Schema<ListDbaasLogTokenResponseBodyList>;
+export type ListDbaasLogTokenResponse = ListDbaasLogTokenResponseBodyList;
+export declare const ListDbaasLogTokenResponse: S.Schema<ListDbaasLogTokenResponse>;
+export interface ListDbaasLogUrlRequest {
+    /** Service name */
+    serviceName: string;
+}
+export declare const ListDbaasLogUrlRequest: S.Schema<ListDbaasLogUrlRequest>;
+export type ListDbaasLogUrlResponseBodyList = Array<DbaasLogsUrl>;
+export declare const ListDbaasLogUrlResponseBodyList: S.Schema<ListDbaasLogUrlResponseBodyList>;
+export type ListDbaasLogUrlResponse = ListDbaasLogUrlResponseBodyList;
+export declare const ListDbaasLogUrlResponse: S.Schema<ListDbaasLogUrlResponse>;
+export interface PutDbaasLogRequest {
+    /** Service name */
+    serviceName: string;
+    /** Service custom name */
+    displayName?: string | null;
+    /** Enable IAM for this service */
+    enableIam?: boolean | null;
+}
+export declare const PutDbaasLogRequest: S.Schema<PutDbaasLogRequest>;
+/** Allowed networks for ARCHIVE flow type */
+export type PutDbaasLogClusterRequestArchiveAllowedNetworksList = Array<string>;
+export declare const PutDbaasLogClusterRequestArchiveAllowedNetworksList: S.Schema<PutDbaasLogClusterRequestArchiveAllowedNetworksList>;
+/** Allowed networks for DIRECT_INPUT flow type */
+export type PutDbaasLogClusterRequestDirectInputAllowedNetworksList = Array<string>;
+export declare const PutDbaasLogClusterRequestDirectInputAllowedNetworksList: S.Schema<PutDbaasLogClusterRequestDirectInputAllowedNetworksList>;
+/** Allowed networks for QUERY flow type */
+export type PutDbaasLogClusterRequestQueryAllowedNetworksList = Array<string>;
+export declare const PutDbaasLogClusterRequestQueryAllowedNetworksList: S.Schema<PutDbaasLogClusterRequestQueryAllowedNetworksList>;
+export interface PutDbaasLogClusterRequest {
+    /** Service name */
+    serviceName: string;
+    /** Cluster ID */
+    clusterId: string;
+    /** Allowed networks for ARCHIVE flow type */
+    archiveAllowedNetworks?: PutDbaasLogClusterRequestArchiveAllowedNetworksList | null;
+    /** Allowed networks for DIRECT_INPUT flow type */
+    directInputAllowedNetworks?: PutDbaasLogClusterRequestDirectInputAllowedNetworksList | null;
+    /** Allowed networks for QUERY flow type */
+    queryAllowedNetworks?: PutDbaasLogClusterRequestQueryAllowedNetworksList | null;
+}
+export declare const PutDbaasLogClusterRequest: S.Schema<PutDbaasLogClusterRequest>;
+/** IP blocks */
+export type PutDbaasLogInputRequestAllowedNetworksList = Array<string>;
+export declare const PutDbaasLogInputRequestAllowedNetworksList: S.Schema<PutDbaasLogInputRequestAllowedNetworksList>;
+export interface PutDbaasLogInputRequest {
+    /** Service name */
+    serviceName: string;
+    /** Input ID */
+    inputId: string;
+    /** IP blocks */
+    allowedNetworks?: PutDbaasLogInputRequestAllowedNetworksList | null;
+    /** Whether the workload is auto-scaled */
+    autoscale?: boolean | null;
+    /** Description */
+    description: string;
+    /** Engine ID */
+    engineId: string;
+    /** Exposed port */
+    exposedPort?: string | null;
+    /** Maximum number of instances in auto-scaled mode */
+    maxScaleInstance?: number | null;
+    /** Minimum number of instances in auto-scaled mode */
+    minScaleInstance?: number | null;
+    /** Number of instance running */
+    nbInstance?: number | null;
+    /** If set, notify when scaling happens */
+    scalingNotifyEnabled?: boolean | null;
+    /** Stream ID */
+    streamId: string;
+    /** Title */
+    title: string;
+}
+export declare const PutDbaasLogInputRequest: S.Schema<PutDbaasLogInputRequest>;
+export interface PutDbaasLogInputConfigurationFlowggerRequest {
+    /** Service name */
+    serviceName: string;
+    /** Input ID */
+    inputId: string;
+    /** configuration log format */
+    logFormat: DbaasLogsFlowggerConfigurationLogFormatEnum | (string & {});
+    /** Log framing */
+    logFraming: DbaasLogsFlowggerConfigurationLogFramingEnum | (string & {});
+}
+export declare const PutDbaasLogInputConfigurationFlowggerRequest: S.Schema<PutDbaasLogInputConfigurationFlowggerRequest>;
+export interface PutDbaasLogInputConfigurationLogstashRequest {
+    /** Service name */
+    serviceName: string;
+    /** Input ID */
+    inputId: string;
+    /** Filter section */
+    filterSection?: string | null;
+    /** Input section */
+    inputSection: string;
+    /** Pattern section */
+    patternSection?: string | null;
+}
+export declare const PutDbaasLogInputConfigurationLogstashRequest: S.Schema<PutDbaasLogInputConfigurationLogstashRequest>;
+export interface PutDbaasLogOutputGraylogDashboardRequest {
+    /** Service name */
+    serviceName: string;
+    /** Dashboard ID */
+    dashboardId: string;
+    /** Description */
+    description: string;
+    /** Title */
+    title: string;
+}
+export declare const PutDbaasLogOutputGraylogDashboardRequest: S.Schema<PutDbaasLogOutputGraylogDashboardRequest>;
+/** Encryption keys used to encrypt stream archives */
+export type PutDbaasLogOutputGraylogStreamRequestEncryptionKeysIdsList = Array<string>;
+export declare const PutDbaasLogOutputGraylogStreamRequestEncryptionKeysIdsList: S.Schema<PutDbaasLogOutputGraylogStreamRequestEncryptionKeysIdsList>;
+export interface PutDbaasLogOutputGraylogStreamRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+    /** Cold storage compression */
+    coldStorageCompression?: DbaasLogsStreamColdStorageCompressionEnum | (string & {}) | null;
+    /** Cold storage content */
+    coldStorageContent?: DbaasLogsStreamColdStorageContentEnum | (string & {}) | null;
+    /** Cold storage enabled */
+    coldStorageEnabled?: boolean | null;
+    /** Cold storage notify enabled */
+    coldStorageNotifyEnabled?: boolean | null;
+    /** Cold storage retention time */
+    coldStorageRetention?: number | null;
+    /** Description */
+    description: string;
+    /** Encryption keys used to encrypt stream archives */
+    encryptionKeysIds?: PutDbaasLogOutputGraylogStreamRequestEncryptionKeysIdsList | null;
+    /** ES indexing enabled */
+    indexingEnabled?: boolean | null;
+    /** Maximum indexing size (in GB) */
+    indexingMaxSize?: number | null;
+    /** If set, notify when size is near 80, 90 or 100 % of the maximum configured setting */
+    indexingNotifyEnabled?: boolean | null;
+    /** If set, pause indexing when maximum size is reach */
+    pauseIndexingOnMaxSize?: boolean | null;
+    /** Title */
+    title: string;
+    /** Web socket enabled */
+    webSocketEnabled?: boolean | null;
+}
+export declare const PutDbaasLogOutputGraylogStreamRequest: S.Schema<PutDbaasLogOutputGraylogStreamRequest>;
+export interface PutDbaasLogOutputGraylogStreamAlertRequest {
+    /** Service name */
+    serviceName: string;
+    /** Stream ID */
+    streamId: string;
+    /** Alert ID */
+    alertId: string;
+    /** Backlog */
+    backlog: number;
+    /** Condition type */
+    conditionType?: DbaasLogsStreamAlertConditionConditionTypeEnum | (string & {}) | null;
+    /** Constraint type */
+    constraintType?: DbaasLogsStreamAlertConditionConstraintTypeEnum | (string & {}) | null;
+    /** Field */
+    field?: string | null;
+    /** Grace period */
+    grace: number;
+    /** Query filter */
+    queryFilter?: string | null;
+    /** Repeat notifications enabled */
+    repeatNotificationsEnabled?: boolean | null;
+    /** Threshold */
+    threshold?: number | null;
+    /** Threshold type */
+    thresholdType?: DbaasLogsStreamAlertConditionThresholdTypeEnum | (string & {}) | null;
+    /** Time */
+    time?: number | null;
+    /** Title */
+    title: string;
+    /** Value */
+    value?: string | null;
+}
+export declare const PutDbaasLogOutputGraylogStreamAlertRequest: S.Schema<PutDbaasLogOutputGraylogStreamAlertRequest>;
+export interface PutDbaasLogOutputMetricTenantRequest {
+    /** Service name */
+    serviceName: string;
+    /** Tenant ID */
+    tenantId: string;
+    /** Metric tenant description */
+    description: string;
+    /** Maximum number of time series inside the tenant */
+    maxSeries?: number;
+    /** Delete samples older than the specified retention period. */
+    retentionId: string;
+    /** Metric tenant title */
+    title: string;
+}
+export declare const PutDbaasLogOutputMetricTenantRequest: S.Schema<PutDbaasLogOutputMetricTenantRequest>;
+export interface PutDbaasLogOutputOpensearchAliasRequest {
+    /** Service name */
+    serviceName: string;
+    /** Alias ID */
+    aliasId: string;
+    /** Description */
+    description: string;
+}
+export declare const PutDbaasLogOutputOpensearchAliasRequest: S.Schema<PutDbaasLogOutputOpensearchAliasRequest>;
+export interface PutDbaasLogOutputOpensearchIndexRequest {
+    /** Service name */
+    serviceName: string;
+    /** Index ID */
+    indexId: string;
+    /** If set, notify when size is near 80, 90 or 100 % of its maximum capacity */
+    alertNotifyEnabled?: boolean | null;
+    /** Description */
+    description: string;
+}
+export declare const PutDbaasLogOutputOpensearchIndexRequest: S.Schema<PutDbaasLogOutputOpensearchIndexRequest>;
+export interface PutDbaasLogOutputOpensearchOsdRequest {
+    /** Service name */
+    serviceName: string;
+    /** Osd ID */
+    osdId: string;
+    /** Description */
+    description: string;
+}
+export declare const PutDbaasLogOutputOpensearchOsdRequest: S.Schema<PutDbaasLogOutputOpensearchOsdRequest>;
+export interface PutDbaasLogRoleRequest {
+    /** Service name */
+    serviceName: string;
+    /** Role ID */
+    roleId: string;
+    /** Description */
+    description: string;
+    /** Name */
+    name: string;
+}
+export declare const PutDbaasLogRoleRequest: S.Schema<PutDbaasLogRoleRequest>;
+export interface PutDbaasLogRoleMemberRequest {
+    /** Service name */
+    serviceName: string;
+    /** Role ID */
+    roleId: string;
+    /** Username */
+    username: string;
+    /** Custom note */
+    note?: string | null;
+}
+export declare const PutDbaasLogRoleMemberRequest: S.Schema<PutDbaasLogRoleMemberRequest>;
+export interface PutDbaasLogServiceInfosRequest {
+    /** Service name */
+    serviceName: string;
+    /** Way of handling the renew */
+    renew?: ServiceRenewType | null;
+}
+export declare const PutDbaasLogServiceInfosRequest: S.Schema<PutDbaasLogServiceInfosRequest>;
+export interface PutDbaasLogServiceInfosResponse {
+}
+export declare const PutDbaasLogServiceInfosResponse: S.Schema<PutDbaasLogServiceInfosResponse>;
+export interface RestartDbaasLogsInputRequest {
+    /** Service name */
+    serviceName: string;
+    /** Input ID */
+    inputId: string;
+}
+export declare const RestartDbaasLogsInputRequest: S.Schema<RestartDbaasLogsInputRequest>;
+export interface StartDbaasLogsInputRequest {
+    /** Service name */
+    serviceName: string;
+    /** Input ID */
+    inputId: string;
+}
+export declare const StartDbaasLogsInputRequest: S.Schema<StartDbaasLogsInputRequest>;
+export type CreateDbaasLogChangeContactError = OvhOpError;
+/** Launch a contact change procedure */
+export declare const createDbaasLogChangeContact: API.OperationMethod<CreateDbaasLogChangeContactRequest, CreateDbaasLogChangeContactResponse, CreateDbaasLogChangeContactError, OvhOpContext>;
+export type CreateDbaasLogEncryptionKeyError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Add a new encryption key */
+export declare const createDbaasLogEncryptionKey: API.OperationMethod<CreateDbaasLogEncryptionKeyRequest, DbaasLogsOperation, CreateDbaasLogEncryptionKeyError, OvhOpContext>;
+export type CreateDbaasLogInputError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Register a new input object */
+export declare const createDbaasLogInput: API.OperationMethod<CreateDbaasLogInputRequest, DbaasLogsOperation, CreateDbaasLogInputError, OvhOpContext>;
+export type CreateDbaasLogInputConfigtestError = Forbidden | NotFound | OvhOpError;
+/** Validate configuration of specified input */
+export declare const createDbaasLogInputConfigtest: API.OperationMethod<CreateDbaasLogInputConfigtestRequest, DbaasLogsOperation, CreateDbaasLogInputConfigtestError, OvhOpContext>;
+export type CreateDbaasLogInputEndError = Forbidden | NotFound | OvhOpError;
+/** Schedule the end of specified input */
+export declare const createDbaasLogInputEnd: API.OperationMethod<CreateDbaasLogInputEndRequest, DbaasLogsOperation, CreateDbaasLogInputEndError, OvhOpContext>;
+export type CreateDbaasLogInputLogUrlError = Forbidden | NotFound | OvhOpError;
+/** Generate a temporary url to retrieve input logs */
+export declare const createDbaasLogInputLogUrl: API.OperationMethod<CreateDbaasLogInputLogUrlRequest, DbaasLogsTemporaryLogsLink, CreateDbaasLogInputLogUrlError, OvhOpContext>;
+export type CreateDbaasLogOutputGraylogDashboardError = Forbidden | NotFound | OvhOpError;
+/** Register a new graylog dashboard */
+export declare const createDbaasLogOutputGraylogDashboard: API.OperationMethod<CreateDbaasLogOutputGraylogDashboardRequest, DbaasLogsOperation, CreateDbaasLogOutputGraylogDashboardError, OvhOpContext>;
+export type CreateDbaasLogOutputGraylogStreamError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Register a new graylog stream */
+export declare const createDbaasLogOutputGraylogStream: API.OperationMethod<CreateDbaasLogOutputGraylogStreamRequest, DbaasLogsOperation, CreateDbaasLogOutputGraylogStreamError, OvhOpContext>;
+export type CreateDbaasLogOutputGraylogStreamAlertError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Register a new alert on specified graylog stream */
+export declare const createDbaasLogOutputGraylogStreamAlert: API.OperationMethod<CreateDbaasLogOutputGraylogStreamAlertRequest, DbaasLogsOperation, CreateDbaasLogOutputGraylogStreamAlertError, OvhOpContext>;
+export type CreateDbaasLogOutputGraylogStreamArchiveUrlError = NotFound | OvhOpError;
+/** Get a public temporary URL to access the archive */
+export declare const createDbaasLogOutputGraylogStreamArchiveUrl: API.OperationMethod<CreateDbaasLogOutputGraylogStreamArchiveUrlRequest, DbaasLogsArchiveUrl, CreateDbaasLogOutputGraylogStreamArchiveUrlError, OvhOpContext>;
+export type CreateDbaasLogOutputGraylogStreamRuleError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Register a new rule on specified graylog stream */
+export declare const createDbaasLogOutputGraylogStreamRule: API.OperationMethod<CreateDbaasLogOutputGraylogStreamRuleRequest, DbaasLogsOperation, CreateDbaasLogOutputGraylogStreamRuleError, OvhOpContext>;
+export type CreateDbaasLogOutputMetricTenantError = Forbidden | Conflict | OvhOpError;
+/** Create a metric tenant */
+export declare const createDbaasLogOutputMetricTenant: API.OperationMethod<CreateDbaasLogOutputMetricTenantRequest, DbaasLogsOperation, CreateDbaasLogOutputMetricTenantError, OvhOpContext>;
+export type CreateDbaasLogOutputOpensearchAliasError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Register a new OpenSearch alias */
+export declare const createDbaasLogOutputOpensearchAlias: API.OperationMethod<CreateDbaasLogOutputOpensearchAliasRequest, DbaasLogsOperation, CreateDbaasLogOutputOpensearchAliasError, OvhOpContext>;
+export type CreateDbaasLogOutputOpensearchAliasIndexError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Attach a OpenSearch index to specified OpenSearch alias */
+export declare const createDbaasLogOutputOpensearchAliasIndex: API.OperationMethod<CreateDbaasLogOutputOpensearchAliasIndexRequest, DbaasLogsOperation, CreateDbaasLogOutputOpensearchAliasIndexError, OvhOpContext>;
+export type CreateDbaasLogOutputOpensearchAliasStreamError = Forbidden | NotFound | OvhOpError;
+/** Attach a Graylog stream to specified OpenSearch alias */
+export declare const createDbaasLogOutputOpensearchAliasStream: API.OperationMethod<CreateDbaasLogOutputOpensearchAliasStreamRequest, DbaasLogsOperation, CreateDbaasLogOutputOpensearchAliasStreamError, OvhOpContext>;
+export type CreateDbaasLogOutputOpensearchIndexError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Register a new OpenSearch index */
+export declare const createDbaasLogOutputOpensearchIndex: API.OperationMethod<CreateDbaasLogOutputOpensearchIndexRequest, DbaasLogsOperation, CreateDbaasLogOutputOpensearchIndexError, OvhOpContext>;
+export type CreateDbaasLogOutputOpensearchOsdError = Forbidden | NotFound | OvhOpError;
+/** Register a new OpenSearch Dashboards instance */
+export declare const createDbaasLogOutputOpensearchOsd: API.OperationMethod<CreateDbaasLogOutputOpensearchOsdRequest, DbaasLogsOperation, CreateDbaasLogOutputOpensearchOsdError, OvhOpContext>;
+export type CreateDbaasLogRoleError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Register a new role */
+export declare const createDbaasLogRole: API.OperationMethod<CreateDbaasLogRoleRequest, DbaasLogsOperation, CreateDbaasLogRoleError, OvhOpContext>;
+export type CreateDbaasLogRoleMemberError = Forbidden | NotFound | OvhOpError;
+/** Append user into the member list of specified role */
+export declare const createDbaasLogRoleMember: API.OperationMethod<CreateDbaasLogRoleMemberRequest, DbaasLogsOperation, CreateDbaasLogRoleMemberError, OvhOpContext>;
+export type CreateDbaasLogRolePermissionAliasError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Append a elasticsearch alias permission to role */
+export declare const createDbaasLogRolePermissionAlias: API.OperationMethod<CreateDbaasLogRolePermissionAliasRequest, DbaasLogsOperation, CreateDbaasLogRolePermissionAliasError, OvhOpContext>;
+export type CreateDbaasLogRolePermissionDashboardError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Append a graylog dashboard permission to role */
+export declare const createDbaasLogRolePermissionDashboard: API.OperationMethod<CreateDbaasLogRolePermissionDashboardRequest, DbaasLogsOperation, CreateDbaasLogRolePermissionDashboardError, OvhOpContext>;
+export type CreateDbaasLogRolePermissionIndexError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Append a elasticsearch index permission to role */
+export declare const createDbaasLogRolePermissionIndex: API.OperationMethod<CreateDbaasLogRolePermissionIndexRequest, DbaasLogsOperation, CreateDbaasLogRolePermissionIndexError, OvhOpContext>;
+export type CreateDbaasLogRolePermissionOsdError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Append a OpenSearch Dashboards permission to role */
+export declare const createDbaasLogRolePermissionOsd: API.OperationMethod<CreateDbaasLogRolePermissionOsdRequest, DbaasLogsOperation, CreateDbaasLogRolePermissionOsdError, OvhOpContext>;
+export type CreateDbaasLogRolePermissionStreamError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Append a graylog stream permission to role */
+export declare const createDbaasLogRolePermissionStream: API.OperationMethod<CreateDbaasLogRolePermissionStreamRequest, DbaasLogsOperation, CreateDbaasLogRolePermissionStreamError, OvhOpContext>;
+export type CreateDbaasLogTokenError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Add a new token */
+export declare const createDbaasLogToken: API.OperationMethod<CreateDbaasLogTokenRequest, DbaasLogsOperation, CreateDbaasLogTokenError, OvhOpContext>;
+export type CreateDbaasLogUserChangePasswordError = Forbidden | NotFound | OvhOpError;
+/** Initiate a password change procedure. */
+export declare const createDbaasLogUserChangePassword: API.OperationMethod<CreateDbaasLogUserChangePasswordRequest, DbaasLogsOperation, CreateDbaasLogUserChangePasswordError, OvhOpContext>;
+export type DeleteDbaasLogEncryptionKeyError = Forbidden | NotFound | OvhOpError;
+/** Delete the specified encryption key */
+export declare const deleteDbaasLogEncryptionKey: API.OperationMethod<DeleteDbaasLogEncryptionKeyRequest, DbaasLogsOperation, DeleteDbaasLogEncryptionKeyError, OvhOpContext>;
+export type DeleteDbaasLogInputError = Forbidden | NotFound | OvhOpError;
+/** Remove the specified input object */
+export declare const deleteDbaasLogInput: API.OperationMethod<DeleteDbaasLogInputRequest, DbaasLogsOperation, DeleteDbaasLogInputError, OvhOpContext>;
+export type DeleteDbaasLogOutputGraylogDashboardError = Forbidden | NotFound | OvhOpError;
+/** Remove specified graylog dashboard */
+export declare const deleteDbaasLogOutputGraylogDashboard: API.OperationMethod<DeleteDbaasLogOutputGraylogDashboardRequest, DbaasLogsOperation, DeleteDbaasLogOutputGraylogDashboardError, OvhOpContext>;
+export type DeleteDbaasLogOutputGraylogStreamError = Forbidden | NotFound | OvhOpError;
+/** Remove specified graylog stream */
+export declare const deleteDbaasLogOutputGraylogStream: API.OperationMethod<DeleteDbaasLogOutputGraylogStreamRequest, DbaasLogsOperation, DeleteDbaasLogOutputGraylogStreamError, OvhOpContext>;
+export type DeleteDbaasLogOutputGraylogStreamAlertError = Forbidden | NotFound | OvhOpError;
+/** Remove alert from specified graylog stream */
+export declare const deleteDbaasLogOutputGraylogStreamAlert: API.OperationMethod<DeleteDbaasLogOutputGraylogStreamAlertRequest, DbaasLogsOperation, DeleteDbaasLogOutputGraylogStreamAlertError, OvhOpContext>;
+export type DeleteDbaasLogOutputGraylogStreamRuleError = Forbidden | NotFound | OvhOpError;
+/** Remove specified graylog stream rule */
+export declare const deleteDbaasLogOutputGraylogStreamRule: API.OperationMethod<DeleteDbaasLogOutputGraylogStreamRuleRequest, DbaasLogsOperation, DeleteDbaasLogOutputGraylogStreamRuleError, OvhOpContext>;
+export type DeleteDbaasLogOutputGraylogStreamSubscriptionError = NotFound | OvhOpError;
+/** Delete a specified subscription targeting a specified graylog stream */
+export declare const deleteDbaasLogOutputGraylogStreamSubscription: API.OperationMethod<DeleteDbaasLogOutputGraylogStreamSubscriptionRequest, DbaasLogsOperation, DeleteDbaasLogOutputGraylogStreamSubscriptionError, OvhOpContext>;
+export type DeleteDbaasLogOutputMetricTenantError = Forbidden | NotFound | OvhOpError;
+/** Delete a metric tenant */
+export declare const deleteDbaasLogOutputMetricTenant: API.OperationMethod<DeleteDbaasLogOutputMetricTenantRequest, DbaasLogsOperation, DeleteDbaasLogOutputMetricTenantError, OvhOpContext>;
+export type DeleteDbaasLogOutputMetricTenantSubscriptionError = NotFound | OvhOpError;
+/** Delete a specified subscription targeting a specified metric tenant */
+export declare const deleteDbaasLogOutputMetricTenantSubscription: API.OperationMethod<DeleteDbaasLogOutputMetricTenantSubscriptionRequest, DbaasLogsOperation, DeleteDbaasLogOutputMetricTenantSubscriptionError, OvhOpContext>;
+export type DeleteDbaasLogOutputOpensearchAliasError = Forbidden | NotFound | OvhOpError;
+/** Remove specified OpenSearch alias */
+export declare const deleteDbaasLogOutputOpensearchAlias: API.OperationMethod<DeleteDbaasLogOutputOpensearchAliasRequest, DbaasLogsOperation, DeleteDbaasLogOutputOpensearchAliasError, OvhOpContext>;
+export type DeleteDbaasLogOutputOpensearchAliasIndexError = Forbidden | NotFound | OvhOpError;
+/** Detach a OpenSearch index from specified OpenSearch alias */
+export declare const deleteDbaasLogOutputOpensearchAliasIndex: API.OperationMethod<DeleteDbaasLogOutputOpensearchAliasIndexRequest, DbaasLogsOperation, DeleteDbaasLogOutputOpensearchAliasIndexError, OvhOpContext>;
+export type DeleteDbaasLogOutputOpensearchAliasStreamError = Forbidden | NotFound | OvhOpError;
+/** Detach a Graylog stream from specified OpenSearch alias */
+export declare const deleteDbaasLogOutputOpensearchAliasStream: API.OperationMethod<DeleteDbaasLogOutputOpensearchAliasStreamRequest, DbaasLogsOperation, DeleteDbaasLogOutputOpensearchAliasStreamError, OvhOpContext>;
+export type DeleteDbaasLogOutputOpensearchIndexError = Forbidden | NotFound | OvhOpError;
+/** Remove specified OpenSearch index */
+export declare const deleteDbaasLogOutputOpensearchIndex: API.OperationMethod<DeleteDbaasLogOutputOpensearchIndexRequest, DbaasLogsOperation, DeleteDbaasLogOutputOpensearchIndexError, OvhOpContext>;
+export type DeleteDbaasLogOutputOpensearchOsdError = Forbidden | NotFound | OvhOpError;
+/** Remove specified OpenSearch Dashboards instance */
+export declare const deleteDbaasLogOutputOpensearchOsd: API.OperationMethod<DeleteDbaasLogOutputOpensearchOsdRequest, DbaasLogsOperation, DeleteDbaasLogOutputOpensearchOsdError, OvhOpContext>;
+export type DeleteDbaasLogRoleError = Forbidden | NotFound | OvhOpError;
+/** Remove specified role */
+export declare const deleteDbaasLogRole: API.OperationMethod<DeleteDbaasLogRoleRequest, DbaasLogsOperation, DeleteDbaasLogRoleError, OvhOpContext>;
+export type DeleteDbaasLogRoleMemberError = Forbidden | NotFound | OvhOpError;
+/** Remove user from the member list of specified role */
+export declare const deleteDbaasLogRoleMember: API.OperationMethod<DeleteDbaasLogRoleMemberRequest, DbaasLogsOperation, DeleteDbaasLogRoleMemberError, OvhOpContext>;
+export type DeleteDbaasLogRolePermissionError = Forbidden | NotFound | OvhOpError;
+/** Remove specified permission */
+export declare const deleteDbaasLogRolePermission: API.OperationMethod<DeleteDbaasLogRolePermissionRequest, DbaasLogsOperation, DeleteDbaasLogRolePermissionError, OvhOpContext>;
+export type DeleteDbaasLogTokenError = Forbidden | NotFound | OvhOpError;
+/** Delete the specified token */
+export declare const deleteDbaasLogToken: API.OperationMethod<DeleteDbaasLogTokenRequest, DbaasLogsOperation, DeleteDbaasLogTokenError, OvhOpContext>;
+export type DuplicateDbaasLogsOutputGraylogDashboardError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Copy all widgets from specified dashboard to a new one */
+export declare const duplicateDbaasLogsOutputGraylogDashboard: API.OperationMethod<DuplicateDbaasLogsOutputGraylogDashboardRequest, DbaasLogsOperation, DuplicateDbaasLogsOutputGraylogDashboardError, OvhOpContext>;
+export type GetDbaasLogError = NotFound | OvhOpError;
+/** Returns the service object of connected identity. */
+export declare const getDbaasLog: API.OperationMethod<GetDbaasLogRequest, DbaasLogsServiceWithIAM, GetDbaasLogError, OvhOpContext>;
+export type GetDbaasLogClusterError = NotFound | OvhOpError;
+/** Returns details of an allowed cluster */
+export declare const getDbaasLogCluster: API.OperationMethod<GetDbaasLogClusterRequest, DbaasLogsCluster, GetDbaasLogClusterError, OvhOpContext>;
+export type GetDbaasLogClusterRetentionError = Forbidden | NotFound | OvhOpError;
+/** Returns details of a retention */
+export declare const getDbaasLogClusterRetention: API.OperationMethod<GetDbaasLogClusterRetentionRequest, DbaasLogsClusterRetention, GetDbaasLogClusterRetentionError, OvhOpContext>;
+export type GetDbaasLogEncryptionKeyError = Forbidden | NotFound | OvhOpError;
+/** Return details of an encryption key */
+export declare const getDbaasLogEncryptionKey: API.OperationMethod<GetDbaasLogEncryptionKeyRequest, DbaasLogsEncryptionKey, GetDbaasLogEncryptionKeyError, OvhOpContext>;
+export type GetDbaasLogInputError = NotFound | OvhOpError;
+/** Returns details of specified input */
+export declare const getDbaasLogInput: API.OperationMethod<GetDbaasLogInputRequest, DbaasLogsInput, GetDbaasLogInputError, OvhOpContext>;
+export type GetDbaasLogInputConfigtestResultError = NotFound | OvhOpError;
+/** Returns the config test operation result */
+export declare const getDbaasLogInputConfigtestResult: API.OperationMethod<GetDbaasLogInputConfigtestResultRequest, DbaasLogsTestResult, GetDbaasLogInputConfigtestResultError, OvhOpContext>;
+export type GetDbaasLogInputConfigurationFlowggerError = NotFound | OvhOpError;
+/** Returns the flowgger configuration */
+export declare const getDbaasLogInputConfigurationFlowgger: API.OperationMethod<GetDbaasLogInputConfigurationFlowggerRequest, DbaasLogsFlowggerConfiguration, GetDbaasLogInputConfigurationFlowggerError, OvhOpContext>;
+export type GetDbaasLogInputConfigurationLogstashError = NotFound | OvhOpError;
+/** Returns the logstash configuration */
+export declare const getDbaasLogInputConfigurationLogstash: API.OperationMethod<GetDbaasLogInputConfigurationLogstashRequest, DbaasLogsLogstashConfiguration, GetDbaasLogInputConfigurationLogstashError, OvhOpContext>;
+export type GetDbaasLogInputEngineError = NotFound | OvhOpError;
+/** Returns details of specified input engine */
+export declare const getDbaasLogInputEngine: API.OperationMethod<GetDbaasLogInputEngineRequest, DbaasLogsEngine, GetDbaasLogInputEngineError, OvhOpContext>;
+export type GetDbaasLogInputEngineHelperError = NotFound | OvhOpError;
+/** Returns details of specified input engine helper */
+export declare const getDbaasLogInputEngineHelper: API.OperationMethod<GetDbaasLogInputEngineHelperRequest, DbaasLogsHelper, GetDbaasLogInputEngineHelperError, OvhOpContext>;
+export type GetDbaasLogMetricsError = NotFound | OvhOpError;
+/** Returns Metrics credentials */
+export declare const getDbaasLogMetrics: API.OperationMethod<GetDbaasLogMetricsRequest, DbaasLogsServiceMetric, GetDbaasLogMetricsError, OvhOpContext>;
+export type GetDbaasLogOperationError = NotFound | OvhOpError;
+/** Returns details of specified operation */
+export declare const getDbaasLogOperation: API.OperationMethod<GetDbaasLogOperationRequest, DbaasLogsOperation, GetDbaasLogOperationError, OvhOpContext>;
+export type GetDbaasLogOutputGraylogDashboardError = NotFound | OvhOpError;
+/** Returns details of specified graylog dashboard */
+export declare const getDbaasLogOutputGraylogDashboard: API.OperationMethod<GetDbaasLogOutputGraylogDashboardRequest, DbaasLogsDashboard, GetDbaasLogOutputGraylogDashboardError, OvhOpContext>;
+export type GetDbaasLogOutputGraylogStreamError = NotFound | OvhOpError;
+/** Returns details of specified graylog stream */
+export declare const getDbaasLogOutputGraylogStream: API.OperationMethod<GetDbaasLogOutputGraylogStreamRequest, DbaasLogsStream, GetDbaasLogOutputGraylogStreamError, OvhOpContext>;
+export type GetDbaasLogOutputGraylogStreamAlertError = NotFound | OvhOpError;
+/** Returns details of specified graylog stream alert */
+export declare const getDbaasLogOutputGraylogStreamAlert: API.OperationMethod<GetDbaasLogOutputGraylogStreamAlertRequest, DbaasLogsStreamAlertCondition, GetDbaasLogOutputGraylogStreamAlertError, OvhOpContext>;
+export type GetDbaasLogOutputGraylogStreamArchiveError = NotFound | OvhOpError;
+/** Returns details of specified archive */
+export declare const getDbaasLogOutputGraylogStreamArchive: API.OperationMethod<GetDbaasLogOutputGraylogStreamArchiveRequest, DbaasLogsArchive, GetDbaasLogOutputGraylogStreamArchiveError, OvhOpContext>;
+export type GetDbaasLogOutputGraylogStreamRuleError = NotFound | OvhOpError;
+/** Returns details of specified graylog stream rule */
+export declare const getDbaasLogOutputGraylogStreamRule: API.OperationMethod<GetDbaasLogOutputGraylogStreamRuleRequest, DbaasLogsStreamRule, GetDbaasLogOutputGraylogStreamRuleError, OvhOpContext>;
+export type GetDbaasLogOutputGraylogStreamSubscriptionError = NotFound | OvhOpError;
+/** Returns details of specified graylog stream subscription */
+export declare const getDbaasLogOutputGraylogStreamSubscription: API.OperationMethod<GetDbaasLogOutputGraylogStreamSubscriptionRequest, DbaasLogsLogSubscription, GetDbaasLogOutputGraylogStreamSubscriptionError, OvhOpContext>;
+export type GetDbaasLogOutputMetricTenantError = Forbidden | NotFound | OvhOpError;
+/** Get the details about a metric tenant */
+export declare const getDbaasLogOutputMetricTenant: API.OperationMethod<GetDbaasLogOutputMetricTenantRequest, DbaasLogsMetricTenant, GetDbaasLogOutputMetricTenantError, OvhOpContext>;
+export type GetDbaasLogOutputMetricTenantSubscriptionError = NotFound | OvhOpError;
+/** Returns details of specified metric tenant subscription */
+export declare const getDbaasLogOutputMetricTenantSubscription: API.OperationMethod<GetDbaasLogOutputMetricTenantSubscriptionRequest, DbaasLogsMetricSubscription, GetDbaasLogOutputMetricTenantSubscriptionError, OvhOpContext>;
+export type GetDbaasLogOutputOpensearchAliasError = NotFound | OvhOpError;
+/** Returns specified OpenSearch alias */
+export declare const getDbaasLogOutputOpensearchAlias: API.OperationMethod<GetDbaasLogOutputOpensearchAliasRequest, DbaasLogsAlias, GetDbaasLogOutputOpensearchAliasError, OvhOpContext>;
+export type GetDbaasLogOutputOpensearchIndexError = NotFound | OvhOpError;
+/** Returns specified OpenSearch index */
+export declare const getDbaasLogOutputOpensearchIndex: API.OperationMethod<GetDbaasLogOutputOpensearchIndexRequest, DbaasLogsIndex, GetDbaasLogOutputOpensearchIndexError, OvhOpContext>;
+export type GetDbaasLogOutputOpensearchOsdError = NotFound | OvhOpError;
+/** Returns specified OpenSearch Dashboards instance */
+export declare const getDbaasLogOutputOpensearchOsd: API.OperationMethod<GetDbaasLogOutputOpensearchOsdRequest, DbaasLogsOsd, GetDbaasLogOutputOpensearchOsdError, OvhOpContext>;
+export type GetDbaasLogRoleError = Forbidden | NotFound | OvhOpError;
+/** Returns details of specified role */
+export declare const getDbaasLogRole: API.OperationMethod<GetDbaasLogRoleRequest, DbaasLogsRole, GetDbaasLogRoleError, OvhOpContext>;
+export type GetDbaasLogRoleMemberError = Forbidden | NotFound | OvhOpError;
+/** Returns the member metadata */
+export declare const getDbaasLogRoleMember: API.OperationMethod<GetDbaasLogRoleMemberRequest, DbaasLogsMember, GetDbaasLogRoleMemberError, OvhOpContext>;
+export type GetDbaasLogRolePermissionError = NotFound | OvhOpError;
+/** Returns details of specified permission */
+export declare const getDbaasLogRolePermission: API.OperationMethod<GetDbaasLogRolePermissionRequest, DbaasLogsPermission, GetDbaasLogRolePermissionError, OvhOpContext>;
+export type GetDbaasLogServiceInfosError = OvhOpError;
+/** Get service information */
+export declare const getDbaasLogServiceInfos: API.OperationMethod<GetDbaasLogServiceInfosRequest, ServicesService, GetDbaasLogServiceInfosError, OvhOpContext>;
+export type GetDbaasLogTokenError = Forbidden | NotFound | OvhOpError;
+/** Returns the specified token */
+export declare const getDbaasLogToken: API.OperationMethod<GetDbaasLogTokenRequest, DbaasLogsToken, GetDbaasLogTokenError, OvhOpContext>;
+export type ListDbaasLogClusterError = NotFound | OvhOpError;
+/** Returns the list of allowed cluster */
+export declare const listDbaasLogCluster: API.OperationMethod<ListDbaasLogClusterRequest, ListDbaasLogClusterResponse, ListDbaasLogClusterError, OvhOpContext>;
+export type ListDbaasLogClusterRetentionError = Forbidden | NotFound | OvhOpError;
+/** List all the retention ID available for a given cluster */
+export declare const listDbaasLogClusterRetention: API.OperationMethod<ListDbaasLogClusterRetentionRequest, ListDbaasLogClusterRetentionResponse, ListDbaasLogClusterRetentionError, OvhOpContext>;
+export type ListDbaasLogEncryptionKeyError = NotFound | OvhOpError;
+/** Return the list of registred encryption keys */
+export declare const listDbaasLogEncryptionKey: API.OperationMethod<ListDbaasLogEncryptionKeyRequest, ListDbaasLogEncryptionKeyResponse, ListDbaasLogEncryptionKeyError, OvhOpContext>;
+export type ListDbaasLogInputError = NotFound | OvhOpError;
+/** Returns the list of registered input attached to the logged user */
+export declare const listDbaasLogInput: API.OperationMethod<ListDbaasLogInputRequest, ListDbaasLogInputResponse, ListDbaasLogInputError, OvhOpContext>;
+export type ListDbaasLogInputActionError = NotFound | OvhOpError;
+/** Returns actions of specified input */
+export declare const listDbaasLogInputAction: API.OperationMethod<ListDbaasLogInputActionRequest, ListDbaasLogInputActionResponse, ListDbaasLogInputActionError, OvhOpContext>;
+export type ListDbaasLogInputEngineError = OvhOpError;
+/** Returns the list of available input engines */
+export declare const listDbaasLogInputEngine: API.OperationMethod<ListDbaasLogInputEngineRequest, ListDbaasLogInputEngineResponse, ListDbaasLogInputEngineError, OvhOpContext>;
+export type ListDbaasLogInputEngineHelperError = OvhOpError;
+/** Return the list of available helpers for the given input engine */
+export declare const listDbaasLogInputEngineHelper: API.OperationMethod<ListDbaasLogInputEngineHelperRequest, ListDbaasLogInputEngineHelperResponse, ListDbaasLogInputEngineHelperError, OvhOpContext>;
+export type ListDbaasLogInputUrlError = NotFound | OvhOpError;
+/** Returns the list of urls of specified input */
+export declare const listDbaasLogInputUrl: API.OperationMethod<ListDbaasLogInputUrlRequest, ListDbaasLogInputUrlResponse, ListDbaasLogInputUrlError, OvhOpContext>;
+export type ListDbaasLogOperationError = NotFound | OvhOpError;
+/** Latest operations */
+export declare const listDbaasLogOperation: API.OperationMethod<ListDbaasLogOperationRequest, ListDbaasLogOperationResponse, ListDbaasLogOperationError, OvhOpContext>;
+export type ListDbaasLogOutputGraylogDashboardError = NotFound | OvhOpError;
+/** Returns the list of graylog dashboards */
+export declare const listDbaasLogOutputGraylogDashboard: API.OperationMethod<ListDbaasLogOutputGraylogDashboardRequest, ListDbaasLogOutputGraylogDashboardResponse, ListDbaasLogOutputGraylogDashboardError, OvhOpContext>;
+export type ListDbaasLogOutputGraylogDashboardUrlError = NotFound | OvhOpError;
+/** Returns the list of urls of specified graylog dashboard */
+export declare const listDbaasLogOutputGraylogDashboardUrl: API.OperationMethod<ListDbaasLogOutputGraylogDashboardUrlRequest, ListDbaasLogOutputGraylogDashboardUrlResponse, ListDbaasLogOutputGraylogDashboardUrlError, OvhOpContext>;
+export type ListDbaasLogOutputGraylogStreamError = NotFound | OvhOpError;
+/** Returns the list of graylog streams */
+export declare const listDbaasLogOutputGraylogStream: API.OperationMethod<ListDbaasLogOutputGraylogStreamRequest, ListDbaasLogOutputGraylogStreamResponse, ListDbaasLogOutputGraylogStreamError, OvhOpContext>;
+export type ListDbaasLogOutputGraylogStreamAlertError = NotFound | OvhOpError;
+/** Returns the list of configured alerts of specified graylog stream */
+export declare const listDbaasLogOutputGraylogStreamAlert: API.OperationMethod<ListDbaasLogOutputGraylogStreamAlertRequest, ListDbaasLogOutputGraylogStreamAlertResponse, ListDbaasLogOutputGraylogStreamAlertError, OvhOpContext>;
+export type ListDbaasLogOutputGraylogStreamArchiveError = NotFound | OvhOpError;
+/** Returns the list of archives */
+export declare const listDbaasLogOutputGraylogStreamArchive: API.OperationMethod<ListDbaasLogOutputGraylogStreamArchiveRequest, ListDbaasLogOutputGraylogStreamArchiveResponse, ListDbaasLogOutputGraylogStreamArchiveError, OvhOpContext>;
+export type ListDbaasLogOutputGraylogStreamArchiveEncryptionKeyError = NotFound | OvhOpError;
+/** Get the list of encryption keys used to encrypt the archive */
+export declare const listDbaasLogOutputGraylogStreamArchiveEncryptionKey: API.OperationMethod<ListDbaasLogOutputGraylogStreamArchiveEncryptionKeyRequest, ListDbaasLogOutputGraylogStreamArchiveEncryptionKeyResponse, ListDbaasLogOutputGraylogStreamArchiveEncryptionKeyError, OvhOpContext>;
+export type ListDbaasLogOutputGraylogStreamRuleError = NotFound | OvhOpError;
+/** Returns the list of rules of specified graylog stream */
+export declare const listDbaasLogOutputGraylogStreamRule: API.OperationMethod<ListDbaasLogOutputGraylogStreamRuleRequest, ListDbaasLogOutputGraylogStreamRuleResponse, ListDbaasLogOutputGraylogStreamRuleError, OvhOpContext>;
+export type ListDbaasLogOutputGraylogStreamSubscriptionError = NotFound | OvhOpError;
+/** Returns the list of subscriptions targeting a specified graylog stream */
+export declare const listDbaasLogOutputGraylogStreamSubscription: API.OperationMethod<ListDbaasLogOutputGraylogStreamSubscriptionRequest, ListDbaasLogOutputGraylogStreamSubscriptionResponse, ListDbaasLogOutputGraylogStreamSubscriptionError, OvhOpContext>;
+export type ListDbaasLogOutputGraylogStreamUrlError = NotFound | OvhOpError;
+/** Returns the list of urls of specified graylog stream */
+export declare const listDbaasLogOutputGraylogStreamUrl: API.OperationMethod<ListDbaasLogOutputGraylogStreamUrlRequest, ListDbaasLogOutputGraylogStreamUrlResponse, ListDbaasLogOutputGraylogStreamUrlError, OvhOpContext>;
+export type ListDbaasLogOutputMetricTenantError = NotFound | OvhOpError;
+/** List service's metric tenants */
+export declare const listDbaasLogOutputMetricTenant: API.OperationMethod<ListDbaasLogOutputMetricTenantRequest, ListDbaasLogOutputMetricTenantResponse, ListDbaasLogOutputMetricTenantError, OvhOpContext>;
+export type ListDbaasLogOutputMetricTenantSubscriptionError = NotFound | OvhOpError;
+/** Returns the list of subscriptions targeting a specified metric tenant */
+export declare const listDbaasLogOutputMetricTenantSubscription: API.OperationMethod<ListDbaasLogOutputMetricTenantSubscriptionRequest, ListDbaasLogOutputMetricTenantSubscriptionResponse, ListDbaasLogOutputMetricTenantSubscriptionError, OvhOpContext>;
+export type ListDbaasLogOutputMetricTenantUrlError = NotFound | OvhOpError;
+/** Returns the list of urls of specified metric tenant */
+export declare const listDbaasLogOutputMetricTenantUrl: API.OperationMethod<ListDbaasLogOutputMetricTenantUrlRequest, ListDbaasLogOutputMetricTenantUrlResponse, ListDbaasLogOutputMetricTenantUrlError, OvhOpContext>;
+export type ListDbaasLogOutputOpensearchAliasError = NotFound | OvhOpError;
+/** Returns the list of alias for connected user */
+export declare const listDbaasLogOutputOpensearchAlias: API.OperationMethod<ListDbaasLogOutputOpensearchAliasRequest, ListDbaasLogOutputOpensearchAliasResponse, ListDbaasLogOutputOpensearchAliasError, OvhOpContext>;
+export type ListDbaasLogOutputOpensearchAliasIndexError = NotFound | OvhOpError;
+/** Returns the list of OpenSearch indexes attached to specified OpenSearch alias */
+export declare const listDbaasLogOutputOpensearchAliasIndex: API.OperationMethod<ListDbaasLogOutputOpensearchAliasIndexRequest, ListDbaasLogOutputOpensearchAliasIndexResponse, ListDbaasLogOutputOpensearchAliasIndexError, OvhOpContext>;
+export type ListDbaasLogOutputOpensearchAliasStreamError = NotFound | OvhOpError;
+/** Returns the list of Graylog streams attached to specified OpenSearch alias */
+export declare const listDbaasLogOutputOpensearchAliasStream: API.OperationMethod<ListDbaasLogOutputOpensearchAliasStreamRequest, ListDbaasLogOutputOpensearchAliasStreamResponse, ListDbaasLogOutputOpensearchAliasStreamError, OvhOpContext>;
+export type ListDbaasLogOutputOpensearchAliasUrlError = NotFound | OvhOpError;
+/** Returns the list of urls of specified alias */
+export declare const listDbaasLogOutputOpensearchAliasUrl: API.OperationMethod<ListDbaasLogOutputOpensearchAliasUrlRequest, ListDbaasLogOutputOpensearchAliasUrlResponse, ListDbaasLogOutputOpensearchAliasUrlError, OvhOpContext>;
+export type ListDbaasLogOutputOpensearchIndexError = NotFound | OvhOpError;
+/** Returns the list of OpenSearch indexes */
+export declare const listDbaasLogOutputOpensearchIndex: API.OperationMethod<ListDbaasLogOutputOpensearchIndexRequest, ListDbaasLogOutputOpensearchIndexResponse, ListDbaasLogOutputOpensearchIndexError, OvhOpContext>;
+export type ListDbaasLogOutputOpensearchIndexUrlError = NotFound | OvhOpError;
+/** Returns the list of urls of specified index */
+export declare const listDbaasLogOutputOpensearchIndexUrl: API.OperationMethod<ListDbaasLogOutputOpensearchIndexUrlRequest, ListDbaasLogOutputOpensearchIndexUrlResponse, ListDbaasLogOutputOpensearchIndexUrlError, OvhOpContext>;
+export type ListDbaasLogOutputOpensearchOsdError = NotFound | OvhOpError;
+/** Returns the list of OpenSearch Dashboards instances */
+export declare const listDbaasLogOutputOpensearchOsd: API.OperationMethod<ListDbaasLogOutputOpensearchOsdRequest, ListDbaasLogOutputOpensearchOsdResponse, ListDbaasLogOutputOpensearchOsdError, OvhOpContext>;
+export type ListDbaasLogOutputOpensearchOsdUrlError = NotFound | OvhOpError;
+/** Returns the list of urls of specified OpenSearch Dashboards */
+export declare const listDbaasLogOutputOpensearchOsdUrl: API.OperationMethod<ListDbaasLogOutputOpensearchOsdUrlRequest, ListDbaasLogOutputOpensearchOsdUrlResponse, ListDbaasLogOutputOpensearchOsdUrlError, OvhOpContext>;
+export type ListDbaasLogRoleError = Forbidden | NotFound | OvhOpError;
+/** Returns the list of roles */
+export declare const listDbaasLogRole: API.OperationMethod<ListDbaasLogRoleRequest, ListDbaasLogRoleResponse, ListDbaasLogRoleError, OvhOpContext>;
+export type ListDbaasLogRoleMemberError = Forbidden | NotFound | OvhOpError;
+/** Returns the member list of specified role */
+export declare const listDbaasLogRoleMember: API.OperationMethod<ListDbaasLogRoleMemberRequest, ListDbaasLogRoleMemberResponse, ListDbaasLogRoleMemberError, OvhOpContext>;
+export type ListDbaasLogRolePermissionError = NotFound | OvhOpError;
+/** Returns the list of permissions of specified role */
+export declare const listDbaasLogRolePermission: API.OperationMethod<ListDbaasLogRolePermissionRequest, ListDbaasLogRolePermissionResponse, ListDbaasLogRolePermissionError, OvhOpContext>;
+export type ListDbaasLogsError = OvhOpError;
+/** List available services */
+export declare const listDbaasLogs: API.OperationMethod<ListDbaasLogsRequest, ListDbaasLogsResponse, ListDbaasLogsError, OvhOpContext>;
+export type ListDbaasLogTokenError = Forbidden | NotFound | OvhOpError;
+/** Returns the list of service tokens */
+export declare const listDbaasLogToken: API.OperationMethod<ListDbaasLogTokenRequest, ListDbaasLogTokenResponse, ListDbaasLogTokenError, OvhOpContext>;
+export type ListDbaasLogUrlError = NotFound | OvhOpError;
+/** Returns platform useful urls */
+export declare const listDbaasLogUrl: API.OperationMethod<ListDbaasLogUrlRequest, ListDbaasLogUrlResponse, ListDbaasLogUrlError, OvhOpContext>;
+export type PutDbaasLogError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Update the service properties */
+export declare const putDbaasLog: API.OperationMethod<PutDbaasLogRequest, DbaasLogsOperation, PutDbaasLogError, OvhOpContext>;
+export type PutDbaasLogClusterError = Forbidden | NotFound | OvhOpError;
+/** Update details of an allowed cluster */
+export declare const putDbaasLogCluster: API.OperationMethod<PutDbaasLogClusterRequest, DbaasLogsOperation, PutDbaasLogClusterError, OvhOpContext>;
+export type PutDbaasLogInputError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Update information of specified input object */
+export declare const putDbaasLogInput: API.OperationMethod<PutDbaasLogInputRequest, DbaasLogsOperation, PutDbaasLogInputError, OvhOpContext>;
+export type PutDbaasLogInputConfigurationFlowggerError = Forbidden | NotFound | OvhOpError;
+/** Update the flowgger configuration */
+export declare const putDbaasLogInputConfigurationFlowgger: API.OperationMethod<PutDbaasLogInputConfigurationFlowggerRequest, DbaasLogsOperation, PutDbaasLogInputConfigurationFlowggerError, OvhOpContext>;
+export type PutDbaasLogInputConfigurationLogstashError = Forbidden | NotFound | OvhOpError;
+/** Update the logstash configuration */
+export declare const putDbaasLogInputConfigurationLogstash: API.OperationMethod<PutDbaasLogInputConfigurationLogstashRequest, DbaasLogsOperation, PutDbaasLogInputConfigurationLogstashError, OvhOpContext>;
+export type PutDbaasLogOutputGraylogDashboardError = Forbidden | NotFound | OvhOpError;
+/** Update information of specified graylog dashboard */
+export declare const putDbaasLogOutputGraylogDashboard: API.OperationMethod<PutDbaasLogOutputGraylogDashboardRequest, DbaasLogsOperation, PutDbaasLogOutputGraylogDashboardError, OvhOpContext>;
+export type PutDbaasLogOutputGraylogStreamError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Update information of specified graylog stream */
+export declare const putDbaasLogOutputGraylogStream: API.OperationMethod<PutDbaasLogOutputGraylogStreamRequest, DbaasLogsOperation, PutDbaasLogOutputGraylogStreamError, OvhOpContext>;
+export type PutDbaasLogOutputGraylogStreamAlertError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Update alert information of specified graylog stream */
+export declare const putDbaasLogOutputGraylogStreamAlert: API.OperationMethod<PutDbaasLogOutputGraylogStreamAlertRequest, DbaasLogsOperation, PutDbaasLogOutputGraylogStreamAlertError, OvhOpContext>;
+export type PutDbaasLogOutputMetricTenantError = Forbidden | NotFound | Conflict | OvhOpError;
+/** Update a metric tenant */
+export declare const putDbaasLogOutputMetricTenant: API.OperationMethod<PutDbaasLogOutputMetricTenantRequest, DbaasLogsOperation, PutDbaasLogOutputMetricTenantError, OvhOpContext>;
+export type PutDbaasLogOutputOpensearchAliasError = Forbidden | NotFound | OvhOpError;
+/** Update specified OpenSearch alias */
+export declare const putDbaasLogOutputOpensearchAlias: API.OperationMethod<PutDbaasLogOutputOpensearchAliasRequest, DbaasLogsOperation, PutDbaasLogOutputOpensearchAliasError, OvhOpContext>;
+export type PutDbaasLogOutputOpensearchIndexError = Forbidden | NotFound | OvhOpError;
+/** Update specified OpenSearch index */
+export declare const putDbaasLogOutputOpensearchIndex: API.OperationMethod<PutDbaasLogOutputOpensearchIndexRequest, DbaasLogsOperation, PutDbaasLogOutputOpensearchIndexError, OvhOpContext>;
+export type PutDbaasLogOutputOpensearchOsdError = Forbidden | NotFound | OvhOpError;
+/** Update specified OpenSearch Dashboards instance */
+export declare const putDbaasLogOutputOpensearchOsd: API.OperationMethod<PutDbaasLogOutputOpensearchOsdRequest, DbaasLogsOperation, PutDbaasLogOutputOpensearchOsdError, OvhOpContext>;
+export type PutDbaasLogRoleError = Forbidden | NotFound | OvhOpError;
+/** Update information of specified role */
+export declare const putDbaasLogRole: API.OperationMethod<PutDbaasLogRoleRequest, DbaasLogsOperation, PutDbaasLogRoleError, OvhOpContext>;
+export type PutDbaasLogRoleMemberError = Forbidden | NotFound | OvhOpError;
+/** Update the member metadata */
+export declare const putDbaasLogRoleMember: API.OperationMethod<PutDbaasLogRoleMemberRequest, DbaasLogsOperation, PutDbaasLogRoleMemberError, OvhOpContext>;
+export type PutDbaasLogServiceInfosError = OvhOpError;
+/** Update service information */
+export declare const putDbaasLogServiceInfos: API.OperationMethod<PutDbaasLogServiceInfosRequest, PutDbaasLogServiceInfosResponse, PutDbaasLogServiceInfosError, OvhOpContext>;
+export type RestartDbaasLogsInputError = Forbidden | NotFound | OvhOpError;
+/** Schedule the restart of specified input */
+export declare const restartDbaasLogsInput: API.OperationMethod<RestartDbaasLogsInputRequest, DbaasLogsOperation, RestartDbaasLogsInputError, OvhOpContext>;
+export type StartDbaasLogsInputError = Forbidden | NotFound | OvhOpError;
+/** Schedule the start of specified input */
+export declare const startDbaasLogsInput: API.OperationMethod<StartDbaasLogsInputRequest, DbaasLogsOperation, StartDbaasLogsInputError, OvhOpContext>;
+//# sourceMappingURL=ldp.d.ts.map