export declare const AntivirusSolutions: {
    /**
     * Option to use Microsoft Defender antivirus scanning software as the scanning solution.
     */
    readonly Defender: "Defender";
    /**
     * Option to use the external ClamAV open-source software as an antivirus scanning solution.
     */
    readonly ClamAv: "ClamAv";
};
/**
 * The list of Antivirus solutions currently provided.
 */
export type AntivirusSolutions = (typeof AntivirusSolutions)[keyof typeof AntivirusSolutions];
export declare const Casing: {
    /**
     * Ignores casing when performing pattern matching. For example, "Hello World" would be found in "hello world".
     */
    readonly Insensitive: "Insensitive";
    /**
     * Requires exact casing for the pattern match. For example, "Hello World" would NOT not be found in "hello world".
     */
    readonly Sensitive: "Sensitive";
};
/**
 * Specifies the text matching conditions based on casing. For more detail please refer to the Casing model.
 */
export type Casing = (typeof Casing)[keyof typeof Casing];
export declare const DataClassType: {
    /**
     * Represents standard message-based data, including Azure Service and Event Hub, used in message replication.
     */
    readonly Messaging: "Messaging";
    /**
     * Represents transactional request/response data types from API endpoints.
     */
    readonly API: "API";
    /**
     * Represents data types that require continuous, real-time streaming replication (e.g., video).
     */
    readonly Stream: "Stream";
    /**
     * Represents standard file-based data, including Azure Blob and Table Storage, used in general-purpose replication.
     */
    readonly Files: "Files";
    /**
     * Represents data related to development, security, and operations workflows such as build artifacts subject to an NCDSMO policy.
     */
    readonly SoftwareArtifacts: "SoftwareArtifacts";
    /**
     * Represents rich content types such as documents (e.g., Word, PDF) and images that require specialized replication handling.
     */
    readonly Complex: "Complex";
};
/**
 * The data replication scenario handled by this FlowProfile. Please not, that this value cannot be updated after creation.
 */
export type DataClassType = (typeof DataClassType)[keyof typeof DataClassType];
export declare const DataType: {
    readonly Blob: "Blob";
    readonly Table: "Table";
};
/**
 * Transfer Storage Blobs or Tables
 */
export type DataType = (typeof DataType)[keyof typeof DataType];
export declare const Direction: {
    readonly Send: "Send";
    readonly Receive: "Receive";
};
/**
 * Direction of data movement
 */
export type Direction = (typeof Direction)[keyof typeof Direction];
export declare const FilterType: {
    /**
     * Defines an allow filter used for allowlist.
     */
    readonly Allow: "Allow";
    /**
     * Defines a denying filter used for blocklisting.
     */
    readonly Deny: "Deny";
};
/**
 * Specifies whether the filter is an allow list or deny list. For more detail, please refer to the FilterType model.
 */
export type FilterType = (typeof FilterType)[keyof typeof FilterType];
export declare const FlowBillingTier: {
    readonly BlobTransport: "BlobTransport";
    readonly Standard: "Standard";
    readonly Premium: "Premium";
};
/**
 * Billing tier for this messaging flow
 */
export type FlowBillingTier = (typeof FlowBillingTier)[keyof typeof FlowBillingTier];
export declare const FlowProfileStatus: {
    /**
     * Defines a FlowProfile that can no longer be selected.
     */
    readonly Obsolete: "Obsolete";
    /**
     * Defines a FlowProfile that is enabled.
     */
    readonly Enabled: "Enabled";
};
/**
 * The operational status of the FlowProfile.
 */
export type FlowProfileStatus = (typeof FlowProfileStatus)[keyof typeof FlowProfileStatus];
export declare const FlowStatus: {
    readonly Enabled: "Enabled";
    readonly Disabled: "Disabled";
};
/**
 * Status of the current flow
 */
export type FlowStatus = (typeof FlowStatus)[keyof typeof FlowStatus];
export declare const FlowType: {
    readonly Unknown: "Unknown";
    readonly Complex: "Complex";
    readonly DevSecOps: "DevSecOps";
    readonly Messaging: "Messaging";
    readonly Mission: "Mission";
    readonly MicrosoftInternal: "MicrosoftInternal";
    readonly BasicFiles: "BasicFiles";
    readonly Data: "Data";
    readonly Standard: "Standard";
    readonly StreamingVideo: "StreamingVideo";
    readonly Opaque: "Opaque";
    readonly MissionOpaqueXML: "MissionOpaqueXML";
};
/**
 * Flow type for the specified resource
 */
export type FlowType = (typeof FlowType)[keyof typeof FlowType];
export declare const ListApprovedSchemasDirection: {
    readonly Send: "Send";
    readonly Receive: "Receive";
};
/**
 * The direction pipeline to filter approved schemas.
 */
export type ListApprovedSchemasDirection = (typeof ListApprovedSchemasDirection)[keyof typeof ListApprovedSchemasDirection];
export declare const ManagedServiceIdentityType: {
    readonly None: "None";
    readonly SystemAssigned: "SystemAssigned";
    readonly UserAssigned: "UserAssigned";
    readonly SystemAssigned_UserAssigned: "SystemAssigned,UserAssigned";
};
/**
 * Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
 */
export type ManagedServiceIdentityType = (typeof ManagedServiceIdentityType)[keyof typeof ManagedServiceIdentityType];
export declare const MatchType: {
    /**
     * The option to pattern match substrings within all text content. For example, "hello world" would be found in "chello worlds".
     */
    readonly Partial: "Partial";
    /**
     * The option to pattern match the entire string explicitly. For example, "hello world" would NOT be found in "chello worlds".
     */
    readonly Complete: "Complete";
};
/**
 * Specifies the text matching condition for text comparison. For more detail please refer to the MatchType model.
 */
export type MatchType = (typeof MatchType)[keyof typeof MatchType];
export declare const SchemaDirection: {
    readonly Send: "Send";
    readonly Receive: "Receive";
};
/**
 * The direction of the schema.
 */
export type SchemaDirection = (typeof SchemaDirection)[keyof typeof SchemaDirection];
export declare const SchemaStatus: {
    readonly New: "New";
    readonly Approved: "Approved";
};
/**
 * Status of the schema
 */
export type SchemaStatus = (typeof SchemaStatus)[keyof typeof SchemaStatus];
export declare const SchemaType: {
    readonly Xsd: "Xsd";
    readonly Zip: "Zip";
};
/**
 * The Schema Type
 */
export type SchemaType = (typeof SchemaType)[keyof typeof SchemaType];
export declare const StreamProtocol: {
    readonly UDP: "UDP";
    readonly SRT: "SRT";
    readonly RTP: "RTP";
};
/**
 * The protocol of the stream
 */
export type StreamProtocol = (typeof StreamProtocol)[keyof typeof StreamProtocol];
export declare const XmlReferenceType: {
    /**
     * Defines a referencing procedure where the xml schema will be provided inline.
     */
    readonly Inline: "Inline";
};
/**
 * Defines the method for referencing the xml schema.
 */
export type XmlReferenceType = (typeof XmlReferenceType)[keyof typeof XmlReferenceType];