@azure/arm-iotoperations 1.0.0-beta.1

package/dist/browser/models/models.d.ts

@@ -0,0 +1,1921 @@
+/** Instance dataflowEndpoint resource */
+export interface DataflowEndpointResource extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: DataflowEndpointProperties;
+    /** Edge location of the resource. */
+    extendedLocation: ExtendedLocation;
+}
+export declare function dataflowEndpointResourceSerializer(item: DataflowEndpointResource): any;
+export declare function dataflowEndpointResourceDeserializer(item: any): DataflowEndpointResource;
+/** DataflowEndpoint Resource properties. NOTE - Only one type of endpoint is supported for one Resource */
+export interface DataflowEndpointProperties {
+    /** Endpoint Type. */
+    endpointType: EndpointType;
+    /** Azure Data Explorer endpoint. */
+    dataExplorerSettings?: DataflowEndpointDataExplorer;
+    /** Azure Data Lake endpoint. */
+    dataLakeStorageSettings?: DataflowEndpointDataLakeStorage;
+    /** Microsoft Fabric endpoint. */
+    fabricOneLakeSettings?: DataflowEndpointFabricOneLake;
+    /** Kafka endpoint. */
+    kafkaSettings?: DataflowEndpointKafka;
+    /** Local persistent volume endpoint. */
+    localStorageSettings?: DataflowEndpointLocalStorage;
+    /** Broker endpoint. */
+    mqttSettings?: DataflowEndpointMqtt;
+    /** The status of the last operation. */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function dataflowEndpointPropertiesSerializer(item: DataflowEndpointProperties): any;
+export declare function dataflowEndpointPropertiesDeserializer(item: any): DataflowEndpointProperties;
+/** DataflowEndpoint Type properties */
+export declare enum KnownEndpointType {
+    /** Azure Data Explorer Type */
+    DataExplorer = "DataExplorer",
+    /** Azure Data Lake Type */
+    DataLakeStorage = "DataLakeStorage",
+    /** Microsoft Fabric Type */
+    FabricOneLake = "FabricOneLake",
+    /** Kafka Type */
+    Kafka = "Kafka",
+    /** Local Storage Type */
+    LocalStorage = "LocalStorage",
+    /** Broker Type */
+    Mqtt = "Mqtt"
+}
+/**
+ * DataflowEndpoint Type properties \
+ * {@link KnownEndpointType} can be used interchangeably with EndpointType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **DataExplorer**: Azure Data Explorer Type \
+ * **DataLakeStorage**: Azure Data Lake Type \
+ * **FabricOneLake**: Microsoft Fabric Type \
+ * **Kafka**: Kafka Type \
+ * **LocalStorage**: Local Storage Type \
+ * **Mqtt**: Broker Type
+ */
+export type EndpointType = string;
+/** Azure Data Explorer endpoint properties */
+export interface DataflowEndpointDataExplorer {
+    /** Authentication configuration. NOTE - only authentication property is allowed per entry. */
+    authentication: DataflowEndpointDataExplorerAuthentication;
+    /** Database name. */
+    database: string;
+    /** Host of the Azure Data Explorer in the form of <cluster>.<region>.kusto.windows.net . */
+    host: string;
+    /** Azure Data Explorer endpoint batching configuration. */
+    batching?: BatchingConfiguration;
+}
+export declare function dataflowEndpointDataExplorerSerializer(item: DataflowEndpointDataExplorer): any;
+export declare function dataflowEndpointDataExplorerDeserializer(item: any): DataflowEndpointDataExplorer;
+/** Azure Data Explorer Authentication properties. NOTE - only authentication property is allowed per entry. */
+export interface DataflowEndpointDataExplorerAuthentication {
+    /** Mode of Authentication. */
+    method: DataExplorerAuthMethod;
+    /** System-assigned managed identity authentication. */
+    systemAssignedManagedIdentitySettings?: DataflowEndpointAuthenticationSystemAssignedManagedIdentity;
+    /** User-assigned managed identity authentication. */
+    userAssignedManagedIdentitySettings?: DataflowEndpointAuthenticationUserAssignedManagedIdentity;
+}
+export declare function dataflowEndpointDataExplorerAuthenticationSerializer(item: DataflowEndpointDataExplorerAuthentication): any;
+export declare function dataflowEndpointDataExplorerAuthenticationDeserializer(item: any): DataflowEndpointDataExplorerAuthentication;
+/** Alias for DataExplorerAuthMethod */
+export type DataExplorerAuthMethod = ManagedIdentityMethod;
+export declare function dataExplorerAuthMethodSerializer(item: DataExplorerAuthMethod): any;
+export declare function dataExplorerAuthMethodDeserializer(item: any): DataExplorerAuthMethod;
+/** Managed Identity Method */
+export declare enum KnownManagedIdentityMethod {
+    /** SystemAssignedManagedIdentity type */
+    SystemAssignedManagedIdentity = "SystemAssignedManagedIdentity",
+    /** UserAssignedManagedIdentity type */
+    UserAssignedManagedIdentity = "UserAssignedManagedIdentity"
+}
+/**
+ * Managed Identity Method \
+ * {@link KnownManagedIdentityMethod} can be used interchangeably with ManagedIdentityMethod,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **SystemAssignedManagedIdentity**: SystemAssignedManagedIdentity type \
+ * **UserAssignedManagedIdentity**: UserAssignedManagedIdentity type
+ */
+export type ManagedIdentityMethod = string;
+/** DataflowEndpoint Authentication SystemAssignedManagedIdentity properties */
+export interface DataflowEndpointAuthenticationSystemAssignedManagedIdentity {
+    /** Audience of the service to authenticate against. Optional; defaults to the audience for Service host configuration. */
+    audience?: string;
+}
+export declare function dataflowEndpointAuthenticationSystemAssignedManagedIdentitySerializer(item: DataflowEndpointAuthenticationSystemAssignedManagedIdentity): any;
+export declare function dataflowEndpointAuthenticationSystemAssignedManagedIdentityDeserializer(item: any): DataflowEndpointAuthenticationSystemAssignedManagedIdentity;
+/** DataflowEndpoint Authentication UserAssignedManagedIdentity properties */
+export interface DataflowEndpointAuthenticationUserAssignedManagedIdentity {
+    /** Client ID for the user-assigned managed identity. */
+    clientId: string;
+    /** Resource identifier (application ID URI) of the resource, affixed with the .default suffix. */
+    scope?: string;
+    /** Tenant ID. */
+    tenantId: string;
+}
+export declare function dataflowEndpointAuthenticationUserAssignedManagedIdentitySerializer(item: DataflowEndpointAuthenticationUserAssignedManagedIdentity): any;
+export declare function dataflowEndpointAuthenticationUserAssignedManagedIdentityDeserializer(item: any): DataflowEndpointAuthenticationUserAssignedManagedIdentity;
+/** Batching configuration */
+export interface BatchingConfiguration {
+    /** Batching latency in seconds. */
+    latencySeconds?: number;
+    /** Maximum number of messages in a batch. */
+    maxMessages?: number;
+}
+export declare function batchingConfigurationSerializer(item: BatchingConfiguration): any;
+export declare function batchingConfigurationDeserializer(item: any): BatchingConfiguration;
+/** Azure Data Lake endpoint properties */
+export interface DataflowEndpointDataLakeStorage {
+    /** Authentication configuration. NOTE - only authentication property is allowed per entry. */
+    authentication: DataflowEndpointDataLakeStorageAuthentication;
+    /** Host of the Azure Data Lake in the form of <account>.blob.core.windows.net . */
+    host: string;
+    /** Azure Data Lake endpoint batching configuration. */
+    batching?: BatchingConfiguration;
+}
+export declare function dataflowEndpointDataLakeStorageSerializer(item: DataflowEndpointDataLakeStorage): any;
+export declare function dataflowEndpointDataLakeStorageDeserializer(item: any): DataflowEndpointDataLakeStorage;
+/** Azure Data Lake endpoint Authentication properties.  NOTE Enum - Only one method is supported for one entry */
+export interface DataflowEndpointDataLakeStorageAuthentication {
+    /** Mode of Authentication. */
+    method: DataLakeStorageAuthMethod;
+    /** SAS token authentication. */
+    accessTokenSettings?: DataflowEndpointAuthenticationAccessToken;
+    /** System-assigned managed identity authentication. */
+    systemAssignedManagedIdentitySettings?: DataflowEndpointAuthenticationSystemAssignedManagedIdentity;
+    /** User-assigned managed identity authentication. */
+    userAssignedManagedIdentitySettings?: DataflowEndpointAuthenticationUserAssignedManagedIdentity;
+}
+export declare function dataflowEndpointDataLakeStorageAuthenticationSerializer(item: DataflowEndpointDataLakeStorageAuthentication): any;
+export declare function dataflowEndpointDataLakeStorageAuthenticationDeserializer(item: any): DataflowEndpointDataLakeStorageAuthentication;
+/** Alias for DataLakeStorageAuthMethod */
+export type DataLakeStorageAuthMethod = ManagedIdentityMethod | AccessTokenMethod;
+export declare function dataLakeStorageAuthMethodSerializer(item: DataLakeStorageAuthMethod): any;
+export declare function dataLakeStorageAuthMethodDeserializer(item: any): DataLakeStorageAuthMethod;
+/** Access Token Method */
+export declare enum KnownAccessTokenMethod {
+    /** AccessToken Option */
+    AccessToken = "AccessToken"
+}
+/**
+ * Access Token Method \
+ * {@link KnownAccessTokenMethod} can be used interchangeably with AccessTokenMethod,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **AccessToken**: AccessToken Option
+ */
+export type AccessTokenMethod = string;
+/** DataflowEndpoint Authentication Access Token properties */
+export interface DataflowEndpointAuthenticationAccessToken {
+    /** Token secret name. */
+    secretRef: string;
+}
+export declare function dataflowEndpointAuthenticationAccessTokenSerializer(item: DataflowEndpointAuthenticationAccessToken): any;
+export declare function dataflowEndpointAuthenticationAccessTokenDeserializer(item: any): DataflowEndpointAuthenticationAccessToken;
+/** Microsoft Fabric endpoint properties */
+export interface DataflowEndpointFabricOneLake {
+    /** Authentication configuration. NOTE - only one authentication property is allowed per entry. */
+    authentication: DataflowEndpointFabricOneLakeAuthentication;
+    /** Names of the workspace and lakehouse. */
+    names: DataflowEndpointFabricOneLakeNames;
+    /** Type of location of the data in the workspace. Can be either tables or files. */
+    oneLakePathType: DataflowEndpointFabricPathType;
+    /** Host of the Microsoft Fabric in the form of https://<host>.fabric.microsoft.com. */
+    host: string;
+    /** Batching configuration. */
+    batching?: BatchingConfiguration;
+}
+export declare function dataflowEndpointFabricOneLakeSerializer(item: DataflowEndpointFabricOneLake): any;
+export declare function dataflowEndpointFabricOneLakeDeserializer(item: any): DataflowEndpointFabricOneLake;
+/** Microsoft Fabric endpoint. Authentication properties. NOTE - Only one method is supported for one entry */
+export interface DataflowEndpointFabricOneLakeAuthentication {
+    /** Mode of Authentication. */
+    method: FabricOneLakeAuthMethod;
+    /** System-assigned managed identity authentication. */
+    systemAssignedManagedIdentitySettings?: DataflowEndpointAuthenticationSystemAssignedManagedIdentity;
+    /** User-assigned managed identity authentication. */
+    userAssignedManagedIdentitySettings?: DataflowEndpointAuthenticationUserAssignedManagedIdentity;
+}
+export declare function dataflowEndpointFabricOneLakeAuthenticationSerializer(item: DataflowEndpointFabricOneLakeAuthentication): any;
+export declare function dataflowEndpointFabricOneLakeAuthenticationDeserializer(item: any): DataflowEndpointFabricOneLakeAuthentication;
+/** Alias for FabricOneLakeAuthMethod */
+export type FabricOneLakeAuthMethod = ManagedIdentityMethod;
+export declare function fabricOneLakeAuthMethodSerializer(item: FabricOneLakeAuthMethod): any;
+export declare function fabricOneLakeAuthMethodDeserializer(item: any): FabricOneLakeAuthMethod;
+/** Microsoft Fabric endpoint Names properties */
+export interface DataflowEndpointFabricOneLakeNames {
+    /** Lakehouse name. */
+    lakehouseName: string;
+    /** Workspace name. */
+    workspaceName: string;
+}
+export declare function dataflowEndpointFabricOneLakeNamesSerializer(item: DataflowEndpointFabricOneLakeNames): any;
+export declare function dataflowEndpointFabricOneLakeNamesDeserializer(item: any): DataflowEndpointFabricOneLakeNames;
+/** DataflowEndpoint Fabric Path Type properties */
+export declare enum KnownDataflowEndpointFabricPathType {
+    /** FILES Type */
+    Files = "Files",
+    /** TABLES Type */
+    Tables = "Tables"
+}
+/**
+ * DataflowEndpoint Fabric Path Type properties \
+ * {@link KnownDataflowEndpointFabricPathType} can be used interchangeably with DataflowEndpointFabricPathType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Files**: FILES Type \
+ * **Tables**: TABLES Type
+ */
+export type DataflowEndpointFabricPathType = string;
+/** Kafka endpoint properties */
+export interface DataflowEndpointKafka {
+    /** Authentication configuration. NOTE - only authentication property is allowed per entry. */
+    authentication: DataflowEndpointKafkaAuthentication;
+    /** Consumer group ID. */
+    consumerGroupId?: string;
+    /** Kafka endpoint host. */
+    host: string;
+    /** Batching configuration. */
+    batching?: DataflowEndpointKafkaBatching;
+    /** Copy Broker properties. No effect if the endpoint is used as a source or if the dataflow doesn't have an Broker source. */
+    copyMqttProperties?: OperationalMode;
+    /** Compression. Can be none, gzip, lz4, or snappy. No effect if the endpoint is used as a source. */
+    compression?: DataflowEndpointKafkaCompression;
+    /** Kafka acks. Can be all, one, or zero. No effect if the endpoint is used as a source. */
+    kafkaAcks?: DataflowEndpointKafkaAcks;
+    /** Partition handling strategy. Can be default or static. No effect if the endpoint is used as a source. */
+    partitionStrategy?: DataflowEndpointKafkaPartitionStrategy;
+    /** TLS configuration. */
+    tls?: TlsProperties;
+    /** Cloud event mapping config. */
+    cloudEventAttributes?: CloudEventAttributeType;
+}
+export declare function dataflowEndpointKafkaSerializer(item: DataflowEndpointKafka): any;
+export declare function dataflowEndpointKafkaDeserializer(item: any): DataflowEndpointKafka;
+/** Kafka endpoint Authentication properties. NOTE - only authentication property is allowed per entry */
+export interface DataflowEndpointKafkaAuthentication {
+    /** Mode of Authentication. */
+    method: KafkaAuthMethod;
+    /** System-assigned managed identity authentication. */
+    systemAssignedManagedIdentitySettings?: DataflowEndpointAuthenticationSystemAssignedManagedIdentity;
+    /** User-assigned managed identity authentication. */
+    userAssignedManagedIdentitySettings?: DataflowEndpointAuthenticationUserAssignedManagedIdentity;
+    /** SASL authentication. */
+    saslSettings?: DataflowEndpointAuthenticationSasl;
+    /** X.509 certificate authentication. */
+    x509CertificateSettings?: DataflowEndpointAuthenticationX509;
+}
+export declare function dataflowEndpointKafkaAuthenticationSerializer(item: DataflowEndpointKafkaAuthentication): any;
+export declare function dataflowEndpointKafkaAuthenticationDeserializer(item: any): DataflowEndpointKafkaAuthentication;
+/** Alias for KafkaAuthMethod */
+export type KafkaAuthMethod = ManagedIdentityMethod | SaslMethod | X509CertificateMethod | AnonymousMethod;
+export declare function kafkaAuthMethodSerializer(item: KafkaAuthMethod): any;
+export declare function kafkaAuthMethodDeserializer(item: any): KafkaAuthMethod;
+/** Sasl Method */
+export declare enum KnownSaslMethod {
+    /** Sasl Option */
+    Sasl = "Sasl"
+}
+/**
+ * Sasl Method \
+ * {@link KnownSaslMethod} can be used interchangeably with SaslMethod,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Sasl**: Sasl Option
+ */
+export type SaslMethod = string;
+/** x509 Certificate Method */
+export declare enum KnownX509CertificateMethod {
+    /** x509Certificate Option */
+    X509Certificate = "X509Certificate"
+}
+/**
+ * x509 Certificate Method \
+ * {@link Knownx509CertificateMethod} can be used interchangeably with x509CertificateMethod,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **X509Certificate**: x509Certificate Option
+ */
+export type X509CertificateMethod = string;
+/** x509 Certificate Method */
+export declare enum KnownAnonymousMethod {
+    /** Anonymous Option */
+    Anonymous = "Anonymous"
+}
+/**
+ * x509 Certificate Method \
+ * {@link KnownAnonymousMethod} can be used interchangeably with AnonymousMethod,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Anonymous**: Anonymous Option
+ */
+export type AnonymousMethod = string;
+/** DataflowEndpoint Authentication Sasl properties */
+export interface DataflowEndpointAuthenticationSasl {
+    /** Type of SASL authentication. Can be PLAIN, SCRAM-SHA-256, or SCRAM-SHA-512. */
+    saslType: DataflowEndpointAuthenticationSaslType;
+    /** Token secret name. */
+    secretRef: string;
+}
+export declare function dataflowEndpointAuthenticationSaslSerializer(item: DataflowEndpointAuthenticationSasl): any;
+export declare function dataflowEndpointAuthenticationSaslDeserializer(item: any): DataflowEndpointAuthenticationSasl;
+/** DataflowEndpoint Authentication Sasl Type properties */
+export declare enum KnownDataflowEndpointAuthenticationSaslType {
+    /** PLAIN Type */
+    Plain = "Plain",
+    /** SCRAM_SHA_256 Type */
+    ScramSha256 = "ScramSha256",
+    /** SCRAM_SHA_512 Type */
+    ScramSha512 = "ScramSha512"
+}
+/**
+ * DataflowEndpoint Authentication Sasl Type properties \
+ * {@link KnownDataflowEndpointAuthenticationSaslType} can be used interchangeably with DataflowEndpointAuthenticationSaslType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Plain**: PLAIN Type \
+ * **ScramSha256**: SCRAM_SHA_256 Type \
+ * **ScramSha512**: SCRAM_SHA_512 Type
+ */
+export type DataflowEndpointAuthenticationSaslType = string;
+/** DataflowEndpoint Authentication X509 properties */
+export interface DataflowEndpointAuthenticationX509 {
+    /** Secret reference of the X.509 certificate. */
+    secretRef: string;
+}
+export declare function dataflowEndpointAuthenticationX509Serializer(item: DataflowEndpointAuthenticationX509): any;
+export declare function dataflowEndpointAuthenticationX509Deserializer(item: any): DataflowEndpointAuthenticationX509;
+/** Kafka endpoint Batching properties */
+export interface DataflowEndpointKafkaBatching {
+    /** Mode for batching. */
+    mode?: OperationalMode;
+    /** Batching latency in milliseconds. */
+    latencyMs?: number;
+    /** Maximum number of bytes in a batch. */
+    maxBytes?: number;
+    /** Maximum number of messages in a batch. */
+    maxMessages?: number;
+}
+export declare function dataflowEndpointKafkaBatchingSerializer(item: DataflowEndpointKafkaBatching): any;
+export declare function dataflowEndpointKafkaBatchingDeserializer(item: any): DataflowEndpointKafkaBatching;
+/** Mode properties */
+export declare enum KnownOperationalMode {
+    /** Enabled is equivalent to True */
+    Enabled = "Enabled",
+    /** Disabled is equivalent to False. */
+    Disabled = "Disabled"
+}
+/**
+ * Mode properties \
+ * {@link KnownOperationalMode} can be used interchangeably with OperationalMode,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Enabled**: Enabled is equivalent to True \
+ * **Disabled**: Disabled is equivalent to False.
+ */
+export type OperationalMode = string;
+/** Kafka endpoint Compression properties */
+export declare enum KnownDataflowEndpointKafkaCompression {
+    /** NONE Option */
+    None = "None",
+    /** Gzip Option */
+    Gzip = "Gzip",
+    /** SNAPPY Option */
+    Snappy = "Snappy",
+    /** LZ4 Option */
+    Lz4 = "Lz4"
+}
+/**
+ * Kafka endpoint Compression properties \
+ * {@link KnownDataflowEndpointKafkaCompression} can be used interchangeably with DataflowEndpointKafkaCompression,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **None**: NONE Option \
+ * **Gzip**: Gzip Option \
+ * **Snappy**: SNAPPY Option \
+ * **Lz4**: LZ4 Option
+ */
+export type DataflowEndpointKafkaCompression = string;
+/** DataflowEndpoint Kafka Acks properties */
+export declare enum KnownDataflowEndpointKafkaAcks {
+    /** ZERO Option */
+    Zero = "Zero",
+    /** ONE Option */
+    One = "One",
+    /** ALL Option */
+    All = "All"
+}
+/**
+ * DataflowEndpoint Kafka Acks properties \
+ * {@link KnownDataflowEndpointKafkaAcks} can be used interchangeably with DataflowEndpointKafkaAcks,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Zero**: ZERO Option \
+ * **One**: ONE Option \
+ * **All**: ALL Option
+ */
+export type DataflowEndpointKafkaAcks = string;
+/** DataflowEndpoint Kafka Partition Strategy properties */
+export declare enum KnownDataflowEndpointKafkaPartitionStrategy {
+    /** Default: Assigns messages to random partitions, using a round-robin algorithm. */
+    Default = "Default",
+    /** Static: Assigns messages to a fixed partition number that's derived from the instance ID of the dataflow. */
+    Static = "Static",
+    /** TOPIC Option */
+    Topic = "Topic",
+    /** PROPERTY Option */
+    Property = "Property"
+}
+/**
+ * DataflowEndpoint Kafka Partition Strategy properties \
+ * {@link KnownDataflowEndpointKafkaPartitionStrategy} can be used interchangeably with DataflowEndpointKafkaPartitionStrategy,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Default**: Default: Assigns messages to random partitions, using a round-robin algorithm. \
+ * **Static**: Static: Assigns messages to a fixed partition number that's derived from the instance ID of the dataflow. \
+ * **Topic**: TOPIC Option \
+ * **Property**: PROPERTY Option
+ */
+export type DataflowEndpointKafkaPartitionStrategy = string;
+/** Tls properties */
+export interface TlsProperties {
+    /** Mode for TLS. */
+    mode?: OperationalMode;
+    /** Trusted CA certificate config map. */
+    trustedCaCertificateConfigMapRef?: string;
+}
+export declare function tlsPropertiesSerializer(item: TlsProperties): any;
+export declare function tlsPropertiesDeserializer(item: any): TlsProperties;
+/** How to map events to the cloud. */
+export declare enum KnownCloudEventAttributeType {
+    /** Propagate type */
+    Propagate = "Propagate",
+    /** CreateOrRemap type */
+    CreateOrRemap = "CreateOrRemap"
+}
+/**
+ * How to map events to the cloud. \
+ * {@link KnownCloudEventAttributeType} can be used interchangeably with CloudEventAttributeType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Propagate**: Propagate type \
+ * **CreateOrRemap**: CreateOrRemap type
+ */
+export type CloudEventAttributeType = string;
+/** Local persistent volume endpoint properties */
+export interface DataflowEndpointLocalStorage {
+    /** Persistent volume claim name. */
+    persistentVolumeClaimRef: string;
+}
+export declare function dataflowEndpointLocalStorageSerializer(item: DataflowEndpointLocalStorage): any;
+export declare function dataflowEndpointLocalStorageDeserializer(item: any): DataflowEndpointLocalStorage;
+/** Broker endpoint properties */
+export interface DataflowEndpointMqtt {
+    /** authentication properties. DEFAULT: kubernetes.audience=aio-internal. NOTE - Enum field only property is allowed */
+    authentication: DataflowEndpointMqttAuthentication;
+    /** Client ID prefix. Client ID generated by the dataflow is <prefix>-TBD. Optional; no prefix if omitted. */
+    clientIdPrefix?: string;
+    /** Host of the Broker in the form of <hostname>:<port>. Optional; connects to Broker if omitted. */
+    host?: string;
+    /** Enable or disable websockets. */
+    protocol?: BrokerProtocolType;
+    /** Broker KeepAlive for connection in seconds. */
+    keepAliveSeconds?: number;
+    /** Whether or not to keep the retain setting. */
+    retain?: MqttRetainType;
+    /** The max number of messages to keep in flight. For subscribe, this is the receive maximum. For publish, this is the maximum number of messages to send before waiting for an ack. */
+    maxInflightMessages?: number;
+    /** Qos for Broker connection. */
+    qos?: number;
+    /** Session expiry in seconds. */
+    sessionExpirySeconds?: number;
+    /** TLS configuration. */
+    tls?: TlsProperties;
+    /** Cloud event mapping config. */
+    cloudEventAttributes?: CloudEventAttributeType;
+}
+export declare function dataflowEndpointMqttSerializer(item: DataflowEndpointMqtt): any;
+export declare function dataflowEndpointMqttDeserializer(item: any): DataflowEndpointMqtt;
+/** Mqtt endpoint Authentication properties. NOTE - only authentication property is allowed per entry. */
+export interface DataflowEndpointMqttAuthentication {
+    /** Mode of Authentication. */
+    method: MqttAuthMethod;
+    /** System-assigned managed identity authentication. */
+    systemAssignedManagedIdentitySettings?: DataflowEndpointAuthenticationSystemAssignedManagedIdentity;
+    /** User-assigned managed identity authentication. */
+    userAssignedManagedIdentitySettings?: DataflowEndpointAuthenticationUserAssignedManagedIdentity;
+    /** Kubernetes service account token authentication. Default audience if not set is aio-internal */
+    serviceAccountTokenSettings?: DataflowEndpointAuthenticationServiceAccountToken;
+    /** X.509 certificate authentication. */
+    x509CertificateSettings?: DataflowEndpointAuthenticationX509;
+}
+export declare function dataflowEndpointMqttAuthenticationSerializer(item: DataflowEndpointMqttAuthentication): any;
+export declare function dataflowEndpointMqttAuthenticationDeserializer(item: any): DataflowEndpointMqttAuthentication;
+/** Alias for MqttAuthMethod */
+export type MqttAuthMethod = ManagedIdentityMethod | ServiceAccountTokenMethod | X509CertificateMethod | AnonymousMethod;
+export declare function mqttAuthMethodSerializer(item: MqttAuthMethod): any;
+export declare function mqttAuthMethodDeserializer(item: any): MqttAuthMethod;
+/** Service Account Token Method */
+export declare enum KnownServiceAccountTokenMethod {
+    /** ServiceAccountToken Option */
+    ServiceAccountToken = "ServiceAccountToken"
+}
+/**
+ * Service Account Token Method \
+ * {@link KnownServiceAccountTokenMethod} can be used interchangeably with ServiceAccountTokenMethod,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **ServiceAccountToken**: ServiceAccountToken Option
+ */
+export type ServiceAccountTokenMethod = string;
+/** Service Account Token for BrokerAuthentication */
+export interface DataflowEndpointAuthenticationServiceAccountToken {
+    /** Audience of the service account. Optional, defaults to the broker internal service account audience. */
+    audience: string;
+}
+export declare function dataflowEndpointAuthenticationServiceAccountTokenSerializer(item: DataflowEndpointAuthenticationServiceAccountToken): any;
+export declare function dataflowEndpointAuthenticationServiceAccountTokenDeserializer(item: any): DataflowEndpointAuthenticationServiceAccountToken;
+/** Broker Protocol types */
+export declare enum KnownBrokerProtocolType {
+    /** protocol broker */
+    Mqtt = "Mqtt",
+    /** protocol websocket */
+    WebSockets = "WebSockets"
+}
+/**
+ * Broker Protocol types \
+ * {@link KnownBrokerProtocolType} can be used interchangeably with BrokerProtocolType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Mqtt**: protocol broker \
+ * **WebSockets**: protocol websocket
+ */
+export type BrokerProtocolType = string;
+/** Broker Retain types */
+export declare enum KnownMqttRetainType {
+    /** Retain the messages. */
+    Keep = "Keep",
+    /** Never retain messages. */
+    Never = "Never"
+}
+/**
+ * Broker Retain types \
+ * {@link KnownMqttRetainType} can be used interchangeably with MqttRetainType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Keep**: Retain the messages. \
+ * **Never**: Never retain messages.
+ */
+export type MqttRetainType = string;
+/** The provisioning state of a resource type. */
+export declare enum KnownProvisioningState {
+    /** Resource has been created. */
+    Succeeded = "Succeeded",
+    /** Resource creation failed. */
+    Failed = "Failed",
+    /** Resource creation was canceled. */
+    Canceled = "Canceled",
+    /** Resource creation was provisioning. */
+    Provisioning = "Provisioning",
+    /** Resource creation was updating. */
+    Updating = "Updating",
+    /** Resource creation was deleting. */
+    Deleting = "Deleting",
+    /** Resource creation was accepted. */
+    Accepted = "Accepted"
+}
+/**
+ * The provisioning state of a resource type. \
+ * {@link KnownProvisioningState} can be used interchangeably with ResourceProvisioningState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Succeeded**: Resource has been created. \
+ * **Failed**: Resource creation failed. \
+ * **Canceled**: Resource creation canceled. \
+ * **Provisioning**: Resource creation provisioning. \
+ * **Updating**: Resource creation updating. \
+ * **Deleting**: Resource creation deleting. \
+ * **Accepted**: Resource creation was accepted.
+ */
+export type ProvisioningState = string;
+export declare function provisioningStateSerializer(item: ProvisioningState): any;
+export declare function provisioningStateDeserializer(item: any): ProvisioningState;
+/** Extended location is an extension of Azure locations. They provide a way to use their Azure ARC enabled Kubernetes clusters as target locations for deploying Azure services instances. */
+export interface ExtendedLocation {
+    /** The name of the extended location. */
+    name: string;
+    /** Type of ExtendedLocation. */
+    type: ExtendedLocationType;
+}
+export declare function extendedLocationSerializer(item: ExtendedLocation): any;
+export declare function extendedLocationDeserializer(item: any): ExtendedLocation;
+/** The enum defining type of ExtendedLocation accepted. */
+export declare enum KnownExtendedLocationType {
+    /** CustomLocation type */
+    CustomLocation = "CustomLocation"
+}
+/**
+ * The enum defining type of ExtendedLocation accepted. \
+ * {@link KnownExtendedLocationType} can be used interchangeably with ExtendedLocationType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **CustomLocation**: CustomLocation type
+ */
+export type ExtendedLocationType = string;
+/** The resource model definition for a Azure Resource Manager proxy resource. It will not have tags and a location */
+export interface ProxyResource extends Resource {
+}
+export declare function proxyResourceSerializer(item: ProxyResource): any;
+export declare function proxyResourceDeserializer(item: any): ProxyResource;
+/** Common fields that are returned in the response for all Azure Resource Manager resources */
+export interface Resource {
+    /** Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} */
+    readonly id?: string;
+    /** The name of the resource */
+    readonly name?: string;
+    /** The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" */
+    readonly type?: string;
+    /** Azure Resource Manager metadata containing createdBy and modifiedBy information. */
+    readonly systemData?: SystemData;
+}
+export declare function resourceSerializer(item: Resource): any;
+export declare function resourceDeserializer(item: any): Resource;
+/** Metadata pertaining to creation and last modification of the resource. */
+export interface SystemData {
+    /** The identity that created the resource. */
+    createdBy?: string;
+    /** The type of identity that created the resource. */
+    createdByType?: CreatedByType;
+    /** The timestamp of resource creation (UTC). */
+    createdAt?: Date;
+    /** The identity that last modified the resource. */
+    lastModifiedBy?: string;
+    /** The type of identity that last modified the resource. */
+    lastModifiedByType?: CreatedByType;
+    /** The timestamp of resource last modification (UTC) */
+    lastModifiedAt?: Date;
+}
+export declare function systemDataDeserializer(item: any): SystemData;
+/** The kind of entity that created the resource. */
+export declare enum KnownCreatedByType {
+    /** The entity was created by a user. */
+    User = "User",
+    /** The entity was created by an application. */
+    Application = "Application",
+    /** The entity was created by a managed identity. */
+    ManagedIdentity = "ManagedIdentity",
+    /** The entity was created by a key. */
+    Key = "Key"
+}
+/**
+ * The kind of entity that created the resource. \
+ * {@link KnowncreatedByType} can be used interchangeably with createdByType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **User**: The entity was created by a user. \
+ * **Application**: The entity was created by an application. \
+ * **ManagedIdentity**: The entity was created by a managed identity. \
+ * **Key**: The entity was created by a key.
+ */
+export type CreatedByType = string;
+/** The response of a DataflowEndpointResource list operation. */
+export interface _DataflowEndpointResourceListResult {
+    /** The DataflowEndpointResource items on this page */
+    value: DataflowEndpointResource[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _dataflowEndpointResourceListResultDeserializer(item: any): _DataflowEndpointResourceListResult;
+export declare function dataflowEndpointResourceArraySerializer(result: Array<DataflowEndpointResource>): any[];
+export declare function dataflowEndpointResourceArrayDeserializer(result: Array<DataflowEndpointResource>): any[];
+/** Instance dataflowProfile dataflow resource */
+export interface DataflowResource extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: DataflowProperties;
+    /** Edge location of the resource. */
+    extendedLocation: ExtendedLocation;
+}
+export declare function dataflowResourceSerializer(item: DataflowResource): any;
+export declare function dataflowResourceDeserializer(item: any): DataflowResource;
+/** Dataflow Resource properties */
+export interface DataflowProperties {
+    /** Mode for Dataflow. Optional; defaults to Enabled. */
+    mode?: OperationalMode;
+    /** List of operations including source and destination references as well as transformation. */
+    operations: DataflowOperation[];
+    /** The status of the last operation. */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function dataflowPropertiesSerializer(item: DataflowProperties): any;
+export declare function dataflowPropertiesDeserializer(item: any): DataflowProperties;
+/** Dataflow Operation properties. NOTE - One only method is allowed to be used for one entry. */
+export interface DataflowOperation {
+    /** Type of operation. */
+    operationType: OperationType;
+    /** Optional user provided name of the transformation. */
+    name?: string;
+    /** Source configuration. */
+    sourceSettings?: DataflowSourceOperationSettings;
+    /** Built In Transformation configuration. */
+    builtInTransformationSettings?: DataflowBuiltInTransformationSettings;
+    /** Destination configuration. */
+    destinationSettings?: DataflowDestinationOperationSettings;
+}
+export declare function dataflowOperationSerializer(item: DataflowOperation): any;
+export declare function dataflowOperationDeserializer(item: any): DataflowOperation;
+/** Dataflow Operation Type properties */
+export declare enum KnownOperationType {
+    /** Dataflow Source Operation */
+    Source = "Source",
+    /** Dataflow Destination Operation */
+    Destination = "Destination",
+    /** Dataflow BuiltIn Transformation Operation */
+    BuiltInTransformation = "BuiltInTransformation"
+}
+/**
+ * Dataflow Operation Type properties \
+ * {@link KnownOperationType} can be used interchangeably with OperationType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Source**: Dataflow Source Operation \
+ * **Destination**: Dataflow Destination Operation \
+ * **BuiltInTransformation**: Dataflow BuiltIn Transformation Operation
+ */
+export type OperationType = string;
+/** Dataflow Source Operation properties */
+export interface DataflowSourceOperationSettings {
+    /** Reference to the Dataflow Endpoint resource. Can only be of Broker and Kafka type. */
+    endpointRef: string;
+    /** Reference to the resource in Azure Device Registry where the data in the endpoint originates from. */
+    assetRef?: string;
+    /** Content is a JSON Schema. Allowed: JSON Schema/draft-7. */
+    serializationFormat?: SourceSerializationFormat;
+    /** Schema CR reference. Data will be deserialized according to the schema, and dropped if it doesn't match. */
+    schemaRef?: string;
+    /** List of source locations. Can be Broker or Kafka topics. Supports wildcards # and +. */
+    dataSources: string[];
+}
+export declare function dataflowSourceOperationSettingsSerializer(item: DataflowSourceOperationSettings): any;
+export declare function dataflowSourceOperationSettingsDeserializer(item: any): DataflowSourceOperationSettings;
+/** Serialization Format properties */
+export declare enum KnownSourceSerializationFormat {
+    /** JSON Format */
+    Json = "Json"
+}
+/**
+ * Serialization Format properties \
+ * {@link KnownSourceSerializationFormat} can be used interchangeably with SourceSerializationFormat,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Json**: JSON Format
+ */
+export type SourceSerializationFormat = string;
+/** Dataflow BuiltIn Transformation properties */
+export interface DataflowBuiltInTransformationSettings {
+    /** Serialization format. Optional; defaults to JSON. Allowed value JSON Schema/draft-7, Parquet. Default: Json */
+    serializationFormat?: TransformationSerializationFormat;
+    /** Reference to the schema that describes the output of the transformation. */
+    schemaRef?: string;
+    /** Enrich data from Broker State Store. Dataset references a key in Broker State Store. */
+    datasets?: DataflowBuiltInTransformationDataset[];
+    /** Filters input record or datapoints based on condition. */
+    filter?: DataflowBuiltInTransformationFilter[];
+    /** Maps input to output message. */
+    map?: DataflowBuiltInTransformationMap[];
+}
+export declare function dataflowBuiltInTransformationSettingsSerializer(item: DataflowBuiltInTransformationSettings): any;
+export declare function dataflowBuiltInTransformationSettingsDeserializer(item: any): DataflowBuiltInTransformationSettings;
+/** Transformation Format properties */
+export declare enum KnownTransformationSerializationFormat {
+    /** Delta Format */
+    Delta = "Delta",
+    /** JSON Format */
+    Json = "Json",
+    /** Parquet Format */
+    Parquet = "Parquet"
+}
+/**
+ * Transformation Format properties \
+ * {@link KnownTransformationSerializationFormat} can be used interchangeably with TransformationSerializationFormat,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Delta**: Delta Format \
+ * **Json**: JSON Format \
+ * **Parquet**: Parquet Format
+ */
+export type TransformationSerializationFormat = string;
+/** Dataflow BuiltIn Transformation dataset properties */
+export interface DataflowBuiltInTransformationDataset {
+    /** The key of the dataset. */
+    key: string;
+    /** A user provided optional description of the dataset. */
+    description?: string;
+    /** The reference to the schema that describes the dataset. Allowed: JSON Schema/draft-7. */
+    schemaRef?: string;
+    /** List of fields for enriching from the Broker State Store. */
+    inputs: string[];
+    /** Condition to enrich data from Broker State Store. Example: $1 < 0 || $1 > $2 (Assuming inputs section $1 and $2 are provided) */
+    expression?: string;
+}
+export declare function dataflowBuiltInTransformationDatasetSerializer(item: DataflowBuiltInTransformationDataset): any;
+export declare function dataflowBuiltInTransformationDatasetDeserializer(item: any): DataflowBuiltInTransformationDataset;
+export declare function dataflowBuiltInTransformationDatasetArraySerializer(result: Array<DataflowBuiltInTransformationDataset>): any[];
+export declare function dataflowBuiltInTransformationDatasetArrayDeserializer(result: Array<DataflowBuiltInTransformationDataset>): any[];
+/** Dataflow BuiltIn Transformation filter properties */
+export interface DataflowBuiltInTransformationFilter {
+    /** The type of dataflow operation. */
+    type?: FilterType;
+    /** A user provided optional description of the filter. */
+    description?: string;
+    /** List of fields for filtering in JSON path expression. */
+    inputs: string[];
+    /** Condition to filter data. Can reference input fields with {n} where n is the index of the input field starting from 1. Example: $1 < 0 || $1 > $2 (Assuming inputs section $1 and $2 are provided) */
+    expression: string;
+}
+export declare function dataflowBuiltInTransformationFilterSerializer(item: DataflowBuiltInTransformationFilter): any;
+export declare function dataflowBuiltInTransformationFilterDeserializer(item: any): DataflowBuiltInTransformationFilter;
+/** Filter Type properties */
+export declare enum KnownFilterType {
+    /** Filter type */
+    Filter = "Filter"
+}
+/**
+ * Filter Type properties \
+ * {@link KnownFilterType} can be used interchangeably with FilterType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Filter**: Filter type
+ */
+export type FilterType = string;
+export declare function dataflowBuiltInTransformationFilterArraySerializer(result: Array<DataflowBuiltInTransformationFilter>): any[];
+export declare function dataflowBuiltInTransformationFilterArrayDeserializer(result: Array<DataflowBuiltInTransformationFilter>): any[];
+/** Dataflow BuiltIn Transformation map properties */
+export interface DataflowBuiltInTransformationMap {
+    /** Type of transformation. */
+    type?: DataflowMappingType;
+    /** A user provided optional description of the mapping function. */
+    description?: string;
+    /** List of fields for mapping in JSON path expression. */
+    inputs: string[];
+    /** Modify the inputs field(s) to the final output field. Example: $1 * 2.2 (Assuming inputs section $1 is provided) */
+    expression?: string;
+    /** Where and how the input fields to be organized in the output record. */
+    output: string;
+}
+export declare function dataflowBuiltInTransformationMapSerializer(item: DataflowBuiltInTransformationMap): any;
+export declare function dataflowBuiltInTransformationMapDeserializer(item: any): DataflowBuiltInTransformationMap;
+/** Dataflow type mapping properties */
+export declare enum KnownDataflowMappingType {
+    /** New Properties type */
+    NewProperties = "NewProperties",
+    /** Rename type */
+    Rename = "Rename",
+    /** Compute type */
+    Compute = "Compute",
+    /** Pass-through type */
+    PassThrough = "PassThrough",
+    /** Built in function type */
+    BuiltInFunction = "BuiltInFunction"
+}
+/**
+ * Dataflow type mapping properties \
+ * {@link KnownDataflowMappingType} can be used interchangeably with DataflowMappingType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **NewProperties**: New Properties type \
+ * **Rename**: Rename type \
+ * **Compute**: Compute type \
+ * **PassThrough**: Pass-through type \
+ * **BuiltInFunction**: Built in function type
+ */
+export type DataflowMappingType = string;
+export declare function dataflowBuiltInTransformationMapArraySerializer(result: Array<DataflowBuiltInTransformationMap>): any[];
+export declare function dataflowBuiltInTransformationMapArrayDeserializer(result: Array<DataflowBuiltInTransformationMap>): any[];
+/** Dataflow Destination Operation properties */
+export interface DataflowDestinationOperationSettings {
+    /** Reference to the Endpoint CR. Can be of Broker, Kafka, Fabric, ADLS, ADX type. */
+    endpointRef: string;
+    /** Destination location, can be a topic or table name. Supports dynamic values with $topic, $systemProperties, $userProperties, $payload, $context, and $subscription. */
+    dataDestination: string;
+}
+export declare function dataflowDestinationOperationSettingsSerializer(item: DataflowDestinationOperationSettings): any;
+export declare function dataflowDestinationOperationSettingsDeserializer(item: any): DataflowDestinationOperationSettings;
+export declare function dataflowOperationArraySerializer(result: Array<DataflowOperation>): any[];
+export declare function dataflowOperationArrayDeserializer(result: Array<DataflowOperation>): any[];
+/** The response of a DataflowResource list operation. */
+export interface _DataflowResourceListResult {
+    /** The DataflowResource items on this page */
+    value: DataflowResource[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _dataflowResourceListResultDeserializer(item: any): _DataflowResourceListResult;
+export declare function dataflowResourceArraySerializer(result: Array<DataflowResource>): any[];
+export declare function dataflowResourceArrayDeserializer(result: Array<DataflowResource>): any[];
+/** Instance dataflowProfile resource */
+export interface DataflowProfileResource extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: DataflowProfileProperties;
+    /** Edge location of the resource. */
+    extendedLocation: ExtendedLocation;
+}
+export declare function dataflowProfileResourceSerializer(item: DataflowProfileResource): any;
+export declare function dataflowProfileResourceDeserializer(item: any): DataflowProfileResource;
+/** DataflowProfile Resource properties */
+export interface DataflowProfileProperties {
+    /** Spec defines the desired identities of NBC diagnostics settings. */
+    diagnostics?: ProfileDiagnostics;
+    /** To manually scale the dataflow profile, specify the maximum number of instances you want to run. */
+    instanceCount?: number;
+    /** The status of the last operation. */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function dataflowProfilePropertiesSerializer(item: DataflowProfileProperties): any;
+export declare function dataflowProfilePropertiesDeserializer(item: any): DataflowProfileProperties;
+/** DataflowProfile Diagnostics properties */
+export interface ProfileDiagnostics {
+    /** Diagnostic log settings for the resource. */
+    logs?: DiagnosticsLogs;
+    /** The metrics settings for the resource. */
+    metrics?: Metrics;
+}
+export declare function profileDiagnosticsSerializer(item: ProfileDiagnostics): any;
+export declare function profileDiagnosticsDeserializer(item: any): ProfileDiagnostics;
+/** Diagnostic Log properties */
+export interface DiagnosticsLogs {
+    /** The log level. Examples - 'debug', 'info', 'warn', 'error', 'trace'. */
+    level?: string;
+}
+export declare function diagnosticsLogsSerializer(item: DiagnosticsLogs): any;
+export declare function diagnosticsLogsDeserializer(item: any): DiagnosticsLogs;
+/** Diagnostic Metrics properties */
+export interface Metrics {
+    /** The prometheus port to expose the metrics. */
+    prometheusPort?: number;
+}
+export declare function metricsSerializer(item: Metrics): any;
+export declare function metricsDeserializer(item: any): Metrics;
+/** The response of a DataflowProfileResource list operation. */
+export interface _DataflowProfileResourceListResult {
+    /** The DataflowProfileResource items on this page */
+    value: DataflowProfileResource[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _dataflowProfileResourceListResultDeserializer(item: any): _DataflowProfileResourceListResult;
+export declare function dataflowProfileResourceArraySerializer(result: Array<DataflowProfileResource>): any[];
+export declare function dataflowProfileResourceArrayDeserializer(result: Array<DataflowProfileResource>): any[];
+/** Instance broker authorizations resource */
+export interface BrokerAuthorizationResource extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: BrokerAuthorizationProperties;
+    /** Edge location of the resource. */
+    extendedLocation: ExtendedLocation;
+}
+export declare function brokerAuthorizationResourceSerializer(item: BrokerAuthorizationResource): any;
+export declare function brokerAuthorizationResourceDeserializer(item: any): BrokerAuthorizationResource;
+/** BrokerAuthorization Resource properties */
+export interface BrokerAuthorizationProperties {
+    /** The list of authorization policies supported by the Authorization Resource. */
+    authorizationPolicies: AuthorizationConfig;
+    /** The status of the last operation. */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function brokerAuthorizationPropertiesSerializer(item: BrokerAuthorizationProperties): any;
+export declare function brokerAuthorizationPropertiesDeserializer(item: any): BrokerAuthorizationProperties;
+/** Broker AuthorizationConfig properties */
+export interface AuthorizationConfig {
+    /** Enable caching of the authorization rules. */
+    cache?: OperationalMode;
+    /** The authorization rules to follow. If no rule is set, but Authorization Resource is used that would mean DenyAll. */
+    rules?: AuthorizationRule[];
+}
+export declare function authorizationConfigSerializer(item: AuthorizationConfig): any;
+export declare function authorizationConfigDeserializer(item: any): AuthorizationConfig;
+/** AuthorizationConfig Rule Properties */
+export interface AuthorizationRule {
+    /** Give access to Broker methods and topics. */
+    brokerResources: BrokerResourceRule[];
+    /** Give access to clients based on the following properties. */
+    principals: PrincipalDefinition;
+    /** Give access to state store resources. */
+    stateStoreResources?: StateStoreResourceRule[];
+}
+export declare function authorizationRuleSerializer(item: AuthorizationRule): any;
+export declare function authorizationRuleDeserializer(item: any): AuthorizationRule;
+/** Broker Resource Rule properties. This defines the objects that represent the actions or topics, such as - method.Connect, method.Publish, etc. */
+export interface BrokerResourceRule {
+    /** Give access for a Broker method (i.e., Connect, Subscribe, or Publish). */
+    method: BrokerResourceDefinitionMethods;
+    /** A list of client IDs that match the clients. The client IDs are case-sensitive and must match the client IDs provided by the clients during connection. This subfield may be set if the method is Connect. */
+    clientIds?: string[];
+    /** A list of topics or topic patterns that match the topics that the clients can publish or subscribe to. This subfield is required if the method is Publish or Subscribe. */
+    topics?: string[];
+}
+export declare function brokerResourceRuleSerializer(item: BrokerResourceRule): any;
+export declare function brokerResourceRuleDeserializer(item: any): BrokerResourceRule;
+/** BrokerResourceDefinitionMethods methods allowed */
+export declare enum KnownBrokerResourceDefinitionMethods {
+    /** Allowed Connecting to Broker */
+    Connect = "Connect",
+    /** Allowed Publishing to Broker */
+    Publish = "Publish",
+    /** Allowed Subscribing to Broker */
+    Subscribe = "Subscribe"
+}
+/**
+ * BrokerResourceDefinitionMethods methods allowed \
+ * {@link KnownBrokerResourceDefinitionMethods} can be used interchangeably with BrokerResourceDefinitionMethods,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Connect**: Allowed Connecting to Broker \
+ * **Publish**: Allowed Publishing to Broker \
+ * **Subscribe**: Allowed Subscribing to Broker
+ */
+export type BrokerResourceDefinitionMethods = string;
+export declare function brokerResourceRuleArraySerializer(result: Array<BrokerResourceRule>): any[];
+export declare function brokerResourceRuleArrayDeserializer(result: Array<BrokerResourceRule>): any[];
+/** PrincipalDefinition properties of Rule */
+export interface PrincipalDefinition {
+    /** A list of key-value pairs that match the attributes of the clients. The attributes are case-sensitive and must match the attributes provided by the clients during authentication. */
+    attributes?: Record<string, string>[];
+    /** A list of client IDs that match the clients. The client IDs are case-sensitive and must match the client IDs provided by the clients during connection. */
+    clientIds?: string[];
+    /** A list of usernames that match the clients. The usernames are case-sensitive and must match the usernames provided by the clients during authentication. */
+    usernames?: string[];
+}
+export declare function principalDefinitionSerializer(item: PrincipalDefinition): any;
+export declare function principalDefinitionDeserializer(item: any): PrincipalDefinition;
+/** State Store Resource Rule properties. */
+export interface StateStoreResourceRule {
+    /** Allowed keyTypes pattern, string, binary. The key type used for matching, for example pattern tries to match the key to a glob-style pattern and string checks key is equal to value provided in keys. */
+    keyType: StateStoreResourceKeyTypes;
+    /** Give access to state store keys for the corresponding principals defined. When key type is pattern set glob-style pattern (e.g., '*', 'clients/*'). */
+    keys: string[];
+    /** Give access for `Read`, `Write` and `ReadWrite` access level. */
+    method: StateStoreResourceDefinitionMethods;
+}
+export declare function stateStoreResourceRuleSerializer(item: StateStoreResourceRule): any;
+export declare function stateStoreResourceRuleDeserializer(item: any): StateStoreResourceRule;
+/** StateStoreResourceKeyTypes properties */
+export declare enum KnownStateStoreResourceKeyTypes {
+    /** Key type - pattern */
+    Pattern = "Pattern",
+    /** Key type - string */
+    String = "String",
+    /** Key type - binary */
+    Binary = "Binary"
+}
+/**
+ * StateStoreResourceKeyTypes properties \
+ * {@link KnownStateStoreResourceKeyTypes} can be used interchangeably with StateStoreResourceKeyTypes,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Pattern**: Key type - pattern \
+ * **String**: Key type - string \
+ * **Binary**: Key type - binary
+ */
+export type StateStoreResourceKeyTypes = string;
+/** StateStoreResourceDefinitionMethods methods allowed */
+export declare enum KnownStateStoreResourceDefinitionMethods {
+    /** Get/KeyNotify from Store */
+    Read = "Read",
+    /** Set/Delete in Store */
+    Write = "Write",
+    /** Allowed all operations on Store - Get/KeyNotify/Set/Delete */
+    ReadWrite = "ReadWrite"
+}
+/**
+ * StateStoreResourceDefinitionMethods methods allowed \
+ * {@link KnownStateStoreResourceDefinitionMethods} can be used interchangeably with StateStoreResourceDefinitionMethods,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Read**: Get\/KeyNotify from Store \
+ * **Write**: Set\/Delete in Store \
+ * **ReadWrite**: Allowed all operations on Store - Get\/KeyNotify\/Set\/Delete
+ */
+export type StateStoreResourceDefinitionMethods = string;
+export declare function stateStoreResourceRuleArraySerializer(result: Array<StateStoreResourceRule>): any[];
+export declare function stateStoreResourceRuleArrayDeserializer(result: Array<StateStoreResourceRule>): any[];
+export declare function authorizationRuleArraySerializer(result: Array<AuthorizationRule>): any[];
+export declare function authorizationRuleArrayDeserializer(result: Array<AuthorizationRule>): any[];
+/** The response of a BrokerAuthorizationResource list operation. */
+export interface _BrokerAuthorizationResourceListResult {
+    /** The BrokerAuthorizationResource items on this page */
+    value: BrokerAuthorizationResource[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _brokerAuthorizationResourceListResultDeserializer(item: any): _BrokerAuthorizationResourceListResult;
+export declare function brokerAuthorizationResourceArraySerializer(result: Array<BrokerAuthorizationResource>): any[];
+export declare function brokerAuthorizationResourceArrayDeserializer(result: Array<BrokerAuthorizationResource>): any[];
+/** Instance broker authentication resource */
+export interface BrokerAuthenticationResource extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: BrokerAuthenticationProperties;
+    /** Edge location of the resource. */
+    extendedLocation: ExtendedLocation;
+}
+export declare function brokerAuthenticationResourceSerializer(item: BrokerAuthenticationResource): any;
+export declare function brokerAuthenticationResourceDeserializer(item: any): BrokerAuthenticationResource;
+/** BrokerAuthentication Resource properties */
+export interface BrokerAuthenticationProperties {
+    /** Defines a set of Broker authentication methods to be used on `BrokerListeners`. For each array element one authenticator type supported. */
+    authenticationMethods: BrokerAuthenticatorMethods[];
+    /** The status of the last operation. */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function brokerAuthenticationPropertiesSerializer(item: BrokerAuthenticationProperties): any;
+export declare function brokerAuthenticationPropertiesDeserializer(item: any): BrokerAuthenticationProperties;
+/** Set of broker authentication policies. Only one method is supported for each entry. */
+export interface BrokerAuthenticatorMethods {
+    /** Custom authentication configuration. */
+    method: BrokerAuthenticationMethod;
+    /** Custom authentication configuration. */
+    customSettings?: BrokerAuthenticatorMethodCustom;
+    /** ServiceAccountToken authentication configuration. */
+    serviceAccountTokenSettings?: BrokerAuthenticatorMethodSat;
+    /** X.509 authentication configuration. */
+    x509Settings?: BrokerAuthenticatorMethodX509;
+}
+export declare function brokerAuthenticatorMethodsSerializer(item: BrokerAuthenticatorMethods): any;
+export declare function brokerAuthenticatorMethodsDeserializer(item: any): BrokerAuthenticatorMethods;
+/** Broker Authentication Mode */
+export declare enum KnownBrokerAuthenticationMethod {
+    /** Custom authentication configuration. */
+    Custom = "Custom",
+    /** ServiceAccountToken authentication configuration. */
+    ServiceAccountToken = "ServiceAccountToken",
+    /** X.509 authentication configuration. */
+    X509 = "X509"
+}
+/**
+ * Broker Authentication Mode \
+ * {@link KnownBrokerAuthenticationMethod} can be used interchangeably with BrokerAuthenticationMethod,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Custom**: Custom authentication configuration. \
+ * **ServiceAccountToken**: ServiceAccountToken authentication configuration. \
+ * **X509**: X.509 authentication configuration.
+ */
+export type BrokerAuthenticationMethod = string;
+/** Custom method for BrokerAuthentication */
+export interface BrokerAuthenticatorMethodCustom {
+    /** Optional authentication needed for authenticating with the custom authentication server. */
+    auth?: BrokerAuthenticatorCustomAuth;
+    /** Optional CA certificate for validating the custom authentication server's certificate. */
+    caCertConfigMap?: string;
+    /** Endpoint of the custom authentication server. Must be an HTTPS endpoint. */
+    endpoint: string;
+    /** Additional HTTP headers to pass to the custom authentication server. */
+    headers?: Record<string, string>;
+}
+export declare function brokerAuthenticatorMethodCustomSerializer(item: BrokerAuthenticatorMethodCustom): any;
+export declare function brokerAuthenticatorMethodCustomDeserializer(item: any): BrokerAuthenticatorMethodCustom;
+/** Custom Authentication properties */
+export interface BrokerAuthenticatorCustomAuth {
+    /** X509 Custom Auth type details. */
+    x509: X509ManualCertificate;
+}
+export declare function brokerAuthenticatorCustomAuthSerializer(item: BrokerAuthenticatorCustomAuth): any;
+export declare function brokerAuthenticatorCustomAuthDeserializer(item: any): BrokerAuthenticatorCustomAuth;
+/** X509 Certificate Authentication properties. */
+export interface X509ManualCertificate {
+    /** Kubernetes secret containing an X.509 client certificate. This is a reference to the secret through an identifying name, not the secret itself. */
+    secretRef: string;
+}
+export declare function x509ManualCertificateSerializer(item: X509ManualCertificate): any;
+export declare function x509ManualCertificateDeserializer(item: any): X509ManualCertificate;
+/** Service Account Token for BrokerAuthentication */
+export interface BrokerAuthenticatorMethodSat {
+    /** List of allowed audience. */
+    audiences: string[];
+}
+export declare function brokerAuthenticatorMethodSatSerializer(item: BrokerAuthenticatorMethodSat): any;
+export declare function brokerAuthenticatorMethodSatDeserializer(item: any): BrokerAuthenticatorMethodSat;
+/** X509 for BrokerAuthentication. */
+export interface BrokerAuthenticatorMethodX509 {
+    /** X509 authorization attributes properties. */
+    authorizationAttributes?: Record<string, BrokerAuthenticatorMethodX509Attributes>;
+    /** Name of the trusted client ca cert resource. */
+    trustedClientCaCert?: string;
+}
+export declare function brokerAuthenticatorMethodX509Serializer(item: BrokerAuthenticatorMethodX509): any;
+export declare function brokerAuthenticatorMethodX509Deserializer(item: any): BrokerAuthenticatorMethodX509;
+/** BrokerAuthenticatorMethodX509Attributes properties. */
+export interface BrokerAuthenticatorMethodX509Attributes {
+    /** Attributes object. */
+    attributes: Record<string, string>;
+    /** Subject of the X509 attribute. */
+    subject: string;
+}
+export declare function brokerAuthenticatorMethodX509AttributesSerializer(item: BrokerAuthenticatorMethodX509Attributes): any;
+export declare function brokerAuthenticatorMethodX509AttributesDeserializer(item: any): BrokerAuthenticatorMethodX509Attributes;
+export declare function brokerAuthenticatorMethodX509AttributesRecordSerializer(item: Record<string, BrokerAuthenticatorMethodX509Attributes>): Record<string, any>;
+export declare function brokerAuthenticatorMethodX509AttributesRecordDeserializer(item: Record<string, any>): Record<string, BrokerAuthenticatorMethodX509Attributes>;
+export declare function brokerAuthenticatorMethodsArraySerializer(result: Array<BrokerAuthenticatorMethods>): any[];
+export declare function brokerAuthenticatorMethodsArrayDeserializer(result: Array<BrokerAuthenticatorMethods>): any[];
+/** The response of a BrokerAuthenticationResource list operation. */
+export interface _BrokerAuthenticationResourceListResult {
+    /** The BrokerAuthenticationResource items on this page */
+    value: BrokerAuthenticationResource[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _brokerAuthenticationResourceListResultDeserializer(item: any): _BrokerAuthenticationResourceListResult;
+export declare function brokerAuthenticationResourceArraySerializer(result: Array<BrokerAuthenticationResource>): any[];
+export declare function brokerAuthenticationResourceArrayDeserializer(result: Array<BrokerAuthenticationResource>): any[];
+/** Instance broker resource */
+export interface BrokerListenerResource extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: BrokerListenerProperties;
+    /** Edge location of the resource. */
+    extendedLocation: ExtendedLocation;
+}
+export declare function brokerListenerResourceSerializer(item: BrokerListenerResource): any;
+export declare function brokerListenerResourceDeserializer(item: any): BrokerListenerResource;
+/** Defines a Broker listener. A listener is a collection of ports on which the broker accepts connections from clients. */
+export interface BrokerListenerProperties {
+    /** Kubernetes Service name of this listener. */
+    serviceName?: string;
+    /** Ports on which this listener accepts client connections. */
+    ports: ListenerPort[];
+    /** Kubernetes Service type of this listener. */
+    serviceType?: ServiceType;
+    /** The status of the last operation. */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function brokerListenerPropertiesSerializer(item: BrokerListenerProperties): any;
+export declare function brokerListenerPropertiesDeserializer(item: any): BrokerListenerProperties;
+/** Defines a TCP port on which a `BrokerListener` listens. */
+export interface ListenerPort {
+    /** Reference to client authentication settings. Omit to disable authentication. */
+    authenticationRef?: string;
+    /** Reference to client authorization settings. Omit to disable authorization. */
+    authorizationRef?: string;
+    /** Kubernetes node port. Only relevant when this port is associated with a `NodePort` listener. */
+    nodePort?: number;
+    /** TCP port for accepting client connections. */
+    port: number;
+    /** Protocol to use for client connections. */
+    protocol?: BrokerProtocolType;
+    /** TLS server certificate settings for this port. Omit to disable TLS. */
+    tls?: TlsCertMethod;
+}
+export declare function listenerPortSerializer(item: ListenerPort): any;
+export declare function listenerPortDeserializer(item: any): ListenerPort;
+/** Collection of different TLS types, NOTE- Enum at a time only one of them needs to be supported */
+export interface TlsCertMethod {
+    /** Mode of TLS server certificate management. */
+    mode: TlsCertMethodMode;
+    /** Option 1 - Automatic TLS server certificate management with cert-manager. */
+    certManagerCertificateSpec?: CertManagerCertificateSpec;
+    /** Option 2 - Manual TLS server certificate management through a defined secret. */
+    manual?: X509ManualCertificate;
+}
+export declare function tlsCertMethodSerializer(item: TlsCertMethod): any;
+export declare function tlsCertMethodDeserializer(item: any): TlsCertMethod;
+/** Broker Authentication Mode */
+export declare enum KnownTlsCertMethodMode {
+    /** Automatic TLS server certificate configuration. */
+    Automatic = "Automatic",
+    /** Manual TLS server certificate configuration. */
+    Manual = "Manual"
+}
+/**
+ * Broker Authentication Mode \
+ * {@link KnownTlsCertMethodMode} can be used interchangeably with TlsCertMethodMode,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Automatic**: Automatic TLS server certificate configuration. \
+ * **Manual**: Manual TLS server certificate configuration.
+ */
+export type TlsCertMethodMode = string;
+/** Automatic TLS server certificate management with cert-manager */
+export interface CertManagerCertificateSpec {
+    /** Lifetime of certificate. Must be specified using a Go time.Duration format (h|m|s). E.g. 240h for 240 hours and 45m for 45 minutes. */
+    duration?: string;
+    /** Secret for storing server certificate. Any existing data will be overwritten. This is a reference to the secret through an identifying name, not the secret itself. */
+    secretName?: string;
+    /** When to begin renewing certificate. Must be specified using a Go time.Duration format (h|m|s). E.g. 240h for 240 hours and 45m for 45 minutes. */
+    renewBefore?: string;
+    /** cert-manager issuerRef. */
+    issuerRef: CertManagerIssuerRef;
+    /** Type of certificate private key. */
+    privateKey?: CertManagerPrivateKey;
+    /** Additional Subject Alternative Names (SANs) to include in the certificate. */
+    san?: SanForCert;
+}
+export declare function certManagerCertificateSpecSerializer(item: CertManagerCertificateSpec): any;
+export declare function certManagerCertificateSpecDeserializer(item: any): CertManagerCertificateSpec;
+/** Cert-Manager issuerRef properties */
+export interface CertManagerIssuerRef {
+    /** group of issuer. */
+    group: string;
+    /** kind of issuer (Issuer or ClusterIssuer). */
+    kind: CertManagerIssuerKind;
+    /** name of issuer. */
+    name: string;
+}
+export declare function certManagerIssuerRefSerializer(item: CertManagerIssuerRef): any;
+export declare function certManagerIssuerRefDeserializer(item: any): CertManagerIssuerRef;
+/** CertManagerIssuerKind properties */
+export declare enum KnownCertManagerIssuerKind {
+    /** Issuer kind. */
+    Issuer = "Issuer",
+    /** ClusterIssuer kind. */
+    ClusterIssuer = "ClusterIssuer"
+}
+/**
+ * CertManagerIssuerKind properties \
+ * {@link KnownCertManagerIssuerKind} can be used interchangeably with CertManagerIssuerKind,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Issuer**: Issuer kind. \
+ * **ClusterIssuer**: ClusterIssuer kind.
+ */
+export type CertManagerIssuerKind = string;
+/** Cert Manager private key properties */
+export interface CertManagerPrivateKey {
+    /** algorithm for private key. */
+    algorithm: PrivateKeyAlgorithm;
+    /** cert-manager private key rotationPolicy. */
+    rotationPolicy: PrivateKeyRotationPolicy;
+}
+export declare function certManagerPrivateKeySerializer(item: CertManagerPrivateKey): any;
+export declare function certManagerPrivateKeyDeserializer(item: any): CertManagerPrivateKey;
+/** Private key algorithm types. */
+export declare enum KnownPrivateKeyAlgorithm {
+    /** Algorithm - ec256. */
+    Ec256 = "Ec256",
+    /** Algorithm - ec384. */
+    Ec384 = "Ec384",
+    /** Algorithm - ec521. */
+    Ec521 = "Ec521",
+    /** Algorithm - ed25519. */
+    Ed25519 = "Ed25519",
+    /** Algorithm - rsa2048. */
+    Rsa2048 = "Rsa2048",
+    /** Algorithm - rsa4096. */
+    Rsa4096 = "Rsa4096",
+    /** Algorithm - rsa8192. */
+    Rsa8192 = "Rsa8192"
+}
+/**
+ * Private key algorithm types. \
+ * {@link KnownPrivateKeyAlgorithm} can be used interchangeably with PrivateKeyAlgorithm,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Ec256**: Algorithm - ec256. \
+ * **Ec384**: Algorithm - ec384. \
+ * **Ec521**: Algorithm - ec521. \
+ * **Ed25519**: Algorithm - ed25519. \
+ * **Rsa2048**: Algorithm - rsa2048. \
+ * **Rsa4096**: Algorithm - rsa4096. \
+ * **Rsa8192**: Algorithm - rsa8192.
+ */
+export type PrivateKeyAlgorithm = string;
+/** Private key rotation policy. */
+export declare enum KnownPrivateKeyRotationPolicy {
+    /** Rotation Policy - Always. */
+    Always = "Always",
+    /** Rotation Policy - Never. */
+    Never = "Never"
+}
+/**
+ * Private key rotation policy. \
+ * {@link KnownPrivateKeyRotationPolicy} can be used interchangeably with PrivateKeyRotationPolicy,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Always**: Rotation Policy - Always. \
+ * **Never**: Rotation Policy - Never.
+ */
+export type PrivateKeyRotationPolicy = string;
+/** Subject Alternative Names (SANs) for certificate. */
+export interface SanForCert {
+    /** DNS SANs. */
+    dns: string[];
+    /** IP address SANs. */
+    ip: string[];
+}
+export declare function sanForCertSerializer(item: SanForCert): any;
+export declare function sanForCertDeserializer(item: any): SanForCert;
+export declare function listenerPortArraySerializer(result: Array<ListenerPort>): any[];
+export declare function listenerPortArrayDeserializer(result: Array<ListenerPort>): any[];
+/** Kubernetes Service Types supported by Listener */
+export declare enum KnownServiceType {
+    /** Cluster IP Service. */
+    ClusterIp = "ClusterIp",
+    /** Load Balancer Service. */
+    LoadBalancer = "LoadBalancer",
+    /** Node Port Service. */
+    NodePort = "NodePort"
+}
+/**
+ * Kubernetes Service Types supported by Listener \
+ * {@link KnownServiceType} can be used interchangeably with ServiceType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **ClusterIp**: Cluster IP Service. \
+ * **LoadBalancer**: Load Balancer Service. \
+ * **NodePort**: Node Port Service.
+ */
+export type ServiceType = string;
+/** The response of a BrokerListenerResource list operation. */
+export interface _BrokerListenerResourceListResult {
+    /** The BrokerListenerResource items on this page */
+    value: BrokerListenerResource[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _brokerListenerResourceListResultDeserializer(item: any): _BrokerListenerResourceListResult;
+export declare function brokerListenerResourceArraySerializer(result: Array<BrokerListenerResource>): any[];
+export declare function brokerListenerResourceArrayDeserializer(result: Array<BrokerListenerResource>): any[];
+/** Instance broker resource */
+export interface BrokerResource extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: BrokerProperties;
+    /** Edge location of the resource. */
+    extendedLocation: ExtendedLocation;
+}
+export declare function brokerResourceSerializer(item: BrokerResource): any;
+export declare function brokerResourceDeserializer(item: any): BrokerResource;
+/** Broker Resource properties */
+export interface BrokerProperties {
+    /** Advanced settings of Broker. */
+    advanced?: AdvancedSettings;
+    /** The cardinality details of the broker. */
+    cardinality?: Cardinality;
+    /** Spec defines the desired identities of Broker diagnostics settings. */
+    diagnostics?: BrokerDiagnostics;
+    /** Settings of Disk Backed Message Buffer. */
+    diskBackedMessageBuffer?: DiskBackedMessageBuffer;
+    /** This setting controls whether Kubernetes CPU resource limits are requested. Increasing the number of replicas or workers proportionally increases the amount of CPU resources requested. If this setting is enabled and there are insufficient CPU resources, an error will be emitted. */
+    generateResourceLimits?: GenerateResourceLimits;
+    /** Memory profile of Broker. */
+    memoryProfile?: BrokerMemoryProfile;
+    /** The status of the last operation. */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function brokerPropertiesSerializer(item: BrokerProperties): any;
+export declare function brokerPropertiesDeserializer(item: any): BrokerProperties;
+/** Broker Advanced Settings */
+export interface AdvancedSettings {
+    /** Configurations related to All Clients. */
+    clients?: ClientConfig;
+    /** The setting to enable or disable encryption of internal Traffic. */
+    encryptInternalTraffic?: OperationalMode;
+    /** Certificate rotation and private key configuration. */
+    internalCerts?: CertManagerCertOptions;
+}
+export declare function advancedSettingsSerializer(item: AdvancedSettings): any;
+export declare function advancedSettingsDeserializer(item: any): AdvancedSettings;
+/** The settings of Client Config. */
+export interface ClientConfig {
+    /** Upper bound of Session Expiry Interval, in seconds. */
+    maxSessionExpirySeconds?: number;
+    /** Upper bound of Message Expiry Interval, in seconds. */
+    maxMessageExpirySeconds?: number;
+    /** Max message size for a packet in Bytes. */
+    maxPacketSizeBytes?: number;
+    /** The limit on the number of queued messages for a subscriber. */
+    subscriberQueueLimit?: SubscriberQueueLimit;
+    /** Upper bound of Receive Maximum that a client can request in the CONNECT packet. */
+    maxReceiveMaximum?: number;
+    /** Upper bound of a client's Keep Alive, in seconds. */
+    maxKeepAliveSeconds?: number;
+}
+export declare function clientConfigSerializer(item: ClientConfig): any;
+export declare function clientConfigDeserializer(item: any): ClientConfig;
+/** The settings of Subscriber Queue Limit. */
+export interface SubscriberQueueLimit {
+    /** The maximum length of the queue before messages start getting dropped. */
+    length?: number;
+    /** The strategy to use for dropping messages from the queue. */
+    strategy?: SubscriberMessageDropStrategy;
+}
+export declare function subscriberQueueLimitSerializer(item: SubscriberQueueLimit): any;
+export declare function subscriberQueueLimitDeserializer(item: any): SubscriberQueueLimit;
+/** The enum defining strategies for dropping messages from the subscriber queue. */
+export declare enum KnownSubscriberMessageDropStrategy {
+    /** Messages are never dropped. */
+    None = "None",
+    /** The oldest message is dropped. */
+    DropOldest = "DropOldest"
+}
+/**
+ * The enum defining strategies for dropping messages from the subscriber queue. \
+ * {@link KnownSubscriberMessageDropStrategy} can be used interchangeably with SubscriberMessageDropStrategy,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **None**: Messages are never dropped. \
+ * **DropOldest**: The oldest message is dropped.
+ */
+export type SubscriberMessageDropStrategy = string;
+/** Cert Manager Cert properties */
+export interface CertManagerCertOptions {
+    /** Lifetime of certificate. Must be specified using a Go time.Duration format (h|m|s). E.g. 240h for 240 hours and 45m for 45 minutes. */
+    duration: string;
+    /** When to begin renewing certificate. Must be specified using a Go time.Duration format (h|m|s). E.g. 240h for 240 hours and 45m for 45 minutes. */
+    renewBefore: string;
+    /** Configuration of certificate private key. */
+    privateKey: CertManagerPrivateKey;
+}
+export declare function certManagerCertOptionsSerializer(item: CertManagerCertOptions): any;
+export declare function certManagerCertOptionsDeserializer(item: any): CertManagerCertOptions;
+/** Cardinality properties */
+export interface Cardinality {
+    /** The backend broker desired properties */
+    backendChain: BackendChain;
+    /** The frontend desired properties */
+    frontend: Frontend;
+}
+export declare function cardinalitySerializer(item: Cardinality): any;
+export declare function cardinalityDeserializer(item: any): Cardinality;
+/** Desired properties of the backend instances of the broker */
+export interface BackendChain {
+    /** The desired number of physical backend partitions. */
+    partitions: number;
+    /** The desired numbers of backend replicas (pods) in a physical partition. */
+    redundancyFactor: number;
+    /** Number of logical backend workers per replica (pod). */
+    workers?: number;
+}
+export declare function backendChainSerializer(item: BackendChain): any;
+export declare function backendChainDeserializer(item: any): BackendChain;
+/** The desired properties of the frontend instances of the Broker */
+export interface Frontend {
+    /** The desired number of frontend instances (pods). */
+    replicas: number;
+    /** Number of logical frontend workers per instance (pod). */
+    workers?: number;
+}
+export declare function frontendSerializer(item: Frontend): any;
+export declare function frontendDeserializer(item: any): Frontend;
+/** Broker Diagnostic Setting properties */
+export interface BrokerDiagnostics {
+    /** Diagnostic log settings for the resource. */
+    logs?: DiagnosticsLogs;
+    /** The metrics settings for the resource. */
+    metrics?: Metrics;
+    /** The self check properties. */
+    selfCheck?: SelfCheck;
+    /** The trace properties. */
+    traces?: Traces;
+}
+export declare function brokerDiagnosticsSerializer(item: BrokerDiagnostics): any;
+export declare function brokerDiagnosticsDeserializer(item: any): BrokerDiagnostics;
+/** Broker Diagnostic Self check properties */
+export interface SelfCheck {
+    /** The toggle to enable/disable self check. */
+    mode?: OperationalMode;
+    /** The self check interval. */
+    intervalSeconds?: number;
+    /** The timeout for self check. */
+    timeoutSeconds?: number;
+}
+export declare function selfCheckSerializer(item: SelfCheck): any;
+export declare function selfCheckDeserializer(item: any): SelfCheck;
+/** Broker Diagnostic Trace properties */
+export interface Traces {
+    /** The toggle to enable/disable traces. */
+    mode?: OperationalMode;
+    /** The cache size in megabytes. */
+    cacheSizeMegabytes?: number;
+    /** The self tracing properties. */
+    selfTracing?: SelfTracing;
+    /** The span channel capacity. */
+    spanChannelCapacity?: number;
+}
+export declare function tracesSerializer(item: Traces): any;
+export declare function tracesDeserializer(item: any): Traces;
+/** Diagnostic Self tracing properties */
+export interface SelfTracing {
+    /** The toggle to enable/disable self tracing. */
+    mode?: OperationalMode;
+    /** The self tracing interval. */
+    intervalSeconds?: number;
+}
+export declare function selfTracingSerializer(item: SelfTracing): any;
+export declare function selfTracingDeserializer(item: any): SelfTracing;
+/** DiskBackedMessageBuffer properties */
+export interface DiskBackedMessageBuffer {
+    /** The max size of the message buffer on disk. If a PVC template is specified using one of ephemeralVolumeClaimSpec or persistentVolumeClaimSpec, then this size is used as the request and limit sizes of that template. If neither ephemeralVolumeClaimSpec nor persistentVolumeClaimSpec are specified, then an emptyDir volume is mounted with this size as its limit. See <https://kubernetes.io/docs/concepts/storage/volumes/#emptydir> for details. */
+    maxSize: string;
+    /** Use the specified persistent volume claim template to mount a "generic ephemeral volume" for the message buffer. See <https://kubernetes.io/docs/concepts/storage/ephemeral-volumes/#generic-ephemeral-volumes> for details. */
+    ephemeralVolumeClaimSpec?: VolumeClaimSpec;
+    /** Use the specified persistent volume claim template to mount a persistent volume for the message buffer. */
+    persistentVolumeClaimSpec?: VolumeClaimSpec;
+}
+export declare function diskBackedMessageBufferSerializer(item: DiskBackedMessageBuffer): any;
+export declare function diskBackedMessageBufferDeserializer(item: any): DiskBackedMessageBuffer;
+/** VolumeClaimSpec properties */
+export interface VolumeClaimSpec {
+    /** VolumeName is the binding reference to the PersistentVolume backing this claim. */
+    volumeName?: string;
+    /** volumeMode defines what type of volume is required by the claim. Value of Filesystem is implied when not included in claim spec. This is a beta feature. */
+    volumeMode?: string;
+    /** Name of the StorageClass required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1 */
+    storageClassName?: string;
+    /** AccessModes contains the desired access modes the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1 */
+    accessModes?: string[];
+    /** This field can be used to specify either: * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot) * An existing PVC (PersistentVolumeClaim) If the provisioner or an external controller can support the specified data source, it will create a new volume based on the contents of the specified data source. If the AnyVolumeDataSource feature gate is enabled, this field will always have the same contents as the DataSourceRef field. */
+    dataSource?: LocalKubernetesReference;
+    /** Specifies the object from which to populate the volume with data, if a non-empty volume is desired. This may be any local object from a non-empty API group (non core object) or a PersistentVolumeClaim object. When this field is specified, volume binding will only succeed if the type of the specified object matches some installed volume populator or dynamic provisioner. This field will replace the functionality of the DataSource field and as such if both fields are non-empty, they must have the same value. For backwards compatibility, both fields (DataSource and DataSourceRef) will be set to the same value automatically if one of them is empty and the other is non-empty. There are two important differences between DataSource and DataSourceRef: * While DataSource only allows two specific types of objects, DataSourceRef allows any non-core object, as well as PersistentVolumeClaim objects. * While DataSource ignores disallowed values (dropping them), DataSourceRef preserves all values, and generates an error if a disallowed value is specified. (Beta) Using this field requires the AnyVolumeDataSource feature gate to be enabled. */
+    dataSourceRef?: KubernetesReference;
+    /** Resources represents the minimum resources the volume should have. If RecoverVolumeExpansionFailure feature is enabled users are allowed to specify resource requirements that are lower than previous value but must still be higher than capacity recorded in the status field of the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources */
+    resources?: VolumeClaimResourceRequirements;
+    /** A label query over volumes to consider for binding. */
+    selector?: VolumeClaimSpecSelector;
+}
+export declare function volumeClaimSpecSerializer(item: VolumeClaimSpec): any;
+export declare function volumeClaimSpecDeserializer(item: any): VolumeClaimSpec;
+/** Kubernetes reference */
+export interface LocalKubernetesReference {
+    /** APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required. */
+    apiGroup?: string;
+    /** Kind is the type of resource being referenced */
+    kind: string;
+    /** Name is the name of resource being referenced */
+    name: string;
+}
+export declare function localKubernetesReferenceSerializer(item: LocalKubernetesReference): any;
+export declare function localKubernetesReferenceDeserializer(item: any): LocalKubernetesReference;
+/** Kubernetes reference */
+export interface KubernetesReference {
+    /** APIGroup is the group for the resource being referenced. If APIGroup is not specified, the specified Kind must be in the core API group. For any other third-party types, APIGroup is required. */
+    apiGroup?: string;
+    /** Kind is the type of resource being referenced */
+    kind: string;
+    /** Name is the name of resource being referenced */
+    name: string;
+    /** Namespace is the namespace of the resource being referenced. This field is required when the resource has a namespace. */
+    namespace?: string;
+}
+export declare function kubernetesReferenceSerializer(item: KubernetesReference): any;
+export declare function kubernetesReferenceDeserializer(item: any): KubernetesReference;
+/** VolumeClaimResourceRequirements properties */
+export interface VolumeClaimResourceRequirements {
+    /** Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ */
+    limits?: Record<string, string>;
+    /** Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/ */
+    requests?: Record<string, string>;
+}
+export declare function volumeClaimResourceRequirementsSerializer(item: VolumeClaimResourceRequirements): any;
+export declare function volumeClaimResourceRequirementsDeserializer(item: any): VolumeClaimResourceRequirements;
+/** VolumeClaimSpecSelector properties */
+export interface VolumeClaimSpecSelector {
+    /** MatchExpressions is a list of label selector requirements. The requirements are ANDed. */
+    matchExpressions?: VolumeClaimSpecSelectorMatchExpressions[];
+    /** MatchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed. */
+    matchLabels?: Record<string, string>;
+}
+export declare function volumeClaimSpecSelectorSerializer(item: VolumeClaimSpecSelector): any;
+export declare function volumeClaimSpecSelectorDeserializer(item: any): VolumeClaimSpecSelector;
+/** VolumeClaimSpecSelectorMatchExpressions properties */
+export interface VolumeClaimSpecSelectorMatchExpressions {
+    /** key is the label key that the selector applies to. */
+    key: string;
+    /** operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist. */
+    operator: OperatorValues;
+    /** values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch. */
+    values?: string[];
+}
+export declare function volumeClaimSpecSelectorMatchExpressionsSerializer(item: VolumeClaimSpecSelectorMatchExpressions): any;
+export declare function volumeClaimSpecSelectorMatchExpressionsDeserializer(item: any): VolumeClaimSpecSelectorMatchExpressions;
+/** Valid operators are In, NotIn, Exists and DoesNotExist. */
+export declare enum KnownOperatorValues {
+    /** In operator. */
+    In = "In",
+    /** NotIn operator. */
+    NotIn = "NotIn",
+    /** Exists operator. */
+    Exists = "Exists",
+    /** DoesNotExist operator. */
+    DoesNotExist = "DoesNotExist"
+}
+/**
+ * Valid operators are In, NotIn, Exists and DoesNotExist. \
+ * {@link KnownOperatorValues} can be used interchangeably with OperatorValues,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **In**: In operator. \
+ * **NotIn**: NotIn operator. \
+ * **Exists**: Exists operator. \
+ * **DoesNotExist**: DoesNotExist operator.
+ */
+export type OperatorValues = string;
+export declare function volumeClaimSpecSelectorMatchExpressionsArraySerializer(result: Array<VolumeClaimSpecSelectorMatchExpressions>): any[];
+export declare function volumeClaimSpecSelectorMatchExpressionsArrayDeserializer(result: Array<VolumeClaimSpecSelectorMatchExpressions>): any[];
+/** GenerateResourceLimits properties */
+export interface GenerateResourceLimits {
+    /** The toggle to enable/disable cpu resource limits. */
+    cpu?: OperationalMode;
+}
+export declare function generateResourceLimitsSerializer(item: GenerateResourceLimits): any;
+export declare function generateResourceLimitsDeserializer(item: any): GenerateResourceLimits;
+/** The memory profile settings of the Broker */
+export declare enum KnownBrokerMemoryProfile {
+    /** Tiny memory profile. */
+    Tiny = "Tiny",
+    /** Low memory profile. */
+    Low = "Low",
+    /** Medium memory profile. */
+    Medium = "Medium",
+    /** High memory profile. */
+    High = "High"
+}
+/**
+ * The memory profile settings of the Broker \
+ * {@link KnownBrokerMemoryProfile} can be used interchangeably with BrokerMemoryProfile,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Tiny**: Tiny memory profile. \
+ * **Low**: Low memory profile. \
+ * **Medium**: Medium memory profile. \
+ * **High**: High memory profile.
+ */
+export type BrokerMemoryProfile = string;
+/** The response of a BrokerResource list operation. */
+export interface _BrokerResourceListResult {
+    /** The BrokerResource items on this page */
+    value: BrokerResource[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _brokerResourceListResultDeserializer(item: any): _BrokerResourceListResult;
+export declare function brokerResourceArraySerializer(result: Array<BrokerResource>): any[];
+export declare function brokerResourceArrayDeserializer(result: Array<BrokerResource>): any[];
+/** A Instance resource is a logical container for a set of child resources. */
+export interface InstanceResource extends TrackedResource {
+    /** The resource-specific properties for this resource. */
+    properties?: InstanceProperties;
+    /** Edge location of the resource. */
+    extendedLocation: ExtendedLocation;
+    /** The managed service identities assigned to this resource. */
+    identity?: ManagedServiceIdentity;
+}
+export declare function instanceResourceSerializer(item: InstanceResource): any;
+export declare function instanceResourceDeserializer(item: any): InstanceResource;
+/** The properties of the Instance resource. */
+export interface InstanceProperties {
+    /** Detailed description of the Instance. */
+    description?: string;
+    /** The status of the last operation. */
+    readonly provisioningState?: ProvisioningState;
+    /** The Azure IoT Operations version. */
+    readonly version?: string;
+    /** The reference to the Schema Registry for this AIO Instance. */
+    schemaRegistryRef: SchemaRegistryRef;
+}
+export declare function instancePropertiesSerializer(item: InstanceProperties): any;
+export declare function instancePropertiesDeserializer(item: any): InstanceProperties;
+/** The reference to the Schema Registry for this AIO Instance. */
+export interface SchemaRegistryRef {
+    /** The resource ID of the Schema Registry. */
+    resourceId: string;
+}
+export declare function schemaRegistryRefSerializer(item: SchemaRegistryRef): any;
+export declare function schemaRegistryRefDeserializer(item: any): SchemaRegistryRef;
+/** Managed service identity (system assigned and/or user assigned identities) */
+export interface ManagedServiceIdentity {
+    /** The service principal ID of the system assigned identity. This property will only be provided for a system assigned identity. */
+    readonly principalId?: string;
+    /** The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity. */
+    readonly tenantId?: string;
+    /** The type of managed identity assigned to this resource. */
+    type: ManagedServiceIdentityType;
+    /** The identities assigned to this resource by the user. */
+    userAssignedIdentities?: Record<string, UserAssignedIdentity | null>;
+}
+export declare function managedServiceIdentitySerializer(item: ManagedServiceIdentity): any;
+export declare function managedServiceIdentityDeserializer(item: any): ManagedServiceIdentity;
+/** Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). */
+export declare enum KnownManagedServiceIdentityType {
+    /** No managed identity. */
+    None = "None",
+    /** System assigned managed identity. */
+    SystemAssigned = "SystemAssigned",
+    /** User assigned managed identity. */
+    UserAssigned = "UserAssigned",
+    /** System and user assigned managed identity. */
+    SystemAssignedUserAssigned = "SystemAssigned,UserAssigned"
+}
+/**
+ * Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). \
+ * {@link KnownManagedServiceIdentityType} can be used interchangeably with ManagedServiceIdentityType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **None**: No managed identity. \
+ * **SystemAssigned**: System assigned managed identity. \
+ * **UserAssigned**: User assigned managed identity. \
+ * **SystemAssigned,UserAssigned**: System and user assigned managed identity.
+ */
+export type ManagedServiceIdentityType = string;
+/** User assigned identity properties */
+export interface UserAssignedIdentity {
+    /** The principal ID of the assigned identity. */
+    readonly principalId?: string;
+    /** The client ID of the assigned identity. */
+    readonly clientId?: string;
+}
+export declare function userAssignedIdentitySerializer(item: UserAssignedIdentity): any;
+export declare function userAssignedIdentityDeserializer(item: any): UserAssignedIdentity;
+/** The resource model definition for an Azure Resource Manager tracked top level resource which has 'tags' and a 'location' */
+export interface TrackedResource extends Resource {
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The geo-location where the resource lives */
+    location: string;
+}
+export declare function trackedResourceSerializer(item: TrackedResource): any;
+export declare function trackedResourceDeserializer(item: any): TrackedResource;
+/** The Instance update model. */
+export interface InstancePatchModel {
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The managed service identities assigned to this resource. */
+    identity?: ManagedServiceIdentity;
+}
+export declare function instancePatchModelSerializer(item: InstancePatchModel): any;
+/** The response of a InstanceResource list operation. */
+export interface _InstanceResourceListResult {
+    /** The InstanceResource items on this page */
+    value: InstanceResource[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _instanceResourceListResultDeserializer(item: any): _InstanceResourceListResult;
+export declare function instanceResourceArraySerializer(result: Array<InstanceResource>): any[];
+export declare function instanceResourceArrayDeserializer(result: Array<InstanceResource>): any[];
+/** A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results. */
+export interface _OperationListResult {
+    /** The Operation items on this page */
+    value: Operation[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _operationListResultDeserializer(item: any): _OperationListResult;
+/** Details of a REST API operation, returned from the Resource Provider Operations API */
+export interface Operation {
+    /** The name of the operation, as per Resource-Based Access Control (RBAC). Examples: "Microsoft.Compute/virtualMachines/write", "Microsoft.Compute/virtualMachines/capture/action" */
+    readonly name?: string;
+    /** Whether the operation applies to data-plane. This is "true" for data-plane operations and "false" for Azure Resource Manager/control-plane operations. */
+    readonly isDataAction?: boolean;
+    /** Localized display information for this particular operation. */
+    readonly display?: OperationDisplay;
+    /** The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" */
+    readonly origin?: Origin;
+    /** Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. */
+    actionType?: ActionType;
+}
+export declare function operationDeserializer(item: any): Operation;
+/** Localized display information for and operation. */
+export interface OperationDisplay {
+    /** The localized friendly form of the resource provider name, e.g. "Microsoft Monitoring Insights" or "Microsoft Compute". */
+    readonly provider?: string;
+    /** The localized friendly name of the resource type related to this operation. E.g. "Virtual Machines" or "Job Schedule Collections". */
+    readonly resource?: string;
+    /** The concise, localized friendly name for the operation; suitable for dropdowns. E.g. "Create or Update Virtual Machine", "Restart Virtual Machine". */
+    readonly operation?: string;
+    /** The short, localized friendly description of the operation; suitable for tool tips and detailed views. */
+    readonly description?: string;
+}
+export declare function operationDisplayDeserializer(item: any): OperationDisplay;
+/** The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" */
+export declare enum KnownOrigin {
+    /** user */
+    User = "user",
+    /** system */
+    System = "system",
+    /** user,system */
+    UserSystem = "user,system"
+}
+/**
+ * The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" \
+ * {@link KnownOrigin} can be used interchangeably with Origin,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **user**: Indicates the operation is initiated by a user. \
+ * **system**: Indicates the operation is initiated by a system. \
+ * **user,system**: Indicates the operation is initiated by a user or system.
+ */
+export type Origin = string;
+/** Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. */
+export declare enum KnownActionType {
+    /** Actions are for internal-only APIs. */
+    Internal = "Internal"
+}
+/**
+ * Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. \
+ * {@link KnownActionType} can be used interchangeably with ActionType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Internal**: Actions are for internal-only APIs.
+ */
+export type ActionType = string;
+export declare function operationArrayDeserializer(result: Array<Operation>): any[];
+//# sourceMappingURL=models.d.ts.map