type ApiResult = {
    readonly url: string;
    readonly ok: boolean;
    readonly status: number;
    readonly statusText: string;
    readonly body: any;
};

declare class ApiError extends Error {
    readonly url: string;
    readonly status: number;
    readonly statusText: string;
    readonly body: any;
    constructor(response: ApiResult, message: string);
}

declare class CancelError extends Error {
    constructor(message: string);
    get isCancelled(): boolean;
}
interface OnCancel {
    readonly isResolved: boolean;
    readonly isRejected: boolean;
    readonly isCancelled: boolean;
    (cancelHandler: () => void): void;
}
declare class CancelablePromise<T> implements Promise<T> {
    #private;
    readonly [Symbol.toStringTag]: string;
    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
    finally(onFinally?: (() => void) | null): Promise<T>;
    cancel(): void;
    get isCancelled(): boolean;
}

type ApiRequestOptions = {
    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
    readonly url: string;
    readonly path?: Record<string, any>;
    readonly cookies?: Record<string, any>;
    readonly headers?: Record<string, any>;
    readonly query?: Record<string, any>;
    readonly formData?: Record<string, any>;
    readonly body?: any;
    readonly mediaType?: string;
    readonly responseHeader?: string;
    readonly errors?: Record<number, string>;
};

type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
type Headers = Record<string, string>;
type OpenAPIConfig = {
    BASE: string | Resolver<string>;
    VERSION: string;
    WITH_CREDENTIALS: boolean;
    CREDENTIALS: 'include' | 'omit' | 'same-origin';
    TOKEN?: string | Resolver<string>;
    USERNAME?: string | Resolver<string>;
    PASSWORD?: string | Resolver<string>;
    HEADERS?: Headers | Resolver<Headers>;
    ENCODE_PATH?: (path: string) => string;
};
declare const OpenAPI: OpenAPIConfig;

/**
 * Request method
 * @param config The OpenAPI configuration object
 * @param options The request options from the service
 * @returns CancelablePromise<T>
 * @throws ApiError
 */
declare const request: <T>(config: OpenAPIConfig, options: ApiRequestOptions) => CancelablePromise<T>;

type AddressLevel = {
    name: string;
    addressLevelType: AddressLevel.addressLevelType;
    enumVersionId?: string;
};
declare namespace AddressLevel {
    enum addressLevelType {
        LITERAL = "literal",
        VARIABLE = "variable"
    }
}

type Address = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    addressLevels: Array<AddressLevel>;
    addressType?: Address.addressType;
    type?: string;
};
declare namespace Address {
    enum addressType {
        TOPIC = "topic"
    }
}

type AddressSpace = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    brokerType?: string;
    delimiter?: string;
    readonly type?: string;
};

type AddressSpaceResponse = {
    data?: AddressSpace;
    meta?: Record<string, any>;
};

type AddressSpacesResponse = {
    data?: Array<AddressSpace>;
    meta?: Record<string, any>;
};

type CustomAttribute = {
    customAttributeDefinitionId?: string;
    customAttributeDefinitionName?: string;
    value?: string;
};

type Application = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    name: string;
    applicationType: string;
    brokerType: Application.brokerType;
    applicationDomainId: string;
    readonly numberOfVersions?: number;
    customAttributes?: Array<CustomAttribute>;
    type?: string;
};
declare namespace Application {
    enum brokerType {
        KAFKA = "kafka",
        SOLACE = "solace"
    }
}

type PreviewEntityConfigurationDTO = {
    type?: PreviewEntityConfigurationDTO.type;
    identifier?: string;
    value?: string;
    errors?: Array<Record<string, any>>;
};
declare namespace PreviewEntityConfigurationDTO {
    enum type {
        SOLACE_QUEUE = "solaceQueue"
    }
}

type ApplicationDeploymentPreviewDTO = {
    requested?: Array<PreviewEntityConfigurationDTO>;
    existing?: Array<PreviewEntityConfigurationDTO>;
};

type ApplicationChangeRequestPreviewResponse = {
    data?: ApplicationDeploymentPreviewDTO;
    meta?: Record<string, any>;
};

type RuntimeEntityConfiguration = {
    runtimeEntityType?: RuntimeEntityConfiguration.runtimeEntityType;
    configuration?: string;
};
declare namespace RuntimeEntityConfiguration {
    enum runtimeEntityType {
        SOLACE_QUEUE = "solaceQueue"
    }
}

type ApplicationConfigurationPushJob = {
    id?: string;
    eventBrokerId?: string;
    applicationId?: string;
    runtimeEntityConfigurations?: Array<RuntimeEntityConfiguration>;
    sourceType?: ApplicationConfigurationPushJob.sourceType;
    sourceId?: string;
    requestMetadata?: Record<string, any>;
    status?: ApplicationConfigurationPushJob.status;
    createdTime?: string;
    errorDescription?: string;
    updatedTime?: string;
    type?: string;
    isRemoval?: boolean;
};
declare namespace ApplicationConfigurationPushJob {
    enum sourceType {
        CHANGE_RECORD = "changeRecord"
    }
    enum status {
        IN_PROGRESS = "in_progress",
        ERROR = "error",
        VALIDATION_ERROR = "validation_error",
        SUCCESS = "success"
    }
}

type Pagination = {
    pageNumber?: number;
    count?: number;
    pageSize?: number;
    nextPage?: number;
    totalPages?: number;
};

type meta = {
    pagination?: Pagination;
};

type ApplicationConfigPushJobResponse = {
    data?: Array<ApplicationConfigurationPushJob>;
    meta?: meta;
};

type ApplicationDeployment = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    applicationVersionId: string;
    action: ApplicationDeployment.action;
    eventBrokerId: string;
    id?: string;
    type?: string;
};
declare namespace ApplicationDeployment {
    enum action {
        DEPLOY = "deploy",
        UNDEPLOY = "undeploy"
    }
}

type ApplicationDomainStats = {
    schemaCount?: number;
    eventCount?: number;
    applicationCount?: number;
    enumCount?: number;
    eventApiCount?: number;
    eventApiProductCount?: number;
};

type ApplicationDomain = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    name: string;
    description?: string;
    /**
     * Forces all topic addresses within the application domain to be unique.
     */
    uniqueTopicAddressEnforcementEnabled?: boolean;
    /**
     * Forces all topic addresses within the application domain to be prefixed with one of the application domain’s configured topic domains.
     */
    topicDomainEnforcementEnabled?: boolean;
    stats?: ApplicationDomainStats;
    customAttributes?: Array<CustomAttribute>;
    type?: string;
};

type AttractedEventVersionTuple = {
    eventVersionId?: string;
    eventMeshIds?: Array<string>;
};

type Subscription = {
    readonly id?: string;
    subscriptionType?: string;
    value?: string;
    readonly attractedEventVersionIds?: Array<AttractedEventVersionTuple>;
};

type Consumer = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    name?: string;
    applicationVersionId: string;
    brokerType?: string;
    consumerType?: string;
    subscriptions?: Array<Subscription>;
    type?: string;
};

type ApplicationVersion = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    applicationId: string;
    description?: string;
    version: string;
    displayName?: string;
    declaredProducedEventVersionIds?: Array<string>;
    declaredConsumedEventVersionIds?: Array<string>;
    declaredEventApiProductVersionIds?: Array<string>;
    readonly stateId?: string;
    readonly consumers?: Array<Consumer>;
    customAttributes?: Array<CustomAttribute>;
    readonly messagingServiceIds?: Array<string>;
    type?: string;
};

type AssociatedEntity = {
    entityType?: string;
    applicationDomainIds?: Array<string>;
};

type CustomAttributeDefinition = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    id?: string;
    name?: string;
    valueType?: CustomAttributeDefinition.valueType;
    scope: CustomAttributeDefinition.scope;
    associatedEntityTypes?: Array<string>;
    associatedEntities?: Array<AssociatedEntity>;
    type?: string;
};
declare namespace CustomAttributeDefinition {
    enum valueType {
        STRING = "STRING",
        LONG_TEXT = "LONG_TEXT"
    }
    enum scope {
        ORGANIZATION = "organization",
        APPLICATION_DOMAIN = "applicationDomain"
    }
}

type Event = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    name: string;
    shared?: boolean;
    applicationDomainId: string;
    brokerType?: string;
    readonly numberOfVersions?: number;
    customAttributes?: Array<CustomAttribute>;
    readonly type?: string;
};

type EventApi = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The name of the event api.
     */
    name?: string;
    shared?: boolean;
    applicationDomainId?: string;
    readonly numberOfVersions?: number;
    /**
     * The type of the broker used for the event API
     */
    brokerType?: EventApi.brokerType;
    customAttributes?: Array<CustomAttribute>;
    /**
     * The type of this payload, eventApi.
     */
    readonly type?: string;
};
declare namespace EventApi {
    /**
     * The type of the broker used for the event API
     */
    enum brokerType {
        KAFKA = "kafka",
        SOLACE = "solace"
    }
}

type EventApiProduct = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * Primary key set by the server
     */
    readonly id?: string;
    /**
     * The name of the event API product
     */
    name?: string;
    applicationDomainId?: string;
    shared?: boolean;
    readonly numberOfVersions?: number;
    /**
     * The type of the broker used for the event API product
     */
    brokerType?: EventApiProduct.brokerType;
    customAttributes?: Array<CustomAttribute>;
    /**
     * The type of payload
     */
    readonly type?: string;
};
declare namespace EventApiProduct {
    /**
     * The type of the broker used for the event API product
     */
    enum brokerType {
        KAFKA = "kafka",
        SOLACE = "solace"
    }
}

type EventApiProductRegistration = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    applicationDomainId: string;
    registrationId: string;
    accessRequestId: string;
    eventApiProductVersionId: string;
    planId: string;
    state?: EventApiProductRegistration.state;
    /**
     * The type of payload
     */
    readonly type?: string;
    customAttributes?: Record<string, string>;
};
declare namespace EventApiProductRegistration {
    enum state {
        PENDING_APPROVAL = "Pending Approval",
        REJECTED = "Rejected",
        REVOKED = "Revoked",
        APPROVED = "Approved",
        ERROR = "Error",
        LIVE = "Live"
    }
}

/**
 * List of variable that contains address node name and filters
 */
type TopicFilter = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * name of address node
     */
    name?: string;
    /**
     * Different filter values separated by comma
     */
    filterValue?: string;
    eventVersionIds: Array<string>;
    /**
     * The type of payload
     */
    readonly type?: string;
};

/**
 * List of filters that contains eventVersionId name and variables
 */
type Filter = {
    eventVersionId?: string;
    /**
     * List of variable that contains address node name and filters
     */
    topicFilters?: Array<TopicFilter>;
    id?: string;
    /**
     * The type of payload
     */
    readonly type?: string;
};

/**
 * Solace class of service policy
 */
type SolaceClassOfServicePolicy = {
    /**
     * ID value of the object
     */
    readonly id?: string;
    /**
     * The mode that will be used for message delivery (ex: `guaranteed` uses a queue)
     */
    messageDeliveryMode?: SolaceClassOfServicePolicy.messageDeliveryMode;
    accessType?: SolaceClassOfServicePolicy.accessType;
    /**
     * Duration in seconds of how long a message can live in a queue
     */
    maximumTimeToLive?: number;
    /**
     * The arrangement of queues on a broker used for message delivery (ex: `single` uses one queue per event API version in this event API product)
     */
    queueType?: SolaceClassOfServicePolicy.queueType;
    /**
     * Total number of MBs available for the queue to use
     */
    maxMsgSpoolUsage?: number;
    /**
     * The type of payload
     */
    readonly type?: string;
};
declare namespace SolaceClassOfServicePolicy {
    /**
     * The mode that will be used for message delivery (ex: `guaranteed` uses a queue)
     */
    enum messageDeliveryMode {
        DIRECT = "direct",
        GUARANTEED = "guaranteed"
    }
    enum accessType {
        EXCLUSIVE = "exclusive",
        NON_EXCLUSIVE = "non-exclusive"
    }
    /**
     * The arrangement of queues on a broker used for message delivery (ex: `single` uses one queue per event API version in this event API product)
     */
    enum queueType {
        SINGLE = "single",
        COMBINED = "combined"
    }
}

type Plan = {
    /**
     * ID value of the object
     */
    readonly id?: string;
    /**
     * Title of the object
     */
    name?: string;
    solaceClassOfServicePolicy?: SolaceClassOfServicePolicy;
    /**
     * The type of this payload
     */
    readonly type?: string;
};

/**
 * Solace Messaging Services
 */
type SolaceMessagingService = {
    /**
     * ID value of the object
     */
    readonly id?: string;
    /**
     * ID of the Event Portal messaging service
     */
    readonly messagingServiceId?: string;
    /**
     * Name of the Event Portal messaging service
     */
    readonly messagingServiceName?: string;
    /**
     * Values for allowed supported protocols
     */
    supportedProtocols?: Array<string>;
    readonly environmentId?: string;
    readonly environmentName?: string;
    readonly eventMeshId?: string;
    readonly eventMeshName?: string;
    solaceCloudMessagingServiceId?: string;
    /**
     * The type of payload
     */
    readonly type?: string;
};

type EventApiProductVersion = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    eventApiProductId: string;
    description?: string;
    version?: string;
    summary?: string;
    customAttributes?: Array<CustomAttribute>;
    displayName?: string;
    /**
     * List of IDs of associated event API versions
     */
    eventApiVersionIds?: Array<string>;
    stateId?: string;
    eventApiProductRegistrations?: Array<EventApiProductRegistration>;
    plans?: Array<Plan>;
    /**
     * Solace Messaging Services
     */
    solaceMessagingServices?: Array<SolaceMessagingService>;
    /**
     * List of filters that contains eventVersionId name and variables
     */
    filters?: Array<Filter>;
    /**
     * Approval type
     */
    approvalType?: EventApiProductVersion.approvalType;
    /**
     * Publish state
     */
    publishState?: EventApiProductVersion.publishState;
    readonly publishedTime?: string;
    /**
     * The type of payload
     */
    readonly type?: string;
};
declare namespace EventApiProductVersion {
    /**
     * Approval type
     */
    enum approvalType {
        AUTOMATIC = "automatic",
        MANUAL = "manual"
    }
    /**
     * Publish state
     */
    enum publishState {
        UNSET = "unset",
        PUBLISHED = "published"
    }
}

type EventApiVersion = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    eventApiId: string;
    description?: string;
    version?: string;
    displayName?: string;
    producedEventVersionIds?: Array<string>;
    consumedEventVersionIds?: Array<string>;
    declaredEventApiProductVersionIds?: Array<string>;
    customAttributes?: Array<CustomAttribute>;
    stateId?: string;
    type?: string;
};

type AttractingApplicationVersionTuple = {
    applicationVersionId?: string;
    eventMeshIds?: Array<string>;
};

type DeliveryDescriptor = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    brokerType?: string;
    address?: Address;
    keySchemaVersionId?: string;
    keySchemaPrimitiveType?: DeliveryDescriptor.keySchemaPrimitiveType;
    id?: string;
    type?: string;
};
declare namespace DeliveryDescriptor {
    enum keySchemaPrimitiveType {
        BOOLEAN = "BOOLEAN",
        BYTES = "BYTES",
        DOUBLE = "DOUBLE",
        FLOAT = "FLOAT",
        INT = "INT",
        LONG = "LONG",
        NULL = "NULL",
        NUMBER = "NUMBER",
        STRING = "STRING"
    }
}

type EventVersion = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    eventId: string;
    description?: string;
    version: string;
    displayName?: string;
    readonly declaredProducingApplicationVersionIds?: Array<string>;
    readonly declaredConsumingApplicationVersionIds?: Array<string>;
    readonly producingEventApiVersionIds?: Array<string>;
    readonly consumingEventApiVersionIds?: Array<string>;
    readonly attractingApplicationVersionIds?: Array<AttractingApplicationVersionTuple>;
    schemaVersionId?: string;
    schemaPrimitiveType?: EventVersion.schemaPrimitiveType;
    deliveryDescriptor?: DeliveryDescriptor;
    readonly stateId?: string;
    customAttributes?: Array<CustomAttribute>;
    readonly messagingServiceIds?: Array<string>;
    type?: string;
};
declare namespace EventVersion {
    enum schemaPrimitiveType {
        BOOLEAN = "BOOLEAN",
        BYTES = "BYTES",
        DOUBLE = "DOUBLE",
        FLOAT = "FLOAT",
        INT = "INT",
        LONG = "LONG",
        NULL = "NULL",
        NUMBER = "NUMBER",
        STRING = "STRING"
    }
}

type SchemaObject = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    applicationDomainId: string;
    name: string;
    shared?: boolean;
    /**
     * *Deprecation Date: 2022-04-30<br>Removal Date: 2023-04-30<br>Reason: Content types are a runtime concept and don’t provide useful value in their current implementation.*<br>
     */
    contentType?: string;
    schemaType: string;
    readonly numberOfVersions?: number;
    readonly eventVersionRefCount?: number;
    customAttributes?: Array<CustomAttribute>;
    readonly type?: string;
};

type SchemaVersionReferenceDTO = {
    schemaVersionId?: string;
};

type SchemaVersion = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    schemaId: string;
    description?: string;
    version: string;
    displayName?: string;
    content?: string;
    readonly referencedByEventVersionIds?: Array<string>;
    readonly referencedBySchemaVersionIds?: Array<string>;
    schemaVersionReferences?: Array<SchemaVersionReferenceDTO>;
    customAttributes?: Array<CustomAttribute>;
    readonly stateId?: string;
    readonly type?: string;
};

type TopicAddressEnum = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    applicationDomainId: string;
    name: string;
    shared?: boolean;
    readonly numberOfVersions?: number;
    readonly eventVersionRefCount?: number;
    customAttributes?: Array<CustomAttribute>;
    readonly type?: string;
};

type TopicAddressEnumValue = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    enumVersionId?: string;
    value: string;
    label?: string;
    readonly type?: string;
};

type TopicAddressEnumVersion = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    enumId: string;
    description?: string;
    version: string;
    displayName?: string;
    values: Array<TopicAddressEnumValue>;
    readonly referencedByEventVersionIds?: Array<string>;
    readonly referencedByTopicDomainIds?: Array<string>;
    readonly stateId?: string;
    customAttributes?: Array<CustomAttribute>;
    readonly type?: string;
};

type TopicDomain = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    applicationDomainId: string;
    brokerType: string;
    addressLevels: Array<AddressLevel>;
    readonly type?: string;
};

type ApplicationDomainExportDTO = {
    formatVersion?: string;
    applicationDomains?: Array<ApplicationDomain>;
    topicDomains?: Array<TopicDomain>;
    applications?: Array<Application>;
    applicationVersions?: Array<ApplicationVersion>;
    events?: Array<Event>;
    eventVersions?: Array<EventVersion>;
    schemas?: Array<SchemaObject>;
    schemaVersions?: Array<SchemaVersion>;
    enums?: Array<TopicAddressEnum>;
    enumVersions?: Array<TopicAddressEnumVersion>;
    eventApis?: Array<EventApi>;
    eventApiVersions?: Array<EventApiVersion>;
    eventApiProducts?: Array<EventApiProduct>;
    eventApiProductVersions?: Array<EventApiProductVersion>;
    addressSpaces?: Array<AddressSpace>;
    customAttributeDefinitions?: Array<CustomAttributeDefinition>;
};

type ApplicationDomainImportDTO = {
    formatVersion?: string;
    applicationDomains?: Array<ApplicationDomain>;
    topicDomains?: Array<TopicDomain>;
    applications?: Array<Application>;
    applicationVersions?: Array<ApplicationVersion>;
    events?: Array<Event>;
    eventVersions?: Array<EventVersion>;
    schemas?: Array<SchemaObject>;
    schemaVersions?: Array<SchemaVersion>;
    enums?: Array<TopicAddressEnum>;
    enumVersions?: Array<TopicAddressEnumVersion>;
    eventApis?: Array<EventApi>;
    eventApiVersions?: Array<EventApiVersion>;
    eventApiProducts?: Array<EventApiProduct>;
    eventApiProductVersions?: Array<EventApiProductVersion>;
    addressSpaces?: Array<AddressSpace>;
    customAttributeDefinitions?: Array<CustomAttributeDefinition>;
};

type ApplicationDomainResponse = {
    data?: ApplicationDomain;
    meta?: Record<string, any>;
};

type ApplicationDomainsResponse = {
    data?: Array<ApplicationDomain>;
    meta?: meta;
};

type ApplicationRegistration = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    applicationDomainId: string;
    registrationId: string;
    readonly applicationId?: string;
    name: string;
    readonly type?: string;
    customAttributes?: Record<string, string>;
};

type ApplicationRegistrationResponse = {
    data?: ApplicationRegistration;
    meta?: Record<string, any>;
};

type ApplicationRegistrationsResponse = {
    data?: Array<ApplicationRegistration>;
    meta?: Record<string, any>;
};

type ApplicationResponse = {
    data?: Application;
    meta?: Record<string, any>;
};

type ApplicationsResponse = {
    data?: Array<Application>;
    meta?: meta;
};

type ApplicationVersionFrontendDTO = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    applicationId: string;
    description?: string;
    version: string;
    displayName?: string;
    declaredProducedEventVersionIds?: Array<string>;
    declaredConsumedEventVersionIds?: Array<string>;
    declaredEventApiProductVersionIds?: Array<string>;
    readonly stateId?: string;
    readonly consumers?: Array<Consumer>;
    customAttributes?: Array<CustomAttribute>;
    readonly messagingServiceIds?: Array<string>;
    parentName?: string;
    clientProfileName?: string;
    type?: string;
};

type ApplicationVersionFrontendResponse = {
    data?: ApplicationVersionFrontendDTO;
    meta?: Record<string, any>;
};

type ApplicationVersionResponse = {
    data?: ApplicationVersion;
    meta?: Record<string, any>;
};

type ApplicationVersionsFrontendResponse = {
    data?: Array<ApplicationVersionFrontendDTO>;
    meta?: meta;
};

type ApplicationVersionsResponse = {
    data?: Array<ApplicationVersion>;
    meta?: meta;
};

type DesignerMappingDTO = {
    id?: string;
    messagingServiceId?: string;
    auditEntityType?: DesignerMappingDTO.auditEntityType;
    identifier?: string;
    attributes?: string;
    entityId?: string;
    versionId?: string;
    parentId?: string;
};
declare namespace DesignerMappingDTO {
    enum auditEntityType {
        ALL = "all",
        KAFKA_CONSUMER_GROUP = "kafkaConsumerGroup",
        KAFKA_CONSUMER_GROUP_AGGREGATE = "kafkaConsumerGroupAggregate",
        KAFKA_TOPIC = "kafkaTopic",
        KAFKA_TOPIC_AGGREGATE = "kafkaTopicAggregate",
        SCHEMA_PARENT = "schemaParent",
        SCHEMA_VERSION = "schemaVersion",
        SOLACE_QUEUE = "solaceQueue",
        SOLACE_QUEUE_AGGREGATE = "solaceQueueAggregate",
        SOLACE_TOPIC = "solaceTopic",
        KAFKA_TOPIC_SCHEMA_VERSION = "kafkaTopicSchemaVersion",
        KAFKA_TOPIC_SCHEMA_PARENT = "kafkaTopicSchemaParent"
    }
}

type RuntimeMappingDTO = {
    id?: string;
    messagingServiceId?: string;
    auditEntityType?: RuntimeMappingDTO.auditEntityType;
    identifier?: string;
    attributes?: string;
    scanId?: string;
};
declare namespace RuntimeMappingDTO {
    enum auditEntityType {
        ALL = "all",
        KAFKA_CONSUMER_GROUP = "kafkaConsumerGroup",
        KAFKA_CONSUMER_GROUP_AGGREGATE = "kafkaConsumerGroupAggregate",
        KAFKA_TOPIC = "kafkaTopic",
        KAFKA_TOPIC_AGGREGATE = "kafkaTopicAggregate",
        SCHEMA_PARENT = "schemaParent",
        SCHEMA_VERSION = "schemaVersion",
        SOLACE_QUEUE = "solaceQueue",
        SOLACE_QUEUE_AGGREGATE = "solaceQueueAggregate",
        SOLACE_TOPIC = "solaceTopic",
        KAFKA_TOPIC_SCHEMA_VERSION = "kafkaTopicSchemaVersion",
        KAFKA_TOPIC_SCHEMA_PARENT = "kafkaTopicSchemaParent"
    }
}

type Tag = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    readonly name: string;
    /**
     * The type of this payload, tag.
     */
    readonly type?: string;
};

type Audit = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    readonly messagingServiceId?: string;
    readonly auditEntityType?: string;
    readonly messagingServiceName?: string;
    readonly identifier?: string;
    readonly status?: string;
    readonly designerMappingId?: string;
    readonly designerMappingAssociationId?: string;
    readonly runtimeMappingId?: string;
    readonly runtimeMappingAssociationId?: string;
    designerMapping?: DesignerMappingDTO;
    runtimeMapping?: RuntimeMappingDTO;
    associatedTags?: Array<Tag>;
    schemaType?: string;
    type?: string;
};

type AuditCommandDTO = {
    auditOperationType?: AuditCommandDTO.auditOperationType;
    auditEntityType?: AuditCommandDTO.auditEntityType;
    sourceId?: string;
    synchronous?: boolean;
    productionModeErrorHandling?: boolean;
};
declare namespace AuditCommandDTO {
    enum auditOperationType {
        AGGREGATE_AUDIT = "aggregateAudit",
        AUDIT = "audit",
        DELETE_ALL = "deleteAll",
        DESIGNER_MAPPING = "designerMapping",
        DESIGNER_UPDATE = "designerUpdate",
        RUNTIME_MAPPING = "runtimeMapping",
        RUNTIME_UPDATE = "runtimeUpdate",
        SCAN = "scan",
        UPDATE_RELATIONSHIPS = "updateRelationships"
    }
    enum auditEntityType {
        ALL = "all",
        KAFKA_CONSUMER_GROUP = "kafkaConsumerGroup",
        KAFKA_CONSUMER_GROUP_AGGREGATE = "kafkaConsumerGroupAggregate",
        KAFKA_TOPIC = "kafkaTopic",
        KAFKA_TOPIC_AGGREGATE = "kafkaTopicAggregate",
        SCHEMA_PARENT = "schemaParent",
        SCHEMA_VERSION = "schemaVersion",
        SOLACE_QUEUE = "solaceQueue",
        SOLACE_QUEUE_AGGREGATE = "solaceQueueAggregate",
        SOLACE_TOPIC = "solaceTopic",
        KAFKA_TOPIC_SCHEMA_VERSION = "kafkaTopicSchemaVersion",
        KAFKA_TOPIC_SCHEMA_PARENT = "kafkaTopicSchemaParent"
    }
}

type AuditRelationDTO = {
    auditEntityType?: string;
    auditId?: string;
    identifier?: string;
    status?: string;
};

type AuditDetail = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    readonly runtimeAttributes?: string;
    readonly designerAttributes?: string;
    readonly versionId?: string;
    readonly entityId?: string;
    readonly parentId?: string;
    readonly scanId?: string;
    readonly status?: string;
    readonly identifier?: string;
    readonly relations?: Array<AuditRelationDTO>;
    readonly extendedAttributes?: string;
    associatedTags?: Array<Tag>;
    type?: string;
};

type AuditDetailResponse = {
    data?: AuditDetail;
    meta?: Record<string, any>;
};

type AuditImportDTO = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    auditIds?: Array<string>;
    properties?: Record<string, string>;
    auditImportAction?: AuditImportDTO.auditImportAction;
    readonly audits?: Array<Audit>;
    id?: string;
    type?: string;
};
declare namespace AuditImportDTO {
    enum auditImportAction {
        UPDATE_EXISTING_PARENT = "updateExistingParent",
        UPDATE_EXISTING_VERSION = "updateExistingVersion",
        CREATE_NEW_PARENT = "createNewParent",
        CREATE_NEW_VERSION = "createNewVersion",
        ADD_TO_EXISTING_VERSION = "addToExistingVersion"
    }
}

type BulkAuditImportDTO = {
    auditImports?: Array<AuditImportDTO>;
};

type AuditImportJobMetadata = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    jobId?: string;
    jobType?: string;
    status?: AuditImportJobMetadata.status;
    messagingServiceId?: string;
    payload?: BulkAuditImportDTO;
    id?: string;
    type?: string;
};
declare namespace AuditImportJobMetadata {
    enum status {
        IN_PROGRESS = "in_progress",
        ERROR = "error",
        VALIDATION_ERROR = "validation_error",
        SUCCESS = "success"
    }
}

type AuditImportJobsMetadataResponse = {
    data?: Array<AuditImportJobMetadata>;
    meta?: meta;
};

type AuditJob = {
    id?: number;
    state: AuditJob.state;
    scanId?: string;
    contextId: string;
    contextType: string;
    auditEntityType: AuditJob.auditEntityType;
    auditOperationType: AuditJob.auditOperationType;
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    type?: string;
};
declare namespace AuditJob {
    enum state {
        COMPLETED = "completed",
        FAILED = "failed",
        STARTED = "started"
    }
    enum auditEntityType {
        ALL = "all",
        KAFKA_CONSUMER_GROUP = "kafkaConsumerGroup",
        KAFKA_CONSUMER_GROUP_AGGREGATE = "kafkaConsumerGroupAggregate",
        KAFKA_TOPIC = "kafkaTopic",
        KAFKA_TOPIC_AGGREGATE = "kafkaTopicAggregate",
        SCHEMA_PARENT = "schemaParent",
        SCHEMA_VERSION = "schemaVersion",
        SOLACE_QUEUE = "solaceQueue",
        SOLACE_QUEUE_AGGREGATE = "solaceQueueAggregate",
        SOLACE_TOPIC = "solaceTopic",
        KAFKA_TOPIC_SCHEMA_VERSION = "kafkaTopicSchemaVersion",
        KAFKA_TOPIC_SCHEMA_PARENT = "kafkaTopicSchemaParent"
    }
    enum auditOperationType {
        AGGREGATE_AUDIT = "aggregateAudit",
        AUDIT = "audit",
        DELETE_ALL = "deleteAll",
        DESIGNER_MAPPING = "designerMapping",
        DESIGNER_UPDATE = "designerUpdate",
        RUNTIME_MAPPING = "runtimeMapping",
        RUNTIME_UPDATE = "runtimeUpdate",
        SCAN = "scan",
        UPDATE_RELATIONSHIPS = "updateRelationships"
    }
}

type AuditJobResponse = {
    data?: Array<AuditJob>;
    meta?: Record<string, any>;
};

type AuditResult = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    readonly eventBrokerId?: string;
    readonly auditEntityType?: string;
    readonly eventBrokerName?: string;
    readonly identifier?: string;
    readonly status?: string;
    schemaType?: string;
    type?: string;
};

type AuditResultDetail = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    readonly parentId?: string;
    readonly versionId?: string;
    readonly entityId?: string;
    readonly scanId?: string;
    readonly status?: string;
    readonly identifier?: string;
    readonly relations?: Array<AuditRelationDTO>;
    type?: string;
};

type AuditResultDetailResponse = {
    data?: AuditResultDetail;
    meta?: Record<string, any>;
};

type AuditResultsResponse = {
    data?: Array<AuditResult>;
    meta?: meta;
};

type AuditResultStatsDTO = {
    auditStatusDistribution?: Record<string, number>;
    auditAssociatedTagIds?: Array<string>;
    eventBrokerIds?: Array<string>;
    nonDraftAuditIds?: Array<string>;
    auditDetail?: Record<string, AuditDetail>;
};

type AuditResultStatsRequestDTO = {
    auditEntityType?: AuditResultStatsRequestDTO.auditEntityType;
    eventMeshId?: string;
    eventBrokerIds?: Array<string>;
    hidden?: boolean;
    statuses?: Array<'designerOnly' | 'match' | 'partialMatch' | 'runtimeOnly'>;
    tags?: Array<'To Be Created' | 'To Be Deleted'>;
    excludedIds?: Array<string>;
    startsWith?: string;
    contains?: string;
};
declare namespace AuditResultStatsRequestDTO {
    enum auditEntityType {
        ALL = "all",
        KAFKA_CONSUMER_GROUP = "kafkaConsumerGroup",
        KAFKA_CONSUMER_GROUP_AGGREGATE = "kafkaConsumerGroupAggregate",
        KAFKA_TOPIC = "kafkaTopic",
        KAFKA_TOPIC_AGGREGATE = "kafkaTopicAggregate",
        SCHEMA_PARENT = "schemaParent",
        SCHEMA_VERSION = "schemaVersion",
        SOLACE_QUEUE = "solaceQueue",
        SOLACE_QUEUE_AGGREGATE = "solaceQueueAggregate",
        SOLACE_TOPIC = "solaceTopic",
        KAFKA_TOPIC_SCHEMA_VERSION = "kafkaTopicSchemaVersion",
        KAFKA_TOPIC_SCHEMA_PARENT = "kafkaTopicSchemaParent"
    }
}

type AuditsResponse = {
    data?: Array<Audit>;
    meta?: meta;
};

type TargetEntitiesRequestDTO = {
    selectedEntityIds?: Array<string>;
    entityType?: TargetEntitiesRequestDTO.entityType;
};
declare namespace TargetEntitiesRequestDTO {
    enum entityType {
        APPLICATION = "application",
        SCHEMA = "schema",
        EVENT = "event"
    }
}

type ChangeAppDomainEntitiesDTO = {
    targetAppDomainId?: string;
    entities?: Array<TargetEntitiesRequestDTO>;
};

type Configuration = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    contextType?: Configuration.contextType;
    contextId: string;
    /**
     * Refer <a href="/cloud/reference/getconfigurationtypes">here</a> for details on configuration types.
     */
    configurationTypeId: string;
    /**
     * Refer <a href="/cloud/reference/getconfigurationtypes">here</a> for details on configuration types.
     */
    configurationType: string;
    entityType: Configuration.entityType;
    entityId: string;
    readonly identifier?: string;
    value?: Record<string, any>;
    type?: string;
};
declare namespace Configuration {
    enum contextType {
        EVENT_BROKER = "EVENT_BROKER"
    }
    enum entityType {
        ADDRESS = "address",
        APPLICATION = "application",
        APPLICATION_VERSION = "applicationVersion",
        AUDIT = "audit",
        CONSUMER = "consumer",
        EVENT_VERSION = "eventVersion",
        SCHEMA = "schema",
        SCHEMA_VERSION = "schemaVersion",
        SUBSCRIPTION = "subscription"
    }
}

type ConfigurationResponse = {
    data?: Configuration;
    meta?: Record<string, any>;
};

type ConfigurationsResponse = {
    data?: Array<Configuration>;
    meta?: meta;
};

type ConfigurationType = {
    readonly id?: string;
    name: string;
    brokerType: string;
    associatedEntityTypes?: Array<string>;
    readonly createdTime?: string;
    readonly updatedTime?: string;
    valueSchema?: Record<string, any>;
    type?: string;
};

type ConfigurationTypeResponse = {
    data?: ConfigurationType;
    meta?: Record<string, any>;
};

type ConfigurationTypesResponse = {
    data?: Array<ConfigurationType>;
    meta?: meta;
};

type ConsumerResponse = {
    data?: Consumer;
    meta?: Record<string, any>;
};

type ConsumersResponse = {
    data?: Array<Consumer>;
    meta?: meta;
};

type CustomAttributeDefinitionResponse = {
    data?: CustomAttributeDefinition;
    meta?: Record<string, any>;
};

type CustomAttributeDefinitionsResponse = {
    data?: Array<CustomAttributeDefinition>;
    meta?: meta;
};

type CustomAttributeFrontEndDTO = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    id?: string;
    name?: string;
    valueType?: CustomAttributeFrontEndDTO.valueType;
    scope: CustomAttributeFrontEndDTO.scope;
    associatedEntityTypes?: Array<string>;
    associatedEntities?: Array<AssociatedEntity>;
    valuesEntityTypes?: Array<string>;
    values?: Array<any>;
    type?: string;
};
declare namespace CustomAttributeFrontEndDTO {
    enum valueType {
        STRING = "STRING",
        LONG_TEXT = "LONG_TEXT"
    }
    enum scope {
        ORGANIZATION = "organization",
        APPLICATION_DOMAIN = "applicationDomain"
    }
}

type CustomAttributesFrontEndResponse = {
    data?: Array<CustomAttributeFrontEndDTO>;
    meta?: Record<string, any>;
};

declare enum ResourceType {
    UNKNOWN = "unknown",
    APPLICATION_DOMAIN = "application_domain",
    EP_ENUM = "ep_enum",
    EVENT = "event",
    SCHEMA = "schema",
    APPLICATION = "application",
    EVENT_ARCHIVE = "event_archive",
    SCHEMA_ARCHIVE = "schema_archive",
    APPLICATION_ARCHIVE = "application_archive",
    TAG = "tag",
    VIRTUAL_BROKER = "virtual_broker",
    TOPIC_VALUE_SET = "topic_value_set",
    API_PRODUCTS = "api_products",
    APPLICATION_DOMAIN_SAMPLE = "application_domain_sample",
    MODELED_EVENT_MESH = "modeled_event_mesh",
    ADDRESS_SPACE = "address_space",
    TOPIC_DOMAIN = "topic_domain",
    EVENT_API = "event_api",
    EVENT_API_PRODUCT = "event_api_product",
    APPLICATION_REGISTRATION = "application_registration",
    CUSTOM_ATTRIBUTE = "custom_attribute",
    APIM_EVENT_API_PRODUCT = "apim_event_api_product",
    SCHEMA_REGISTRY = "schema_registry",
    EVENT_BROKER_SERVICE = "event_broker_service",
    EVENT_BROKER_SERVICE_CONNECTION_ENDPOINT = "event_broker_service_connection_endpoint",
    EVENT_BROKER_INFRASTRUCTURE = "event_broker_infrastructure"
}

type Entitlement = {
    resourceType?: ResourceType;
    attributes?: Record<string, any>;
    actions?: Array<string>;
};

type EntityType = {
    readonly value?: string;
    type?: string;
};

type EntityTypesResponse = {
    data?: Array<EntityType>;
    meta?: meta;
};

type Environment = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    readonly name?: string;
    readonly description?: string;
    readonly revision?: number;
    readonly numberOfEventMeshes?: number;
    configPush?: Environment.configPush;
    readonly type?: string;
};
declare namespace Environment {
    enum configPush {
        AUTO = "auto",
        DISABLED = "disabled"
    }
}

type EnvironmentResponse = {
    data?: Environment;
    meta?: Record<string, any>;
};

type EnvironmentsResponse = {
    data?: Array<Environment>;
    meta?: meta;
};

type EPResponseSetString = {
    data?: Array<string>;
    meta?: meta;
};

type EpUserEntitlements = {
    readonly userId?: string;
    readonly entitlements?: Array<Entitlement>;
    readonly id?: string;
    readonly type?: string;
};

type EpUserEntitlementsResponse = {
    data?: EpUserEntitlements;
    meta?: Record<string, any>;
};

type ErrorResponse = {
    message?: string;
    errorId?: string;
    meta?: Record<string, any>;
    validationDetails?: Record<string, Array<string>>;
    errorType?: string;
};

type EventApiProductRegistrationResponse = {
    data?: EventApiProductRegistration;
    meta?: Record<string, any>;
};

type EventApiProductRegistrationsResponse = {
    data?: Array<EventApiProductRegistration>;
    meta?: Record<string, any>;
};

type EventApiProductResponse = {
    data?: EventApiProduct;
    meta?: Record<string, any>;
};

type EventApiProductsResponse = {
    data?: Array<EventApiProduct>;
    meta?: meta;
};

type EventApiProductVersionResponse = {
    data?: EventApiProductVersion;
    meta?: Record<string, any>;
};

type EventApiProductVersionsResponse = {
    data?: Array<EventApiProductVersion>;
    meta?: meta;
};

type EventApiResponse = {
    data?: EventApi;
    meta?: Record<string, any>;
};

type EventApisResponse = {
    data?: Array<EventApi>;
    meta?: meta;
};

type EventApiVersionResponse = {
    data?: EventApiVersion;
    meta?: Record<string, any>;
};

type EventApiVersionsResponse = {
    data?: Array<EventApiVersion>;
    meta?: meta;
};

type EventBrokerScanDataUploadDetails = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The ID of the uploaded scan request.
     */
    readonly scanId?: string;
    /**
     * The event broker id of the data collection upload request.
     */
    readonly eventBrokerId?: string;
    readonly eventBrokerType?: EventBrokerScanDataUploadDetails.eventBrokerType;
    /**
     * The uploaded data collection types.
     */
    readonly dataCollectionTypes?: Array<'brokerConfiguration' | 'clusterConfiguration' | 'consumerGroups' | 'consumerGroupConfiguration' | 'overrideTopicConfiguration' | 'queueConfiguration' | 'queueListing' | 'schema' | 'subscriptionConfiguration' | 'topicConfiguration' | 'topicListing'>;
    /**
     * The status of the event broker scan.
     */
    readonly status?: EventBrokerScanDataUploadDetails.status;
    /**
     * The scan types for which the data is uploaded.
     */
    readonly scanTypes?: Array<'KAFKA_ALL' | 'KAFKA_BROKER_CONFIGURATION' | 'KAFKA_CLUSTER_CONFIGURATION' | 'KAFKA_CONSUMER_GROUPS' | 'KAFKA_CONSUMER_GROUPS_CONFIGURATION' | 'KAFKA_FEATURES' | 'KAFKA_PRODUCERS' | 'KAFKA_TOPIC_CONFIGURATION' | 'KAFKA_TOPIC_CONFIGURATION_FULL' | 'KAFKA_TOPIC_LISTING' | 'KAFKA_TOPIC_OVERRIDE_CONFIGURATION' | 'CONFLUENT_SCHEMA_REGISTRY_SCHEMA' | 'SOLACE_ALL' | 'SOLACE_QUEUE_CONFIG' | 'SOLACE_QUEUE_LISTING' | 'SOLACE_SUBSCRIPTION_CONFIG'>;
    /**
     * The data upload destination.
     */
    readonly destinations?: Array<'EVENT_PORTAL' | 'FILE_WRITER'>;
    /**
     * The type of this payload, ema data collection.
     */
    readonly type?: string;
};
declare namespace EventBrokerScanDataUploadDetails {
    enum eventBrokerType {
        SOLACE = "solace",
        KAFKA = "kafka"
    }
    /**
     * The status of the event broker scan.
     */
    enum status {
        COMPLETE = "COMPLETE",
        FAILED = "FAILED",
        INITIATED = "INITIATED",
        IN_PROGRESS = "IN_PROGRESS",
        TIMED_OUT = "TIMED_OUT",
        TIMED_OUT_ON_INITIATION = "TIMED_OUT_ON_INITIATION",
        TIMED_OUT_ON_NO_DATA = "TIMED_OUT_ON_NO_DATA",
        TIMED_OUT_ON_PARTIAL_DATA = "TIMED_OUT_ON_PARTIAL_DATA"
    }
}

type EventBrokerDataCollectionUploadResponse = {
    data?: EventBrokerScanDataUploadDetails;
    meta?: Record<string, any>;
};

type JsonNode = {};

type EventBrokerScanData = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    readonly eventBrokerId?: string;
    data: JsonNode;
    scanTypes?: Array<'KAFKA_ALL' | 'KAFKA_BROKER_CONFIGURATION' | 'KAFKA_CLUSTER_CONFIGURATION' | 'KAFKA_CONSUMER_GROUPS' | 'KAFKA_CONSUMER_GROUPS_CONFIGURATION' | 'KAFKA_FEATURES' | 'KAFKA_PRODUCERS' | 'KAFKA_TOPIC_CONFIGURATION' | 'KAFKA_TOPIC_CONFIGURATION_FULL' | 'KAFKA_TOPIC_LISTING' | 'KAFKA_TOPIC_OVERRIDE_CONFIGURATION' | 'CONFLUENT_SCHEMA_REGISTRY_SCHEMA' | 'SOLACE_ALL' | 'SOLACE_QUEUE_CONFIG' | 'SOLACE_QUEUE_LISTING' | 'SOLACE_SUBSCRIPTION_CONFIG'>;
    /**
     * The type of this payload, ema data collection.
     */
    readonly type?: string;
};

type EventManagementAgent = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The name of the EMA.
     */
    name: string;
    /**
     * The region in which the EMA belongs to, extracted from the EventManagementAgentRegion.
     */
    readonly region?: string;
    /**
     * The SMF username for a customer's EMA to use to communicate to event-portal.
     */
    readonly clientUsername?: string;
    /**
     * The SMF password for a customer's EMA to use to communicate to event-portal.
     */
    readonly clientPassword?: string;
    readonly referencedByMessagingServiceIds?: Array<string>;
    /**
     * Used by admin APIs to get a list of EMAs against the given orgId
     */
    readonly orgId?: string;
    /**
     * The connection status of EP to the actual EMA which this object represents.
     */
    readonly status?: string;
    /**
     * The timestamp of last heartbeat received from the EMA
     */
    readonly lastConnectedTime?: string;
    /**
     * The version of the current connected EMA
     */
    readonly version?: string;
    /**
     * The mode in which the EMA operates.
     */
    readonly runtimeAgentMode?: EventManagementAgent.runtimeAgentMode;
    /**
     * Does this EMA require upgrade to latest released version.
     */
    readonly updateRequired?: boolean;
    /**
     * The ID of the associated EventManagementAgentRegion.
     */
    eventManagementAgentRegionId?: string;
    readonly type?: string;
};
declare namespace EventManagementAgent {
    /**
     * The mode in which the EMA operates.
     */
    enum runtimeAgentMode {
        SCAN_WITH_EVENT_PORTAL = "scanWithEventPortal",
        UPLOAD_SCAN_FILE = "uploadScanFile"
    }
}

type EventManagementAgentRegion = {
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The id of the service from maas-core.
     */
    serviceId: string;
    /**
     * The name of the EventManagementAgentRegion.
     */
    name: string;
    /**
     * The name of the cloud provider.
     */
    cloudProvider: string;
    /**
     * The name of the region.
     */
    region: string;
    /**
     * The host name of the region.
     */
    host: string;
    /**
     * The name of the region's msgVpn.
     */
    msgVpn: string;
    /**
     * The SMF port number.
     */
    port?: number;
    readonly createdBy?: string;
    readonly updatedBy?: string;
    readonly createdTime?: string;
    readonly updatedTime?: string;
};

type EventManagementAgentRegionsResponse = {
    data?: Array<EventManagementAgentRegion>;
    meta?: meta;
};

type EventManagementAgentResponse = {
    data?: EventManagementAgent;
    meta?: Record<string, any>;
};

type EventManagementAgentRunCommand = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * The raw docker run command used to start the Event Management Agent.
     */
    readonly rawDockerRunCommand: string;
    /**
     * The formatted docker run command used to start the Event Management Agent.
     */
    readonly formattedDockerRunCommand: string;
    id?: string;
    type?: string;
};

type EventManagementAgentRunCommandResponse = {
    data?: EventManagementAgentRunCommand;
    meta?: meta;
};

type EventManagementAgentsResponse = {
    data?: Array<EventManagementAgent>;
    meta?: meta;
};

type EventMesh = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The name of the event mesh.
     */
    name?: string;
    /**
     * The environmentId of the Event Mesh
     */
    environmentId?: string;
    /**
     * The description of the event mesh.
     */
    description?: string;
    /**
     * The type of the broker used in the event mesh.
     */
    brokerType?: EventMesh.brokerType;
    /**
     * The type of this payload, eventMesh.
     */
    readonly type?: string;
};
declare namespace EventMesh {
    /**
     * The type of the broker used in the event mesh.
     */
    enum brokerType {
        KAFKA = "kafka",
        SOLACE = "solace"
    }
}

type EventMeshFrontEndDTO = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    environmentName?: string;
    id?: string;
    name?: string;
    environmentId?: string;
    description?: string;
    brokerType?: string;
    applicationVersionIds?: Array<string>;
    referencedByMessagingServiceIds?: Array<string>;
    type?: string;
};

type EventMeshesFrontEndResponse = {
    data?: Array<EventMeshFrontEndDTO>;
    meta?: Record<string, any>;
};

type EventMeshesResponse = {
    data?: Array<EventMesh>;
    meta?: meta;
};

type EventMeshFrontEndResponse = {
    data?: EventMeshFrontEndDTO;
    meta?: Record<string, any>;
};

type EventMeshResponse = {
    data?: EventMesh;
    meta?: Record<string, any>;
};

type EventResponse = {
    data?: Event;
    meta?: Record<string, any>;
};

type EventsResponse = {
    data?: Array<Event>;
    meta?: meta;
};

type EventV2KpiMetric = {
    id?: string;
    eventVersionId?: string;
    eventId?: string;
    eventName?: string;
    semanticVersion?: string;
    stateId?: string;
    shared?: boolean;
    consumerCount?: number;
    brokerType?: string;
    topicAddress?: string;
    type?: string;
};

type EventV2KpiMetricResponse = {
    data?: Array<EventV2KpiMetric>;
    meta?: meta;
};

type EventVersionFrontend = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    eventId: string;
    description?: string;
    version: string;
    displayName?: string;
    readonly declaredProducingApplicationVersionIds?: Array<string>;
    readonly declaredConsumingApplicationVersionIds?: Array<string>;
    readonly producingEventApiVersionIds?: Array<string>;
    readonly consumingEventApiVersionIds?: Array<string>;
    readonly attractingApplicationVersionIds?: Array<AttractingApplicationVersionTuple>;
    schemaVersionId?: string;
    schemaPrimitiveType?: EventVersionFrontend.schemaPrimitiveType;
    deliveryDescriptor?: DeliveryDescriptor;
    readonly stateId?: string;
    customAttributes?: Array<CustomAttribute>;
    readonly messagingServiceIds?: Array<string>;
    declaredProducingApplicationVersionIdsInEventMesh?: Array<string>;
    declaredConsumingApplicationVersionIdsInEventMesh?: Array<string>;
    parentName?: string;
    type?: string;
};
declare namespace EventVersionFrontend {
    enum schemaPrimitiveType {
        BOOLEAN = "BOOLEAN",
        BYTES = "BYTES",
        DOUBLE = "DOUBLE",
        FLOAT = "FLOAT",
        INT = "INT",
        LONG = "LONG",
        NULL = "NULL",
        NUMBER = "NUMBER",
        STRING = "STRING"
    }
}

type EventVersionResponse = {
    data?: EventVersion;
    meta?: Record<string, any>;
};

type EventVersionsFrontendResponse = {
    data?: Array<EventVersionFrontend>;
    meta?: meta;
};

type EventVersionsResponse = {
    data?: Array<EventVersion>;
    meta?: meta;
};

type GatewayMessagingService = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    id?: string;
    messagingServiceId?: string;
    eventApiProductVersionId?: string;
    supportedProtocols?: Array<'smfc' | 'smf' | 'smfs' | 'amqp' | 'amqps' | 'mqtt' | 'mqtts' | 'mqttws' | 'mqttwss' | 'secure-mqtt' | 'secure-mqttws' | 'rest' | 'rests'>;
    type?: string;
};

type GatewayMessagingServiceResponse = {
    data?: GatewayMessagingService;
    meta?: Record<string, any>;
};

type GraphEdgeDTO = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    id?: string;
    sourceId?: string;
    destinationId?: string;
    type?: string;
};

type GraphNodeExtendedAttributeDTO = {
    attributeName?: string;
    value?: string;
};

type GraphNodePosition = {
    xcoordinate?: number;
    ycoordinate?: number;
};

type GraphNodeReferenceDTO = {
    referenceId?: string;
    referenceType?: string;
};

type GraphNodeDTO = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    id?: string;
    graphModelId?: string;
    displayName?: string;
    position?: GraphNodePosition;
    nodeType?: string;
    references?: Array<GraphNodeReferenceDTO>;
    extendedAttributes?: Array<GraphNodeExtendedAttributeDTO>;
    type?: string;
};

type GraphNodeWrapperDTO = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    node?: GraphNodeDTO;
    edges?: Array<GraphEdgeDTO>;
    id?: string;
    type?: string;
};

type GraphModelDTO = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    id?: string;
    orgId?: string;
    name?: string;
    graphType?: string;
    context?: string;
    contextId?: string;
    nodes?: Array<GraphNodeWrapperDTO>;
    type?: string;
};

type GraphModelResponse = {
    data?: GraphModelDTO;
    meta?: Record<string, any>;
};

type GraphModelsResponse = {
    data?: Array<GraphModelDTO>;
    meta?: Record<string, any>;
};

type GraphNodeResponse = {
    data?: GraphNodeDTO;
    meta?: Record<string, any>;
};

type GraphNodesResponse = {
    data?: Array<GraphNodeWrapperDTO>;
    meta?: Record<string, any>;
};

type ImportActionPreviewResultDTO = {
    entityCount?: number;
    auditIds?: Array<string>;
    relatedDesignerEntityIds?: Array<string>;
};

type InvalidNonStateReference = {
    entityId?: string;
    entityType?: string;
};

type InvalidStateReference = (ErrorResponse & {
    targetStateId?: string;
    inboundInvalidNonStateReferences?: Array<InvalidNonStateReference>;
    inboundInvalidStateReferences?: Array<InvalidStateReference>;
    outboundInvalidStateReferences?: Array<InvalidStateReference>;
    errorType?: string;
});

type JobAdministrationDTO = {
    jobId?: string;
    orgId?: string;
    jobType?: string;
    status?: JobAdministrationDTO.status;
    loggingReason?: string;
    jobDetails?: string;
    createdTime?: string;
    updatedTime?: string;
    createdBy?: string;
    changedBy?: string;
    type?: string;
};
declare namespace JobAdministrationDTO {
    enum status {
        IN_PROGRESS = "in_progress",
        ERROR = "error",
        VALIDATION_ERROR = "validation_error",
        SUCCESS = "success"
    }
}

type JobType = {};

type JobBO = {
    id?: string;
    jobType?: JobType;
    status?: JobBO.status;
    details?: string;
    results?: string;
    error?: string;
    orgId?: string;
    createdTime?: number;
    updatedTime?: number;
    changedBy?: string;
    createdBy?: string;
};
declare namespace JobBO {
    enum status {
        IN_PROGRESS = "in_progress",
        ERROR = "error",
        VALIDATION_ERROR = "validation_error",
        SUCCESS = "success"
    }
}

type JobDTO = {
    id?: string;
    status?: JobDTO.status;
    jobType?: string;
    error?: any;
    results?: any;
    type?: string;
};
declare namespace JobDTO {
    enum status {
        IN_PROGRESS = "in_progress",
        ERROR = "error",
        VALIDATION_ERROR = "validation_error",
        SUCCESS = "success"
    }
}

type KafkaConsumerGroupAuditResultSetDTO = {
    aggregateAuditResult?: Audit;
    kafkaConsumerGroupAuditResults?: Array<Audit>;
    readonly id?: string;
    readonly type?: string;
};

type KafkaConsumerGroupAuditResultSetResponse = {
    data?: KafkaConsumerGroupAuditResultSetDTO;
    meta?: Record<string, any>;
};

type KafkaConsumerGroupAuditResultSetsResponse = {
    data?: Array<KafkaConsumerGroupAuditResultSetDTO>;
    meta?: meta;
};

type KafkaTopicSchemaVersionRelationAuditResultSet = {
    eventVersionId?: string;
    schemaVersionAudit?: Audit;
    kafkaTopicSchemaVersionRelationAudit?: Audit;
};

type KafkaTopicSchemaParentRelationAuditResultSet = {
    readonly eventId?: string;
    schemaParentAudit?: Audit;
    kafkaTopicSchemaParentRelationAudit?: Audit;
    kafkaTopicSchemaVersionRelationAuditResultSets?: Array<KafkaTopicSchemaVersionRelationAuditResultSet>;
};

type KafkaTopicAuditResultSet = {
    readonly eventIds?: Array<string>;
    aggregateAuditResult?: Audit;
    topicAudit?: Audit;
    kafkaTopicSchemaParentRelationAuditResultSets?: Array<KafkaTopicSchemaParentRelationAuditResultSet>;
    readonly id?: string;
    readonly type?: string;
};

type KafkaTopicAuditResultSetResponse = {
    data?: KafkaTopicAuditResultSet;
    meta?: meta;
};

type KafkaTopicAuditResultSetsResponse = {
    data?: Array<KafkaTopicAuditResultSet>;
    meta?: meta;
};

type KpiEventReuseMetricDTO = {
    sharedReuseIndex?: number;
    sharedTotalEvents?: number;
    sharedConsumerCount?: number;
    nonSharedReuseIndex?: number;
    nonSharedTotalEvents?: number;
    nonSharedConsumerCount?: number;
    brokerType?: string;
    id?: string;
    type?: string;
};

type KpiMetrics = {
    orgId?: string;
    applicationDomainId?: string;
    kafkaKpiMetrics?: KpiEventReuseMetricDTO;
    solaceKpiMetrics?: KpiEventReuseMetricDTO;
    id?: string;
    type?: string;
};

type KpiMetricsResponse = {
    data?: KpiMetrics;
    meta?: meta;
};

type LoadSampleOperationDTO = {
    sampleCollectionName?: LoadSampleOperationDTO.sampleCollectionName;
    sampleCollectionVersion?: LoadSampleOperationDTO.sampleCollectionVersion;
    environmentVariables?: Record<string, any>;
};
declare namespace LoadSampleOperationDTO {
    enum sampleCollectionName {
        KAFKA_ACME_SAMPLE = "kafka-acme-sample"
    }
    enum sampleCollectionVersion {
        V1 = "v1"
    }
}

type MergeApplicationVersionsDTO = {
    name: string;
    applicationDomainId: string;
    version: string;
    applicationVersionIds: Array<string>;
    smartMergeEnable?: boolean;
};

type MessagingServiceCredentials = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The ID of the authentication object associated to the credentials object.
     */
    readonly messagingServiceAuthenticationId?: string;
    /**
     * The name of the credentials object.
     */
    name: string;
    /**
     * A JSON map containing the credentials information.
     */
    credentials: Record<string, any>;
    readonly type?: string;
};

type MessagingServiceAuthentication = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The ID of the connection object associated to the authentication object.
     */
    readonly messagingServiceConnectionId?: string;
    /**
     * The name of the authentication object.
     */
    name: string;
    /**
     * The type of the authentication object.
     */
    authenticationType: string;
    /**
     * A JSON map containing a map of extra details for the authentication.
     */
    authenticationDetails?: Record<string, any>;
    messagingServiceCredentials?: Array<MessagingServiceCredentials>;
    readonly type?: string;
};

type MessagingServiceConnection = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The messagingServiceId associated to the connection object.
     */
    readonly messagingServiceId?: string;
    /**
     * The name of the connection object.
     */
    name?: string;
    /**
     * The url of the connection object.
     */
    url?: string;
    /**
     * The protocol of the connection object.
     */
    protocol?: string;
    /**
     * The protocolVersion of the connection object.
     */
    protocolVersion?: string;
    /**
     * A JSON map containing a map of connection-specific values.
     */
    bindings?: Record<string, any>;
    messagingServiceAuthentications?: Array<MessagingServiceAuthentication>;
    readonly type?: string;
};

type MessagingService = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The eventMeshId associated to the messaging service.
     */
    eventMeshId?: string;
    /**
     * The runtimeAgentId associated to the messaging service.
     */
    runtimeAgentId?: string;
    /**
     * The solaceCloudMessagingServiceId associated to the messaging service.
     */
    solaceCloudMessagingServiceId?: string;
    /**
     * The type of the messaging service.
     */
    messagingServiceType?: MessagingService.messagingServiceType;
    /**
     * The name of the messaging service.
     */
    name?: string;
    messagingServiceConnections?: Array<MessagingServiceConnection>;
    eventManagementAgentId?: string;
    readonly type?: string;
};
declare namespace MessagingService {
    /**
     * The type of the messaging service.
     */
    enum messagingServiceType {
        SOLACE = "solace",
        KAFKA = "kafka"
    }
}

type MessagingServiceAssociationDTO = {
    messagingServiceIds?: Array<string>;
};

type MessagingServiceAssociationResponse = {
    data?: MessagingServiceAssociationDTO;
    meta?: Record<string, any>;
};

/**
 * The list of authentication properties.
 */
type resourceAuthenticationProperties = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The property name.
     */
    name?: string;
    /**
     * The property value.
     */
    value?: string;
    /**
     * The authentication Id the property is associated to.
     */
    readonly authenticationDetailsId?: string;
    /**
     * The type of this payload, resourceAuthenticationProperties.
     */
    readonly type?: string;
};

/**
 * The list of credential operations.
 */
type ResourceCredentialOperationsBO = {
    orgId: string;
    createdTime?: number;
    updatedTime?: number;
    changedBy?: string;
    createdBy?: string;
    id?: string;
    name?: string;
    credentialDetailsId?: string;
    entityType?: string;
    key?: string;
};

/**
 * The list of credential properties.
 */
type ResourceCredentialPropertiesBO = {
    orgId: string;
    createdTime?: number;
    updatedTime?: number;
    changedBy?: string;
    createdBy?: string;
    id?: string;
    name?: string;
    value?: string;
    credentialDetailsId?: string;
    entityType?: string;
    key?: string;
};

/**
 * The list of credential details.
 */
type resourceCredentialDetails = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The credential source.
     */
    source?: string;
    /**
     * The authentication Id the credential object is associated to.
     */
    readonly authenticationDetailsId?: string;
    properties?: Array<ResourceCredentialPropertiesBO>;
    operations?: Array<ResourceCredentialOperationsBO>;
    /**
     * The type of this payload, resourceCredentialDetails.
     */
    readonly type?: string;
};

/**
 * The list of connection authentications.
 */
type resourceAuthenticationDetails = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The authentication protocol.
     */
    protocol?: string;
    /**
     * The authentication protocol version.
     */
    protocolVersion?: string;
    /**
     * The connection Id that the authentication object is associated to.
     */
    readonly connectionDetailsId?: string;
    properties?: Array<resourceAuthenticationProperties>;
    credentials?: Array<resourceCredentialDetails>;
    /**
     * The type of this payload, resourceAuthenticationDetails.
     */
    readonly type?: string;
};

/**
 * The list of connection properties.
 */
type resourceConnectionProperties = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The property name.
     */
    name?: string;
    /**
     * The property value.
     */
    value?: string;
    /**
     * The connection Id the property is associated to.
     */
    readonly connectionDetailsId?: string;
    /**
     * The type of this payload, resourceConnectionProperties.
     */
    readonly type?: string;
};

type resourceConnectionDetails = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The id of the resource the connection object is associated to.
     */
    readonly resourceId?: string;
    /**
     * The type of the resource the connection object is associated to.
     */
    readonly resourceType?: resourceConnectionDetails.resourceType;
    /**
     * The name of the connection object.
     */
    name: string;
    /**
     * The url of the connection object.
     */
    url?: string;
    properties?: Array<resourceConnectionProperties>;
    authentications?: Array<resourceAuthenticationDetails>;
    /**
     * The type of this payload, resourceConnection.
     */
    readonly type?: string;
};
declare namespace resourceConnectionDetails {
    /**
     * The type of the resource the connection object is associated to.
     */
    enum resourceType {
        SCHEMA = "schema"
    }
}

type SchemaRegistry = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The type of the Schema Registry.
     */
    schemaRegistryType?: SchemaRegistry.schemaRegistryType;
    /**
     * The type of the broker used in the event mesh.
     */
    brokerType?: SchemaRegistry.brokerType;
    messagingServiceIds?: Array<string>;
    connections?: Array<resourceConnectionDetails>;
    /**
     * The type of this payload, schemaRegistry.
     */
    readonly type?: string;
};
declare namespace SchemaRegistry {
    /**
     * The type of the Schema Registry.
     */
    enum schemaRegistryType {
        CONFLUENT = "confluent"
    }
    /**
     * The type of the broker used in the event mesh.
     */
    enum brokerType {
        KAFKA = "kafka"
    }
}

type MessagingServiceFrontEndDTO = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The eventMeshId associated to the messaging service.
     */
    eventMeshId?: string;
    /**
     * The runtimeAgentId associated to the messaging service.
     */
    runtimeAgentId?: string;
    /**
     * The solaceCloudMessagingServiceId associated to the messaging service.
     */
    solaceCloudMessagingServiceId?: string;
    /**
     * The type of the messaging service.
     */
    messagingServiceType?: MessagingServiceFrontEndDTO.messagingServiceType;
    /**
     * The name of the messaging service.
     */
    name?: string;
    messagingServiceConnections?: Array<MessagingServiceConnection>;
    schemaRegistriesToCreate?: Array<SchemaRegistry>;
    schemaRegistriesToUpdate?: Array<SchemaRegistry>;
    schemaRegistriesToDissociate?: Array<string>;
    readonly type?: string;
    eventManagementAgentId?: string;
};
declare namespace MessagingServiceFrontEndDTO {
    /**
     * The type of the messaging service.
     */
    enum messagingServiceType {
        SOLACE = "solace",
        KAFKA = "kafka"
    }
}

type MessagingServiceInfoDTO = {
    name?: string;
    eventMeshId?: string;
    id?: string;
    type?: string;
};

type MessagingServiceOperation = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    scanTypes: Array<'KAFKA_ALL' | 'CONFLUENT_SCHEMA_REGISTRY_SCHEMA' | 'SOLACE_ALL'>;
    destinations?: Array<'EVENT_PORTAL' | 'FILE_WRITER'>;
    readonly type?: string;
};

type MessagingServiceOperationResponse = {
    data?: MessagingServiceOperation;
    meta?: Record<string, any>;
};

type MessagingServiceRemoveAssociation = {
    /**
     * The target association to be removed from the messaging service.
     */
    association?: MessagingServiceRemoveAssociation.association;
};
declare namespace MessagingServiceRemoveAssociation {
    /**
     * The target association to be removed from the messaging service.
     */
    enum association {
        RUNTIME_AGENT = "RUNTIME_AGENT",
        EVENT_MESH = "EVENT_MESH",
        EVENT_MANAGEMENT_AGENT = "EVENT_MANAGEMENT_AGENT"
    }
}

type MessagingServiceResponse = {
    data?: MessagingService;
    meta?: Record<string, any>;
};

type MessagingServiceScan = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The status of the messaging service scan.
     */
    readonly status?: string;
    /**
     * The description of the messaging service scan status.
     */
    readonly statusDescription?: string;
    /**
     * The messagingServiceId of the scan.
     */
    readonly messagingServiceId?: string;
    /**
     * The messagingServiceName of the scan.
     */
    readonly messagingServiceName?: string;
    /**
     * The scanTypes that were requested for the scan.
     */
    readonly scanTypes?: string;
    /**
     * The destinations which EMA will send the scan results.
     */
    readonly destinations?: string;
    /**
     * Whether the scan is used by audit.
     */
    readonly isUsedByAudit?: boolean;
    readonly type?: string;
};

type MessagingServiceScanData = {
    readonly createdTime?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The ID of the scan.
     */
    readonly scanId?: string;
    /**
     * The type of dataCollection this object holds scan data for.
     */
    readonly dataCollectionType?: MessagingServiceScanData.dataCollectionType;
    /**
     * The scan data in JSON format.
     */
    readonly data?: string;
    readonly type?: string;
};
declare namespace MessagingServiceScanData {
    /**
     * The type of dataCollection this object holds scan data for.
     */
    enum dataCollectionType {
        BROKER_CONFIGURATION = "brokerConfiguration",
        CLUSTER_CONFIGURATION = "clusterConfiguration",
        CONSUMER_GROUPS = "consumerGroups",
        CONSUMER_GROUP_CONFIGURATION = "consumerGroupConfiguration",
        OVERRIDE_TOPIC_CONFIGURATION = "overrideTopicConfiguration",
        QUEUE_CONFIGURATION = "queueConfiguration",
        QUEUE_LISTING = "queueListing",
        SCHEMA = "schema",
        SUBSCRIPTION_CONFIGURATION = "subscriptionConfiguration",
        TOPIC_CONFIGURATION = "topicConfiguration",
        TOPIC_LISTING = "topicListing"
    }
}

type MessagingServiceScanDataListResponse = {
    data?: Array<MessagingServiceScanData>;
    meta?: meta;
};

type MessagingServiceScanDataResponse = {
    data?: MessagingServiceScanData;
    meta?: Record<string, any>;
};

type MessagingServiceScanLog = {
    readonly createdTime?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The ID of the scan.
     */
    readonly scanId?: string;
    /**
     * The log message.
     */
    readonly log?: string;
    /**
     * The level of the log message.
     */
    readonly logLevel?: string;
    readonly type?: string;
};

type MessagingServiceScanLogListResponse = {
    data?: Array<MessagingServiceScanLog>;
    meta?: meta;
};

type MessagingServiceScanResponse = {
    data?: MessagingServiceScan;
    meta?: Record<string, any>;
};

type MessagingServiceScansResponse = {
    data?: Array<MessagingServiceScan>;
    meta?: meta;
};

type MessagingServicesInfoResponse = {
    data?: Array<MessagingServiceInfoDTO>;
    meta?: meta;
};

type MessagingServicesResponse = {
    data?: Array<MessagingService>;
    meta?: meta;
};

type OperationDTO = {
    id?: string;
    operationType?: string;
    createdBy?: string;
    createdTime?: string;
    completedTime?: string;
    status?: OperationDTO.status;
    results?: any;
    error?: any;
};
declare namespace OperationDTO {
    enum status {
        IN_PROGRESS = "in_progress",
        ERROR = "error",
        VALIDATION_ERROR = "validation_error",
        SUCCESS = "success"
    }
}

type OperationResponse = {
    data?: OperationDTO;
    meta?: Record<string, any>;
};

type OrgStats = {
    readonly schemaCount?: number;
    readonly schemaVersionCount?: number;
    readonly eventCount?: number;
    readonly eventVersionCount?: number;
    readonly applicationCount?: number;
    readonly applicationVersionCount?: number;
    readonly applicationDomainCount?: number;
    readonly eventApiCount?: number;
    readonly eventApiVersionCount?: number;
    readonly subscriptionCount?: number;
    readonly consumerCount?: number;
    readonly enumCount?: number;
    readonly enumVersionCount?: number;
    readonly enumValueCount?: number;
    readonly eventApiProductCount?: number;
    readonly eventApiProductVersionCount?: number;
    readonly publishedEventApiProductVersionCount?: number;
    readonly environmentCount?: number;
    readonly eventMeshCount?: number;
    readonly applicationVersionsInEventMeshesCount?: number;
    readonly customAttributeDefinitionCount?: number;
    readonly customAttributeCount?: number;
    readonly configurationCount?: number;
    readonly sumUniqueEventsInEachEnvironmentCount?: number;
    readonly sumUniqueSchemasInEachEnvironmentCount?: number;
    readonly sumUniqueApplicationsInEachEnvironmentCount?: number;
    readonly messageServiceCount?: number;
    readonly caGlobalDefParentCount?: number;
    readonly caGlobalParentValueCount?: number;
    readonly caGlobalDefVersionCount?: number;
    readonly caGlobalVersionValueCount?: number;
    readonly caAppDomainScopedDefParentCount?: number;
    readonly caAppDomainScopedParentValueCount?: number;
    readonly caAppDomainScopedDefVersionCount?: number;
    readonly caAppDomainScopedVersionValueCount?: number;
    readonly caAppDomainScopedAppDomainValueCount?: number;
    readonly caAppDomainScopedAppDomainDefCount?: number;
    readonly caGlobalAppDomainValueCount?: number;
    readonly caGlobalAppDomainDefCount?: number;
};

type OrgDTO = {
    id?: string;
    eventPortalAccessEnabled?: boolean;
    topicAddressResourcesAccessEnabled?: boolean;
    createdTime?: number;
    updatedTime?: number;
    objectLimit?: number;
    objectVersionLimit?: number;
    applicationDomainLimit?: number;
    eventMeshLimit?: number;
    eventApiLimit?: number;
    eventApiProductLimit?: number;
    consumerLimit?: number;
    topicDomainLimitPerApplicationDomain?: number;
    enumLimit?: number;
    enumValueLimit?: number;
    messagingServiceLimit?: number;
    configurationLimit?: number;
    subscriptionLimit?: number;
    subscriptionPerApplicationVersionLimit?: number;
    graphNodeLimit?: number;
    applicationDomainGraphNodeLimit?: number;
    schemaRegistryLimit?: number;
    objectRelationshipVisualizationLimit?: number;
    productTier?: OrgDTO.productTier;
    organizationType?: OrgDTO.organizationType;
    stats?: OrgStats;
    type?: string;
};
declare namespace OrgDTO {
    enum productTier {
        NONE = "None",
        STANDARD = "Standard",
        SMALL = "Small",
        MEDIUM = "Medium",
        LARGE = "Large",
        EXTRA_LARGE = "Extra Large",
        CUSTOM = "Custom"
    }
    enum organizationType {
        ENTERPRISE = "enterprise"
    }
}

type OrgsResponse = {
    data?: Array<OrgDTO>;
    meta?: Record<string, any>;
};

type ResourceConnectionResponse = {
    data?: Array<resourceConnectionDetails>;
    meta?: Record<string, any>;
};

type ResponseAuditResultStatsDTO = {
    data?: AuditResultStatsDTO;
    meta?: Record<string, any>;
};

type ResponseJobDTO = {
    data?: JobDTO;
    meta?: Record<string, any>;
};

type ResponseOrgDTO = {
    data?: OrgDTO;
    meta?: Record<string, any>;
};

type RuntimeImportAllResponseDTO = {
    jobURIs?: Array<string>;
};

type ResponseRuntimeImportAllResponseDTO = {
    data?: RuntimeImportAllResponseDTO;
    meta?: Record<string, any>;
};

type RuntimeAgentFrontEndDTO = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The name of the EMA.
     */
    name: string;
    /**
     * The region in which the EMA belongs to, extracted from the EventManagementAgentRegion.
     */
    readonly region?: string;
    /**
     * The SMF username for a customer's EMA to use to communicate to event-portal.
     */
    readonly clientUsername?: string;
    /**
     * The SMF password for a customer's EMA to use to communicate to event-portal.
     */
    readonly clientPassword?: string;
    readonly referencedByMessagingServiceIds?: Array<string>;
    /**
     * Used by admin APIs to get a list of EMAs against the given orgId
     */
    readonly orgId?: string;
    /**
     * The connection status of EP to the actual EMA which this object represents.
     */
    readonly status?: string;
    /**
     * The timestamp of last heartbeat received from the EMA
     */
    readonly lastConnectedTime?: string;
    /**
     * The version of the current connected EMA
     */
    readonly version?: string;
    /**
     * The mode in which the EMA operates.
     */
    readonly runtimeAgentMode?: RuntimeAgentFrontEndDTO.runtimeAgentMode;
    /**
     * Does this EMA require upgrade to latest released version.
     */
    readonly updateRequired?: boolean;
    messagingServicesToUpdate?: Array<string>;
    messagingServicesToCreate?: Array<MessagingService>;
    messagingServicesToDisassociate?: Array<string>;
    readonly type?: string;
    /**
     * The ID of the associated EventManagementAgentRegion.
     */
    eventManagementAgentRegionId?: string;
};
declare namespace RuntimeAgentFrontEndDTO {
    /**
     * The mode in which the EMA operates.
     */
    enum runtimeAgentMode {
        SCAN_WITH_EVENT_PORTAL = "scanWithEventPortal",
        UPLOAD_SCAN_FILE = "uploadScanFile"
    }
}

type RuntimeAgentOperationDTO = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    id?: string;
    runtimeAgentId?: string;
    messagingServiceId?: string;
    scanType?: string;
    entityTypes?: Array<string>;
    type?: string;
};

type RuntimeAgentOperationResponse = {
    data?: RuntimeAgentOperationDTO;
    meta?: Record<string, any>;
};

type RuntimeAgentRegionInternalDTO = {
    /**
     * Primary key set by the server.
     */
    readonly id?: string;
    /**
     * The id of the service from maas-core.
     */
    serviceId: string;
    /**
     * The name of the EventManagementAgentRegion.
     */
    name: string;
    /**
     * The name of the cloud provider.
     */
    cloudProvider: string;
    /**
     * The name of the region.
     */
    region: string;
    /**
     * The host name of the region.
     */
    host: string;
    /**
     * The name of the region's msgVpn.
     */
    msgVpn: string;
    /**
     * The SMF port number.
     */
    port?: number;
    readonly createdBy?: string;
    readonly updatedBy?: string;
    readonly createdTime?: string;
    readonly updatedTime?: string;
    sempPort?: number;
    clientUsername: string;
    clientPassword: string;
    sempUsername: string;
    sempPassword: string;
    clientProfileName?: string;
};

type RuntimeAgentRegionInternalResponse = {
    data?: RuntimeAgentRegionInternalDTO;
    meta?: Record<string, any>;
};

type RuntimeAgentRegionInternalsResponse = {
    data?: Array<RuntimeAgentRegionInternalDTO>;
    meta?: Record<string, any>;
};

type RuntimeImportFiltersDTO = {
    auditStatus?: RuntimeImportFiltersDTO.auditStatus;
    nameContains?: string;
    eventBrokerId?: string;
    tags?: Array<'To Be Created' | 'To Be Deleted'>;
    hidden?: boolean;
    eventMeshId?: string;
    auditEntityType?: RuntimeImportFiltersDTO.auditEntityType;
    excludedAuditIds?: Array<string>;
    sort?: string;
};
declare namespace RuntimeImportFiltersDTO {
    enum auditStatus {
        DESIGNER_ONLY = "designerOnly",
        MATCH = "match",
        PARTIAL_MATCH = "partialMatch",
        RUNTIME_ONLY = "runtimeOnly"
    }
    enum auditEntityType {
        ALL = "all",
        KAFKA_CONSUMER_GROUP = "kafkaConsumerGroup",
        KAFKA_CONSUMER_GROUP_AGGREGATE = "kafkaConsumerGroupAggregate",
        KAFKA_TOPIC = "kafkaTopic",
        KAFKA_TOPIC_AGGREGATE = "kafkaTopicAggregate",
        SCHEMA_PARENT = "schemaParent",
        SCHEMA_VERSION = "schemaVersion",
        SOLACE_QUEUE = "solaceQueue",
        SOLACE_QUEUE_AGGREGATE = "solaceQueueAggregate",
        SOLACE_TOPIC = "solaceTopic",
        KAFKA_TOPIC_SCHEMA_VERSION = "kafkaTopicSchemaVersion",
        KAFKA_TOPIC_SCHEMA_PARENT = "kafkaTopicSchemaParent"
    }
}

type RuntimeImportAllDTO = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    properties?: Record<string, string>;
    auditImportAction?: RuntimeImportAllDTO.auditImportAction;
    filters?: RuntimeImportFiltersDTO;
    aggregationStrategy?: RuntimeImportAllDTO.aggregationStrategy;
    id?: string;
    type?: string;
};
declare namespace RuntimeImportAllDTO {
    enum auditImportAction {
        UPDATE_EXISTING_PARENT = "updateExistingParent",
        UPDATE_EXISTING_VERSION = "updateExistingVersion",
        CREATE_NEW_PARENT = "createNewParent",
        CREATE_NEW_VERSION = "createNewVersion",
        ADD_TO_EXISTING_VERSION = "addToExistingVersion"
    }
    enum aggregationStrategy {
        ALL_AUDIT_RESULTS_TO_ONE_PARENT = "ALL_AUDIT_RESULTS_TO_ONE_PARENT",
        ONE_AUDIT_RESULT_PER_PARENT = "ONE_AUDIT_RESULT_PER_PARENT",
        AUDIT_RESULTS_GROUPED_BY_PARENT = "AUDIT_RESULTS_GROUPED_BY_PARENT"
    }
}

type RuntimeImportPreviewDTO = {
    auditIds?: Array<string>;
};

type SchemaImportPreviewDTO = {
    createNewParent?: ImportActionPreviewResultDTO;
    updateExistingParent?: ImportActionPreviewResultDTO;
    additionalCreateNewParentAuditIds?: Array<string>;
    additionalUpdateExistingParentAuditIds?: Array<string>;
};

type SchemaImportPreviewResponse = {
    data?: SchemaImportPreviewDTO;
    meta?: Record<string, any>;
};

type SchemaRegistriesResponse = {
    data?: Array<SchemaRegistry>;
    meta?: meta;
};

type SchemaRegistryResponse = {
    data?: SchemaRegistry;
    meta?: Record<string, any>;
};

type SchemaResponse = {
    data?: SchemaObject;
    meta?: Record<string, any>;
};

type SchemasResponse = {
    data?: Array<SchemaObject>;
    meta?: meta;
};

type SchemaVersionFrontEnd = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    schemaId: string;
    description?: string;
    version: string;
    displayName?: string;
    content?: string;
    readonly referencedByEventVersionIds?: Array<string>;
    readonly referencedBySchemaVersionIds?: Array<string>;
    schemaVersionReferences?: Array<SchemaVersionReferenceDTO>;
    customAttributes?: Array<CustomAttribute>;
    readonly stateId?: string;
    referencedByEventVersionIdsInEventMesh?: Array<string>;
    parentName?: string;
    readonly type?: string;
};

type SchemaVersionResponse = {
    data?: SchemaVersion;
    meta?: Record<string, any>;
};

type SchemaVersionsFrontEndResponse = {
    data?: Array<SchemaVersionFrontEnd>;
    meta?: meta;
};

type SchemaVersionsResponse = {
    data?: Array<SchemaVersion>;
    meta?: meta;
};

type SolaceQueueAuditResultSetDTO = {
    aggregateAuditResult?: Audit;
    solaceQueueAuditResults?: Array<Audit>;
    readonly id?: string;
    readonly type?: string;
};

type SolaceQueueAggregateResponse = {
    data?: SolaceQueueAuditResultSetDTO;
    meta?: Record<string, any>;
};

type SolaceQueueAuditResultSetsResponse = {
    data?: Array<SolaceQueueAuditResultSetDTO>;
    meta?: meta;
};

type VersionedObjectStateChangeRequest = {
    stateId?: string;
};

type StateChangeRequestResponse = {
    data?: VersionedObjectStateChangeRequest;
    meta?: Record<string, any>;
};

type StateDTO = {
    id?: string;
    description?: string;
    name?: string;
    stateOrder?: number;
    type?: string;
};

type StatesResponse = {
    data?: Array<StateDTO>;
    meta?: Record<string, any>;
};

type StitchedEventVersionIdResultDTO = {
    eventVersionId?: string;
    eventMeshIds?: Array<string>;
};

type SubscriptionStitchingEvalRequestDTO = {
    brokerType: string;
    subscriptions?: Array<Subscription>;
};

type SuggestedAddressLevelDTO = {
    name: string;
    addressLevelType: SuggestedAddressLevelDTO.addressLevelType;
    enumVersionId?: string;
    enumVersion?: TopicAddressEnumVersion;
};
declare namespace SuggestedAddressLevelDTO {
    enum addressLevelType {
        LITERAL = "literal",
        VARIABLE = "variable"
    }
}

type SuggestionApiInputDTO = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    readonly id?: string;
    addressLevels: Array<AddressLevel>;
    brokerType?: string;
    addressType?: SuggestionApiInputDTO.addressType;
    type?: string;
};
declare namespace SuggestionApiInputDTO {
    enum addressType {
        TOPIC = "topic"
    }
}

type TagEntityAssociationsObject = {
    tagId: string;
    entityType: string;
    entitiesToAssociate?: Array<string>;
    entitiesToDisassociate?: Array<string>;
};

type TagAssociationsObject = {
    tags: Array<TagEntityAssociationsObject>;
};

type TagResponse = {
    data?: Tag;
    meta?: Record<string, any>;
};

type tagsResponse = {
    data?: Array<Tag>;
    meta?: meta;
};

type ToggleInfoDTO = {
    id: string;
    type?: string;
    description?: string;
    defaultValue?: boolean;
};

type ToggleOrgInfoDTO = {
    id: string;
    description?: string;
    enabled?: boolean;
};

type ToggleOrgInfoListResponse = {
    data?: Array<ToggleOrgInfoDTO>;
    meta?: Record<string, any>;
};

type ToggleOverrideDTO = {
    id: string;
    readonly type?: string;
    orgId?: string;
    enabled?: boolean;
};

type ToggleOverrideListResponse = {
    data?: Array<ToggleOverrideDTO>;
    meta?: Record<string, any>;
};

type TogglesInfoResponse = {
    data?: Array<ToggleInfoDTO>;
    meta?: Record<string, any>;
};

type ToggleStatusDTO = {
    id: string;
    enabled: boolean;
};

type ToggleStatusListResponse = {
    data?: Array<ToggleStatusDTO>;
    meta?: Record<string, any>;
};

type TopicAddressEnumResponse = {
    data?: TopicAddressEnum;
    meta?: Record<string, any>;
};

type TopicAddressEnumsResponse = {
    data?: Array<TopicAddressEnum>;
    meta?: meta;
};

type TopicAddressEnumVersionResponse = {
    data?: TopicAddressEnumVersion;
    meta?: Record<string, any>;
};

type TopicAddressEnumVersionsResponse = {
    data?: Array<TopicAddressEnumVersion>;
    meta?: meta;
};

type TopicAddressResourceDTO = {
    readonly createdTime?: string;
    readonly updatedTime?: string;
    readonly createdBy?: string;
    readonly changedBy?: string;
    id?: string;
    applicationDomainId?: string;
    name?: string;
    resource?: string;
    description?: string;
    type?: string;
};

type TopicAddressResourceResponse = {
    data?: TopicAddressResourceDTO;
    meta?: Record<string, any>;
};

type TopicAddressResourcesResponse = {
    data?: Array<TopicAddressResourceDTO>;
    meta?: Record<string, any>;
};

type TopicAggregateImportPreviewDTO = {
    createNewParent?: ImportActionPreviewResultDTO;
    updateExistingParent?: ImportActionPreviewResultDTO;
    referencedSchemaImportPreview?: SchemaImportPreviewDTO;
};

type TopicAggregateImportPreviewResponse = {
    data?: TopicAggregateImportPreviewDTO;
    meta?: Record<string, any>;
};

type TopicDomainAnalysisDTO = {
    presentInOtherApplicationDomains?: boolean;
    otherApplicationDomainCount?: number;
    otherEntitledApplicationDomains?: Array<ApplicationDomain>;
};

type TopicDomainResponse = {
    data?: TopicDomain;
    meta?: Record<string, any>;
};

type TopicDomainsResponse = {
    data?: Array<TopicDomain>;
    meta?: meta;
};

declare const $Address: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly addressLevels: {
            readonly type: "array";
            readonly contains: {
                readonly type: "AddressLevel";
            };
            readonly isRequired: true;
        };
        readonly addressType: {
            readonly type: "Enum";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $AddressLevel: {
    readonly properties: {
        readonly name: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly addressLevelType: {
            readonly type: "Enum";
            readonly isRequired: true;
        };
        readonly enumVersionId: {
            readonly type: "string";
        };
    };
};

declare const $AddressSpace: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly brokerType: {
            readonly type: "string";
        };
        readonly delimiter: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $AddressSpaceResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "AddressSpace";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $AddressSpacesResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "AddressSpace";
            };
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $Application: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly isRequired: true;
            readonly maxLength: 255;
            readonly minLength: 1;
        };
        readonly applicationType: {
            readonly type: "string";
            readonly isRequired: true;
            readonly maxLength: 255;
            readonly minLength: 1;
        };
        readonly brokerType: {
            readonly type: "Enum";
            readonly isRequired: true;
        };
        readonly applicationDomainId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly numberOfVersions: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly customAttributes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttribute";
            };
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $ApplicationChangeRequestPreviewResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "ApplicationDeploymentPreviewDTO";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $ApplicationConfigPushJobResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "ApplicationConfigurationPushJob";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $ApplicationConfigurationPushJob: {
    readonly properties: {
        readonly id: {
            readonly type: "string";
        };
        readonly eventBrokerId: {
            readonly type: "string";
        };
        readonly applicationId: {
            readonly type: "string";
        };
        readonly runtimeEntityConfigurations: {
            readonly type: "array";
            readonly contains: {
                readonly type: "RuntimeEntityConfiguration";
            };
        };
        readonly sourceType: {
            readonly type: "Enum";
        };
        readonly sourceId: {
            readonly type: "string";
        };
        readonly requestMetadata: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
        readonly status: {
            readonly type: "Enum";
        };
        readonly createdTime: {
            readonly type: "string";
        };
        readonly errorDescription: {
            readonly type: "string";
        };
        readonly updatedTime: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
        readonly isRemoval: {
            readonly type: "boolean";
        };
    };
};

declare const $ApplicationDeployment: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly applicationVersionId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly action: {
            readonly type: "Enum";
            readonly isRequired: true;
        };
        readonly eventBrokerId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly id: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $ApplicationDeploymentPreviewDTO: {
    readonly properties: {
        readonly requested: {
            readonly type: "array";
            readonly contains: {
                readonly type: "PreviewEntityConfigurationDTO";
            };
        };
        readonly existing: {
            readonly type: "array";
            readonly contains: {
                readonly type: "PreviewEntityConfigurationDTO";
            };
        };
    };
};

declare const $ApplicationDomain: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly isRequired: true;
            readonly maxLength: 255;
            readonly minLength: 1;
        };
        readonly description: {
            readonly type: "string";
            readonly maxLength: 10000;
        };
        readonly uniqueTopicAddressEnforcementEnabled: {
            readonly type: "boolean";
            readonly description: "Forces all topic addresses within the application domain to be unique.";
        };
        readonly topicDomainEnforcementEnabled: {
            readonly type: "boolean";
            readonly description: "Forces all topic addresses within the application domain to be prefixed with one of the application domain’s configured topic domains.";
        };
        readonly stats: {
            readonly type: "ApplicationDomainStats";
        };
        readonly customAttributes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttribute";
            };
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $ApplicationDomainExportDTO: {
    readonly properties: {
        readonly formatVersion: {
            readonly type: "string";
        };
        readonly applicationDomains: {
            readonly type: "array";
            readonly contains: {
                readonly type: "ApplicationDomain";
            };
        };
        readonly topicDomains: {
            readonly type: "array";
            readonly contains: {
                readonly type: "TopicDomain";
            };
        };
        readonly applications: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Application";
            };
        };
        readonly applicationVersions: {
            readonly type: "array";
            readonly contains: {
                readonly type: "ApplicationVersion";
            };
        };
        readonly events: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Event";
            };
        };
        readonly eventVersions: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventVersion";
            };
        };
        readonly schemas: {
            readonly type: "array";
            readonly contains: {
                readonly type: "SchemaObject";
            };
        };
        readonly schemaVersions: {
            readonly type: "array";
            readonly contains: {
                readonly type: "SchemaVersion";
            };
        };
        readonly enums: {
            readonly type: "array";
            readonly contains: {
                readonly type: "TopicAddressEnum";
            };
        };
        readonly enumVersions: {
            readonly type: "array";
            readonly contains: {
                readonly type: "TopicAddressEnumVersion";
            };
        };
        readonly eventApis: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventApi";
            };
        };
        readonly eventApiVersions: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventApiVersion";
            };
        };
        readonly eventApiProducts: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventApiProduct";
            };
        };
        readonly eventApiProductVersions: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventApiProductVersion";
            };
        };
        readonly addressSpaces: {
            readonly type: "array";
            readonly contains: {
                readonly type: "AddressSpace";
            };
        };
        readonly customAttributeDefinitions: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttributeDefinition";
            };
        };
    };
};

declare const $ApplicationDomainImportDTO: {
    readonly properties: {
        readonly formatVersion: {
            readonly type: "string";
        };
        readonly applicationDomains: {
            readonly type: "array";
            readonly contains: {
                readonly type: "ApplicationDomain";
            };
        };
        readonly topicDomains: {
            readonly type: "array";
            readonly contains: {
                readonly type: "TopicDomain";
            };
        };
        readonly applications: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Application";
            };
        };
        readonly applicationVersions: {
            readonly type: "array";
            readonly contains: {
                readonly type: "ApplicationVersion";
            };
        };
        readonly events: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Event";
            };
        };
        readonly eventVersions: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventVersion";
            };
        };
        readonly schemas: {
            readonly type: "array";
            readonly contains: {
                readonly type: "SchemaObject";
            };
        };
        readonly schemaVersions: {
            readonly type: "array";
            readonly contains: {
                readonly type: "SchemaVersion";
            };
        };
        readonly enums: {
            readonly type: "array";
            readonly contains: {
                readonly type: "TopicAddressEnum";
            };
        };
        readonly enumVersions: {
            readonly type: "array";
            readonly contains: {
                readonly type: "TopicAddressEnumVersion";
            };
        };
        readonly eventApis: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventApi";
            };
        };
        readonly eventApiVersions: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventApiVersion";
            };
        };
        readonly eventApiProducts: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventApiProduct";
            };
        };
        readonly eventApiProductVersions: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventApiProductVersion";
            };
        };
        readonly addressSpaces: {
            readonly type: "array";
            readonly contains: {
                readonly type: "AddressSpace";
            };
        };
        readonly customAttributeDefinitions: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttributeDefinition";
            };
        };
    };
};

declare const $ApplicationDomainResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "ApplicationDomain";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $ApplicationDomainsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "ApplicationDomain";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $ApplicationDomainStats: {
    readonly properties: {
        readonly schemaCount: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly eventCount: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly applicationCount: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly enumCount: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly eventApiCount: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly eventApiProductCount: {
            readonly type: "number";
            readonly format: "int32";
        };
    };
    readonly isReadOnly: true;
};

declare const $ApplicationRegistration: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly applicationDomainId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly registrationId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly applicationId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly isRequired: true;
            readonly maxLength: 60;
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly customAttributes: {
            readonly type: "dictionary";
            readonly contains: {
                readonly type: "string";
            };
        };
    };
};

declare const $ApplicationRegistrationResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "ApplicationRegistration";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $ApplicationRegistrationsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "ApplicationRegistration";
            };
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $ApplicationResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "Application";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $ApplicationsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Application";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $ApplicationVersion: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly applicationId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly description: {
            readonly type: "string";
            readonly maxLength: 10000;
        };
        readonly version: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly displayName: {
            readonly type: "string";
            readonly maxLength: 40;
        };
        readonly declaredProducedEventVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly declaredConsumedEventVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly declaredEventApiProductVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly stateId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly consumers: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Consumer";
            };
            readonly isReadOnly: true;
        };
        readonly customAttributes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttribute";
            };
        };
        readonly messagingServiceIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $ApplicationVersionFrontendDTO: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly applicationId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly description: {
            readonly type: "string";
            readonly maxLength: 10000;
        };
        readonly version: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly displayName: {
            readonly type: "string";
            readonly maxLength: 40;
        };
        readonly declaredProducedEventVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly declaredConsumedEventVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly declaredEventApiProductVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly stateId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly consumers: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Consumer";
            };
            readonly isReadOnly: true;
        };
        readonly customAttributes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttribute";
            };
        };
        readonly messagingServiceIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly parentName: {
            readonly type: "string";
        };
        readonly clientProfileName: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $ApplicationVersionFrontendResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "ApplicationVersionFrontendDTO";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $ApplicationVersionResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "ApplicationVersion";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $ApplicationVersionsFrontendResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "ApplicationVersionFrontendDTO";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $ApplicationVersionsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "ApplicationVersion";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $AssociatedEntity: {
    readonly properties: {
        readonly entityType: {
            readonly type: "string";
        };
        readonly applicationDomainIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
    };
};

declare const $AttractedEventVersionTuple: {
    readonly properties: {
        readonly eventVersionId: {
            readonly type: "string";
        };
        readonly eventMeshIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
    };
    readonly isReadOnly: true;
};

declare const $AttractingApplicationVersionTuple: {
    readonly properties: {
        readonly applicationVersionId: {
            readonly type: "string";
        };
        readonly eventMeshIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
    };
    readonly isReadOnly: true;
};

declare const $Audit: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly messagingServiceId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly auditEntityType: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly messagingServiceName: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly identifier: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly status: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly designerMappingId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly designerMappingAssociationId: {
            readonly type: "string";
            readonly isReadOnly: true;
            readonly format: "uuid";
        };
        readonly runtimeMappingId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly runtimeMappingAssociationId: {
            readonly type: "string";
            readonly isReadOnly: true;
            readonly format: "uuid";
        };
        readonly designerMapping: {
            readonly type: "DesignerMappingDTO";
        };
        readonly runtimeMapping: {
            readonly type: "RuntimeMappingDTO";
        };
        readonly associatedTags: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Tag";
            };
        };
        readonly schemaType: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
    };
    readonly isReadOnly: true;
};

declare const $AuditCommandDTO: {
    readonly properties: {
        readonly auditOperationType: {
            readonly type: "Enum";
        };
        readonly auditEntityType: {
            readonly type: "Enum";
        };
        readonly sourceId: {
            readonly type: "string";
        };
        readonly synchronous: {
            readonly type: "boolean";
        };
        readonly productionModeErrorHandling: {
            readonly type: "boolean";
        };
    };
};

declare const $AuditDetail: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly runtimeAttributes: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly designerAttributes: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly versionId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly entityId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly parentId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly scanId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly status: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly identifier: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly relations: {
            readonly type: "array";
            readonly contains: {
                readonly type: "AuditRelationDTO";
            };
            readonly isReadOnly: true;
        };
        readonly extendedAttributes: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly associatedTags: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Tag";
            };
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $AuditDetailResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "AuditDetail";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $AuditImportDTO: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly auditIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly properties: {
            readonly type: "dictionary";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly auditImportAction: {
            readonly type: "Enum";
        };
        readonly audits: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Audit";
            };
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $AuditImportJobMetadata: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly jobId: {
            readonly type: "string";
        };
        readonly jobType: {
            readonly type: "string";
        };
        readonly status: {
            readonly type: "Enum";
        };
        readonly messagingServiceId: {
            readonly type: "string";
        };
        readonly payload: {
            readonly type: "BulkAuditImportDTO";
        };
        readonly id: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $AuditImportJobsMetadataResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "AuditImportJobMetadata";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $AuditJob: {
    readonly properties: {
        readonly id: {
            readonly type: "number";
            readonly format: "int64";
        };
        readonly state: {
            readonly type: "Enum";
            readonly isRequired: true;
        };
        readonly scanId: {
            readonly type: "string";
        };
        readonly contextId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly contextType: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly auditEntityType: {
            readonly type: "Enum";
            readonly isRequired: true;
        };
        readonly auditOperationType: {
            readonly type: "Enum";
            readonly isRequired: true;
        };
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $AuditJobResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "AuditJob";
            };
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $AuditRelationDTO: {
    readonly properties: {
        readonly auditEntityType: {
            readonly type: "string";
        };
        readonly auditId: {
            readonly type: "string";
        };
        readonly identifier: {
            readonly type: "string";
        };
        readonly status: {
            readonly type: "string";
        };
    };
    readonly isReadOnly: true;
};

declare const $AuditResult: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly eventBrokerId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly auditEntityType: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly eventBrokerName: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly identifier: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly status: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly schemaType: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $AuditResultDetail: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly parentId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly versionId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly entityId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly scanId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly status: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly identifier: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly relations: {
            readonly type: "array";
            readonly contains: {
                readonly type: "AuditRelationDTO";
            };
            readonly isReadOnly: true;
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $AuditResultDetailResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "AuditResultDetail";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $AuditResultsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "AuditResult";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $AuditResultStatsDTO: {
    readonly properties: {
        readonly auditStatusDistribution: {
            readonly type: "dictionary";
            readonly contains: {
                readonly type: "number";
                readonly format: "int32";
            };
        };
        readonly auditAssociatedTagIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly eventBrokerIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly nonDraftAuditIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly auditDetail: {
            readonly type: "dictionary";
            readonly contains: {
                readonly type: "AuditDetail";
            };
        };
    };
};

declare const $AuditResultStatsRequestDTO: {
    readonly properties: {
        readonly auditEntityType: {
            readonly type: "Enum";
        };
        readonly eventMeshId: {
            readonly type: "string";
        };
        readonly eventBrokerIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly hidden: {
            readonly type: "boolean";
        };
        readonly statuses: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Enum";
            };
        };
        readonly tags: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Enum";
            };
        };
        readonly excludedIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly startsWith: {
            readonly type: "string";
        };
        readonly contains: {
            readonly type: "string";
        };
    };
};

declare const $AuditsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Audit";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $BulkAuditImportDTO: {
    readonly properties: {
        readonly auditImports: {
            readonly type: "array";
            readonly contains: {
                readonly type: "AuditImportDTO";
            };
        };
    };
};

declare const $ChangeAppDomainEntitiesDTO: {
    readonly properties: {
        readonly targetAppDomainId: {
            readonly type: "string";
        };
        readonly entities: {
            readonly type: "array";
            readonly contains: {
                readonly type: "TargetEntitiesRequestDTO";
            };
        };
    };
};

declare const $Configuration: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly contextType: {
            readonly type: "Enum";
        };
        readonly contextId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly configurationTypeId: {
            readonly type: "string";
            readonly description: "Refer <a href=\"/cloud/reference/getconfigurationtypes\">here</a> for details on configuration types.";
            readonly isRequired: true;
        };
        readonly configurationType: {
            readonly type: "string";
            readonly description: "Refer <a href=\"/cloud/reference/getconfigurationtypes\">here</a> for details on configuration types.";
            readonly isRequired: true;
        };
        readonly entityType: {
            readonly type: "Enum";
            readonly isRequired: true;
        };
        readonly entityId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly identifier: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly value: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $ConfigurationResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "Configuration";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $ConfigurationsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Configuration";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $ConfigurationType: {
    readonly properties: {
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly isRequired: true;
            readonly maxLength: 255;
            readonly minLength: 1;
        };
        readonly brokerType: {
            readonly type: "string";
            readonly isRequired: true;
            readonly maxLength: 255;
            readonly minLength: 1;
        };
        readonly associatedEntityTypes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly valueSchema: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $ConfigurationTypeResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "ConfigurationType";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $ConfigurationTypesResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "ConfigurationType";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $Consumer: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly maxLength: 255;
            readonly minLength: 1;
        };
        readonly applicationVersionId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly brokerType: {
            readonly type: "string";
        };
        readonly consumerType: {
            readonly type: "string";
        };
        readonly subscriptions: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Subscription";
            };
        };
        readonly type: {
            readonly type: "string";
        };
    };
    readonly isReadOnly: true;
};

declare const $ConsumerResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "Consumer";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $ConsumersResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Consumer";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $CustomAttribute: {
    readonly properties: {
        readonly customAttributeDefinitionId: {
            readonly type: "string";
        };
        readonly customAttributeDefinitionName: {
            readonly type: "string";
            readonly pattern: "a-zA-Z0-9_\\-\\.";
        };
        readonly value: {
            readonly type: "string";
            readonly pattern: "a-zA-Z0-9_\\-\\.";
        };
    };
};

declare const $CustomAttributeDefinition: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
        };
        readonly name: {
            readonly type: "string";
            readonly pattern: "[a-zA-Z0-9\\._-]+";
        };
        readonly valueType: {
            readonly type: "Enum";
        };
        readonly scope: {
            readonly type: "Enum";
            readonly isRequired: true;
        };
        readonly associatedEntityTypes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly associatedEntities: {
            readonly type: "array";
            readonly contains: {
                readonly type: "AssociatedEntity";
            };
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $CustomAttributeDefinitionResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "CustomAttributeDefinition";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $CustomAttributeDefinitionsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttributeDefinition";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $CustomAttributeFrontEndDTO: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
        };
        readonly name: {
            readonly type: "string";
            readonly pattern: "[a-zA-Z0-9\\._-]+";
        };
        readonly valueType: {
            readonly type: "Enum";
        };
        readonly scope: {
            readonly type: "Enum";
            readonly isRequired: true;
        };
        readonly associatedEntityTypes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly associatedEntities: {
            readonly type: "array";
            readonly contains: {
                readonly type: "AssociatedEntity";
            };
        };
        readonly valuesEntityTypes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly values: {
            readonly type: "array";
            readonly contains: {
                readonly properties: {};
            };
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $CustomAttributesFrontEndResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttributeFrontEndDTO";
            };
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $DeliveryDescriptor: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly brokerType: {
            readonly type: "string";
        };
        readonly address: {
            readonly type: "Address";
        };
        readonly keySchemaVersionId: {
            readonly type: "string";
        };
        readonly keySchemaPrimitiveType: {
            readonly type: "Enum";
        };
        readonly id: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $DesignerMappingDTO: {
    readonly properties: {
        readonly id: {
            readonly type: "string";
        };
        readonly messagingServiceId: {
            readonly type: "string";
        };
        readonly auditEntityType: {
            readonly type: "Enum";
        };
        readonly identifier: {
            readonly type: "string";
        };
        readonly attributes: {
            readonly type: "string";
        };
        readonly entityId: {
            readonly type: "string";
        };
        readonly versionId: {
            readonly type: "string";
        };
        readonly parentId: {
            readonly type: "string";
        };
    };
    readonly isReadOnly: true;
};

declare const $Entitlement: {
    readonly properties: {
        readonly resourceType: {
            readonly type: "ResourceType";
        };
        readonly attributes: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
        readonly actions: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
    };
    readonly isReadOnly: true;
};

declare const $EntityType: {
    readonly properties: {
        readonly value: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $EntityTypesResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EntityType";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $Environment: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly description: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly revision: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly numberOfEventMeshes: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly configPush: {
            readonly type: "Enum";
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $EnvironmentResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "Environment";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $EnvironmentsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Environment";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $EPResponseSetString: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $EpUserEntitlements: {
    readonly properties: {
        readonly userId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly entitlements: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Entitlement";
            };
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $EpUserEntitlementsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "EpUserEntitlements";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $ErrorResponse: {
    readonly properties: {
        readonly message: {
            readonly type: "string";
        };
        readonly errorId: {
            readonly type: "string";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
        readonly validationDetails: {
            readonly type: "dictionary";
            readonly contains: {
                readonly type: "array";
                readonly contains: {
                    readonly type: "string";
                };
            };
        };
        readonly errorType: {
            readonly type: "string";
        };
    };
};

declare const $Event: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly isRequired: true;
            readonly maxLength: 2048;
            readonly minLength: 1;
        };
        readonly shared: {
            readonly type: "boolean";
        };
        readonly applicationDomainId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly brokerType: {
            readonly type: "string";
        };
        readonly numberOfVersions: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly customAttributes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttribute";
            };
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $EventApi: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly description: "The name of the event api.";
            readonly maxLength: 60;
            readonly minLength: 1;
        };
        readonly shared: {
            readonly type: "boolean";
        };
        readonly applicationDomainId: {
            readonly type: "string";
        };
        readonly numberOfVersions: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly brokerType: {
            readonly type: "Enum";
        };
        readonly customAttributes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttribute";
            };
        };
        readonly type: {
            readonly type: "string";
            readonly description: "The type of this payload, eventApi.";
            readonly isReadOnly: true;
        };
    };
};

declare const $EventApiProduct: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly description: "The name of the event API product";
            readonly maxLength: 60;
            readonly minLength: 1;
        };
        readonly applicationDomainId: {
            readonly type: "string";
        };
        readonly shared: {
            readonly type: "boolean";
        };
        readonly numberOfVersions: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly brokerType: {
            readonly type: "Enum";
        };
        readonly customAttributes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttribute";
            };
        };
        readonly type: {
            readonly type: "string";
            readonly description: "The type of payload";
            readonly isReadOnly: true;
        };
    };
};

declare const $EventApiProductRegistration: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly applicationDomainId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly registrationId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly accessRequestId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly eventApiProductVersionId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly planId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly state: {
            readonly type: "Enum";
        };
        readonly type: {
            readonly type: "string";
            readonly description: "The type of payload";
            readonly isReadOnly: true;
        };
        readonly customAttributes: {
            readonly type: "dictionary";
            readonly contains: {
                readonly type: "string";
            };
        };
    };
};

declare const $EventApiProductRegistrationResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "EventApiProductRegistration";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $EventApiProductRegistrationsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventApiProductRegistration";
            };
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $EventApiProductResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "EventApiProduct";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $EventApiProductsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventApiProduct";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $EventApiProductVersion: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly eventApiProductId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly description: {
            readonly type: "string";
            readonly maxLength: 10000;
        };
        readonly version: {
            readonly type: "string";
        };
        readonly summary: {
            readonly type: "string";
        };
        readonly customAttributes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttribute";
            };
        };
        readonly displayName: {
            readonly type: "string";
            readonly maxLength: 40;
        };
        readonly eventApiVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly description: "List of IDs of associated event API versions";
            };
        };
        readonly stateId: {
            readonly type: "string";
        };
        readonly eventApiProductRegistrations: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventApiProductRegistration";
            };
        };
        readonly plans: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Plan";
            };
        };
        readonly solaceMessagingServices: {
            readonly type: "array";
            readonly contains: {
                readonly type: "SolaceMessagingService";
            };
        };
        readonly filters: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Filter";
            };
        };
        readonly approvalType: {
            readonly type: "Enum";
        };
        readonly publishState: {
            readonly type: "Enum";
        };
        readonly publishedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly type: {
            readonly type: "string";
            readonly description: "The type of payload";
            readonly isReadOnly: true;
        };
    };
};

declare const $EventApiProductVersionResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "EventApiProductVersion";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $EventApiProductVersionsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventApiProductVersion";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $EventApiResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "EventApi";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $EventApisResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventApi";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $EventApiVersion: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly eventApiId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly description: {
            readonly type: "string";
            readonly maxLength: 10000;
        };
        readonly version: {
            readonly type: "string";
        };
        readonly displayName: {
            readonly type: "string";
            readonly maxLength: 40;
        };
        readonly producedEventVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly consumedEventVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly declaredEventApiProductVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly customAttributes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttribute";
            };
        };
        readonly stateId: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $EventApiVersionResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "EventApiVersion";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $EventApiVersionsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventApiVersion";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $EventBrokerDataCollectionUploadResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "EventBrokerScanDataUploadDetails";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $EventBrokerScanData: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly eventBrokerId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly data: {
            readonly type: "JsonNode";
            readonly isRequired: true;
        };
        readonly scanTypes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Enum";
            };
        };
        readonly type: {
            readonly type: "string";
            readonly description: "The type of this payload, ema data collection.";
            readonly isReadOnly: true;
        };
    };
};

declare const $EventBrokerScanDataUploadDetails: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly scanId: {
            readonly type: "string";
            readonly description: "The ID of the uploaded scan request.";
            readonly isReadOnly: true;
        };
        readonly eventBrokerId: {
            readonly type: "string";
            readonly description: "The event broker id of the data collection upload request.";
            readonly isReadOnly: true;
        };
        readonly eventBrokerType: {
            readonly type: "Enum";
            readonly isReadOnly: true;
        };
        readonly dataCollectionTypes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Enum";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly status: {
            readonly type: "Enum";
            readonly isReadOnly: true;
        };
        readonly scanTypes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Enum";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly destinations: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Enum";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly type: {
            readonly type: "string";
            readonly description: "The type of this payload, ema data collection.";
            readonly isReadOnly: true;
        };
    };
};

declare const $EventManagementAgent: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly description: "The name of the EMA.";
            readonly isRequired: true;
        };
        readonly region: {
            readonly type: "string";
            readonly description: "The region in which the EMA belongs to, extracted from the EventManagementAgentRegion.";
            readonly isReadOnly: true;
        };
        readonly clientUsername: {
            readonly type: "string";
            readonly description: "The SMF username for a customer's EMA to use to communicate to event-portal.";
            readonly isReadOnly: true;
        };
        readonly clientPassword: {
            readonly type: "string";
            readonly description: "The SMF password for a customer's EMA to use to communicate to event-portal.";
            readonly isReadOnly: true;
        };
        readonly referencedByMessagingServiceIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly description: "The list of messagingServiceIds user provides in GET APIs to filter the results.";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly orgId: {
            readonly type: "string";
            readonly description: "Used by admin APIs to get a list of EMAs against the given orgId";
            readonly isReadOnly: true;
        };
        readonly status: {
            readonly type: "string";
            readonly description: "The connection status of EP to the actual EMA which this object represents.";
            readonly isReadOnly: true;
        };
        readonly lastConnectedTime: {
            readonly type: "string";
            readonly description: "The timestamp of last heartbeat received from the EMA";
            readonly isReadOnly: true;
        };
        readonly version: {
            readonly type: "string";
            readonly description: "The version of the current connected EMA";
            readonly isReadOnly: true;
        };
        readonly runtimeAgentMode: {
            readonly type: "Enum";
            readonly isReadOnly: true;
        };
        readonly updateRequired: {
            readonly type: "boolean";
            readonly description: "Does this EMA require upgrade to latest released version.";
            readonly isReadOnly: true;
        };
        readonly eventManagementAgentRegionId: {
            readonly type: "string";
            readonly description: "The ID of the associated EventManagementAgentRegion.";
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $EventManagementAgentRegion: {
    readonly properties: {
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly serviceId: {
            readonly type: "string";
            readonly description: "The id of the service from maas-core.";
            readonly isRequired: true;
        };
        readonly name: {
            readonly type: "string";
            readonly description: "The name of the EventManagementAgentRegion.";
            readonly isRequired: true;
        };
        readonly cloudProvider: {
            readonly type: "string";
            readonly description: "The name of the cloud provider.";
            readonly isRequired: true;
        };
        readonly region: {
            readonly type: "string";
            readonly description: "The name of the region.";
            readonly isRequired: true;
        };
        readonly host: {
            readonly type: "string";
            readonly description: "The host name of the region.";
            readonly isRequired: true;
        };
        readonly msgVpn: {
            readonly type: "string";
            readonly description: "The name of the region's msgVpn.";
            readonly isRequired: true;
        };
        readonly port: {
            readonly type: "number";
            readonly description: "The SMF port number.";
            readonly format: "int32";
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $EventManagementAgentRegionsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventManagementAgentRegion";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $EventManagementAgentResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "EventManagementAgent";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $EventManagementAgentRunCommand: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly rawDockerRunCommand: {
            readonly type: "string";
            readonly description: "The raw docker run command used to start the Event Management Agent.";
            readonly isReadOnly: true;
            readonly isRequired: true;
        };
        readonly formattedDockerRunCommand: {
            readonly type: "string";
            readonly description: "The formatted docker run command used to start the Event Management Agent.";
            readonly isReadOnly: true;
            readonly isRequired: true;
        };
        readonly id: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $EventManagementAgentRunCommandResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "EventManagementAgentRunCommand";
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $EventManagementAgentsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventManagementAgent";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $EventMesh: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly description: "The name of the event mesh.";
            readonly maxLength: 40;
            readonly minLength: 1;
        };
        readonly environmentId: {
            readonly type: "string";
            readonly description: "The environmentId of the Event Mesh";
            readonly maxLength: 255;
            readonly minLength: 1;
        };
        readonly description: {
            readonly type: "string";
            readonly description: "The description of the event mesh.";
            readonly maxLength: 10000;
            readonly minLength: 1;
        };
        readonly brokerType: {
            readonly type: "Enum";
        };
        readonly type: {
            readonly type: "string";
            readonly description: "The type of this payload, eventMesh.";
            readonly isReadOnly: true;
        };
    };
};

declare const $EventMeshesFrontEndResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventMeshFrontEndDTO";
            };
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $EventMeshesResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventMesh";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $EventMeshFrontEndDTO: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly environmentName: {
            readonly type: "string";
        };
        readonly id: {
            readonly type: "string";
        };
        readonly name: {
            readonly type: "string";
        };
        readonly environmentId: {
            readonly type: "string";
        };
        readonly description: {
            readonly type: "string";
        };
        readonly brokerType: {
            readonly type: "string";
        };
        readonly applicationVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly referencedByMessagingServiceIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $EventMeshFrontEndResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "EventMeshFrontEndDTO";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $EventMeshResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "EventMesh";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $EventResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "Event";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $EventsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Event";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $EventV2KpiMetric: {
    readonly properties: {
        readonly id: {
            readonly type: "string";
        };
        readonly eventVersionId: {
            readonly type: "string";
        };
        readonly eventId: {
            readonly type: "string";
        };
        readonly eventName: {
            readonly type: "string";
        };
        readonly semanticVersion: {
            readonly type: "string";
        };
        readonly stateId: {
            readonly type: "string";
        };
        readonly shared: {
            readonly type: "boolean";
        };
        readonly consumerCount: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly brokerType: {
            readonly type: "string";
        };
        readonly topicAddress: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $EventV2KpiMetricResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventV2KpiMetric";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $EventVersion: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly eventId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly description: {
            readonly type: "string";
            readonly maxLength: 10000;
        };
        readonly version: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly displayName: {
            readonly type: "string";
            readonly maxLength: 40;
        };
        readonly declaredProducingApplicationVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly declaredConsumingApplicationVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly producingEventApiVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly consumingEventApiVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly attractingApplicationVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "AttractingApplicationVersionTuple";
            };
            readonly isReadOnly: true;
        };
        readonly schemaVersionId: {
            readonly type: "string";
        };
        readonly schemaPrimitiveType: {
            readonly type: "Enum";
        };
        readonly deliveryDescriptor: {
            readonly type: "DeliveryDescriptor";
        };
        readonly stateId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly customAttributes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttribute";
            };
        };
        readonly messagingServiceIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $EventVersionFrontend: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly eventId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly description: {
            readonly type: "string";
            readonly maxLength: 10000;
        };
        readonly version: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly displayName: {
            readonly type: "string";
            readonly maxLength: 40;
        };
        readonly declaredProducingApplicationVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly declaredConsumingApplicationVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly producingEventApiVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly consumingEventApiVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly attractingApplicationVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "AttractingApplicationVersionTuple";
            };
            readonly isReadOnly: true;
        };
        readonly schemaVersionId: {
            readonly type: "string";
        };
        readonly schemaPrimitiveType: {
            readonly type: "Enum";
        };
        readonly deliveryDescriptor: {
            readonly type: "DeliveryDescriptor";
        };
        readonly stateId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly customAttributes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttribute";
            };
        };
        readonly messagingServiceIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly declaredProducingApplicationVersionIdsInEventMesh: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly declaredConsumingApplicationVersionIdsInEventMesh: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly parentName: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $EventVersionResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "EventVersion";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $EventVersionsFrontendResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventVersionFrontend";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $EventVersionsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "EventVersion";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $Filter: {
    readonly description: "List of filters that contains eventVersionId name and variables";
    readonly properties: {
        readonly eventVersionId: {
            readonly type: "string";
        };
        readonly topicFilters: {
            readonly type: "array";
            readonly contains: {
                readonly type: "TopicFilter";
            };
        };
        readonly id: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
            readonly description: "The type of payload";
            readonly isReadOnly: true;
        };
    };
};

declare const $GatewayMessagingService: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
        };
        readonly messagingServiceId: {
            readonly type: "string";
        };
        readonly eventApiProductVersionId: {
            readonly type: "string";
        };
        readonly supportedProtocols: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Enum";
            };
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $GatewayMessagingServiceResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "GatewayMessagingService";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $GraphEdgeDTO: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
        };
        readonly sourceId: {
            readonly type: "string";
        };
        readonly destinationId: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $GraphModelDTO: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
        };
        readonly orgId: {
            readonly type: "string";
        };
        readonly name: {
            readonly type: "string";
        };
        readonly graphType: {
            readonly type: "string";
        };
        readonly context: {
            readonly type: "string";
        };
        readonly contextId: {
            readonly type: "string";
        };
        readonly nodes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "GraphNodeWrapperDTO";
            };
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $GraphModelResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "GraphModelDTO";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $GraphModelsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "GraphModelDTO";
            };
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $GraphNodeDTO: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
        };
        readonly graphModelId: {
            readonly type: "string";
        };
        readonly displayName: {
            readonly type: "string";
        };
        readonly position: {
            readonly type: "GraphNodePosition";
        };
        readonly nodeType: {
            readonly type: "string";
        };
        readonly references: {
            readonly type: "array";
            readonly contains: {
                readonly type: "GraphNodeReferenceDTO";
            };
        };
        readonly extendedAttributes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "GraphNodeExtendedAttributeDTO";
            };
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $GraphNodeExtendedAttributeDTO: {
    readonly properties: {
        readonly attributeName: {
            readonly type: "string";
        };
        readonly value: {
            readonly type: "string";
        };
    };
};

declare const $GraphNodePosition: {
    readonly properties: {
        readonly xcoordinate: {
            readonly type: "number";
            readonly format: "double";
        };
        readonly ycoordinate: {
            readonly type: "number";
            readonly format: "double";
        };
    };
};

declare const $GraphNodeReferenceDTO: {
    readonly properties: {
        readonly referenceId: {
            readonly type: "string";
        };
        readonly referenceType: {
            readonly type: "string";
        };
    };
};

declare const $GraphNodeResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "GraphNodeDTO";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $GraphNodesResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "GraphNodeWrapperDTO";
            };
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $GraphNodeWrapperDTO: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly node: {
            readonly type: "GraphNodeDTO";
        };
        readonly edges: {
            readonly type: "array";
            readonly contains: {
                readonly type: "GraphEdgeDTO";
            };
        };
        readonly id: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $ImportActionPreviewResultDTO: {
    readonly properties: {
        readonly entityCount: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly auditIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly relatedDesignerEntityIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
    };
};

declare const $InvalidNonStateReference: {
    readonly properties: {
        readonly entityId: {
            readonly type: "string";
        };
        readonly entityType: {
            readonly type: "string";
        };
    };
};

declare const $InvalidStateReference: {
    readonly type: "all-of";
    readonly contains: readonly [{
        readonly type: "ErrorResponse";
    }, {
        readonly properties: {
            readonly targetStateId: {
                readonly type: "string";
            };
            readonly inboundInvalidNonStateReferences: {
                readonly type: "array";
                readonly contains: {
                    readonly type: "InvalidNonStateReference";
                };
            };
            readonly inboundInvalidStateReferences: {
                readonly type: "array";
                readonly contains: {
                    readonly type: "InvalidStateReference";
                };
            };
            readonly outboundInvalidStateReferences: {
                readonly type: "array";
                readonly contains: {
                    readonly type: "InvalidStateReference";
                };
            };
            readonly errorType: {
                readonly type: "string";
            };
        };
    }];
};

declare const $JobAdministrationDTO: {
    readonly properties: {
        readonly jobId: {
            readonly type: "string";
        };
        readonly orgId: {
            readonly type: "string";
        };
        readonly jobType: {
            readonly type: "string";
        };
        readonly status: {
            readonly type: "Enum";
        };
        readonly loggingReason: {
            readonly type: "string";
        };
        readonly jobDetails: {
            readonly type: "string";
        };
        readonly createdTime: {
            readonly type: "string";
        };
        readonly updatedTime: {
            readonly type: "string";
        };
        readonly createdBy: {
            readonly type: "string";
        };
        readonly changedBy: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $JobBO: {
    readonly properties: {
        readonly id: {
            readonly type: "string";
        };
        readonly jobType: {
            readonly type: "JobType";
        };
        readonly status: {
            readonly type: "Enum";
        };
        readonly details: {
            readonly type: "string";
        };
        readonly results: {
            readonly type: "string";
            readonly format: "byte";
        };
        readonly error: {
            readonly type: "string";
            readonly format: "byte";
        };
        readonly orgId: {
            readonly type: "string";
        };
        readonly createdTime: {
            readonly type: "number";
            readonly format: "int64";
        };
        readonly updatedTime: {
            readonly type: "number";
            readonly format: "int64";
        };
        readonly changedBy: {
            readonly type: "string";
        };
        readonly createdBy: {
            readonly type: "string";
        };
    };
};

declare const $JobDTO: {
    readonly properties: {
        readonly id: {
            readonly type: "string";
        };
        readonly status: {
            readonly type: "Enum";
        };
        readonly jobType: {
            readonly type: "string";
        };
        readonly error: {
            readonly properties: {};
        };
        readonly results: {
            readonly properties: {};
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $JobType: {
    readonly properties: {};
};

declare const $JsonNode: {
    readonly properties: {};
};

declare const $KafkaConsumerGroupAuditResultSetDTO: {
    readonly properties: {
        readonly aggregateAuditResult: {
            readonly type: "Audit";
        };
        readonly kafkaConsumerGroupAuditResults: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Audit";
            };
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $KafkaConsumerGroupAuditResultSetResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "KafkaConsumerGroupAuditResultSetDTO";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $KafkaConsumerGroupAuditResultSetsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "KafkaConsumerGroupAuditResultSetDTO";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $KafkaTopicAuditResultSet: {
    readonly properties: {
        readonly eventIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly aggregateAuditResult: {
            readonly type: "Audit";
        };
        readonly topicAudit: {
            readonly type: "Audit";
        };
        readonly kafkaTopicSchemaParentRelationAuditResultSets: {
            readonly type: "array";
            readonly contains: {
                readonly type: "KafkaTopicSchemaParentRelationAuditResultSet";
            };
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $KafkaTopicAuditResultSetResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "KafkaTopicAuditResultSet";
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $KafkaTopicAuditResultSetsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "KafkaTopicAuditResultSet";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $KafkaTopicSchemaParentRelationAuditResultSet: {
    readonly properties: {
        readonly eventId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly schemaParentAudit: {
            readonly type: "Audit";
        };
        readonly kafkaTopicSchemaParentRelationAudit: {
            readonly type: "Audit";
        };
        readonly kafkaTopicSchemaVersionRelationAuditResultSets: {
            readonly type: "array";
            readonly contains: {
                readonly type: "KafkaTopicSchemaVersionRelationAuditResultSet";
            };
        };
    };
};

declare const $KafkaTopicSchemaVersionRelationAuditResultSet: {
    readonly properties: {
        readonly eventVersionId: {
            readonly type: "string";
        };
        readonly schemaVersionAudit: {
            readonly type: "Audit";
        };
        readonly kafkaTopicSchemaVersionRelationAudit: {
            readonly type: "Audit";
        };
    };
};

declare const $KpiEventReuseMetricDTO: {
    readonly properties: {
        readonly sharedReuseIndex: {
            readonly type: "number";
        };
        readonly sharedTotalEvents: {
            readonly type: "number";
            readonly format: "int64";
        };
        readonly sharedConsumerCount: {
            readonly type: "number";
            readonly format: "int64";
        };
        readonly nonSharedReuseIndex: {
            readonly type: "number";
        };
        readonly nonSharedTotalEvents: {
            readonly type: "number";
            readonly format: "int64";
        };
        readonly nonSharedConsumerCount: {
            readonly type: "number";
            readonly format: "int64";
        };
        readonly brokerType: {
            readonly type: "string";
        };
        readonly id: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $KpiMetrics: {
    readonly properties: {
        readonly orgId: {
            readonly type: "string";
        };
        readonly applicationDomainId: {
            readonly type: "string";
        };
        readonly kafkaKpiMetrics: {
            readonly type: "KpiEventReuseMetricDTO";
        };
        readonly solaceKpiMetrics: {
            readonly type: "KpiEventReuseMetricDTO";
        };
        readonly id: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $KpiMetricsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "KpiMetrics";
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $LoadSampleOperationDTO: {
    readonly properties: {
        readonly sampleCollectionName: {
            readonly type: "Enum";
        };
        readonly sampleCollectionVersion: {
            readonly type: "Enum";
        };
        readonly environmentVariables: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $MergeApplicationVersionsDTO: {
    readonly properties: {
        readonly name: {
            readonly type: "string";
            readonly isRequired: true;
            readonly maxLength: 255;
            readonly minLength: 1;
        };
        readonly applicationDomainId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly version: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly applicationVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
            readonly isRequired: true;
        };
        readonly smartMergeEnable: {
            readonly type: "boolean";
        };
    };
};

declare const $MessagingService: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly eventMeshId: {
            readonly type: "string";
            readonly description: "The eventMeshId associated to the messaging service.";
        };
        readonly runtimeAgentId: {
            readonly type: "string";
            readonly description: "The runtimeAgentId associated to the messaging service.";
        };
        readonly solaceCloudMessagingServiceId: {
            readonly type: "string";
            readonly description: "The solaceCloudMessagingServiceId associated to the messaging service.";
        };
        readonly messagingServiceType: {
            readonly type: "Enum";
        };
        readonly name: {
            readonly type: "string";
            readonly description: "The name of the messaging service.";
        };
        readonly messagingServiceConnections: {
            readonly type: "array";
            readonly contains: {
                readonly type: "MessagingServiceConnection";
            };
        };
        readonly eventManagementAgentId: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $MessagingServiceAssociationDTO: {
    readonly properties: {
        readonly messagingServiceIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
    };
};

declare const $MessagingServiceAssociationResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "MessagingServiceAssociationDTO";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $MessagingServiceAuthentication: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly messagingServiceConnectionId: {
            readonly type: "string";
            readonly description: "The ID of the connection object associated to the authentication object.";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly description: "The name of the authentication object.";
            readonly isRequired: true;
        };
        readonly authenticationType: {
            readonly type: "string";
            readonly description: "The type of the authentication object.";
            readonly isRequired: true;
        };
        readonly authenticationDetails: {
            readonly type: "dictionary";
            readonly contains: {
                readonly description: "A JSON map containing a map of extra details for the authentication.";
                readonly properties: {};
            };
        };
        readonly messagingServiceCredentials: {
            readonly type: "array";
            readonly contains: {
                readonly type: "MessagingServiceCredentials";
            };
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $MessagingServiceConnection: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly messagingServiceId: {
            readonly type: "string";
            readonly description: "The messagingServiceId associated to the connection object.";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly description: "The name of the connection object.";
        };
        readonly url: {
            readonly type: "string";
            readonly description: "The url of the connection object.";
        };
        readonly protocol: {
            readonly type: "string";
            readonly description: "The protocol of the connection object.";
        };
        readonly protocolVersion: {
            readonly type: "string";
            readonly description: "The protocolVersion of the connection object.";
        };
        readonly bindings: {
            readonly type: "dictionary";
            readonly contains: {
                readonly description: "A JSON map containing a map of connection-specific values. ";
                readonly properties: {};
            };
        };
        readonly messagingServiceAuthentications: {
            readonly type: "array";
            readonly contains: {
                readonly type: "MessagingServiceAuthentication";
            };
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $MessagingServiceCredentials: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly messagingServiceAuthenticationId: {
            readonly type: "string";
            readonly description: "The ID of the authentication object associated to the credentials object.";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly description: "The name of the credentials object.";
            readonly isRequired: true;
        };
        readonly credentials: {
            readonly type: "dictionary";
            readonly contains: {
                readonly description: "A JSON map containing the credentials information.";
                readonly properties: {};
            };
            readonly isRequired: true;
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $MessagingServiceFrontEndDTO: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly eventMeshId: {
            readonly type: "string";
            readonly description: "The eventMeshId associated to the messaging service.";
        };
        readonly runtimeAgentId: {
            readonly type: "string";
            readonly description: "The runtimeAgentId associated to the messaging service.";
        };
        readonly solaceCloudMessagingServiceId: {
            readonly type: "string";
            readonly description: "The solaceCloudMessagingServiceId associated to the messaging service.";
        };
        readonly messagingServiceType: {
            readonly type: "Enum";
        };
        readonly name: {
            readonly type: "string";
            readonly description: "The name of the messaging service.";
        };
        readonly messagingServiceConnections: {
            readonly type: "array";
            readonly contains: {
                readonly type: "MessagingServiceConnection";
            };
        };
        readonly schemaRegistriesToCreate: {
            readonly type: "array";
            readonly contains: {
                readonly type: "SchemaRegistry";
            };
        };
        readonly schemaRegistriesToUpdate: {
            readonly type: "array";
            readonly contains: {
                readonly type: "SchemaRegistry";
            };
        };
        readonly schemaRegistriesToDissociate: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly eventManagementAgentId: {
            readonly type: "string";
        };
    };
};

declare const $MessagingServiceInfoDTO: {
    readonly properties: {
        readonly name: {
            readonly type: "string";
        };
        readonly eventMeshId: {
            readonly type: "string";
        };
        readonly id: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $MessagingServiceOperation: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly scanTypes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Enum";
            };
            readonly isRequired: true;
        };
        readonly destinations: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Enum";
            };
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $MessagingServiceOperationResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "MessagingServiceOperation";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $MessagingServiceRemoveAssociation: {
    readonly properties: {
        readonly association: {
            readonly type: "Enum";
        };
    };
};

declare const $MessagingServiceResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "MessagingService";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $MessagingServiceScan: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly status: {
            readonly type: "string";
            readonly description: "The status of the messaging service scan.";
            readonly isReadOnly: true;
        };
        readonly statusDescription: {
            readonly type: "string";
            readonly description: "The description of the messaging service scan status.";
            readonly isReadOnly: true;
        };
        readonly messagingServiceId: {
            readonly type: "string";
            readonly description: "The messagingServiceId of the scan.";
            readonly isReadOnly: true;
        };
        readonly messagingServiceName: {
            readonly type: "string";
            readonly description: "The messagingServiceName of the scan.";
            readonly isReadOnly: true;
        };
        readonly scanTypes: {
            readonly type: "string";
            readonly description: "The scanTypes that were requested for the scan.";
            readonly isReadOnly: true;
        };
        readonly destinations: {
            readonly type: "string";
            readonly description: "The destinations which EMA will send the scan results.";
            readonly isReadOnly: true;
        };
        readonly isUsedByAudit: {
            readonly type: "boolean";
            readonly description: "Whether the scan is used by audit.";
            readonly isReadOnly: true;
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $MessagingServiceScanData: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly scanId: {
            readonly type: "string";
            readonly description: "The ID of the scan.";
            readonly isReadOnly: true;
        };
        readonly dataCollectionType: {
            readonly type: "Enum";
            readonly isReadOnly: true;
        };
        readonly data: {
            readonly type: "string";
            readonly description: "The scan data in JSON format.";
            readonly isReadOnly: true;
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $MessagingServiceScanDataListResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "MessagingServiceScanData";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $MessagingServiceScanDataResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "MessagingServiceScanData";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $MessagingServiceScanLog: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly scanId: {
            readonly type: "string";
            readonly description: "The ID of the scan.";
            readonly isReadOnly: true;
        };
        readonly log: {
            readonly type: "string";
            readonly description: "The log message.";
            readonly isReadOnly: true;
        };
        readonly logLevel: {
            readonly type: "string";
            readonly description: "The level of the log message.";
            readonly isReadOnly: true;
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $MessagingServiceScanLogListResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "MessagingServiceScanLog";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $MessagingServiceScanResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "MessagingServiceScan";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $MessagingServiceScansResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "MessagingServiceScan";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $MessagingServicesInfoResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "MessagingServiceInfoDTO";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $MessagingServicesResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "MessagingService";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $meta: {
    readonly properties: {
        readonly pagination: {
            readonly type: "Pagination";
        };
    };
};

declare const $OperationDTO: {
    readonly properties: {
        readonly id: {
            readonly type: "string";
        };
        readonly operationType: {
            readonly type: "string";
        };
        readonly createdBy: {
            readonly type: "string";
        };
        readonly createdTime: {
            readonly type: "string";
        };
        readonly completedTime: {
            readonly type: "string";
        };
        readonly status: {
            readonly type: "Enum";
        };
        readonly results: {
            readonly properties: {};
        };
        readonly error: {
            readonly properties: {};
        };
    };
};

declare const $OperationResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "OperationDTO";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $OrgDTO: {
    readonly properties: {
        readonly id: {
            readonly type: "string";
        };
        readonly eventPortalAccessEnabled: {
            readonly type: "boolean";
        };
        readonly topicAddressResourcesAccessEnabled: {
            readonly type: "boolean";
        };
        readonly createdTime: {
            readonly type: "number";
            readonly format: "int64";
        };
        readonly updatedTime: {
            readonly type: "number";
            readonly format: "int64";
        };
        readonly objectLimit: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly objectVersionLimit: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly applicationDomainLimit: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly eventMeshLimit: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly eventApiLimit: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly eventApiProductLimit: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly consumerLimit: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly topicDomainLimitPerApplicationDomain: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly enumLimit: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly enumValueLimit: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly messagingServiceLimit: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly configurationLimit: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly subscriptionLimit: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly subscriptionPerApplicationVersionLimit: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly graphNodeLimit: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly applicationDomainGraphNodeLimit: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly schemaRegistryLimit: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly objectRelationshipVisualizationLimit: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly productTier: {
            readonly type: "Enum";
        };
        readonly organizationType: {
            readonly type: "Enum";
        };
        readonly stats: {
            readonly type: "OrgStats";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $OrgsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "OrgDTO";
            };
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $OrgStats: {
    readonly properties: {
        readonly schemaCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly schemaVersionCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly eventCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly eventVersionCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly applicationCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly applicationVersionCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly applicationDomainCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly eventApiCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly eventApiVersionCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly subscriptionCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly consumerCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly enumCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly enumVersionCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly enumValueCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly eventApiProductCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly eventApiProductVersionCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly publishedEventApiProductVersionCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly environmentCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly eventMeshCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly applicationVersionsInEventMeshesCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly customAttributeDefinitionCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly customAttributeCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly configurationCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly sumUniqueEventsInEachEnvironmentCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly sumUniqueSchemasInEachEnvironmentCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly sumUniqueApplicationsInEachEnvironmentCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly messageServiceCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly caGlobalDefParentCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly caGlobalParentValueCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly caGlobalDefVersionCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly caGlobalVersionValueCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly caAppDomainScopedDefParentCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly caAppDomainScopedParentValueCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly caAppDomainScopedDefVersionCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly caAppDomainScopedVersionValueCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly caAppDomainScopedAppDomainValueCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly caAppDomainScopedAppDomainDefCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly caGlobalAppDomainValueCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly caGlobalAppDomainDefCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
    };
};

declare const $Pagination: {
    readonly properties: {
        readonly pageNumber: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly count: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly pageSize: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly nextPage: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly totalPages: {
            readonly type: "number";
            readonly format: "int32";
        };
    };
};

declare const $Plan: {
    readonly properties: {
        readonly id: {
            readonly type: "string";
            readonly description: "ID value of the object";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly description: "Title of the object";
        };
        readonly solaceClassOfServicePolicy: {
            readonly type: "SolaceClassOfServicePolicy";
        };
        readonly type: {
            readonly type: "string";
            readonly description: "The type of this payload";
            readonly isReadOnly: true;
        };
    };
};

declare const $PreviewEntityConfigurationDTO: {
    readonly properties: {
        readonly type: {
            readonly type: "Enum";
        };
        readonly identifier: {
            readonly type: "string";
        };
        readonly value: {
            readonly type: "string";
        };
        readonly errors: {
            readonly type: "array";
            readonly contains: {
                readonly type: "dictionary";
                readonly contains: {
                    readonly properties: {};
                };
            };
        };
    };
};

declare const $resourceAuthenticationDetails: {
    readonly description: "The list of connection authentications.";
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly protocol: {
            readonly type: "string";
            readonly description: "The authentication protocol.";
            readonly maxLength: 60;
        };
        readonly protocolVersion: {
            readonly type: "string";
            readonly description: "The authentication protocol version.";
            readonly maxLength: 60;
        };
        readonly connectionDetailsId: {
            readonly type: "string";
            readonly description: "The connection Id that the authentication object is associated to.";
            readonly isReadOnly: true;
        };
        readonly properties: {
            readonly type: "array";
            readonly contains: {
                readonly type: "resourceAuthenticationProperties";
            };
        };
        readonly credentials: {
            readonly type: "array";
            readonly contains: {
                readonly type: "resourceCredentialDetails";
            };
        };
        readonly type: {
            readonly type: "string";
            readonly description: "The type of this payload, resourceAuthenticationDetails.";
            readonly isReadOnly: true;
        };
    };
};

declare const $resourceAuthenticationProperties: {
    readonly description: "The list of authentication properties.";
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly description: "The property name.";
        };
        readonly value: {
            readonly type: "string";
            readonly description: "The property value.";
        };
        readonly authenticationDetailsId: {
            readonly type: "string";
            readonly description: "The authentication Id the property is associated to.";
            readonly isReadOnly: true;
        };
        readonly type: {
            readonly type: "string";
            readonly description: "The type of this payload, resourceAuthenticationProperties.";
            readonly isReadOnly: true;
        };
    };
};

declare const $resourceConnectionDetails: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly resourceId: {
            readonly type: "string";
            readonly description: "The id of the resource the connection object is associated to.";
            readonly isReadOnly: true;
        };
        readonly resourceType: {
            readonly type: "Enum";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly description: "The name of the connection object.";
            readonly isRequired: true;
            readonly maxLength: 255;
        };
        readonly url: {
            readonly type: "string";
            readonly description: "The url of the connection object.";
            readonly maxLength: 255;
        };
        readonly properties: {
            readonly type: "array";
            readonly contains: {
                readonly type: "resourceConnectionProperties";
            };
        };
        readonly authentications: {
            readonly type: "array";
            readonly contains: {
                readonly type: "resourceAuthenticationDetails";
            };
        };
        readonly type: {
            readonly type: "string";
            readonly description: "The type of this payload, resourceConnection.";
            readonly isReadOnly: true;
        };
    };
};

declare const $resourceConnectionProperties: {
    readonly description: "The list of connection properties.";
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly description: "The property name.";
        };
        readonly value: {
            readonly type: "string";
            readonly description: "The property value.";
        };
        readonly connectionDetailsId: {
            readonly type: "string";
            readonly description: "The connection Id the property is associated to.";
            readonly isReadOnly: true;
        };
        readonly type: {
            readonly type: "string";
            readonly description: "The type of this payload, resourceConnectionProperties.";
            readonly isReadOnly: true;
        };
    };
};

declare const $ResourceConnectionResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "resourceConnectionDetails";
            };
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $resourceCredentialDetails: {
    readonly description: "The list of credential details.";
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly source: {
            readonly type: "string";
            readonly description: "The credential source.";
            readonly maxLength: 255;
        };
        readonly authenticationDetailsId: {
            readonly type: "string";
            readonly description: "The authentication Id the credential object is associated to.";
            readonly isReadOnly: true;
        };
        readonly properties: {
            readonly type: "array";
            readonly contains: {
                readonly type: "ResourceCredentialPropertiesBO";
            };
        };
        readonly operations: {
            readonly type: "array";
            readonly contains: {
                readonly type: "ResourceCredentialOperationsBO";
            };
        };
        readonly type: {
            readonly type: "string";
            readonly description: "The type of this payload, resourceCredentialDetails.";
            readonly isReadOnly: true;
        };
    };
};

declare const $ResourceCredentialOperationsBO: {
    readonly description: "The list of credential operations.";
    readonly properties: {
        readonly orgId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly createdTime: {
            readonly type: "number";
            readonly format: "int64";
        };
        readonly updatedTime: {
            readonly type: "number";
            readonly format: "int64";
        };
        readonly changedBy: {
            readonly type: "string";
        };
        readonly createdBy: {
            readonly type: "string";
        };
        readonly id: {
            readonly type: "string";
        };
        readonly name: {
            readonly type: "string";
        };
        readonly credentialDetailsId: {
            readonly type: "string";
        };
        readonly entityType: {
            readonly type: "string";
        };
        readonly key: {
            readonly type: "string";
        };
    };
};

declare const $ResourceCredentialPropertiesBO: {
    readonly description: "The list of credential properties.";
    readonly properties: {
        readonly orgId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly createdTime: {
            readonly type: "number";
            readonly format: "int64";
        };
        readonly updatedTime: {
            readonly type: "number";
            readonly format: "int64";
        };
        readonly changedBy: {
            readonly type: "string";
        };
        readonly createdBy: {
            readonly type: "string";
        };
        readonly id: {
            readonly type: "string";
        };
        readonly name: {
            readonly type: "string";
        };
        readonly value: {
            readonly type: "string";
        };
        readonly credentialDetailsId: {
            readonly type: "string";
        };
        readonly entityType: {
            readonly type: "string";
        };
        readonly key: {
            readonly type: "string";
        };
    };
};

declare const $ResourceType: {
    readonly type: "Enum";
};

declare const $ResponseAuditResultStatsDTO: {
    readonly properties: {
        readonly data: {
            readonly type: "AuditResultStatsDTO";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $ResponseJobDTO: {
    readonly properties: {
        readonly data: {
            readonly type: "JobDTO";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $ResponseOrgDTO: {
    readonly properties: {
        readonly data: {
            readonly type: "OrgDTO";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $ResponseRuntimeImportAllResponseDTO: {
    readonly properties: {
        readonly data: {
            readonly type: "RuntimeImportAllResponseDTO";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $RuntimeAgentFrontEndDTO: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly description: "The name of the EMA.";
            readonly isRequired: true;
        };
        readonly region: {
            readonly type: "string";
            readonly description: "The region in which the EMA belongs to, extracted from the EventManagementAgentRegion.";
            readonly isReadOnly: true;
        };
        readonly clientUsername: {
            readonly type: "string";
            readonly description: "The SMF username for a customer's EMA to use to communicate to event-portal.";
            readonly isReadOnly: true;
        };
        readonly clientPassword: {
            readonly type: "string";
            readonly description: "The SMF password for a customer's EMA to use to communicate to event-portal.";
            readonly isReadOnly: true;
        };
        readonly referencedByMessagingServiceIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly description: "The list of messagingServiceIds user provides in GET APIs to filter the results.";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly orgId: {
            readonly type: "string";
            readonly description: "Used by admin APIs to get a list of EMAs against the given orgId";
            readonly isReadOnly: true;
        };
        readonly status: {
            readonly type: "string";
            readonly description: "The connection status of EP to the actual EMA which this object represents.";
            readonly isReadOnly: true;
        };
        readonly lastConnectedTime: {
            readonly type: "string";
            readonly description: "The timestamp of last heartbeat received from the EMA";
            readonly isReadOnly: true;
        };
        readonly version: {
            readonly type: "string";
            readonly description: "The version of the current connected EMA";
            readonly isReadOnly: true;
        };
        readonly runtimeAgentMode: {
            readonly type: "Enum";
            readonly isReadOnly: true;
        };
        readonly updateRequired: {
            readonly type: "boolean";
            readonly description: "Does this EMA require upgrade to latest released version.";
            readonly isReadOnly: true;
        };
        readonly messagingServicesToUpdate: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly messagingServicesToCreate: {
            readonly type: "array";
            readonly contains: {
                readonly type: "MessagingService";
            };
        };
        readonly messagingServicesToDisassociate: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly eventManagementAgentRegionId: {
            readonly type: "string";
            readonly description: "The ID of the associated EventManagementAgentRegion.";
        };
    };
};

declare const $RuntimeAgentOperationDTO: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
        };
        readonly runtimeAgentId: {
            readonly type: "string";
        };
        readonly messagingServiceId: {
            readonly type: "string";
        };
        readonly scanType: {
            readonly type: "string";
        };
        readonly entityTypes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $RuntimeAgentOperationResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "RuntimeAgentOperationDTO";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $RuntimeAgentRegionInternalDTO: {
    readonly properties: {
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly serviceId: {
            readonly type: "string";
            readonly description: "The id of the service from maas-core.";
            readonly isRequired: true;
        };
        readonly name: {
            readonly type: "string";
            readonly description: "The name of the EventManagementAgentRegion.";
            readonly isRequired: true;
        };
        readonly cloudProvider: {
            readonly type: "string";
            readonly description: "The name of the cloud provider.";
            readonly isRequired: true;
        };
        readonly region: {
            readonly type: "string";
            readonly description: "The name of the region.";
            readonly isRequired: true;
        };
        readonly host: {
            readonly type: "string";
            readonly description: "The host name of the region.";
            readonly isRequired: true;
        };
        readonly msgVpn: {
            readonly type: "string";
            readonly description: "The name of the region's msgVpn.";
            readonly isRequired: true;
        };
        readonly port: {
            readonly type: "number";
            readonly description: "The SMF port number.";
            readonly format: "int32";
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly sempPort: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly clientUsername: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly clientPassword: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly sempUsername: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly sempPassword: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly clientProfileName: {
            readonly type: "string";
        };
    };
};

declare const $RuntimeAgentRegionInternalResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "RuntimeAgentRegionInternalDTO";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $RuntimeAgentRegionInternalsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "RuntimeAgentRegionInternalDTO";
            };
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $RuntimeEntityConfiguration: {
    readonly properties: {
        readonly runtimeEntityType: {
            readonly type: "Enum";
        };
        readonly configuration: {
            readonly type: "string";
        };
    };
};

declare const $RuntimeImportAllDTO: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly properties: {
            readonly type: "dictionary";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly auditImportAction: {
            readonly type: "Enum";
        };
        readonly filters: {
            readonly type: "RuntimeImportFiltersDTO";
        };
        readonly aggregationStrategy: {
            readonly type: "Enum";
        };
        readonly id: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $RuntimeImportAllResponseDTO: {
    readonly properties: {
        readonly jobURIs: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
    };
};

declare const $RuntimeImportFiltersDTO: {
    readonly properties: {
        readonly auditStatus: {
            readonly type: "Enum";
        };
        readonly nameContains: {
            readonly type: "string";
        };
        readonly eventBrokerId: {
            readonly type: "string";
        };
        readonly tags: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Enum";
            };
        };
        readonly hidden: {
            readonly type: "boolean";
        };
        readonly eventMeshId: {
            readonly type: "string";
        };
        readonly auditEntityType: {
            readonly type: "Enum";
        };
        readonly excludedAuditIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly sort: {
            readonly type: "string";
        };
    };
};

declare const $RuntimeImportPreviewDTO: {
    readonly properties: {
        readonly auditIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
    };
};

declare const $RuntimeMappingDTO: {
    readonly properties: {
        readonly id: {
            readonly type: "string";
        };
        readonly messagingServiceId: {
            readonly type: "string";
        };
        readonly auditEntityType: {
            readonly type: "Enum";
        };
        readonly identifier: {
            readonly type: "string";
        };
        readonly attributes: {
            readonly type: "string";
        };
        readonly scanId: {
            readonly type: "string";
        };
    };
    readonly isReadOnly: true;
};

declare const $SchemaImportPreviewDTO: {
    readonly properties: {
        readonly createNewParent: {
            readonly type: "ImportActionPreviewResultDTO";
        };
        readonly updateExistingParent: {
            readonly type: "ImportActionPreviewResultDTO";
        };
        readonly additionalCreateNewParentAuditIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly additionalUpdateExistingParentAuditIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
    };
};

declare const $SchemaImportPreviewResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "SchemaImportPreviewDTO";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $SchemaObject: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly applicationDomainId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly name: {
            readonly type: "string";
            readonly isRequired: true;
            readonly maxLength: 2048;
        };
        readonly shared: {
            readonly type: "boolean";
        };
        readonly contentType: {
            readonly type: "string";
            readonly description: "*Deprecation Date: 2022-04-30<br>Removal Date: 2023-04-30<br>Reason: Content types are a runtime concept and don’t provide useful value in their current implementation.*<br>";
            readonly maxLength: 255;
        };
        readonly schemaType: {
            readonly type: "string";
            readonly isRequired: true;
            readonly maxLength: 255;
        };
        readonly numberOfVersions: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly eventVersionRefCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly customAttributes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttribute";
            };
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $SchemaRegistriesResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "SchemaRegistry";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $SchemaRegistry: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly description: "Primary key set by the server.";
            readonly isReadOnly: true;
        };
        readonly schemaRegistryType: {
            readonly type: "Enum";
        };
        readonly brokerType: {
            readonly type: "Enum";
        };
        readonly messagingServiceIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly description: "The messagingServiceIds associated with the Schema Registry";
            };
        };
        readonly connections: {
            readonly type: "array";
            readonly contains: {
                readonly type: "resourceConnectionDetails";
            };
        };
        readonly type: {
            readonly type: "string";
            readonly description: "The type of this payload, schemaRegistry.";
            readonly isReadOnly: true;
        };
    };
};

declare const $SchemaRegistryResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "SchemaRegistry";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $SchemaResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "SchemaObject";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $SchemasResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "SchemaObject";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $SchemaVersion: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly schemaId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly description: {
            readonly type: "string";
            readonly maxLength: 10000;
        };
        readonly version: {
            readonly type: "string";
            readonly isRequired: true;
            readonly pattern: "^\\d+\\.\\d+\\.\\d+$";
        };
        readonly displayName: {
            readonly type: "string";
            readonly maxLength: 40;
        };
        readonly content: {
            readonly type: "string";
        };
        readonly referencedByEventVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly referencedBySchemaVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly schemaVersionReferences: {
            readonly type: "array";
            readonly contains: {
                readonly type: "SchemaVersionReferenceDTO";
            };
        };
        readonly customAttributes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttribute";
            };
        };
        readonly stateId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $SchemaVersionFrontEnd: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly schemaId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly description: {
            readonly type: "string";
            readonly maxLength: 10000;
        };
        readonly version: {
            readonly type: "string";
            readonly isRequired: true;
            readonly pattern: "^\\d+\\.\\d+\\.\\d+$";
        };
        readonly displayName: {
            readonly type: "string";
            readonly maxLength: 40;
        };
        readonly content: {
            readonly type: "string";
        };
        readonly referencedByEventVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly referencedBySchemaVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly schemaVersionReferences: {
            readonly type: "array";
            readonly contains: {
                readonly type: "SchemaVersionReferenceDTO";
            };
        };
        readonly customAttributes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttribute";
            };
        };
        readonly stateId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly referencedByEventVersionIdsInEventMesh: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly parentName: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $SchemaVersionReferenceDTO: {
    readonly properties: {
        readonly schemaVersionId: {
            readonly type: "string";
        };
    };
};

declare const $SchemaVersionResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "SchemaVersion";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $SchemaVersionsFrontEndResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "SchemaVersionFrontEnd";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $SchemaVersionsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "SchemaVersion";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $SolaceClassOfServicePolicy: {
    readonly description: "Solace class of service policy";
    readonly properties: {
        readonly id: {
            readonly type: "string";
            readonly description: "ID value of the object";
            readonly isReadOnly: true;
        };
        readonly messageDeliveryMode: {
            readonly type: "Enum";
        };
        readonly accessType: {
            readonly type: "Enum";
        };
        readonly maximumTimeToLive: {
            readonly type: "number";
            readonly description: "Duration in seconds of how long a message can live in a queue";
            readonly format: "int32";
        };
        readonly queueType: {
            readonly type: "Enum";
        };
        readonly maxMsgSpoolUsage: {
            readonly type: "number";
            readonly description: "Total number of MBs available for the queue to use";
            readonly format: "int32";
        };
        readonly type: {
            readonly type: "string";
            readonly description: "The type of payload";
            readonly isReadOnly: true;
        };
    };
};

declare const $SolaceMessagingService: {
    readonly description: "Solace Messaging Services";
    readonly properties: {
        readonly id: {
            readonly type: "string";
            readonly description: "ID value of the object";
            readonly isReadOnly: true;
        };
        readonly messagingServiceId: {
            readonly type: "string";
            readonly description: "ID of the Event Portal messaging service";
            readonly isReadOnly: true;
        };
        readonly messagingServiceName: {
            readonly type: "string";
            readonly description: "Name of the Event Portal messaging service";
            readonly isReadOnly: true;
        };
        readonly supportedProtocols: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly description: "Values for allowed supported protocols";
            };
        };
        readonly environmentId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly environmentName: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly eventMeshId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly eventMeshName: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly solaceCloudMessagingServiceId: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
            readonly description: "The type of payload";
            readonly isReadOnly: true;
        };
    };
};

declare const $SolaceQueueAggregateResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "SolaceQueueAuditResultSetDTO";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $SolaceQueueAuditResultSetDTO: {
    readonly properties: {
        readonly aggregateAuditResult: {
            readonly type: "Audit";
        };
        readonly solaceQueueAuditResults: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Audit";
            };
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $SolaceQueueAuditResultSetsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "SolaceQueueAuditResultSetDTO";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $StateChangeRequestResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "VersionedObjectStateChangeRequest";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $StateDTO: {
    readonly properties: {
        readonly id: {
            readonly type: "string";
        };
        readonly description: {
            readonly type: "string";
        };
        readonly name: {
            readonly type: "string";
        };
        readonly stateOrder: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $StatesResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "StateDTO";
            };
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $StitchedEventVersionIdResultDTO: {
    readonly properties: {
        readonly eventVersionId: {
            readonly type: "string";
        };
        readonly eventMeshIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
    };
};

declare const $Subscription: {
    readonly properties: {
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly subscriptionType: {
            readonly type: "string";
        };
        readonly value: {
            readonly type: "string";
        };
        readonly attractedEventVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "AttractedEventVersionTuple";
            };
            readonly isReadOnly: true;
        };
    };
};

declare const $SubscriptionStitchingEvalRequestDTO: {
    readonly properties: {
        readonly brokerType: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly subscriptions: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Subscription";
            };
        };
    };
};

declare const $SuggestedAddressLevelDTO: {
    readonly properties: {
        readonly name: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly addressLevelType: {
            readonly type: "Enum";
            readonly isRequired: true;
        };
        readonly enumVersionId: {
            readonly type: "string";
        };
        readonly enumVersion: {
            readonly type: "TopicAddressEnumVersion";
        };
    };
};

declare const $SuggestionApiInputDTO: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly addressLevels: {
            readonly type: "array";
            readonly contains: {
                readonly type: "AddressLevel";
            };
            readonly isRequired: true;
        };
        readonly brokerType: {
            readonly type: "string";
        };
        readonly addressType: {
            readonly type: "Enum";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $Tag: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly isReadOnly: true;
            readonly isRequired: true;
            readonly maxLength: 60;
        };
        readonly type: {
            readonly type: "string";
            readonly description: "The type of this payload, tag.";
            readonly isReadOnly: true;
        };
    };
};

declare const $TagAssociationsObject: {
    readonly properties: {
        readonly tags: {
            readonly type: "array";
            readonly contains: {
                readonly type: "TagEntityAssociationsObject";
            };
            readonly isRequired: true;
        };
    };
};

declare const $TagEntityAssociationsObject: {
    readonly properties: {
        readonly tagId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly entityType: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly entitiesToAssociate: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly entitiesToDisassociate: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
    };
};

declare const $TagResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "Tag";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $tagsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "Tag";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $TargetEntitiesRequestDTO: {
    readonly properties: {
        readonly selectedEntityIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
        };
        readonly entityType: {
            readonly type: "Enum";
        };
    };
};

declare const $ToggleInfoDTO: {
    readonly properties: {
        readonly id: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly type: {
            readonly type: "string";
        };
        readonly description: {
            readonly type: "string";
        };
        readonly defaultValue: {
            readonly type: "boolean";
        };
    };
};

declare const $ToggleOrgInfoDTO: {
    readonly properties: {
        readonly id: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly description: {
            readonly type: "string";
        };
        readonly enabled: {
            readonly type: "boolean";
        };
    };
};

declare const $ToggleOrgInfoListResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "ToggleOrgInfoDTO";
            };
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $ToggleOverrideDTO: {
    readonly properties: {
        readonly id: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly orgId: {
            readonly type: "string";
        };
        readonly enabled: {
            readonly type: "boolean";
        };
    };
};

declare const $ToggleOverrideListResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "ToggleOverrideDTO";
            };
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $TogglesInfoResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "ToggleInfoDTO";
            };
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $ToggleStatusDTO: {
    readonly properties: {
        readonly id: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly enabled: {
            readonly type: "boolean";
            readonly isRequired: true;
        };
    };
};

declare const $ToggleStatusListResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "ToggleStatusDTO";
            };
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $TopicAddressEnum: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly applicationDomainId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly name: {
            readonly type: "string";
            readonly isRequired: true;
            readonly maxLength: 60;
        };
        readonly shared: {
            readonly type: "boolean";
        };
        readonly numberOfVersions: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly eventVersionRefCount: {
            readonly type: "number";
            readonly isReadOnly: true;
            readonly format: "int32";
        };
        readonly customAttributes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttribute";
            };
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $TopicAddressEnumResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "TopicAddressEnum";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $TopicAddressEnumsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "TopicAddressEnum";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $TopicAddressEnumValue: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly enumVersionId: {
            readonly type: "string";
        };
        readonly value: {
            readonly type: "string";
            readonly isRequired: true;
            readonly maxLength: 255;
        };
        readonly label: {
            readonly type: "string";
            readonly maxLength: 40;
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $TopicAddressEnumVersion: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly enumId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly description: {
            readonly type: "string";
            readonly maxLength: 10000;
        };
        readonly version: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly displayName: {
            readonly type: "string";
            readonly maxLength: 40;
        };
        readonly values: {
            readonly type: "array";
            readonly contains: {
                readonly type: "TopicAddressEnumValue";
            };
            readonly isRequired: true;
        };
        readonly referencedByEventVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly referencedByTopicDomainIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
                readonly isReadOnly: true;
            };
            readonly isReadOnly: true;
        };
        readonly stateId: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly customAttributes: {
            readonly type: "array";
            readonly contains: {
                readonly type: "CustomAttribute";
            };
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $TopicAddressEnumVersionResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "TopicAddressEnumVersion";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $TopicAddressEnumVersionsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "TopicAddressEnumVersion";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $TopicAddressResourceDTO: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
        };
        readonly applicationDomainId: {
            readonly type: "string";
        };
        readonly name: {
            readonly type: "string";
        };
        readonly resource: {
            readonly type: "string";
        };
        readonly description: {
            readonly type: "string";
        };
        readonly type: {
            readonly type: "string";
        };
    };
};

declare const $TopicAddressResourceResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "TopicAddressResourceDTO";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $TopicAddressResourcesResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "TopicAddressResourceDTO";
            };
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $TopicAggregateImportPreviewDTO: {
    readonly properties: {
        readonly createNewParent: {
            readonly type: "ImportActionPreviewResultDTO";
        };
        readonly updateExistingParent: {
            readonly type: "ImportActionPreviewResultDTO";
        };
        readonly referencedSchemaImportPreview: {
            readonly type: "SchemaImportPreviewDTO";
        };
    };
};

declare const $TopicAggregateImportPreviewResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "TopicAggregateImportPreviewDTO";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $TopicDomain: {
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly id: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly applicationDomainId: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly brokerType: {
            readonly type: "string";
            readonly isRequired: true;
        };
        readonly addressLevels: {
            readonly type: "array";
            readonly contains: {
                readonly type: "AddressLevel";
            };
            readonly isRequired: true;
        };
        readonly type: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
    };
};

declare const $TopicDomainAnalysisDTO: {
    readonly properties: {
        readonly presentInOtherApplicationDomains: {
            readonly type: "boolean";
        };
        readonly otherApplicationDomainCount: {
            readonly type: "number";
            readonly format: "int32";
        };
        readonly otherEntitledApplicationDomains: {
            readonly type: "array";
            readonly contains: {
                readonly type: "ApplicationDomain";
            };
        };
    };
};

declare const $TopicDomainResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "TopicDomain";
        };
        readonly meta: {
            readonly type: "dictionary";
            readonly contains: {
                readonly properties: {};
            };
        };
    };
};

declare const $TopicDomainsResponse: {
    readonly properties: {
        readonly data: {
            readonly type: "array";
            readonly contains: {
                readonly type: "TopicDomain";
            };
        };
        readonly meta: {
            readonly type: "meta";
        };
    };
};

declare const $TopicFilter: {
    readonly description: "List of variable that contains address node name and filters";
    readonly properties: {
        readonly createdTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly updatedTime: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly createdBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly changedBy: {
            readonly type: "string";
            readonly isReadOnly: true;
        };
        readonly name: {
            readonly type: "string";
            readonly description: "name of address node";
        };
        readonly filterValue: {
            readonly type: "string";
            readonly description: "Different filter values separated by comma";
        };
        readonly eventVersionIds: {
            readonly type: "array";
            readonly contains: {
                readonly type: "string";
            };
            readonly isRequired: true;
        };
        readonly type: {
            readonly type: "string";
            readonly description: "The type of payload";
            readonly isReadOnly: true;
        };
    };
};

declare const $VersionedObjectStateChangeRequest: {
    readonly properties: {
        readonly stateId: {
            readonly type: "string";
        };
    };
};

declare class ApplicationDomainOperationsService {
    /**
     * Create change application domain operation
     * Use this API to execute a change application domain operation.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application_domain:move_contents:*` ]
     * @returns any Successfully executed a change application domain operation.
     * @throws ApiError
     */
    static createChangeApplicationDomainOperation({ requestBody, xContextId, }: {
        /** The change application domain operation **/
        requestBody: ChangeAppDomainEntitiesDTO;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<any>;
    /**
     * Get a change application domain operation's details
     * Use this API to retrieve a single change application domain operation by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns OperationResponse The change application domain operation.
     * @throws ApiError
     */
    static getChangeApplicationDomainOperation({ id, xContextId, }: {
        /** The ID of the change application domain operation. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<OperationResponse>;
}

declare class ApplicationDomainsService {
    /**
     * Get a list of the application domains
     * Use this API to get a list of application domains that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns ApplicationDomainsResponse Get a list of application domains and the accompanying metadata.
     * @throws ApiError
     */
    static getApplicationDomains({ xContextId, pageSize, pageNumber, name, ids, include, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of application domains to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Name to be used to match the application domain. **/
        name?: string;
        /** Match only application domains with the given IDs separated by commas. **/
        ids?: Array<string>;
        /** Specify extra data to be included, options are: stats **/
        include?: Array<string>;
    }): CancelablePromise<ApplicationDomainsResponse>;
    /**
     * Create an application domain
     * To help keep your event-driven architecture organized, use application domains to create namespaces for your applications, events and schemas.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application_domain:create:*` ]
     * @returns ApplicationDomainResponse Created. The newly saved application domain is returned in the response body.
     * @throws ApiError
     */
    static createApplicationDomain({ requestBody, xContextId, }: {
        /** Application domains have a name and topic domain. **/
        requestBody: ApplicationDomain;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<ApplicationDomainResponse>;
    /**
     * Get an application domain
     * Use this API to get a single application domain by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application_domain:get:*` ]
     * @returns ApplicationDomainResponse The application domain.
     * @throws ApiError
     */
    static getApplicationDomain({ id, xContextId, include, }: {
        /** The ID of the application domain. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** Specify extra data to be included, options are: stats **/
        include?: Array<string>;
    }): CancelablePromise<ApplicationDomainResponse>;
    /**
     * Delete an application domain
     * Use this API to delete an application domain. This action also deletes all applications, events, and schemas in the application domain. You cannot undo this operation.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application_domain:delete:*` ]
     * @returns void
     * @throws ApiError
     */
    static deleteApplicationDomain({ id, xContextId, }: {
        /** The ID of the application domain. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * Update an application domain
     * Use this API to update an application domain. You only need to specify the fields that need to be updated.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application_domain:update:*` ]
     * @returns ApplicationDomainResponse The updated application domain.
     * @throws ApiError
     */
    static updateApplicationDomain({ id, requestBody, xContextId, }: {
        /** The ID of the application domain. **/
        id: string;
        /** The application domain. **/
        requestBody: ApplicationDomain;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<ApplicationDomainResponse>;
    /**
     * (Beta) Create application domains and their entities from import
     * Use this API to import application domains and their nested entities. Please note that this endpoint is in beta and could be subject to change in the future<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application_domain:import:*` ]
     * @returns any Successfully registered import job with location identified in the response header
     * @throws ApiError
     */
    static importApplicationDomains({ requestBody, xContextId, }: {
        /** Application domain import file **/
        requestBody: ApplicationDomainImportDTO;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<any>;
    /**
     * (Beta) Get application domains and their entities for export
     * Use this API to export application domains and their nested entities. Please note that this endpoint is in beta and could be subject to change in the future<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application_domain:export:*` ]
     * @returns ApplicationDomainExportDTO Export file containing the application domains and accompanying entities
     * @throws ApiError
     */
    static exportApplicationDomains({ ids, xContextId, }: {
        /** The IDs of the application domains to export  **/
        ids: Array<string>;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<ApplicationDomainExportDTO>;
}

declare class ApplicationsService {
    /**
     * Get a list of applications
     * Use this API to get a list of applications that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns ApplicationsResponse Get a list of applications and the accompanying metadata.
     * @throws ApiError
     */
    static getApplications({ xContextId, pageSize, pageNumber, name, applicationDomainId, ids, sort, customAttributes, applicationType, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of applications to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Name of the application to match on. **/
        name?: string;
        /** Match only applications in the given application domain. **/
        applicationDomainId?: string;
        /** Match only applications with the given IDs separated by commas. **/
        ids?: Array<string>;
        /** Sort based on the provided parameters. <br> The value can be either a standalone field name (`?sort=<field>`) or a field and direction, delimited by a colon (`?sort=<field>:<asc|desc>`). If the direction is not specified, the default is ascending. **/
        sort?: string;
        /** Returns the entities that match the custom attribute filter.<br>To filter by custom attribute name and value, use the format: `customAttributes=<custom-attribute-name>==<custom-attribute-value>`. <br>To filter by custom attribute name, use the format: `customAttributes=<custom-attribute-name>`. <br>The filter supports the `AND` operator for multiple custom attribute definitions (not multiple values for a given definition). Use `;` (`semicolon`) to separate multiple queries with `AND` operation. <br>Note: the filter supports custom attribute values containing only the characters `[a-zA-Z0-9_\-\. ]`. **/
        customAttributes?: string;
        /** Match only applications with the given applicationType. **/
        applicationType?: string;
    }): CancelablePromise<ApplicationsResponse>;
    /**
     * Create an application
     * To model your event-driven architecture, applications are a fundamental building block for modelling the producers and consumers of events. Use this API to create applications and model the events they produce and consume.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application:create:*` ]
     * @returns ApplicationResponse Created an application. Returns the newly saved application in the response body.
     * @throws ApiError
     */
    static createApplication({ requestBody, xContextId, }: {
        /** Applications have a name and live within an application domain. Events can be added to the application as produced or consumed. **/
        requestBody: Application;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<ApplicationResponse>;
    /**
     * Get an application
     * Use this API to get a single application by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application:get:*` ]
     * @returns ApplicationResponse The application.
     * @throws ApiError
     */
    static getApplication({ id, xContextId, }: {
        /** The ID of the application. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<ApplicationResponse>;
    /**
     * Delete an application
     * Use this API to delete an application.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application:delete:*` ]
     * @returns void
     * @throws ApiError
     */
    static deleteApplication({ id, xContextId, }: {
        /** The ID of the application **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * Update an application
     * Use this API to update an application. You only need to specify the fields that need to be updated.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application:update:*` ]
     * @returns ApplicationResponse The updated application.
     * @throws ApiError
     */
    static updateApplication({ id, requestBody, xContextId, }: {
        /** The ID of the application to update. **/
        id: string;
        /** The application. **/
        requestBody: Application;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<ApplicationResponse>;
    /**
     * Get a list of application versions
     * Use this API to get a list of application versions that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns ApplicationVersionsResponse Get a list of application versions and the accompanying metadata.
     * @throws ApiError
     */
    static getApplicationVersions({ xContextId, pageSize, pageNumber, applicationIds, ids, messagingServiceIds, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of application versions to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Match only application versions of these application IDs, separated by commas. **/
        applicationIds?: Array<string>;
        /** Match only application versions with the given IDs, separated by commas. **/
        ids?: Array<string>;
        /** Match only application versions with the given messaging service IDs, separated by commas. **/
        messagingServiceIds?: Array<string>;
    }): CancelablePromise<ApplicationVersionsResponse>;
    /**
     * Create an application version
     * Create an application version<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application:update:*` ]
     * @returns ApplicationVersionResponse Created an application version. Returns the newly saved application version in the response body.
     * @throws ApiError
     */
    static createApplicationVersion({ requestBody, xContextId, }: {
        /** App version request body description **/
        requestBody: ApplicationVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<ApplicationVersionResponse>;
    /**
     * Get an application version
     * Use this API to get a single application version by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application:get:*` ]
     * @returns ApplicationVersionResponse The application version.
     * @throws ApiError
     */
    static getApplicationVersion({ versionId, xContextId, }: {
        /** The ID of the application version. **/
        versionId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<ApplicationVersionResponse>;
    /**
     * Delete an application version
     * Use this API to delete an application version.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application:update:*` ]
     * @returns void
     * @throws ApiError
     */
    static deleteApplicationVersion({ versionId, xContextId, }: {
        /** The ID of the application version **/
        versionId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * Update an application version
     * Use this API to update an application version. You only need to specify the fields that need to be updated.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application:update:*` ]
     * @returns ApplicationVersionResponse The updated application version.
     * @throws ApiError
     */
    static updateApplicationVersion({ versionId, requestBody, xContextId, include, relationsBrokerType, }: {
        /** The ID of the application version to update. **/
        versionId: string;
        /** The application version. **/
        requestBody: ApplicationVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
        include?: Array<string>;
        relationsBrokerType?: string;
    }): CancelablePromise<ApplicationVersionResponse>;
    /**
     * Update the state of an application version
     * Use this API to update the state of an application version. You only need to specify the target stateId field.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application:update_state:*` ]
     * @returns StateChangeRequestResponse The updated state of the application version.
     * @throws ApiError
     */
    static updateApplicationVersionState({ versionId, requestBody, xContextId, }: {
        /** The ID of the application version to update. **/
        versionId: string;
        /** The state change object. **/
        requestBody: VersionedObjectStateChangeRequest;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<StateChangeRequestResponse>;
    /**
     * Replace messaging service association for an application version
     * Use this API to replace the messaging service association for an application version.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_runtime:write` ]
     * @returns MessagingServiceAssociationResponse The updated messaging service associations.
     * @throws ApiError
     */
    static updateMsgSvcAssociationForAppVersion({ versionId, requestBody, xContextId, }: {
        /** The ID of the application version **/
        versionId: string;
        /** The messaging service association object **/
        requestBody: MessagingServiceAssociationDTO;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<MessagingServiceAssociationResponse>;
    /**
     * Get the AsyncAPI specification for an application version
     * Use this API to get the AsyncAPI specification for an application version annotated with Event Portal metadata.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application:generate_async_api:*` ]
     * @returns string The AsyncAPI specification for the application version.
     * @throws ApiError
     */
    static getAsyncApiForApplicationVersion({ applicationVersionId, xContextId, format, showVersioning, includedExtensions, asyncApiVersion, environmentOptions, messagingServiceId, }: {
        /** The ID of the application version. **/
        applicationVersionId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The format in which to get the AsyncAPI specification. Possible values are yaml and json. **/
        format?: 'json' | 'yaml';
        /** Include versions in each AsyncAPI object's name when only one version is present **/
        showVersioning?: boolean;
        /** The event portal database keys to include for each AsyncAPI object. **/
        includedExtensions?: 'all' | 'parent' | 'version' | 'none';
        /** The version of AsyncAPI to use. **/
        asyncApiVersion?: '2.0.0' | '2.2.0' | '2.5.0';
        /** Determines whether bindings are applied to declared consumed events or published consumed events in the event mesh or both. **/
        environmentOptions?: 'include_declared_and_attracted_events' | 'include_attracted_events_only';
        /** Applies bindings from consumed events that are published in this messaging service's modeled event mesh. **/
        messagingServiceId?: string;
    }): CancelablePromise<string>;
}

declare class AuditResultsService {
    /**
     * Get a list of audit results
     * This provides a list of audit results for the given event mesh and/or event brokers.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `audit:read` ]
     * @returns AuditResultsResponse The list of audit records and the accompanying metadata.
     * @throws ApiError
     */
    static listAuditResults({ xContextId, pageSize, pageNumber, eventBrokerIds, eventMeshId, auditEntityTypes, statuses, startsWith, contains, sort, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of audit records to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Match only audit records belonging to the given event brokers. **/
        eventBrokerIds?: Array<string>;
        /** Match only audit records belonging to the given event mesh. **/
        eventMeshId?: string;
        /** Match only audit records belonging to the given entity types. **/
        auditEntityTypes?: Array<'all' | 'kafkaConsumerGroup' | 'kafkaConsumerGroupAggregate' | 'kafkaTopic' | 'kafkaTopicAggregate' | 'schemaParent' | 'schemaVersion' | 'solaceQueue' | 'solaceQueueAggregate' | 'solaceTopic' | 'kafkaTopicSchemaVersion' | 'kafkaTopicSchemaParent'>;
        /** Match only audit records with the given statuses. **/
        statuses?: Array<'designerOnly' | 'match' | 'partialMatch' | 'runtimeOnly'>;
        /** Match only audit records with identifiers starting with the given value. **/
        startsWith?: string;
        /** Match audit records with identifiers containing the given value. **/
        contains?: string;
        /** Sort based on the provided parameters. <br> The value can be either a standalone field name (`?sort=<field>`) or a field and direction, delimited by a colon (`?sort=<field>:<asc|desc>`). If the direction is not specified, the default is ascending. Sorting is supported for status and identifier. **/
        sort?: string;
    }): CancelablePromise<AuditResultsResponse>;
    /**
     * Get the details of a single audit result
     * This provides the details of a single audit result, given its id.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `audit:read` ]
     * @returns AuditResultDetailResponse The audit detail.
     * @throws ApiError
     */
    static getAuditResultDetail({ auditResultId, xContextId, }: {
        /** The ID of the audit. **/
        auditResultId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<AuditResultDetailResponse>;
}

declare class BffApplicationVersionsFrontendService {
    /**
     * Get a list of application versions
     * Use this API to get a list of application versions that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns ApplicationVersionsFrontendResponse Get a list of application versions and the accompanying metadata.
     * @throws ApiError
     */
    static getApplicationVersionsForFrontend({ xContextId, pageSize, pageNumber, applicationIds, ids, messagingServiceIds, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of application versions to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Match only application versions of these application IDs, separated by commas. **/
        applicationIds?: Array<string>;
        /** Match only application versions with the given IDs, separated by commas. **/
        ids?: Array<string>;
        /** Match only application versions with the given messaging service IDs, separated by commas. **/
        messagingServiceIds?: Array<string>;
    }): CancelablePromise<ApplicationVersionsFrontendResponse>;
}

declare class ConfigurationsService {
    /**
     * (Beta) Get a list of configurations
     * Use this API to get a list of configurations that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `ep_configuration:read` ]
     * @returns ConfigurationsResponse Get a list of configurations and the accompanying metadata.
     * @throws ApiError
     */
    static getConfigurations({ xContextId, pageSize, pageNumber, eventBrokerIds, ids, configurationTypes, entityTypes, entityIds, sort, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of configurations to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Match only configurations with the given messaging service IDs separated by commas. **/
        eventBrokerIds?: Array<string>;
        /** Match only configurations with the given IDs separated by commas. **/
        ids?: Array<string>;
        /** Match only configurations with the given configuration type names separated by commas.<br>Refer <a href="/cloud/reference/getconfigurationtypes">here</a> for details on configuration types. **/
        configurationTypes?: Array<string>;
        /** Match only configurations with the given entity type values separated by commas. **/
        entityTypes?: Array<string>;
        /** Match only configurations with the given entity IDs separated by commas. **/
        entityIds?: Array<string>;
        /** Sort based on the provided parameters. <br> The value can be either a standalone field name (`?sort=<field>`) or a field and direction, delimited by a colon (`?sort=<field>:<asc|desc>`). If the direction is not specified, the default is ascending. **/
        sort?: string;
    }): CancelablePromise<ConfigurationsResponse>;
    /**
     * (Beta) Get a configuration
     * Use this API to get a single configuration by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `ep_configuration:read` ]
     * @returns ConfigurationResponse The configuration.
     * @throws ApiError
     */
    static getConfiguration({ id, xContextId, }: {
        /** The ID of the configuration. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<ConfigurationResponse>;
}

declare class ConfigurationTypesService {
    /**
     * (Beta) Get a list of configuration types
     * Use this API to get a list of configuration types that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `ep_configuration:read` ]
     * @returns ConfigurationTypesResponse Get a list of configuration types and the accompanying metadata.
     * @throws ApiError
     */
    static getConfigurationTypes({ xContextId, pageSize, pageNumber, ids, names, associatedEntityTypes, brokerType, sort, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of configuration types to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Match only configuration types with the given IDs separated by commas. **/
        ids?: Array<string>;
        /** Match only configuration types with the given names separated by commas. **/
        names?: Array<string>;
        /** Match only configuration types with the given associated entity type values separated by commas. **/
        associatedEntityTypes?: Array<string>;
        /** Match only configuration types with the given broker type. **/
        brokerType?: string;
        /** Sort based on the provided parameters. <br> The value can be either a standalone field name (`?sort=<field>`) or a field and direction, delimited by a colon (`?sort=<field>:<asc|desc>`). If the direction is not specified, the default is ascending. **/
        sort?: string;
    }): CancelablePromise<ConfigurationTypesResponse>;
    /**
     * (Beta) Get a configuration type
     * Use this API to get a single configuration type by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `ep_configuration:read` ]
     * @returns ConfigurationTypeResponse The configuration type.
     * @throws ApiError
     */
    static getConfigurationType({ id, xContextId, }: {
        /** The ID of the configuration type. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<ConfigurationTypeResponse>;
}

declare class ConsumersService {
    /**
     * Get a list of consumers
     * Use this API to get a list of consumers that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns ConsumersResponse Get a list of consumers and the accompanying metadata.
     * @throws ApiError
     */
    static getConsumers({ xContextId, pageSize, pageNumber, applicationVersionIds, ids, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of consumers to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Match only consumers with the given application version IDs, separated by commas. **/
        applicationVersionIds?: Array<string>;
        /** Match only consumers with the given IDs separated by commas. **/
        ids?: Array<string>;
    }): CancelablePromise<ConsumersResponse>;
    /**
     * Create a consumer
     * Use this API to create a consumer.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application:update:*` ]
     * @returns ConsumerResponse Created a consumer. Returns the newly saved consumer in the response body.
     * @throws ApiError
     */
    static createConsumer({ requestBody, xContextId, }: {
        /** The consumer. **/
        requestBody: Consumer;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<ConsumerResponse>;
    /**
     * Get a consumer
     * Use this API to get a single consumer by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application:get:*` ]
     * @returns ConsumerResponse The consumer.
     * @throws ApiError
     */
    static getConsumer({ id, xContextId, }: {
        /** The ID of the consumer. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<ConsumerResponse>;
    /**
     * Delete a consumer
     * Use this API to delete a consumer.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application:update:*` ]
     * @returns void
     * @throws ApiError
     */
    static deleteConsumer({ id, xContextId, }: {
        /** The ID of the consumer **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * Update a consumer
     * Use this API to update a consumer.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `application:update:*` ]
     * @returns ConsumerResponse Updated a consumer. Returns the newly saved consumer in the response body.
     * @throws ApiError
     */
    static updateConsumer({ id, requestBody, xContextId, }: {
        /** The ID of the consumer. **/
        id: string;
        /** The consumer. **/
        requestBody: Consumer;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<ConsumerResponse>;
}

declare class CustomAttributeDefinitionsService {
    /**
     * Get a list of custom attribute definitions
     * Use this API to get a list of custom attribute definitions that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns CustomAttributeDefinitionsResponse Get a list of custom attribute definitions and the accompanying metadata.
     * @throws ApiError
     */
    static getCustomAttributeDefinitions({ xContextId, pageSize, pageNumber, associatedEntityTypes, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of custom attribute definitions to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Match only custom attribute definitions with the given associated entity type names separated by commas. **/
        associatedEntityTypes?: Array<string>;
    }): CancelablePromise<CustomAttributeDefinitionsResponse>;
    /**
     * Create a custom attribute definition
     * Use this API to create a custom attribute definition.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `custom_attribute:write` ]
     * @returns CustomAttributeDefinitionResponse Created a custom attribute definition. Returns the newly saved custom attribute definition in the response body.
     * @throws ApiError
     */
    static createCustomAttributeDefinition({ requestBody, xContextId, }: {
        /** The custom attribute definition. **/
        requestBody: CustomAttributeDefinition;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<CustomAttributeDefinitionResponse>;
    /**
     * Get a custom attribute definition
     * Use this API to get a single custom attribute definition by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns CustomAttributeDefinitionResponse The custom attribute definition.
     * @throws ApiError
     */
    static getCustomAttributeDefinition({ id, xContextId, }: {
        /** The ID of the custom attribute definition. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<CustomAttributeDefinitionResponse>;
    /**
     * Delete a custom attribute definition
     * Use this API to delete a custom attribute definition.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `custom_attribute:write` ]
     * @returns void
     * @throws ApiError
     */
    static deleteCustomAttributeDefinition({ id, xContextId, }: {
        /** The ID of the custom attribute definition **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * Update a custom attribute definition
     * Use this API to update a custom attribute definition. You can only update the associated entity types.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `custom_attribute:write` ]
     * @returns CustomAttributeDefinitionResponse The updated custom attribute definition.
     * @throws ApiError
     */
    static updateCustomAttributeDefinition({ id, requestBody, xContextId, }: {
        /** The ID of the custom attribute definition to update. **/
        id: string;
        /** The custom attribute definition. **/
        requestBody: CustomAttributeDefinition;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<CustomAttributeDefinitionResponse>;
    /**
     * Get a list the custom attribute definitions of provided application domain
     * Use this API to get a list of custom attribute definitions that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `custom_attribute:get:*` ]
     * @returns CustomAttributeDefinitionsResponse Get a list of custom attribute definitions of a given application domain id.
     * @throws ApiError
     */
    static getCustomAttributeDefinitionsByApplicationDomain({ applicationDomainId, xContextId, pageSize, pageNumber, }: {
        /** Match only custom attribute definitions with the given application domain Id  **/
        applicationDomainId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of custom attribute definitions to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
    }): CancelablePromise<CustomAttributeDefinitionsResponse>;
    /**
     * Create a custom attribute definition for provided application domain
     * Use this API to create a custom attribute definition for provided application domain.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `custom_attribute:create:*` ]
     * @returns CustomAttributeDefinitionResponse Created a custom attribute definition in provided application domain and Returns the newly saved custom attribute definition in the response body.
     * @throws ApiError
     */
    static createCustomAttributeDefinitionByApplicationDomain({ applicationDomainId, requestBody, xContextId, }: {
        /** The ID of the application domain **/
        applicationDomainId: string;
        /** The custom attribute definition. **/
        requestBody: CustomAttributeDefinition;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<CustomAttributeDefinitionResponse>;
    /**
     * Delete a custom attribute definition of provided application domain
     * Use this API to delete a custom attribute definition by given application domain.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `custom_attribute:delete:*` ]
     * @returns void
     * @throws ApiError
     */
    static deleteCustomAttributeDefinitionByApplicationDomain({ applicationDomainId, xContextId, }: {
        /** The ID of the application domain **/
        applicationDomainId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * Delete a custom attribute definition of provided application domain
     * Use this API to delete a custom attribute definition of given application domain.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `custom_attribute:delete:*` ]
     * @returns void
     * @throws ApiError
     */
    static deleteCustomAttributeDefinitionOfApplicationDomain({ applicationDomainId, customAttributeId, xContextId, }: {
        /** The ID of the application domain **/
        applicationDomainId: string;
        /** The ID of the custom attribute definition **/
        customAttributeId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * Update a custom attribute definition for provided application domain
     * Use this API to update a custom attribute definition for provided application domain.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `custom_attribute:update:*` ]
     * @returns CustomAttributeDefinitionResponse Updated a custom attribute definition in provided application domain and Returns the newly saved custom attribute definition in the response body.
     * @throws ApiError
     */
    static updateCustomAttributeDefinitionByApplicationDomain({ applicationDomainId, customAttributeId, requestBody, xContextId, }: {
        /** The ID of the application domain **/
        applicationDomainId: string;
        /** The ID of the custom attribute definition **/
        customAttributeId: string;
        /** The custom attribute definition. **/
        requestBody: CustomAttributeDefinition;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<CustomAttributeDefinitionResponse>;
}

declare class EnumsService {
    /**
     * Get a list of enumerations
     * Use this API to get a list of enumerations based on certain criteria.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns TopicAddressEnumsResponse Get a list of enumerations and the accompanying metadata.
     * @throws ApiError
     */
    static getEnums({ xContextId, pageSize, pageNumber, ids, applicationDomainId, applicationDomainIds, names, shared, sort, customAttributes, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of enumerations to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** The IDs of the enumerations. **/
        ids?: Array<string>;
        /** The application domain ID of the enumerations. **/
        applicationDomainId?: string;
        /** Match only enumerations in the given application domain ids. **/
        applicationDomainIds?: Array<string>;
        /** The names of the enumerations. **/
        names?: Array<string>;
        /** Match only with shared or unshared enumerations. **/
        shared?: boolean;
        /** Sort based on the provided parameters. <br> The value can be either a standalone field name (`?sort=<field>`) or a field and direction, delimited by a colon (`?sort=<field>:<asc|desc>`). If the direction is not specified, the default is ascending. **/
        sort?: string;
        /** Returns the entities that match the custom attribute filter.<br>To filter by custom attribute name and value, use the format: `customAttributes=<custom-attribute-name>==<custom-attribute-value>`. <br>To filter by custom attribute name, use the format: `customAttributes=<custom-attribute-name>`. <br>The filter supports the `AND` operator for multiple custom attribute definitions (not multiple values for a given definition). Use `;` (`semicolon`) to separate multiple queries with `AND` operation. <br>Note: the filter supports custom attribute values containing only the characters `[a-zA-Z0-9_\-\. ]`. **/
        customAttributes?: string;
    }): CancelablePromise<TopicAddressEnumsResponse>;
    /**
     * Create an enumeration
     * An enumeration is a bounded variable with a limited set of literal values. Use this API to create an enumeration to define acceptable values for a level in a topic address or topic domain.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `ep_enum:create:*` ]
     * @returns TopicAddressEnumResponse Created an enumeration. The newly saved enumeration is returned in the response body.
     * @throws ApiError
     */
    static createEnum({ requestBody, xContextId, }: {
        /** Enumeration description. **/
        requestBody: TopicAddressEnum;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<TopicAddressEnumResponse>;
    /**
     * Get an enumeration
     * Use this API to get a single enumeration by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `ep_enum:get:*` ]
     * @returns TopicAddressEnumResponse The enumeration.
     * @throws ApiError
     */
    static getEnum({ id, xContextId, }: {
        /** The ID of the enumeration. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<TopicAddressEnumResponse>;
    /**
     * Delete an enumeration
     * Use this API to delete an enumeration. The enumeration must not have any versions or else it cannot be deleted.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `ep_enum:delete:*` ]
     * @returns void
     * @throws ApiError
     */
    static deleteEnum({ id, xContextId, }: {
        /** The ID of the enumeration. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * Update an enumeration
     * Use this API to update an enumeration object. You only need to specify the fields that need to be updated.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `ep_enum:update:*` ]
     * @returns TopicAddressEnumResponse Updated an enumeration. The newly saved enumeration is returned in the response body.
     * @throws ApiError
     */
    static updateEnum({ id, requestBody, xContextId, }: {
        /** The ID of the enumeration. **/
        id: string;
        /** Enumeration updates. **/
        requestBody: TopicAddressEnum;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<TopicAddressEnumResponse>;
    /**
     * Get a list of enumeration versions
     * Use this API to get a list of enumeration versions that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns TopicAddressEnumVersionsResponse Get a list of enumeration versions and the accompanying metadata.
     * @throws ApiError
     */
    static getEnumVersions({ xContextId, pageSize, pageNumber, enumIds, ids, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of enumeration versions to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Match only enumeration versions of these enumeration IDs, separated by commas. **/
        enumIds?: Array<string>;
        /** Match only enumeration versions with the given IDs, separated by commas. **/
        ids?: Array<string>;
    }): CancelablePromise<TopicAddressEnumVersionsResponse>;
    /**
     * Create an enumeration version
     * Create an enumeration version.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `ep_enum:update:*` ]
     * @returns TopicAddressEnumVersionResponse Created an enumeration version and its values. The newly saved enumeration version is returned in the response body.
     * @throws ApiError
     */
    static createEnumVersion({ requestBody, xContextId, }: {
        /** Enumeration version description with its values. **/
        requestBody: TopicAddressEnumVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<TopicAddressEnumVersionResponse>;
    /**
     * Delete an enumeration version
     * Use this API to delete an enumeration version. The version must not be in use by any events else it cannot be deleted. This also deletes the version's values.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `ep_enum:update:*` ]
     * @returns void
     * @throws ApiError
     */
    static deleteEnumVersion({ id, xContextId, }: {
        /** The ID of the enumeration version. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * Update an enumeration version
     * Use this API to update an enumeration version. You only need to specify the fields that need to be updated.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `ep_enum:update:*` ]
     * @returns TopicAddressEnumVersionResponse The updated enumeration version.
     * @throws ApiError
     */
    static updateEnumVersion({ id, requestBody, xContextId, }: {
        /** The ID of the enumeration version to update. **/
        id: string;
        /** The enumeration version. **/
        requestBody: TopicAddressEnumVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<TopicAddressEnumVersionResponse>;
    /**
     * Update the state of an enumeration version
     * Use this API to update the state of an enumeration version. You only need to specify the target stateId field.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `ep_enum:update_state:*` ]
     * @returns StateChangeRequestResponse The updated state of the enumeration version.
     * @throws ApiError
     */
    static updateEnumVersionState({ id, requestBody, xContextId, }: {
        /** The ID of the enumeration version to update. **/
        id: string;
        /** The state object. **/
        requestBody: VersionedObjectStateChangeRequest;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<StateChangeRequestResponse>;
    /**
     * Get an enumeration version
     * Use this API to get a single enumeration version by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `ep_enum:get:*` ]
     * @returns TopicAddressEnumVersionResponse The enumeration version.
     * @throws ApiError
     */
    static getEnumVersion({ versionId, xContextId, }: {
        /** The ID of the enumeration version. **/
        versionId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<TopicAddressEnumVersionResponse>;
}

declare class EnvironmentsService {
    /**
     * Get a list of environments
     * Use this API to get a list of all environments.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns EnvironmentsResponse Get a list of environments and the accompanying metadata.
     * @throws ApiError
     */
    static getEnvironments({ xContextId, pageSize, pageNumber, sort, like, ids, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of environments to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        sort?: string;
        like?: string;
        ids?: Array<string>;
    }): CancelablePromise<EnvironmentsResponse>;
    /**
     * Get an environment
     * Use this API to get a single environment by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns EnvironmentResponse The environment.
     * @throws ApiError
     */
    static getEnvironment({ id, xContextId, }: {
        /** The ID of the environment. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EnvironmentResponse>;
}

declare class EventApiProductsService {
    /**
     * Get a List of Event API Products
     * Use this API to get a list of Event API Products that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns EventApiProductsResponse The list of Event API Products and the accompanying metadata.
     * @throws ApiError
     */
    static getEventApiProducts({ xContextId, pageSize, pageNumber, brokerType, name, ids, applicationDomainId, applicationDomainIds, shared, sort, customAttributes, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of Event API Products to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Match only Event API Products with the given broken type. **/
        brokerType?: string;
        /** Name of the Event API Product to match on. **/
        name?: string;
        /** Match only Event API Products with the given IDs separated by commas. **/
        ids?: Array<string>;
        /** Match only Event API Products in the given application domain. **/
        applicationDomainId?: string;
        /** Match only Event API Products in the given application domains. **/
        applicationDomainIds?: Array<string>;
        /** Match only with shared or unshared Event API Products. **/
        shared?: boolean;
        /** Sort based on the provided parameters. <br> The value can be either a standalone field name (`?sort=<field>`) or a field and direction, delimited by a colon (`?sort=<field>:<asc|desc>`). If the direction is not specified, the default is ascending. **/
        sort?: string;
        /** Returns the entities that match the custom attribute filter.<br>To filter by custom attribute name and value, use the format: `customAttributes=<custom-attribute-name>==<custom-attribute-value>`. <br>To filter by custom attribute name, use the format: `customAttributes=<custom-attribute-name>`. <br>The filter supports the `AND` operator for multiple custom attribute definitions (not multiple values for a given definition). Use `;` (`semicolon`) to separate multiple queries with `AND` operation. <br>Note: the filter supports custom attribute values containing only the characters `[a-zA-Z0-9_\-\. ]`. **/
        customAttributes?: string;
    }): CancelablePromise<EventApiProductsResponse>;
    /**
     * Create an Event API Product
     * Use this API to create an Event API Product.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api_product:create:*` ]
     * @returns EventApiProductResponse Created an Event API Product. The newly saved Event API Product is returned in the response body.
     * @throws ApiError
     */
    static createEventApiProduct({ requestBody, xContextId, }: {
        /** The Event API Product. **/
        requestBody: EventApiProduct;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventApiProductResponse>;
    /**
     * Get an Event API Product
     * Use this API to get a single Event API Product by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api_product:get:*` ]
     * @returns EventApiProductResponse The Event API Product.
     * @throws ApiError
     */
    static getEventApiProduct({ id, xContextId, }: {
        /** The ID of the Event API Product. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventApiProductResponse>;
    /**
     * Delete an Event API Product
     * Use this API to delete an Event API Product.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api_product:delete:*` ]
     * @returns void
     * @throws ApiError
     */
    static deleteEventApiProduct({ id, xContextId, }: {
        /** The ID of the Event API Product. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * Update an Event API Product
     * Use this API to update an Event API Product. You only need to specify the fields that need to be updated.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api_product:update:*` ]
     * @returns EventApiProductResponse The updated Event API Product.
     * @throws ApiError
     */
    static updateEventApiProduct({ id, requestBody, xContextId, }: {
        /** The ID of the Event API Product to update. **/
        id: string;
        /** The Event API Product. **/
        requestBody: EventApiProduct;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventApiProductResponse>;
    /**
     * (Beta) Get a List of Event API Product Versions
     * Use this API to get a list of Event API Product versions that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns EventApiProductVersionsResponse Get a list of Event API Product versions.
     * @throws ApiError
     */
    static getEventApiProductVersions({ xContextId, pageSize, pageNumber, eventApiProductIds, ids, include, stateId, messagingServiceId, clientAppId, shared, latest, customAttributes, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of results to return in one page of results. **/
        pageSize?: number;
        /** The page number to get results from based on the page size. **/
        pageNumber?: number;
        /** Match only Event API Product versions of these Event API Product IDs, separated by commas. **/
        eventApiProductIds?: Array<string>;
        /** Match Event API Product versions with the given IDs, separated by commas. **/
        ids?: Array<string>;
        /** A list of additional entities to include in the response. **/
        include?: string;
        /** Match Event API Product versions with the given state ID. **/
        stateId?: string;
        /** Match Event API Product versions with the given messagingServiceId. **/
        messagingServiceId?: string;
        /** Match Event API Product versions with the given clientAppId. **/
        clientAppId?: string;
        /** Match Event API Product versions with the parent objects shared setting. **/
        shared?: boolean;
        /** Only return the latest version of Event API Products. **/
        latest?: boolean;
        /** Returns the entities that match the custom attribute filter.<br>To filter by custom attribute name and value, use the format: `customAttributes=<custom-attribute-name>==<custom-attribute-value>`. <br>To filter by custom attribute name, use the format: `customAttributes=<custom-attribute-name>`. <br>The filter supports the `AND` operator for multiple custom attribute definitions (not multiple values for a given definition). Use `;` (`semicolon`) to separate multiple queries with `AND` operation. <br>Note: the filter supports custom attribute values containing only the characters `[a-zA-Z0-9_\-\. ]`. **/
        customAttributes?: string;
    }): CancelablePromise<EventApiProductVersionsResponse>;
    /**
     * (Beta) Create an Event API Product Version
     * Use this API to create an Event API Product version.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api_product:update:*` ]
     * @returns EventApiProductVersionResponse Created an Event API Product version. Returns the newly saved Event API Product version in the response body.
     * @throws ApiError
     */
    static createEventApiProductVersion({ requestBody, xContextId, }: {
        /** Event API Product version. **/
        requestBody: EventApiProductVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventApiProductVersionResponse>;
    /**
     * (Beta) Get an Event API Product Version
     * Use this API to get a single Event API Product version by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api_product:get:*` ]
     * @returns EventApiProductVersionResponse The Event API Product version.
     * @throws ApiError
     */
    static getEventApiProductVersion({ versionId, xContextId, include, clientAppId, }: {
        /** The ID of the Event API Product version. **/
        versionId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** A list of additional entities to include in the response. **/
        include?: string;
        /** Match Event API Product versions with the given clientAppId. **/
        clientAppId?: string;
    }): CancelablePromise<EventApiProductVersionResponse>;
    /**
     * (Beta) Delete an Event API Product Version by ID
     * Use this API to delete an Event API Product version by ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api_product:update:*` ]
     * @returns void
     * @throws ApiError
     */
    static deleteEventApiProductVersion({ versionId, xContextId, }: {
        /** The ID of the Event API Product version. **/
        versionId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * (Beta) Update an Event API Product Version by Version ID
     * Use this API to update an Event API Product version. You only need to specify the fields that need to be updated.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api_product:update:*` ]
     * @returns EventApiProductVersionResponse The updated Event API Product version.
     * @throws ApiError
     */
    static updateEventApiProductVersion({ versionId, requestBody, xContextId, }: {
        /** The ID of the Event API Product version. **/
        versionId: string;
        /** The Event API Product version. **/
        requestBody: EventApiProductVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventApiProductVersionResponse>;
    /**
     * Update the State of an Event API Product Version by ID
     * Use this API to update the state of an Event API Product version. You only need to specify the state ID field with the desired state ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api_product:update_state:*` ]
     * @returns StateChangeRequestResponse The updated state of the Event API Product version.
     * @throws ApiError
     */
    static updateEventApiProductVersionState({ versionId, requestBody, xContextId, }: {
        /** The ID of the Event API Product version. **/
        versionId: string;
        /** The Event API Product version. **/
        requestBody: EventApiProductVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<StateChangeRequestResponse>;
    /**
     * Update an Event API Product Version To Be Published
     * Use this API to publish Event API Product version. Cannot unset once it is published.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api_product:update_state:*` ]
     * @returns StateChangeRequestResponse Updated the state of the Event API Product version to Published.
     * @throws ApiError
     */
    static publishEventApiProductVersion({ versionId, xContextId, requestBody, }: {
        /** The ID of the Event API Product version. **/
        versionId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The Event API Product version. **/
        requestBody?: EventApiProductVersion;
    }): CancelablePromise<StateChangeRequestResponse>;
    /**
     * (Beta) Delete an Association Between a Gateway Messaging Service and an Event API Product Version by Association ID
     * Use this API to disassociate an Event API Product version and gateway messaging service by association ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api_product:update:*` ]
     * @returns void
     * @throws ApiError
     */
    static disassociateGatewayMessagingServiceFromEventApiProductVersionById({ memAssociationId, xContextId, }: {
        /** The association ID to perform the disassociation for. **/
        memAssociationId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * (Beta) Create an Association Between a Gateway Messaging Service and an Event API Product Version
     * Use this API to associate an Event API Product version and gateway messaging service.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api_product:update:*` ]
     * @returns GatewayMessagingServiceResponse Associated GatewayMessagingService to Event API Product version.
     * @throws ApiError
     */
    static associateGatewayMessagingServiceToEapVersion({ eventApiProductVersionId, requestBody, xContextId, }: {
        /** The ID of the Event API Product version to associate. **/
        eventApiProductVersionId: string;
        /** Gateway messaging service Id and supported Protocols. **/
        requestBody: GatewayMessagingService;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<GatewayMessagingServiceResponse>;
    /**
     * (Beta) Delete an Association Between a Gateway Messaging Service and an Event API Product Version
     * Use this API to disassociate an Event API Product version and gateway messaging service.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api_product:update:*` ]
     * @returns void
     * @throws ApiError
     */
    static disassociateGatewayMessagingServiceToEapVersion({ eventApiProductVersionId, memAssociationId, xContextId, }: {
        /** The ID of the Event API Product version to disassociate. **/
        eventApiProductVersionId: string;
        /** The MEM association ID to dissociate from. **/
        memAssociationId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
}

declare class EventApIsService {
    /**
     * Get a List of Event APIs
     * Use this API to get a list of event APIs that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns EventApisResponse Get a list of event APIs and the accompanying metadata.
     * @throws ApiError
     */
    static getEventApis({ xContextId, pageSize, pageNumber, name, ids, applicationDomainId, applicationDomainIds, eventApiVersionIds, availableWithinApplicationDomainIds, shared, brokerType, sort, customAttributes, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of event APIs to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Name of the event API to match on. **/
        name?: string;
        /** Match only event APIs with the given IDs separated by commas. **/
        ids?: Array<string>;
        /** Match only event APIs in the given application domain. **/
        applicationDomainId?: string;
        /** Match only event APIs in the given application domains. **/
        applicationDomainIds?: Array<string>;
        /** Match only event APIs in the given event API version ids. **/
        eventApiVersionIds?: Array<string>;
        /** Additionally match any shared event APIs in any application domain. **/
        availableWithinApplicationDomainIds?: boolean;
        /** Match only with shared or unshared event APIs. **/
        shared?: boolean;
        /** Match only event APIs with the given broker type. **/
        brokerType?: string;
        /** Sort based on the provided parameters. <br> The value can be either a standalone field name (`?sort=<field>`) or a field and direction, delimited by a colon (`?sort=<field>:<asc|desc>`). If the direction is not specified, the default is ascending. **/
        sort?: string;
        /** Returns the entities that match the custom attribute filter.<br>To filter by custom attribute name and value, use the format: `customAttributes=<custom-attribute-name>==<custom-attribute-value>`. <br>To filter by custom attribute name, use the format: `customAttributes=<custom-attribute-name>`. <br>The filter supports the `AND` operator for multiple custom attribute definitions (not multiple values for a given definition). Use `;` (`semicolon`) to separate multiple queries with `AND` operation. <br>Note: the filter supports custom attribute values containing only the characters `[a-zA-Z0-9_\-\. ]`. **/
        customAttributes?: string;
    }): CancelablePromise<EventApisResponse>;
    /**
     * Create an Event API
     * Use this API to create an event API.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api:create:*` ]
     * @returns EventApiResponse Created an event API. The newly saved event API is returned in the response body.
     * @throws ApiError
     */
    static createEventApi({ requestBody, xContextId, }: {
        /** The event API. **/
        requestBody: EventApi;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventApiResponse>;
    /**
     * Get an Event API
     * Use this API to get a single event API by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api:get:*` ]
     * @returns EventApiResponse The event API.
     * @throws ApiError
     */
    static getEventApi({ id, xContextId, }: {
        /** The ID of the event API. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventApiResponse>;
    /**
     * Delete an Event API
     * Use this API to delete an event API.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api:delete:*` ]
     * @returns void
     * @throws ApiError
     */
    static deleteEventApi({ id, xContextId, }: {
        /** The ID of the event API. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * Update an Event API
     * Use this API to update an event API. You only need to specify the fields that need to be updated.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api:update:*` ]
     * @returns EventApiResponse The updated event API.
     * @throws ApiError
     */
    static updateEventApi({ id, requestBody, xContextId, }: {
        /** The ID of the event API to update. **/
        id: string;
        /** The event API. **/
        requestBody: EventApi;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventApiResponse>;
    /**
     * Get a List of Event API Versions
     * Use this API to get a list of event API versions that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns EventApiVersionsResponse Get a list of event API versions.
     * @throws ApiError
     */
    static getEventApiVersions({ xContextId, pageSize, pageNumber, eventApiIds, ids, include, stateId, customAttributes, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of results to return in one page of results. **/
        pageSize?: number;
        /** The page number to get results from based on the page size. **/
        pageNumber?: number;
        /** Match only event API versions of these event API IDs, separated by commas. **/
        eventApiIds?: Array<string>;
        /** Match event API versions with the given IDs, separated by commas. **/
        ids?: Array<string>;
        /** A list of additional entities to include in the response. **/
        include?: string;
        /** Match event API versions with the given state ID. **/
        stateId?: string;
        /** Returns the entities that match the custom attribute filter.<br>To filter by custom attribute name and value, use the format: `customAttributes=<custom-attribute-name>==<custom-attribute-value>`. <br>To filter by custom attribute name, use the format: `customAttributes=<custom-attribute-name>`. <br>The filter supports the `AND` operator for multiple custom attribute definitions (not multiple values for a given definition). Use `;` (`semicolon`) to separate multiple queries with `AND` operation. <br>Note: the filter supports custom attribute values containing only the characters `[a-zA-Z0-9_\-\. ]`. **/
        customAttributes?: string;
    }): CancelablePromise<EventApiVersionsResponse>;
    /**
     * Create an Event API Version
     * Use this API to create an event API version.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api:update:*` ]
     * @returns EventApiVersionResponse Created an event API version. Returns the newly saved event API version in the response body.
     * @throws ApiError
     */
    static createEventApiVersion({ requestBody, xContextId, }: {
        /** Event API version. **/
        requestBody: EventApiVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventApiVersionResponse>;
    /**
     * Get an Event API Version
     * Use this API to get a single event API version by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api:get:*` ]
     * @returns EventApiVersionResponse The event API version.
     * @throws ApiError
     */
    static getEventApiVersion({ versionId, xContextId, include, }: {
        /** The ID of the event API version. **/
        versionId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** A list of additional entities to include in the response. **/
        include?: string;
    }): CancelablePromise<EventApiVersionResponse>;
    /**
     * Delete an Event API Version
     * Use this API to delete an event API version by event API version ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api:update:*` ]
     * @returns void
     * @throws ApiError
     */
    static deleteEventApiVersion({ versionId, xContextId, }: {
        /** The ID of the event API version. **/
        versionId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * Update an Event API by Event API Version ID
     * Use this API to update an event API version by event API version ID.You only need to specify the fields that need to be updated.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api:update:*` ]
     * @returns EventApiVersionResponse The updated event API version.
     * @throws ApiError
     */
    static updateEventApiVersion({ versionId, requestBody, xContextId, }: {
        /** The ID of the event API version. **/
        versionId: string;
        /** The event API version. **/
        requestBody: EventApiVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventApiVersionResponse>;
    /**
     * @deprecated
     * Get a List of Event API Versions
     * *Deprecation Date: 2022-11-01<br>Removal Date: 2023-12-01<br>Reason: Replaced by <a href="/cloud/reference/geteventapiversions">another endpoint.</a><br><br>*Use this API to get a list of event API versions under a particular event API matching the given parameters.
     * @returns EventApiVersionsResponse Get a list of event API versions.
     * @throws ApiError
     */
    static getEventApiVersionsForEventApi({ eventApiId, id, xContextId, displayName, ids, version, stateId, customAttributes, }: {
        /** The ID of the parent event API. **/
        eventApiId: string;
        /** The ID of the event API version. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** Match event API versions with the given display name. **/
        displayName?: string;
        /** Match event API versions with the given IDs separated by commas. **/
        ids?: Array<string>;
        /** Match event API versions with the given version. **/
        version?: string;
        /** Match event API versions with the given state ID. **/
        stateId?: string;
        /** Returns the entities that match the custom attribute filter.<br>To filter by custom attribute name and value, use the format: `customAttributes=<custom-attribute-name>==<custom-attribute-value>`. <br>To filter by custom attribute name, use the format: `customAttributes=<custom-attribute-name>`. <br>The filter supports the `AND` operator for multiple custom attribute definitions (not multiple values for a given definition). Use `;` (`semicolon`) to separate multiple queries with `AND` operation. <br>Note: the filter supports custom attribute values containing only the characters `[a-zA-Z0-9_\-\. ]`. **/
        customAttributes?: string;
    }): CancelablePromise<EventApiVersionsResponse>;
    /**
     * @deprecated
     * Create an Event API Version
     * *Deprecation Date: 2022-11-01<br>Removal Date: 2023-12-01<br>Reason: Replaced by <a href="/cloud/reference/createeventapiversion">another endpoint.</a><br><br>*Use this API to create an event API version.
     * @returns EventApiVersionResponse Created an event API version. Returns the newly saved event API version in the response body.
     * @throws ApiError
     */
    static createEventApiVersionForEventApi({ eventApiId, requestBody, xContextId, }: {
        /** The ID of the parent event API. **/
        eventApiId: string;
        /** Event API version. **/
        requestBody: EventApiVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventApiVersionResponse>;
    /**
     * Update the State of an Event API Version by Event API Version ID
     * Use this API to update the state of an event API version. You only need to specify the state ID field with the desired state ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api:update_state:*` ]
     * @returns StateChangeRequestResponse The updated state of the event API version.
     * @throws ApiError
     */
    static updateEventApiVersionState({ versionId, requestBody, xContextId, }: {
        /** The ID of the event API version. **/
        versionId: string;
        /** The Event API version. **/
        requestBody: EventApiVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<StateChangeRequestResponse>;
    /**
     * @deprecated
     * Get an Event API Version
     * *Deprecation Date: 2022-11-01<br>Removal Date: 2023-12-01<br>Reason: Replaced by <a href="/cloud/reference/geteventapiversion">another endpoint.</a><br><br>*Use this API to get a single event API version using the parent ID and the version's ID.
     * @returns EventApiVersionResponse The event API version.
     * @throws ApiError
     */
    static getEventApiVersionForEventApi({ eventApiId, id, xContextId, }: {
        /** The ID of the parent event API. **/
        eventApiId: string;
        /** The ID of the event API version. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventApiVersionResponse>;
    /**
     * @deprecated
     * Delete an Event API Version
     * *Deprecation Date: 2022-11-01<br>Removal Date: 2023-12-01<br>Reason: Replaced by <a href="/cloud/reference/deleteeventapiversion">another endpoint.</a><br><br>*Use this API to delete an event API version.
     * @returns void
     * @throws ApiError
     */
    static deleteEventApiVersionForEventApi({ eventApiId, id, xContextId, }: {
        /** The ID of the parent event API. **/
        eventApiId: string;
        /** The ID of the event API version. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * @deprecated
     * Update an Event API Version
     * *Deprecation Date: 2022-11-01<br>Removal Date: 2023-12-01<br>Reason: Replaced by <a href="/cloud/reference/updateeventapiversion">another endpoint.</a><br><br>*Use this API to update an event API version. You only need to specify the fields that need to be updated.
     * @returns EventApiVersionResponse The updated event API version.
     * @throws ApiError
     */
    static updateEventApiVersionForEventApi({ eventApiId, id, requestBody, xContextId, }: {
        /** The ID of the parent event API. **/
        eventApiId: string;
        /** The ID of the event API version to update. **/
        id: string;
        /** The event API version. **/
        requestBody: EventApiVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventApiVersionResponse>;
    /**
     * @deprecated
     * Update the State of an Event API Version
     * *Deprecation Date: 2022-11-01<br>Removal Date: 2023-12-01<br>Reason: Replaced by <a href="/cloud/reference/updateeventapiversionstate">another endpoint.</a><br><br>*Use this API to update the state of an event API version. You only need to specify the state ID field with the desired state ID.
     * @returns VersionedObjectStateChangeRequest The updated state of the event API version.
     * @throws ApiError
     */
    static updateEventApiVersionStateForEventApi({ eventApiId, id, requestBody, xContextId, }: {
        /** The ID of the parent event API. **/
        eventApiId: string;
        /** The ID of the event API version to update. **/
        id: string;
        /** The event API version. **/
        requestBody: EventApiVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<VersionedObjectStateChangeRequest>;
    /**
     * @deprecated
     * Get the AsyncAPI Specification for an Event API Version
     * *Deprecation Date: 2022-11-01<br>Removal Date: 2023-12-01<br>Reason: Replaced by <a href="/cloud/reference/getasyncapiforeventapiversion">another endpoint.</a><br><br>*Use this API to get the AsyncAPI specification for an event API version using the parent ID and the version's ID.
     * @returns string The AsyncAPI specification for the event API version.
     * @throws ApiError
     */
    static getEventApiVersionAsyncApiForEventApi({ eventApiId, id, xContextId, showVersioning, includedExtensions, format, version, eventApiProductVersionId, planId, gatewayMessagingServiceIds, }: {
        /** The ID of the parent event API. **/
        eventApiId: string;
        /** The ID of the event API version. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** Include versions in each AsyncAPI object's name when only one version is present. **/
        showVersioning?: boolean;
        /** The event portal database keys to include for each AsyncAPI object. **/
        includedExtensions?: 'all' | 'parent' | 'version' | 'none';
        /** The format in which to get the AsyncAPI specification. Possible values are yaml and json. **/
        format?: 'json' | 'yaml';
        /** The version of AsyncAPI to use. **/
        version?: '2.0.0' | '2.2.0' | '2.5.0';
        /** The ID of the event API Product Version to use for generating bindings. **/
        eventApiProductVersionId?: string;
        /** The ID of the plan to use for generating bindings. **/
        planId?: string;
        /** The list IDs of gateway messaging services for generating bindings. **/
        gatewayMessagingServiceIds?: Array<string>;
    }): CancelablePromise<string>;
    /**
     * Get the AsyncAPI Specification for an Event API Version
     * Use this API to get the AsyncAPI specification for an event API version annotated with Event Portal metadata.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_api:generate_async_api:*` ]
     * @returns string The AsyncAPI specification for the event API version.
     * @throws ApiError
     */
    static getAsyncApiForEventApiVersion({ eventApiVersionId, xContextId, showVersioning, format, includedExtensions, asyncApiVersion, eventApiProductVersionId, planId, gatewayMessagingServiceIds, }: {
        /** The ID of the event API version. **/
        eventApiVersionId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** Include versions in each AsyncAPI object's name when only one version is present **/
        showVersioning?: boolean;
        /** The format in which to get the AsyncAPI specification. Possible values are yaml and json. **/
        format?: 'json' | 'yaml';
        /** The event portal database keys to include for each AsyncAPI object. **/
        includedExtensions?: 'all' | 'parent' | 'version' | 'none';
        /** The version of AsyncAPI to use. **/
        asyncApiVersion?: '2.0.0' | '2.2.0' | '2.5.0';
        /** The ID of the event API Product Version to use for generating bindings. **/
        eventApiProductVersionId?: string;
        /** The ID of the plan to use for generating bindings. **/
        planId?: string;
        /** The list IDs of gateway messaging services for generating bindings. **/
        gatewayMessagingServiceIds?: Array<string>;
    }): CancelablePromise<string>;
}

declare class EventManagementAgentsService {
    /**
     * Get a list of EMAs
     * Use this API to get a list of EMAs that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_management_agent:read` ]
     * @returns EventManagementAgentsResponse The list of EMAs and the accompanying metadata.
     * @throws ApiError
     */
    static getEventManagementAgents({ xContextId, pageSize, pageNumber, sort, ids, createdBy, eventManagementAgentRegionId, include, expand, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of EMAs to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Sort based on the provided parameters. <br> The value can be either a standalone field name (`?sort=<field>`) or a field and direction, delimited by a colon (`?sort=<field>:<asc|desc>`). If the direction is not specified, the default is ascending. **/
        sort?: string;
        /** The IDs of the EMAs. **/
        ids?: Array<string>;
        /** Match only EMAs created by this user **/
        createdBy?: string;
        /** Match only EMAs in the given EMA-Region **/
        eventManagementAgentRegionId?: string;
        /** Specify extra data to be included, options are: referencedByMessagingServiceIds.
         * <br>Replacement: Use expand instead.
         * <br>Reason: The change is to align with the API specification design.
         * <br>Removal Date: 2024-11-03 18:00:00.000.
         *  **/
        include?: string;
        /** Specify extra data to be included, options are: referencedByMessagingServiceIds. **/
        expand?: string;
    }): CancelablePromise<EventManagementAgentsResponse>;
    /**
     * Create an EMA object
     * Use this API to create an EMA object.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_management_agent:write` ]
     * @returns EventManagementAgentResponse Created an EMA. The newly saved EMA object is returned in the response body.
     * @throws ApiError
     */
    static createEventManagementAgent({ requestBody, xContextId, }: {
        /** The EMA object. **/
        requestBody: EventManagementAgent;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventManagementAgentResponse>;
    /**
     * Get an EMA object
     * Use this API to get a single EMA by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_management_agent:read` ]
     * @returns EventManagementAgentResponse The EMA object.
     * @throws ApiError
     */
    static getEventManagementAgent({ id, xContextId, include, expand, }: {
        /** The ID of the EMA object. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** Specify extra data to be included, options are: referencedByMessagingServiceIds.
         * <br>Replacement: Use expand instead.
         * <br>Reason: The change is to align with the API specification design.
         * <br>Removal Date: 2024-11-03 18:00:00.000.
         *  **/
        include?: string;
        /** Specify extra data to be included, options are: referencedByMessagingServiceIds. **/
        expand?: string;
    }): CancelablePromise<EventManagementAgentResponse>;
    /**
     * Delete an EMA object
     * Use this API to delete an EMA.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_management_agent:write` ]
     * @returns void
     * @throws ApiError
     */
    static deleteEventManagementAgent({ id, xContextId, }: {
        /** The ID of the EMA object. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * Update an EMA object
     * Use this API to update an EMA. You only need to specify the fields that need to be updated.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_management_agent:write` ]
     * @returns EventManagementAgentResponse The updated EMA object.
     * @throws ApiError
     */
    static updateEventManagementAgent({ id, requestBody, xContextId, }: {
        /** The ID of the EMA object to update. **/
        id: string;
        /** The EMA object. **/
        requestBody: EventManagementAgent;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventManagementAgentResponse>;
    /**
     * Get the raw configs in string format for an EMA object
     * Use this API to get the raw configs for a single EMA by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_management_agent:read` ]
     * @returns string The EMA config in yaml structure.
     * @throws ApiError
     */
    static getEventManagementAgentConfigRaw({ id, xContextId, configFileType, }: {
        /** The ID of the EMA object. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
        configFileType?: 'connected' | 'standalone';
    }): CancelablePromise<string>;
    /**
     * Get the raw configs in file format for an EMA object
     * Use this API to get the raw configs for a single EMA by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_management_agent:read` ]
     * @returns string The EMA config in a yaml file named application.yml.
     * @throws ApiError
     */
    static getEventManagementAgentConfigFile({ id, xContextId, configFileType, }: {
        /** The ID of the EMA object. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
        configFileType?: 'connected' | 'standalone';
    }): CancelablePromise<string>;
}

declare class EventMeshesService {
    /**
     * Get a list of event meshes
     * Use this API to get a list of event meshes that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `modeled_event_mesh:get:*` ]
     * @returns EventMeshesResponse The list of event meshes and the accompanying metadata.
     * @throws ApiError
     */
    static getEventMeshes({ xContextId, pageSize, pageNumber, name, environmentId, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of event meshes to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Name of the event mesh to match on. **/
        name?: string;
        /** Match only event meshes in the given environment **/
        environmentId?: string;
    }): CancelablePromise<EventMeshesResponse>;
    /**
     * Create an event mesh
     * Create an event mesh.
     * @returns EventMeshResponse Created an event mesh. The newly saved event mesh is returned in the response body.
     * @throws ApiError
     */
    static createEventMesh({ requestBody, xContextId, }: {
        /** Event mesh. **/
        requestBody: EventMesh;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventMeshResponse>;
    /**
     * Get an event mesh
     * Get a single event mesh by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `modeled_event_mesh:get:{id}` ]
     * @returns EventMeshResponse The event mesh.
     * @throws ApiError
     */
    static getEventMesh({ id, xContextId, }: {
        /** The ID of the event mesh. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventMeshResponse>;
    /**
     * Delete an event mesh
     * Use this API to delete an event mesh.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `modeled_event_mesh:delete:*` ]
     * @returns void
     * @throws ApiError
     */
    static deleteEventMesh({ id, xContextId, }: {
        /** The ID of the event mesh. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * Update an event mesh
     * Use this API to update an event mesh. You only need to specify the fields that need to be updated.
     * @returns EventMeshResponse The updated event mesh.
     * @throws ApiError
     */
    static updateEventMesh({ id, requestBody, xContextId, }: {
        /** The ID of the event mesh to update. **/
        id: string;
        /** The event mesh. **/
        requestBody: EventMesh;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventMeshResponse>;
}

declare class EventsService {
    /**
     * Get a list of events
     * Use this API to get a list of events that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns EventsResponse Get a list of events and the accompanying metadata.
     * @throws ApiError
     */
    static getEvents({ xContextId, pageSize, pageNumber, name, shared, brokerType, applicationDomainId, applicationDomainIds, sort, customAttributes, ids, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of events to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Name of the event to match on. **/
        name?: string;
        /** Match only with shared or unshared events. **/
        shared?: boolean;
        /** Match only events with the given broker type **/
        brokerType?: string;
        /** Match only events in the given application domain. **/
        applicationDomainId?: string;
        /** Match only events in the given application domain ids. **/
        applicationDomainIds?: Array<string>;
        /** Sort based on the provided parameters. <br> The value can be either a standalone field name (`?sort=<field>`) or a field and direction, delimited by a colon (`?sort=<field>:<asc|desc>`). If the direction is not specified, the default is ascending. **/
        sort?: string;
        /** Returns the entities that match the custom attribute filter.<br>To filter by custom attribute name and value, use the format: `customAttributes=<custom-attribute-name>==<custom-attribute-value>`. <br>To filter by custom attribute name, use the format: `customAttributes=<custom-attribute-name>`. <br>The filter supports the `AND` operator for multiple custom attribute definitions (not multiple values for a given definition). Use `;` (`semicolon`) to separate multiple queries with `AND` operation. <br>Note: the filter supports custom attribute values containing only the characters `[a-zA-Z0-9_\-\. ]`. **/
        customAttributes?: string;
        /** Match only events with the given IDs separated by commas. **/
        ids?: Array<string>;
    }): CancelablePromise<EventsResponse>;
    /**
     * Create an event
     * Events are the primary building block of an event-driven architecture. Applications publish and subscribe to events and events reference schemas.  In the Event Portal, an event is a type of event as opposed to a specific event instance.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event:create:*` ]
     * @returns EventResponse Created an event. The newly saved event is returned in the response body.
     * @throws ApiError
     */
    static createEvent({ requestBody, xContextId, }: {
        /** The event requires a name and an application domain ID. **/
        requestBody: Event;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventResponse>;
    /**
     * Get an event
     * Use this API to get a single event by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event:get:*` ]
     * @returns EventResponse The event.
     * @throws ApiError
     */
    static getEvent({ id, xContextId, }: {
        /** The ID of the event. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventResponse>;
    /**
     * Delete an event
     * Use this API to delete an event.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event:delete:*` ]
     * @returns void
     * @throws ApiError
     */
    static deleteEvent({ id, xContextId, }: {
        /** The ID of the event. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * Update an event
     * Use this API to update an event. You only need to specify the fields that need to be updated.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event:update:*` ]
     * @returns EventResponse The updated event.
     * @throws ApiError
     */
    static updateEvent({ id, requestBody, xContextId, }: {
        /** The ID of the event to update. **/
        id: string;
        /** The event. **/
        requestBody: Event;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventResponse>;
    /**
     * Get a list of event versions
     * Use this API to get a list of event versions that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns EventVersionsResponse Get a list of event versions and the accompanying metadata.
     * @throws ApiError
     */
    static getEventVersions({ xContextId, pageSize, pageNumber, eventIds, ids, messagingServiceIds, customAttributes, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of event versions to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Match only event versions of these event IDs, separated by commas. **/
        eventIds?: Array<string>;
        /** Match only event versions with the given IDs, separated by commas. **/
        ids?: Array<string>;
        /** Match only event versions with the given messaging service IDs, separated by commas. **/
        messagingServiceIds?: Array<string>;
        /** Returns the entities that match the custom attribute filter.<br>To filter by custom attribute name and value, use the format: `customAttributes=<custom-attribute-name>==<custom-attribute-value>`. <br>To filter by custom attribute name, use the format: `customAttributes=<custom-attribute-name>`. <br>The filter supports the `AND` operator for multiple custom attribute definitions (not multiple values for a given definition). Use `;` (`semicolon`) to separate multiple queries with `AND` operation. <br>Note: the filter supports custom attribute values containing only the characters `[a-zA-Z0-9_\-\. ]`. **/
        customAttributes?: string;
    }): CancelablePromise<EventVersionsResponse>;
    /**
     * Create an event version
     * Create an event version<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event:update:*` ]
     * @returns EventVersionResponse Created an event version. Returns the newly saved event version in the response body.
     * @throws ApiError
     */
    static createEventVersion({ requestBody, xContextId, }: {
        /** App version request body description **/
        requestBody: EventVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventVersionResponse>;
    /**
     * Get an event version
     * Use this API to get a single event version by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event:get:*` ]
     * @returns EventVersionResponse The event version.
     * @throws ApiError
     */
    static getEventVersion({ id, xContextId, }: {
        /** The ID of the event version. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventVersionResponse>;
    /**
     * Delete an event version
     * Use this API to delete an event version.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event:update:*` ]
     * @returns void
     * @throws ApiError
     */
    static deleteEventVersion({ id, xContextId, }: {
        /** The ID of the event version **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * Update an event version
     * Use this API to update an event version. You only need to specify the fields that need to be updated.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event:update:*` ]
     * @returns EventVersionResponse The updated event version.
     * @throws ApiError
     */
    static updateEventVersion({ id, requestBody, xContextId, }: {
        /** The ID of the event version to update. **/
        id: string;
        /** The event version. **/
        requestBody: EventVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventVersionResponse>;
    /**
     * Update the state of an event version
     * Use this API to update the state of event version. You only need to specify the target stateId field<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event:update_state:*` ]
     * @returns StateChangeRequestResponse The updated state of the event version.
     * @throws ApiError
     */
    static updateEventVersionState({ id, requestBody, xContextId, }: {
        /** The ID of the event version to update. **/
        id: string;
        /** The state object. **/
        requestBody: VersionedObjectStateChangeRequest;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<StateChangeRequestResponse>;
    /**
     * @deprecated
     * Get a list of event versions for an event
     * *Deprecation Date: 2022-11-01<br>Removal Date: 2023-12-01<br>Reason: Replaced by <a href="/cloud/reference/geteventversions">another endpoint.</a><br><br>*Use this API to get a list of event versions that match the given parameters.
     * @returns EventVersionsResponse Get a list of event versions.
     * @throws ApiError
     */
    static getEventVersionsForEvent({ eventId, xContextId, customAttributes, displayName, ids, version, }: {
        /** The ID of the parent event. **/
        eventId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** Returns the entities that match the custom attribute filter.<br>To filter by custom attribute name and value, use the format: `customAttributes=<custom-attribute-name>==<custom-attribute-value>`. <br>To filter by custom attribute name, use the format: `customAttributes=<custom-attribute-name>`. <br>The filter supports the `AND` operator for multiple custom attribute definitions (not multiple values for a given definition). Use `;` (`semicolon`) to separate multiple queries with `AND` operation. <br>Note: the filter supports custom attribute values containing only the characters `[a-zA-Z0-9_\-\. ]`. **/
        customAttributes?: string;
        /** Match event versions with the given display name. **/
        displayName?: string;
        /** Match event versions with the given IDs separated by commas. **/
        ids?: Array<string>;
        /** Match event versions with the given version. **/
        version?: string;
    }): CancelablePromise<EventVersionsResponse>;
    /**
     * @deprecated
     * Create an event version
     * *Deprecation Date: 2022-11-01<br>Removal Date: 2023-12-01<br>Reason: Replaced by <a href="/cloud/reference/createeventversion">another endpoint.</a><br><br>*Create an event version
     * @returns EventVersionResponse Created an event version. Returns the newly saved event version in the response body.
     * @throws ApiError
     */
    static createEventVersionForEvent({ eventId, requestBody, xContextId, }: {
        /** The ID of the parent event **/
        eventId: string;
        /** App version request body description **/
        requestBody: EventVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventVersionResponse>;
    /**
     * @deprecated
     * Get an event version
     * *Deprecation Date: 2022-11-01<br>Removal Date: 2023-12-01<br>Reason: Replaced by <a href="/cloud/reference/geteventversion">another endpoint.</a><br><br>*Use this API to get a single event version by its ID.
     * @returns EventVersionResponse The event version.
     * @throws ApiError
     */
    static getEventVersionForEvent({ eventId, id, xContextId, }: {
        /** The ID of the parent event. **/
        eventId: string;
        /** The ID of the event version. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventVersionResponse>;
    /**
     * @deprecated
     * Delete an event version
     * *Deprecation Date: 2022-11-01<br>Removal Date: 2023-12-01<br>Reason: Replaced by <a href="/cloud/reference/deleteeventversion">another endpoint.</a><br><br>*Use this API to delete an event version.
     * @returns void
     * @throws ApiError
     */
    static deleteEventVersionForEvent({ eventId, id, xContextId, }: {
        /** The ID of the parent event **/
        eventId: string;
        /** The ID of the event version **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * @deprecated
     * Update an event version
     * *Deprecation Date: 2022-11-01<br>Removal Date: 2023-12-01<br>Reason: Replaced by <a href="/cloud/reference/updateeventversion">another endpoint.</a><br><br>*Use this API to update an event version. You only need to specify the fields that need to be updated.
     * @returns EventVersionResponse The updated event version.
     * @throws ApiError
     */
    static updateEventVersionForEvent({ eventId, id, requestBody, xContextId, }: {
        /** The ID of the parent event. **/
        eventId: string;
        /** The ID of the event version to update. **/
        id: string;
        /** The event version. **/
        requestBody: EventVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<EventVersionResponse>;
    /**
     * Replace messaging service association for an event version
     * Use this API to replace the messaging service association for an event version.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_runtime:write` ]
     * @returns MessagingServiceAssociationResponse The updated messaging service associations.
     * @throws ApiError
     */
    static updateMsgSvcAssociationForEventVersion({ id, requestBody, xContextId, }: {
        /** The ID of the event version **/
        id: string;
        /** The messaging service association object **/
        requestBody: MessagingServiceAssociationDTO;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<MessagingServiceAssociationResponse>;
    /**
     * @deprecated
     * Update the state of an event version
     * *Deprecation Date: 2022-11-01<br>Removal Date: 2023-12-01<br>Reason: Replaced by <a href="/cloud/reference/updateeventversionstate">another endpoint.</a><br><br>*Use this API to update the state of event version. You only need to specify the target stateId field
     * @returns VersionedObjectStateChangeRequest The updated state of the event version.
     * @throws ApiError
     */
    static updateEventVersionStateForEvent({ eventId, id, requestBody, xContextId, }: {
        /** The ID of the parent event. **/
        eventId: string;
        /** The ID of the event version to update. **/
        id: string;
        /** The event version. **/
        requestBody: EventVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<VersionedObjectStateChangeRequest>;
}

declare class MessagingServicesService {
    /**
     * Get a list of messaging services
     * Use this API to get a list of messaging services that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `messaging_service:read` ]
     * @returns MessagingServicesResponse The list of messaging services and the accompanying metadata.
     * @throws ApiError
     */
    static getMessagingServices({ xContextId, pageSize, pageNumber, sort, ids, messagingServiceType, runtimeAgentId, eventMeshId, eventManagementAgentId, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of messaging services to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Sort based on the provided parameters. <br> The value can be either a standalone field name (`?sort=<field>`) or a field and direction, delimited by a colon (`?sort=<field>:<asc|desc>`). If the direction is not specified, the default is ascending. **/
        sort?: string;
        /** The IDs of the messaging services. **/
        ids?: Array<string>;
        /** Match only messaging services of the given type, options are: solace, kafka. **/
        messagingServiceType?: string;
        /** Match only messaging services in the given runtimeAgentId **/
        runtimeAgentId?: string;
        /** Match only messaging services in the given eventMeshId **/
        eventMeshId?: string;
        eventManagementAgentId?: string;
    }): CancelablePromise<MessagingServicesResponse>;
    /**
     * Create a messaging service
     * Use this API to create a messaging service.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `messaging_service:write` ]
     * @returns MessagingServiceResponse Created a messaging service. The newly saved messaging service is returned in the response body.
     * @throws ApiError
     */
    static createMessagingService({ requestBody, xContextId, }: {
        /** The messaging service. **/
        requestBody: MessagingService;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<MessagingServiceResponse>;
    /**
     * Get a messaging service
     * Use this API to get a single messaging service by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `messaging_service:read` ]
     * @returns MessagingServiceResponse The messaging service.
     * @throws ApiError
     */
    static getMessagingService({ id, xContextId, }: {
        /** The ID of the messaging service. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<MessagingServiceResponse>;
    /**
     * Delete a messaging service
     * Use this API to delete a messaging service.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `messaging_service:write` ]
     * @returns void
     * @throws ApiError
     */
    static deleteMessagingService({ id, xContextId, }: {
        /** The ID of the messaging service. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * Update a messaging service
     * Use this API to update a messaging service. You only need to specify the fields that need to be updated. However, if you want to update anything under subObjects (i.e. anything inside messagingServiceConnections object), you need to provide the original messagingServiceConnections with the updated fields instead of just providing the changed fields.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `messaging_service:write` ]
     * @returns MessagingServiceResponse The updated messaging service.
     * @throws ApiError
     */
    static updateMessagingService({ id, requestBody, xContextId, }: {
        /** The ID of the messaging service to update. **/
        id: string;
        /** The messaging service. **/
        requestBody: MessagingService;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<MessagingServiceResponse>;
    /**
     * Remove an association between an messaging service and the requested entity
     * Use this API to remove the association between a messaging service and either of EVENT_MESH or EVENT_MANAGEMENT_AGENT.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `messaging_service:write` ]
     * @returns MessagingServiceResponse The updated messaging service, e.g. if the API request body had "association": "EVENT_MESH" then the resulting object would not have eventMeshId attribute.
     * @throws ApiError
     */
    static removeAssociationMessagingService({ id, requestBody, xContextId, }: {
        /** The ID of the messaging service. **/
        id: string;
        /** The association object with the value matching either EVENT_MESH or EVENT_MANAGEMENT_AGENT. **/
        requestBody: MessagingServiceRemoveAssociation;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<MessagingServiceResponse>;
    /**
     * Initiate a scan request to run against a messaging service
     * Use this API to make a scan request on a messaging service.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `messaging_service:write` ]
     * @returns MessagingServiceOperationResponse Requested a scan on the messaging service. The operation object with ID set as ID of the created scan Object is returned in the response body.
     * @throws ApiError
     */
    static scanStartMessagingService({ messagingServiceId, requestBody, xContextId, }: {
        /** The ID of the messaging service. **/
        messagingServiceId: string;
        /** The messaging service. **/
        requestBody: MessagingServiceOperation;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<MessagingServiceOperationResponse>;
}

declare class MessagingServiceScanDataService {
    /**
     * Get a list of messaging service scan data
     * Use this API to get a list of messaging service scan data that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `messaging_service_scan:read` ]
     * @returns MessagingServiceScanDataListResponse The list of messaging service scan data and the accompanying metadata.
     * @throws ApiError
     */
    static getMessagingServiceScansData({ scanId, xContextId, pageSize, pageNumber, sort, ids, collectionTypes, }: {
        /** The ID of the messaging service scan we want data for. **/
        scanId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of messaging service scan data to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** The name of the field to sort on. **/
        sort?: string;
        /** The IDs of the messaging service scan data. **/
        ids?: Array<string>;
        /** Match only scan data whose dataCollectionType matches the given list. **/
        collectionTypes?: Array<'brokerConfiguration' | 'clusterConfiguration' | 'consumerGroups' | 'consumerGroupConfiguration' | 'overrideTopicConfiguration' | 'queueConfiguration' | 'queueListing' | 'schema' | 'subscriptionConfiguration' | 'topicConfiguration' | 'topicListing'>;
    }): CancelablePromise<MessagingServiceScanDataListResponse>;
    /**
     * Get a messaging service scan data
     * Use this API to get a single messaging service scan data by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `messaging_service_scan:read` ]
     * @returns MessagingServiceScanDataResponse The messaging service scan data.
     * @throws ApiError
     */
    static getMessagingServiceScanData({ scanId, id, xContextId, }: {
        /** The ID of the messaging service scan. **/
        scanId: string;
        /** The ID of the messaging service scan data. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<MessagingServiceScanDataResponse>;
}

declare class MessagingServiceScanLogsService {
    /**
     * Get a list of messaging service scan logs
     * Use this API to get a list of messaging service scan logs that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `messaging_service_scan:read` ]
     * @returns MessagingServiceScanLogListResponse The list of messaging service scan logs and the accompanying metadata.
     * @throws ApiError
     */
    static getMessagingServiceScansLogs({ scanId, xContextId, pageSize, pageNumber, sort, }: {
        /** The ID of the messaging service scan we want logs for. **/
        scanId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of messaging service scan logs to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Sort based on the provided parameters. <br> The value can be either a standalone field name (`?sort=<field>`) or a field and direction, delimited by a colon (`?sort=<field>:<asc|desc>`). If the direction is not specified, the default is ascending. **/
        sort?: string;
    }): CancelablePromise<MessagingServiceScanLogListResponse>;
}

declare class MessagingServiceScansService {
    /**
     * Get a list of messaging service scans
     * Use this API to get a list of messaging service scans that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `messaging_service_scan:read` ]
     * @returns MessagingServiceScansResponse The list of messaging service scans and the accompanying metadata.
     * @throws ApiError
     */
    static getMessagingServiceScans({ xContextId, pageSize, pageNumber, sort, ids, messagingServiceId, eventMeshId, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of messaging service scans to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Sort based on the provided parameters. <br> The value can be either a standalone field name (`?sort=<field>`) or a field and direction, delimited by a colon (`?sort=<field>:<asc|desc>`). If the direction is not specified, the default is ascending. **/
        sort?: string;
        /** The IDs of the messaging service scans. **/
        ids?: Array<string>;
        /** Match only messaging service scans in the given messagingService **/
        messagingServiceId?: string;
        /** Match only messaging service scans in the given eventMeshId **/
        eventMeshId?: string;
    }): CancelablePromise<MessagingServiceScansResponse>;
    /**
     * Get a messaging service scan
     * Use this API to get a single messaging service scan by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `messaging_service_scan:read` ]
     * @returns MessagingServiceScanResponse The messaging service scan.
     * @throws ApiError
     */
    static getMessagingServiceScan({ id, xContextId, }: {
        /** The ID of the messaging service scan. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<MessagingServiceScanResponse>;
    /**
     * Delete a messaging service scan
     * Use this API to delete a messaging service scan.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `messaging_service_scan:write` ]
     * @returns void
     * @throws ApiError
     */
    static deleteMessagingServiceScan({ id, xContextId, }: {
        /** The ID of the messaging service scan. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
}

declare class SchemasService {
    /**
     * Get a list of schemas
     * Use this API to get a list of schemas that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns SchemasResponse Get a list of schemas and the accompanying metadata.
     * @throws ApiError
     */
    static getSchemas({ xContextId, pageSize, pageNumber, name, shared, applicationDomainId, schemaType, applicationDomainIds, ids, sort, customAttributes, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of schemas to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Name of the schema to match on. **/
        name?: string;
        /** Match only with shared or unshared schemas. **/
        shared?: boolean;
        /** Match only schemas in the given application domain. **/
        applicationDomainId?: string;
        /** Match only schemas with the given schema type **/
        schemaType?: string;
        /** Match only schemas in the given application domain ids. **/
        applicationDomainIds?: Array<string>;
        /** Match only schemas with the given IDs separated by commas. **/
        ids?: Array<string>;
        /** Sort based on the provided parameters. <br> The value can be either a standalone field name (`?sort=<field>`) or a field and direction, delimited by a colon (`?sort=<field>:<asc|desc>`). If the direction is not specified, the default is ascending. **/
        sort?: string;
        /** Returns the entities that match the custom attribute filter.<br>To filter by custom attribute name and value, use the format: `customAttributes=<custom-attribute-name>==<custom-attribute-value>`. <br>To filter by custom attribute name, use the format: `customAttributes=<custom-attribute-name>`. <br>The filter supports the `AND` operator for multiple custom attribute definitions (not multiple values for a given definition). Use `;` (`semicolon`) to separate multiple queries with `AND` operation. <br>Note: the filter supports custom attribute values containing only the characters `[a-zA-Z0-9_\-\. ]`. **/
        customAttributes?: string;
    }): CancelablePromise<SchemasResponse>;
    /**
     * Create a schema
     * To model your event-driven architecture, schemas are a fundamental building block for modelling the payloads of the events flowing through your system. Use this API to create schemas that can later be referenced by events.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `schema:create:*` ]
     * @returns SchemaResponse Created a schema. The newly saved schema is returned in the response body.
     * @throws ApiError
     */
    static createSchema({ requestBody, xContextId, }: {
        /** The schema requires a name, an application domain, a schema type and a content type. **/
        requestBody: SchemaObject;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<SchemaResponse>;
    /**
     * Get a schema
     * Use this API to get a single schema by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `schema:get:*` ]
     * @returns SchemaResponse The schema.
     * @throws ApiError
     */
    static getSchema({ id, xContextId, }: {
        /** The ID of the schema. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<SchemaResponse>;
    /**
     * Delete a schema
     * Use this API to delete a schema. The schema must not be in use by any events else it cannot be deleted.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `schema:delete:*` ]
     * @returns void
     * @throws ApiError
     */
    static deleteSchema({ id, xContextId, }: {
        /** The ID of the schema. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * Update a schema
     * Update a schema.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `schema:update:*` ]
     * @returns SchemaResponse Updated a schema. The newly saved schema is returned in the response body.
     * @throws ApiError
     */
    static updateSchema({ id, requestBody, xContextId, }: {
        /** The ID of the schema. **/
        id: string;
        /** The schema requires a name, an application domain, a schema type and a content type. **/
        requestBody: SchemaObject;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<SchemaResponse>;
    /**
     * Get a list of schema versions
     * Use this API to get a list of schema versions that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns SchemaVersionsResponse Get a list of schema versions and the accompanying metadata.
     * @throws ApiError
     */
    static getSchemaVersions({ xContextId, pageSize, pageNumber, schemaIds, ids, customAttributes, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of schema versions to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Match only schema versions of these schema IDs, separated by commas. **/
        schemaIds?: Array<string>;
        /** Match only schema versions with the given IDs, separated by commas. **/
        ids?: Array<string>;
        /** Returns the entities that match the custom attribute filter.<br>To filter by custom attribute name and value, use the format: `customAttributes=<custom-attribute-name>==<custom-attribute-value>`. <br>To filter by custom attribute name, use the format: `customAttributes=<custom-attribute-name>`. <br>The filter supports the `AND` operator for multiple custom attribute definitions (not multiple values for a given definition). Use `;` (`semicolon`) to separate multiple queries with `AND` operation. <br>Note: the filter supports custom attribute values containing only the characters `[a-zA-Z0-9_\-\. ]`. **/
        customAttributes?: string;
    }): CancelablePromise<SchemaVersionsResponse>;
    /**
     * Create a schema version
     * Creates a schema version<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `schema:update:*` ]
     * @returns SchemaVersionResponse Created a schema version. The newly saved schema version is returned in the response body.
     * @throws ApiError
     */
    static createSchemaVersion({ requestBody, xContextId, }: {
        /** schema version details **/
        requestBody: SchemaVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<SchemaVersionResponse>;
    /**
     * Delete a schema version
     * Use this API to delete a schema version.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `schema:update:*` ]
     * @returns void
     * @throws ApiError
     */
    static deleteSchemaVersion({ id, xContextId, }: {
        /** The ID of the schema version. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
    /**
     * Update a schema version
     * Use this API to update a schema version.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `schema:update:*` ]
     * @returns SchemaVersionResponse The schema version.
     * @throws ApiError
     */
    static updateSchemaVersion({ id, requestBody, xContextId, }: {
        /** The ID of the schema version. **/
        id: string;
        requestBody: SchemaVersion;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<SchemaVersionResponse>;
    /**
     * Update the state of a schema version
     * Use this API to update the state of a schema version.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `schema:update_state:*` ]
     * @returns StateChangeRequestResponse The updated state of the schema version.
     * @throws ApiError
     */
    static updateSchemaVersionState({ id, requestBody, xContextId, }: {
        /** The ID of the schema version. **/
        id: string;
        /** The state change object. **/
        requestBody: VersionedObjectStateChangeRequest;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<StateChangeRequestResponse>;
    /**
     * Get a schema version
     * Use this API to get a single schema version by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `schema:get:*` ]
     * @returns SchemaVersionResponse The schema version.
     * @throws ApiError
     */
    static getSchemaVersion({ versionId, xContextId, }: {
        /** The ID of the schema version. **/
        versionId: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<SchemaVersionResponse>;
}

declare class StatesService {
    /**
     * Get a list of lifecycle states
     * Use this API to get a list of lifecycle states that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns StatesResponse Get a list of lifecycle states and the accompanying metadata.
     * @throws ApiError
     */
    static getStates({ xContextId, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<StatesResponse>;
}

declare class TopicDomainsService {
    /**
     * Get a list of the topic domains
     * Use this API to get a list of topic domains that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `event_designer:access` ]
     * @returns TopicDomainsResponse Get a list of topic domains and the accompanying metadata.
     * @throws ApiError
     */
    static getTopicDomains({ xContextId, pageSize, pageNumber, ids, brokerType, applicationDomainIds, applicationDomainId, }: {
        /** Optional context id the request is running. **/
        xContextId?: string;
        /** The number of topic domains to get per page. **/
        pageSize?: number;
        /** The page number to get. **/
        pageNumber?: number;
        /** Match only topic domains with the given IDs separated by commas. **/
        ids?: Array<string>;
        /** Match only topic domains with the given brokerType. **/
        brokerType?: string;
        /** Match only topic domains with the given application domain ids separated by commas. **/
        applicationDomainIds?: Array<string>;
        applicationDomainId?: string;
    }): CancelablePromise<TopicDomainsResponse>;
    /**
     * Create a topic domain
     * Topic Domains govern the format of topic addresses within an application domain<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `topic_domain:create:*` ]
     * @returns TopicDomainResponse Created a topic domain. Returns the newly saved topic domain in the response body.
     * @throws ApiError
     */
    static createTopicDomain({ requestBody, xContextId, }: {
        requestBody: TopicDomain;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<TopicDomainResponse>;
    /**
     * Get a topic domain
     * Use this API to get a single topic domain by its ID.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `topic_domain:get:*` ]
     * @returns TopicDomainResponse The topic domain.
     * @throws ApiError
     */
    static getTopicDomain({ id, xContextId, }: {
        /** The ID of the topic domain. **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<TopicDomainResponse>;
    /**
     * Delete a topic domain
     * Use this API to delete a topic domain.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ `topic_domain:delete:*` ]
     * @returns void
     * @throws ApiError
     */
    static deleteTopicDomain({ id, xContextId, }: {
        /** The ID of the topic domain **/
        id: string;
        /** Optional context id the request is running. **/
        xContextId?: string;
    }): CancelablePromise<void>;
}

export { $Address, $AddressLevel, $AddressSpace, $AddressSpaceResponse, $AddressSpacesResponse, $Application, $ApplicationChangeRequestPreviewResponse, $ApplicationConfigPushJobResponse, $ApplicationConfigurationPushJob, $ApplicationDeployment, $ApplicationDeploymentPreviewDTO, $ApplicationDomain, $ApplicationDomainExportDTO, $ApplicationDomainImportDTO, $ApplicationDomainResponse, $ApplicationDomainStats, $ApplicationDomainsResponse, $ApplicationRegistration, $ApplicationRegistrationResponse, $ApplicationRegistrationsResponse, $ApplicationResponse, $ApplicationVersion, $ApplicationVersionFrontendDTO, $ApplicationVersionFrontendResponse, $ApplicationVersionResponse, $ApplicationVersionsFrontendResponse, $ApplicationVersionsResponse, $ApplicationsResponse, $AssociatedEntity, $AttractedEventVersionTuple, $AttractingApplicationVersionTuple, $Audit, $AuditCommandDTO, $AuditDetail, $AuditDetailResponse, $AuditImportDTO, $AuditImportJobMetadata, $AuditImportJobsMetadataResponse, $AuditJob, $AuditJobResponse, $AuditRelationDTO, $AuditResult, $AuditResultDetail, $AuditResultDetailResponse, $AuditResultStatsDTO, $AuditResultStatsRequestDTO, $AuditResultsResponse, $AuditsResponse, $BulkAuditImportDTO, $ChangeAppDomainEntitiesDTO, $Configuration, $ConfigurationResponse, $ConfigurationType, $ConfigurationTypeResponse, $ConfigurationTypesResponse, $ConfigurationsResponse, $Consumer, $ConsumerResponse, $ConsumersResponse, $CustomAttribute, $CustomAttributeDefinition, $CustomAttributeDefinitionResponse, $CustomAttributeDefinitionsResponse, $CustomAttributeFrontEndDTO, $CustomAttributesFrontEndResponse, $DeliveryDescriptor, $DesignerMappingDTO, $EPResponseSetString, $Entitlement, $EntityType, $EntityTypesResponse, $Environment, $EnvironmentResponse, $EnvironmentsResponse, $EpUserEntitlements, $EpUserEntitlementsResponse, $ErrorResponse, $Event, $EventApi, $EventApiProduct, $EventApiProductRegistration, $EventApiProductRegistrationResponse, $EventApiProductRegistrationsResponse, $EventApiProductResponse, $EventApiProductVersion, $EventApiProductVersionResponse, $EventApiProductVersionsResponse, $EventApiProductsResponse, $EventApiResponse, $EventApiVersion, $EventApiVersionResponse, $EventApiVersionsResponse, $EventApisResponse, $EventBrokerDataCollectionUploadResponse, $EventBrokerScanData, $EventBrokerScanDataUploadDetails, $EventManagementAgent, $EventManagementAgentRegion, $EventManagementAgentRegionsResponse, $EventManagementAgentResponse, $EventManagementAgentRunCommand, $EventManagementAgentRunCommandResponse, $EventManagementAgentsResponse, $EventMesh, $EventMeshFrontEndDTO, $EventMeshFrontEndResponse, $EventMeshResponse, $EventMeshesFrontEndResponse, $EventMeshesResponse, $EventResponse, $EventV2KpiMetric, $EventV2KpiMetricResponse, $EventVersion, $EventVersionFrontend, $EventVersionResponse, $EventVersionsFrontendResponse, $EventVersionsResponse, $EventsResponse, $Filter, $GatewayMessagingService, $GatewayMessagingServiceResponse, $GraphEdgeDTO, $GraphModelDTO, $GraphModelResponse, $GraphModelsResponse, $GraphNodeDTO, $GraphNodeExtendedAttributeDTO, $GraphNodePosition, $GraphNodeReferenceDTO, $GraphNodeResponse, $GraphNodeWrapperDTO, $GraphNodesResponse, $ImportActionPreviewResultDTO, $InvalidNonStateReference, $InvalidStateReference, $JobAdministrationDTO, $JobBO, $JobDTO, $JobType, $JsonNode, $KafkaConsumerGroupAuditResultSetDTO, $KafkaConsumerGroupAuditResultSetResponse, $KafkaConsumerGroupAuditResultSetsResponse, $KafkaTopicAuditResultSet, $KafkaTopicAuditResultSetResponse, $KafkaTopicAuditResultSetsResponse, $KafkaTopicSchemaParentRelationAuditResultSet, $KafkaTopicSchemaVersionRelationAuditResultSet, $KpiEventReuseMetricDTO, $KpiMetrics, $KpiMetricsResponse, $LoadSampleOperationDTO, $MergeApplicationVersionsDTO, $MessagingService, $MessagingServiceAssociationDTO, $MessagingServiceAssociationResponse, $MessagingServiceAuthentication, $MessagingServiceConnection, $MessagingServiceCredentials, $MessagingServiceFrontEndDTO, $MessagingServiceInfoDTO, $MessagingServiceOperation, $MessagingServiceOperationResponse, $MessagingServiceRemoveAssociation, $MessagingServiceResponse, $MessagingServiceScan, $MessagingServiceScanData, $MessagingServiceScanDataListResponse, $MessagingServiceScanDataResponse, $MessagingServiceScanLog, $MessagingServiceScanLogListResponse, $MessagingServiceScanResponse, $MessagingServiceScansResponse, $MessagingServicesInfoResponse, $MessagingServicesResponse, $OperationDTO, $OperationResponse, $OrgDTO, $OrgStats, $OrgsResponse, $Pagination, $Plan, $PreviewEntityConfigurationDTO, $ResourceConnectionResponse, $ResourceCredentialOperationsBO, $ResourceCredentialPropertiesBO, $ResourceType, $ResponseAuditResultStatsDTO, $ResponseJobDTO, $ResponseOrgDTO, $ResponseRuntimeImportAllResponseDTO, $RuntimeAgentFrontEndDTO, $RuntimeAgentOperationDTO, $RuntimeAgentOperationResponse, $RuntimeAgentRegionInternalDTO, $RuntimeAgentRegionInternalResponse, $RuntimeAgentRegionInternalsResponse, $RuntimeEntityConfiguration, $RuntimeImportAllDTO, $RuntimeImportAllResponseDTO, $RuntimeImportFiltersDTO, $RuntimeImportPreviewDTO, $RuntimeMappingDTO, $SchemaImportPreviewDTO, $SchemaImportPreviewResponse, $SchemaObject, $SchemaRegistriesResponse, $SchemaRegistry, $SchemaRegistryResponse, $SchemaResponse, $SchemaVersion, $SchemaVersionFrontEnd, $SchemaVersionReferenceDTO, $SchemaVersionResponse, $SchemaVersionsFrontEndResponse, $SchemaVersionsResponse, $SchemasResponse, $SolaceClassOfServicePolicy, $SolaceMessagingService, $SolaceQueueAggregateResponse, $SolaceQueueAuditResultSetDTO, $SolaceQueueAuditResultSetsResponse, $StateChangeRequestResponse, $StateDTO, $StatesResponse, $StitchedEventVersionIdResultDTO, $Subscription, $SubscriptionStitchingEvalRequestDTO, $SuggestedAddressLevelDTO, $SuggestionApiInputDTO, $Tag, $TagAssociationsObject, $TagEntityAssociationsObject, $TagResponse, $TargetEntitiesRequestDTO, $ToggleInfoDTO, $ToggleOrgInfoDTO, $ToggleOrgInfoListResponse, $ToggleOverrideDTO, $ToggleOverrideListResponse, $ToggleStatusDTO, $ToggleStatusListResponse, $TogglesInfoResponse, $TopicAddressEnum, $TopicAddressEnumResponse, $TopicAddressEnumValue, $TopicAddressEnumVersion, $TopicAddressEnumVersionResponse, $TopicAddressEnumVersionsResponse, $TopicAddressEnumsResponse, $TopicAddressResourceDTO, $TopicAddressResourceResponse, $TopicAddressResourcesResponse, $TopicAggregateImportPreviewDTO, $TopicAggregateImportPreviewResponse, $TopicDomain, $TopicDomainAnalysisDTO, $TopicDomainResponse, $TopicDomainsResponse, $TopicFilter, $VersionedObjectStateChangeRequest, $meta, $resourceAuthenticationDetails, $resourceAuthenticationProperties, $resourceConnectionDetails, $resourceConnectionProperties, $resourceCredentialDetails, $tagsResponse, Address, AddressLevel, AddressSpace, AddressSpaceResponse, AddressSpacesResponse, ApiError, ApiRequestOptions, ApiResult, Application, ApplicationChangeRequestPreviewResponse, ApplicationConfigPushJobResponse, ApplicationConfigurationPushJob, ApplicationDeployment, ApplicationDeploymentPreviewDTO, ApplicationDomain, ApplicationDomainExportDTO, ApplicationDomainImportDTO, ApplicationDomainOperationsService, ApplicationDomainResponse, ApplicationDomainStats, ApplicationDomainsResponse, ApplicationDomainsService, ApplicationRegistration, ApplicationRegistrationResponse, ApplicationRegistrationsResponse, ApplicationResponse, ApplicationVersion, ApplicationVersionFrontendDTO, ApplicationVersionFrontendResponse, ApplicationVersionResponse, ApplicationVersionsFrontendResponse, ApplicationVersionsResponse, ApplicationsResponse, ApplicationsService, AssociatedEntity, AttractedEventVersionTuple, AttractingApplicationVersionTuple, Audit, AuditCommandDTO, AuditDetail, AuditDetailResponse, AuditImportDTO, AuditImportJobMetadata, AuditImportJobsMetadataResponse, AuditJob, AuditJobResponse, AuditRelationDTO, AuditResult, AuditResultDetail, AuditResultDetailResponse, AuditResultStatsDTO, AuditResultStatsRequestDTO, AuditResultsResponse, AuditResultsService, AuditsResponse, BffApplicationVersionsFrontendService, BulkAuditImportDTO, CancelError, CancelablePromise, ChangeAppDomainEntitiesDTO, Configuration, ConfigurationResponse, ConfigurationType, ConfigurationTypeResponse, ConfigurationTypesResponse, ConfigurationTypesService, ConfigurationsResponse, ConfigurationsService, Consumer, ConsumerResponse, ConsumersResponse, ConsumersService, CustomAttribute, CustomAttributeDefinition, CustomAttributeDefinitionResponse, CustomAttributeDefinitionsResponse, CustomAttributeDefinitionsService, CustomAttributeFrontEndDTO, CustomAttributesFrontEndResponse, DeliveryDescriptor, DesignerMappingDTO, EPResponseSetString, Entitlement, EntityType, EntityTypesResponse, EnumsService, Environment, EnvironmentResponse, EnvironmentsResponse, EnvironmentsService, EpUserEntitlements, EpUserEntitlementsResponse, ErrorResponse, Event, EventApIsService, EventApi, EventApiProduct, EventApiProductRegistration, EventApiProductRegistrationResponse, EventApiProductRegistrationsResponse, EventApiProductResponse, EventApiProductVersion, EventApiProductVersionResponse, EventApiProductVersionsResponse, EventApiProductsResponse, EventApiProductsService, EventApiResponse, EventApiVersion, EventApiVersionResponse, EventApiVersionsResponse, EventApisResponse, EventBrokerDataCollectionUploadResponse, EventBrokerScanData, EventBrokerScanDataUploadDetails, EventManagementAgent, EventManagementAgentRegion, EventManagementAgentRegionsResponse, EventManagementAgentResponse, EventManagementAgentRunCommand, EventManagementAgentRunCommandResponse, EventManagementAgentsResponse, EventManagementAgentsService, EventMesh, EventMeshFrontEndDTO, EventMeshFrontEndResponse, EventMeshResponse, EventMeshesFrontEndResponse, EventMeshesResponse, EventMeshesService, EventResponse, EventV2KpiMetric, EventV2KpiMetricResponse, EventVersion, EventVersionFrontend, EventVersionResponse, EventVersionsFrontendResponse, EventVersionsResponse, EventsResponse, EventsService, Filter, GatewayMessagingService, GatewayMessagingServiceResponse, GraphEdgeDTO, GraphModelDTO, GraphModelResponse, GraphModelsResponse, GraphNodeDTO, GraphNodeExtendedAttributeDTO, GraphNodePosition, GraphNodeReferenceDTO, GraphNodeResponse, GraphNodeWrapperDTO, GraphNodesResponse, Headers, ImportActionPreviewResultDTO, InvalidNonStateReference, InvalidStateReference, JobAdministrationDTO, JobBO, JobDTO, JobType, JsonNode, KafkaConsumerGroupAuditResultSetDTO, KafkaConsumerGroupAuditResultSetResponse, KafkaConsumerGroupAuditResultSetsResponse, KafkaTopicAuditResultSet, KafkaTopicAuditResultSetResponse, KafkaTopicAuditResultSetsResponse, KafkaTopicSchemaParentRelationAuditResultSet, KafkaTopicSchemaVersionRelationAuditResultSet, KpiEventReuseMetricDTO, KpiMetrics, KpiMetricsResponse, LoadSampleOperationDTO, MergeApplicationVersionsDTO, MessagingService, MessagingServiceAssociationDTO, MessagingServiceAssociationResponse, MessagingServiceAuthentication, MessagingServiceConnection, MessagingServiceCredentials, MessagingServiceFrontEndDTO, MessagingServiceInfoDTO, MessagingServiceOperation, MessagingServiceOperationResponse, MessagingServiceRemoveAssociation, MessagingServiceResponse, MessagingServiceScan, MessagingServiceScanData, MessagingServiceScanDataListResponse, MessagingServiceScanDataResponse, MessagingServiceScanDataService, MessagingServiceScanLog, MessagingServiceScanLogListResponse, MessagingServiceScanLogsService, MessagingServiceScanResponse, MessagingServiceScansResponse, MessagingServiceScansService, MessagingServicesInfoResponse, MessagingServicesResponse, MessagingServicesService, OnCancel, OpenAPI, OpenAPIConfig, OperationDTO, OperationResponse, OrgDTO, OrgStats, OrgsResponse, Pagination, Plan, PreviewEntityConfigurationDTO, Resolver, ResourceConnectionResponse, ResourceCredentialOperationsBO, ResourceCredentialPropertiesBO, ResourceType, ResponseAuditResultStatsDTO, ResponseJobDTO, ResponseOrgDTO, ResponseRuntimeImportAllResponseDTO, RuntimeAgentFrontEndDTO, RuntimeAgentOperationDTO, RuntimeAgentOperationResponse, RuntimeAgentRegionInternalDTO, RuntimeAgentRegionInternalResponse, RuntimeAgentRegionInternalsResponse, RuntimeEntityConfiguration, RuntimeImportAllDTO, RuntimeImportAllResponseDTO, RuntimeImportFiltersDTO, RuntimeImportPreviewDTO, RuntimeMappingDTO, SchemaImportPreviewDTO, SchemaImportPreviewResponse, SchemaObject, SchemaRegistriesResponse, SchemaRegistry, SchemaRegistryResponse, SchemaResponse, SchemaVersion, SchemaVersionFrontEnd, SchemaVersionReferenceDTO, SchemaVersionResponse, SchemaVersionsFrontEndResponse, SchemaVersionsResponse, SchemasResponse, SchemasService, SolaceClassOfServicePolicy, SolaceMessagingService, SolaceQueueAggregateResponse, SolaceQueueAuditResultSetDTO, SolaceQueueAuditResultSetsResponse, StateChangeRequestResponse, StateDTO, StatesResponse, StatesService, StitchedEventVersionIdResultDTO, Subscription, SubscriptionStitchingEvalRequestDTO, SuggestedAddressLevelDTO, SuggestionApiInputDTO, Tag, TagAssociationsObject, TagEntityAssociationsObject, TagResponse, TargetEntitiesRequestDTO, ToggleInfoDTO, ToggleOrgInfoDTO, ToggleOrgInfoListResponse, ToggleOverrideDTO, ToggleOverrideListResponse, ToggleStatusDTO, ToggleStatusListResponse, TogglesInfoResponse, TopicAddressEnum, TopicAddressEnumResponse, TopicAddressEnumValue, TopicAddressEnumVersion, TopicAddressEnumVersionResponse, TopicAddressEnumVersionsResponse, TopicAddressEnumsResponse, TopicAddressResourceDTO, TopicAddressResourceResponse, TopicAddressResourcesResponse, TopicAggregateImportPreviewDTO, TopicAggregateImportPreviewResponse, TopicDomain, TopicDomainAnalysisDTO, TopicDomainResponse, TopicDomainsResponse, TopicDomainsService, TopicFilter, VersionedObjectStateChangeRequest, meta, request, resourceAuthenticationDetails, resourceAuthenticationProperties, resourceConnectionDetails, resourceConnectionProperties, resourceCredentialDetails, tagsResponse };