@azure/arm-workloadorchestration 1.0.0-alpha.20250901.1

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

@@ -0,0 +1,1711 @@
+/** DynamicSchema Resource */
+export interface DynamicSchema extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: DynamicSchemaProperties;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function dynamicSchemaSerializer(item: DynamicSchema): any;
+export declare function dynamicSchemaDeserializer(item: any): DynamicSchema;
+/** DynamicSchema Properties */
+export interface DynamicSchemaProperties {
+    /** Display name of the dynamic schema */
+    readonly displayName?: string;
+    /** Type of configuration */
+    readonly configurationType?: ConfigurationType;
+    /** Type of configuration model */
+    readonly configurationModel?: ConfigurationModel;
+    /** Provisioning state of resource */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function dynamicSchemaPropertiesSerializer(item: DynamicSchemaProperties): any;
+export declare function dynamicSchemaPropertiesDeserializer(item: any): DynamicSchemaProperties;
+/** Available configuration types */
+export declare enum KnownConfigurationType {
+    /** Configuration type Shared */
+    Shared = "Shared",
+    /** Configuration type Hierarchy */
+    Hierarchy = "Hierarchy"
+}
+/**
+ * Available configuration types \
+ * {@link KnownConfigurationType} can be used interchangeably with ConfigurationType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Shared**: Configuration type Shared \
+ * **Hierarchy**: Configuration type Hierarchy
+ */
+export type ConfigurationType = string;
+/** Available configuration models */
+export declare enum KnownConfigurationModel {
+    /** Configuration model Application */
+    Application = "Application",
+    /** Configuration model Common */
+    Common = "Common"
+}
+/**
+ * Available configuration models \
+ * {@link KnownConfigurationModel} can be used interchangeably with ConfigurationModel,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Application**: Configuration model Application \
+ * **Common**: Configuration model Common
+ */
+export type ConfigurationModel = string;
+/** Provisioning state of resource */
+export declare enum KnownProvisioningState {
+    /** Resource has been created. */
+    Succeeded = "Succeeded",
+    /** Resource creation failed. */
+    Failed = "Failed",
+    /** Resource creation was canceled. */
+    Canceled = "Canceled",
+    /** Resource Provisioning is initialized */
+    Initialized = "Initialized",
+    /** Resource Provisioning is in progress */
+    Inprogress = "InProgress",
+    /** Resource Provisioning is deleting */
+    Deleting = "Deleting"
+}
+/**
+ * Provisioning state of resource \
+ * {@link KnownProvisioningState} can be used interchangeably with ProvisioningState,
+ *  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 was canceled. \
+ * **Initialized**: Resource Provisioning is initialized \
+ * **InProgress**: Resource Provisioning is in progress \
+ * **Deleting**: Resource Provisioning is deleting
+ */
+export type ProvisioningState = 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;
+/** Common error response for all Azure Resource Manager APIs to return error details for failed operations. */
+export interface ErrorResponse {
+    /** The error object. */
+    error?: ErrorDetail;
+}
+export declare function errorResponseDeserializer(item: any): ErrorResponse;
+/** The error detail. */
+export interface ErrorDetail {
+    /** The error code. */
+    readonly code?: string;
+    /** The error message. */
+    readonly message?: string;
+    /** The error target. */
+    readonly target?: string;
+    /** The error details. */
+    readonly details?: ErrorDetail[];
+    /** The error additional info. */
+    readonly additionalInfo?: ErrorAdditionalInfo[];
+}
+export declare function errorDetailSerializer(item: ErrorDetail): any;
+export declare function errorDetailDeserializer(item: any): ErrorDetail;
+export declare function errorDetailArraySerializer(result: Array<ErrorDetail>): any[];
+export declare function errorDetailArrayDeserializer(result: Array<ErrorDetail>): any[];
+export declare function errorAdditionalInfoArrayDeserializer(result: Array<ErrorAdditionalInfo>): any[];
+/** The resource management error additional info. */
+export interface ErrorAdditionalInfo {
+    /** The additional info type. */
+    readonly type?: string;
+    /** The additional info. */
+    readonly info?: any;
+}
+export declare function errorAdditionalInfoDeserializer(item: any): ErrorAdditionalInfo;
+/** The response of a DynamicSchema list operation. */
+export interface _DynamicSchemaListResult {
+    /** The DynamicSchema items on this page */
+    value: DynamicSchema[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _dynamicSchemaListResultDeserializer(item: any): _DynamicSchemaListResult;
+export declare function dynamicSchemaArraySerializer(result: Array<DynamicSchema>): any[];
+export declare function dynamicSchemaArrayDeserializer(result: Array<DynamicSchema>): any[];
+/** Schema Resource */
+export interface Schema extends TrackedResource {
+    /** The resource-specific properties for this resource. */
+    properties?: SchemaProperties;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function schemaSerializer(item: Schema): any;
+export declare function schemaDeserializer(item: any): Schema;
+/** Schema Properties */
+export interface SchemaProperties {
+    /** Current Version of schema */
+    readonly currentVersion?: string;
+    /** Provisioning state of resource */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function schemaPropertiesSerializer(item: SchemaProperties): any;
+export declare function schemaPropertiesDeserializer(item: any): SchemaProperties;
+/** 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 type used for update operations of the Schema. */
+export interface SchemaUpdate {
+    /** The resource-specific properties for this resource. */
+    properties?: SchemaUpdateProperties;
+    /** Resource tags. */
+    tags?: Record<string, string>;
+}
+export declare function schemaUpdateSerializer(item: SchemaUpdate): any;
+/** The updatable properties of the Schema. */
+export interface SchemaUpdateProperties {
+}
+export declare function schemaUpdatePropertiesSerializer(item: SchemaUpdateProperties): any;
+/** Schema Version With Update Type */
+export interface SchemaVersionWithUpdateType {
+    /** Update type */
+    updateType?: UpdateType;
+    /** Version to create */
+    version?: string;
+    /** Schema Version */
+    schemaVersion: SchemaVersion;
+}
+export declare function schemaVersionWithUpdateTypeSerializer(item: SchemaVersionWithUpdateType): any;
+/** Denotes which part of the version number will be updated */
+export declare enum KnownUpdateType {
+    /** Major version */
+    Major = "Major",
+    /** Minor version */
+    Minor = "Minor",
+    /** Patch version */
+    Patch = "Patch"
+}
+/**
+ * Denotes which part of the version number will be updated \
+ * {@link KnownUpdateType} can be used interchangeably with UpdateType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Major**: Major version \
+ * **Minor**: Minor version \
+ * **Patch**: Patch version
+ */
+export type UpdateType = string;
+/** Schema Version Resource */
+export interface SchemaVersion extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: SchemaVersionProperties;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function schemaVersionSerializer(item: SchemaVersion): any;
+export declare function schemaVersionDeserializer(item: any): SchemaVersion;
+/** Schema Version Properties */
+export interface SchemaVersionProperties {
+    /** Value of schema version */
+    value: string;
+    /** Provisioning state of resource */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function schemaVersionPropertiesSerializer(item: SchemaVersionProperties): any;
+export declare function schemaVersionPropertiesDeserializer(item: any): SchemaVersionProperties;
+/** Version Parameter */
+export interface VersionParameter {
+    /** Version of the Resource */
+    version: string;
+}
+export declare function versionParameterSerializer(item: VersionParameter): any;
+/** Remove Version response */
+export interface RemoveVersionResponse {
+    /** Status for remove version response */
+    status: string;
+}
+export declare function removeVersionResponseDeserializer(item: any): RemoveVersionResponse;
+/** The response of a Schema list operation. */
+export interface _SchemaListResult {
+    /** The Schema items on this page */
+    value: Schema[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _schemaListResultDeserializer(item: any): _SchemaListResult;
+export declare function schemaArraySerializer(result: Array<Schema>): any[];
+export declare function schemaArrayDeserializer(result: Array<Schema>): any[];
+/** The response of a SchemaVersion list operation. */
+export interface _SchemaVersionListResult {
+    /** The SchemaVersion items on this page */
+    value: SchemaVersion[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _schemaVersionListResultDeserializer(item: any): _SchemaVersionListResult;
+export declare function schemaVersionArraySerializer(result: Array<SchemaVersion>): any[];
+export declare function schemaVersionArrayDeserializer(result: Array<SchemaVersion>): any[];
+/** Solution Version Resource. It has the resolved configuration along with edge specification. */
+export interface SolutionVersion extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: SolutionVersionProperties;
+    extendedLocation?: ExtendedLocation;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function solutionVersionSerializer(item: SolutionVersion): any;
+export declare function solutionVersionDeserializer(item: any): SolutionVersion;
+/** Solution Version Properties */
+export interface SolutionVersionProperties {
+    /** Solution Template Version Id */
+    readonly solutionTemplateVersionId?: string;
+    /** Revision number of resolved config for this solution version */
+    readonly revision?: number;
+    /** Name of applicable target's display name */
+    readonly targetDisplayName?: string;
+    /** Resolved configuration values */
+    readonly configuration?: string;
+    /** Configuration on the line level across all solution template versions */
+    readonly targetLevelConfiguration?: string;
+    /** App components spec */
+    specification: Record<string, any>;
+    /** Review id of resolved config for this solution version */
+    readonly reviewId?: string;
+    /** External validation id */
+    readonly externalValidationId?: string;
+    /** State of solution instance */
+    readonly state?: State;
+    /** Current Stage of revision */
+    readonly currentStage?: StageMap;
+    /** Stages of revision */
+    readonly stages?: StageMap[];
+    /** Solution instance name */
+    readonly solutionInstanceName?: string;
+    /** Solution Dependency Context */
+    readonly solutionDependencies?: SolutionDependency[];
+    /** Error Details if any failure is there */
+    readonly errorDetails?: ErrorDetail;
+    /** The URI for tracking the latest action performed on this solution version. */
+    readonly latestActionTrackingUri?: string;
+    /** Object Id of user who triggered the latest action on this solution version. */
+    readonly lastestActionTriggeredBy?: string;
+    /** The type of the latest action performed on this solution version. */
+    readonly actionType?: JobType;
+    /** Provisioning state of resource */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function solutionVersionPropertiesSerializer(item: SolutionVersionProperties): any;
+export declare function solutionVersionPropertiesDeserializer(item: any): SolutionVersionProperties;
+/** Solution Instance State */
+export declare enum KnownState {
+    /** Solution Instance is in review */
+    InReview = "InReview",
+    /** Solution Instance upgrade is in review */
+    UpgradeInReview = "UpgradeInReview",
+    /** Solution Instance is ready to deploy */
+    ReadyToDeploy = "ReadyToDeploy",
+    /** Solution Instance is ready to upgrade */
+    ReadyToUpgrade = "ReadyToUpgrade",
+    /** Solution Instance is deploying */
+    Deploying = "Deploying",
+    /** Solution Instance is deployed */
+    Deployed = "Deployed",
+    /** Solution Instance failed to deploy */
+    Failed = "Failed",
+    /** Solution Instance is undeployed */
+    Undeployed = "Undeployed",
+    /** Solution Instance is pending external validation */
+    PendingExternalValidation = "PendingExternalValidation",
+    /** Solution Instance failed external validation */
+    ExternalValidationFailed = "ExternalValidationFailed",
+    /** Solution Instance is staging the images */
+    Staging = "Staging",
+    /** State is not applicable */
+    NotApplicable = "NotApplicable"
+}
+/**
+ * Solution Instance State \
+ * {@link KnownState} can be used interchangeably with State,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **InReview**: Solution Instance is in review \
+ * **UpgradeInReview**: Solution Instance upgrade is in review \
+ * **ReadyToDeploy**: Solution Instance is ready to deploy \
+ * **ReadyToUpgrade**: Solution Instance is ready to upgrade \
+ * **Deploying**: Solution Instance is deploying \
+ * **Deployed**: Solution Instance is deployed \
+ * **Failed**: Solution Instance failed to deploy \
+ * **Undeployed**: Solution Instance is undeployed \
+ * **PendingExternalValidation**: Solution Instance is pending external validation \
+ * **ExternalValidationFailed**: Solution Instance failed external validation \
+ * **Staging**: Solution Instance is staging the images \
+ * **NotApplicable**: State is not applicable
+ */
+export type State = string;
+/** Stage Map for Solution Version */
+export interface StageMap {
+    /** Display State */
+    readonly displayState: string;
+    /** Stage name */
+    readonly stage: CMStages;
+    /** Stage status */
+    readonly status: StateCategory;
+    /** Stage start time */
+    readonly startTime?: Date;
+    /** Stage end time */
+    readonly endTime?: Date;
+    /** Child stages which represents more granular level stage status if any */
+    readonly childStages?: StageMap[];
+}
+export declare function stageMapDeserializer(item: any): StageMap;
+/** Stages for Solution Version */
+export declare enum KnownCMStages {
+    /** Configuration stage */
+    Configuration = "Configuration",
+    /** Publish stage */
+    Publish = "Publish",
+    /** Deployment stage */
+    Deployment = "Deployment",
+    /** Uninstallation stage */
+    Uninstallation = "Uninstallation",
+    /** External Validation stage */
+    ExternalValidation = "ExternalValidation",
+    /** Staging stage */
+    Staging = "Staging",
+    /** Unstaging stage */
+    Unstaging = "Unstaging"
+}
+/**
+ * Stages for Solution Version \
+ * {@link KnownCMStages} can be used interchangeably with CMStages,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Configuration**: Configuration stage \
+ * **Publish**: Publish stage \
+ * **Deployment**: Deployment stage \
+ * **Uninstallation**: Uninstallation stage \
+ * **ExternalValidation**: External Validation stage \
+ * **Staging**: Staging stage \
+ * **Unstaging**: Unstaging stage
+ */
+export type CMStages = string;
+/** State Category for Solution Version */
+export declare enum KnownStateCategory {
+    /** Pending state [Non-Terminal] */
+    Pending = "Pending",
+    /** InProgress state [Non-Terminal] */
+    InProgress = "InProgress",
+    /** Completed state [Terminal] */
+    Completed = "Completed",
+    /** Failed state [Terminal] */
+    Failed = "Failed",
+    /** None state [Terminal] */
+    None = "None"
+}
+/**
+ * State Category for Solution Version \
+ * {@link KnownStateCategory} can be used interchangeably with StateCategory,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Pending**: Pending state [Non-Terminal] \
+ * **InProgress**: InProgress state [Non-Terminal] \
+ * **Completed**: Completed state [Terminal] \
+ * **Failed**: Failed state [Terminal] \
+ * **None**: None state [Terminal]
+ */
+export type StateCategory = string;
+export declare function stageMapArrayDeserializer(result: Array<StageMap>): any[];
+export declare function solutionDependencyArrayDeserializer(result: Array<SolutionDependency>): any[];
+/** Solution Dependency Context */
+export interface SolutionDependency {
+    /** Solution Version Id */
+    solutionVersionId: string;
+    /** Solution Instance Name */
+    solutionInstanceName?: string;
+    /** Solution Template Version Id */
+    solutionTemplateVersionId: string;
+    /** Target Id */
+    targetId: string;
+    /** Solution dependencies */
+    dependencies?: SolutionDependency[];
+}
+export declare function solutionDependencyDeserializer(item: any): SolutionDependency;
+/** JobType for the job. Supports extensibility via string values. */
+export declare enum KnownJobType {
+    /** A deployment job. */
+    Deploy = "deploy",
+    /** A staging job. */
+    Staging = "staging",
+    /** A validation job. */
+    ExternalValidation = "externalValidation"
+}
+/**
+ * JobType for the job. Supports extensibility via string values. \
+ * {@link KnownJobType} can be used interchangeably with JobType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **deploy**: A deployment job. \
+ * **staging**: A staging job. \
+ * **externalValidation**: A validation job.
+ */
+export type JobType = string;
+/** The complex type of the extended location. */
+export interface ExtendedLocation {
+    /** The name of the extended location. */
+    name: string;
+    /** The type of the extended location. */
+    type: ExtendedLocationType;
+}
+export declare function extendedLocationSerializer(item: ExtendedLocation): any;
+export declare function extendedLocationDeserializer(item: any): ExtendedLocation;
+/** The supported ExtendedLocation types. */
+export declare enum KnownExtendedLocationType {
+    /** Azure Edge Zones location type */
+    EdgeZone = "EdgeZone",
+    /** Azure Custom Locations type */
+    CustomLocation = "CustomLocation"
+}
+/**
+ * The supported ExtendedLocation types. \
+ * {@link KnownExtendedLocationType} can be used interchangeably with ExtendedLocationType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **EdgeZone**: Azure Edge Zones location type \
+ * **CustomLocation**: Azure Custom Locations type
+ */
+export type ExtendedLocationType = string;
+/** The response of a SolutionVersion list operation. */
+export interface _SolutionVersionListResult {
+    /** The SolutionVersion items on this page */
+    value: SolutionVersion[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _solutionVersionListResultDeserializer(item: any): _SolutionVersionListResult;
+export declare function solutionVersionArraySerializer(result: Array<SolutionVersion>): any[];
+export declare function solutionVersionArrayDeserializer(result: Array<SolutionVersion>): any[];
+/** Job extension resource for tracking job execution and substatuses. */
+export interface Job extends ExtensionResource {
+    /** The resource-specific properties for this resource. */
+    properties?: JobProperties;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function jobDeserializer(item: any): Job;
+/** Properties of a Job resource, including type, status, parameters, steps, and error details. */
+export interface JobProperties {
+    /** The type of job. */
+    jobType: JobType;
+    /** Start time of the job (ISO8601). */
+    startTime?: Date;
+    /** End time of the job (ISO8601). */
+    endTime?: Date;
+    /** Status of the job. */
+    status: JobStatus;
+    /** Parameters for the job. */
+    jobParameter?: JobParameterBaseUnion;
+    /** Correlation ID for tracking. */
+    correlationId?: string;
+    /** Steps and substatuses for the job. */
+    steps?: JobStep[];
+    /** The OID or identity that triggered the job. */
+    triggeredBy?: string;
+    /** Provisioning state of the resource. */
+    readonly provisioningState?: ProvisioningState;
+    /** Error Details if any failure is there */
+    readonly errorDetails?: ErrorDetail;
+}
+export declare function jobPropertiesDeserializer(item: any): JobProperties;
+/** Status of a job or job step. */
+export declare enum KnownJobStatus {
+    /** The job or step is not started. */
+    NotStarted = "NotStarted",
+    /** The job or step is in progress. */
+    InProgress = "InProgress",
+    /** The job or step succeeded. */
+    Succeeded = "Succeeded",
+    /** The job or step failed. */
+    Failed = "Failed"
+}
+/**
+ * Status of a job or job step. \
+ * {@link KnownJobStatus} can be used interchangeably with JobStatus,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **NotStarted**: The job or step is not started. \
+ * **InProgress**: The job or step is in progress. \
+ * **Succeeded**: The job or step succeeded. \
+ * **Failed**: The job or step failed.
+ */
+export type JobStatus = string;
+/** Base Job Parameter */
+export interface JobParameterBase {
+    /** Job type discriminator value */
+    /** The discriminator possible values: deploy */
+    jobType: JobType;
+}
+export declare function jobParameterBaseDeserializer(item: any): JobParameterBase;
+/** Alias for JobParameterBaseUnion */
+export type JobParameterBaseUnion = DeployJobParameter | JobParameterBase;
+export declare function jobParameterBaseUnionDeserializer(item: any): JobParameterBaseUnion;
+/** Parameters for a deployment job. */
+export interface DeployJobParameter extends JobParameterBase {
+    /** Job type discriminator value */
+    jobType: "deploy";
+    parameter?: InstallSolutionParameter;
+}
+export declare function deployJobParameterDeserializer(item: any): DeployJobParameter;
+/** Install Solution Parameter */
+export interface InstallSolutionParameter {
+    /** Solution Version ARM Id */
+    solutionVersionId: string;
+}
+export declare function installSolutionParameterSerializer(item: InstallSolutionParameter): any;
+export declare function installSolutionParameterDeserializer(item: any): InstallSolutionParameter;
+export declare function jobStepArrayDeserializer(result: Array<JobStep>): any[];
+/** Job Step */
+export interface JobStep {
+    /** Name of the step */
+    name: string;
+    /** Status of the step */
+    status: JobStatus;
+    /** Start time of the step (ISO8601) */
+    startTime?: Date;
+    /** End time of the step (ISO8601) */
+    endTime?: Date;
+    /** Message for the step */
+    message?: string;
+    /** Statistics for the step */
+    statistics?: JobStepStatisticsBaseUnion;
+    /** Nested substeps for this step */
+    steps?: JobStep[];
+    /** Error Details if any failure is there */
+    readonly errorDetails?: ErrorDetail;
+}
+export declare function jobStepDeserializer(item: any): JobStep;
+/** Base Job Step Statistics */
+export interface JobStepStatisticsBase {
+    /** Statistics type discriminator value */
+    /** The discriminator possible values: deploy */
+    statisticsType: JobType;
+}
+export declare function jobStepStatisticsBaseDeserializer(item: any): JobStepStatisticsBase;
+/** Alias for JobStepStatisticsBaseUnion */
+export type JobStepStatisticsBaseUnion = DeployJobStepStatistics | JobStepStatisticsBase;
+export declare function jobStepStatisticsBaseUnionDeserializer(item: any): JobStepStatisticsBaseUnion;
+/** Deploy statistics for a job step, including total, success, and failed counts. */
+export interface DeployJobStepStatistics extends JobStepStatisticsBase {
+    /** Statistics type discriminator value */
+    statisticsType: "deploy";
+    /** Total count of items processed in this step */
+    totalCount?: number;
+    /** Count of successful items in this step */
+    successCount?: number;
+    /** Count of failed items in this step */
+    failedCount?: number;
+}
+export declare function deployJobStepStatisticsDeserializer(item: any): DeployJobStepStatistics;
+/** The base extension resource. */
+export interface ExtensionResource extends Resource {
+}
+export declare function extensionResourceDeserializer(item: any): ExtensionResource;
+/** The response of a Job list operation. */
+export interface _JobListResult {
+    /** The Job items on this page */
+    value: Job[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _jobListResultDeserializer(item: any): _JobListResult;
+export declare function jobArrayDeserializer(result: Array<Job>): any[];
+/** Target Resource. Represents a resource to be deployed on the edge. */
+export interface Target extends TrackedResource {
+    /** The resource-specific properties for this resource. */
+    properties?: TargetProperties;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+    extendedLocation?: ExtendedLocation;
+}
+export declare function targetSerializer(item: Target): any;
+export declare function targetDeserializer(item: any): Target;
+/** Target Properties */
+export interface TargetProperties {
+    /** Description of target */
+    description: string;
+    /** Display name of target */
+    displayName: string;
+    /** ArmId of Context */
+    contextId: string;
+    /** target spec */
+    targetSpecification: Record<string, any>;
+    /** List of capabilities */
+    capabilities: string[];
+    /** Hierarchy Level */
+    hierarchyLevel: string;
+    /** Status of target */
+    readonly status?: DeploymentStatus;
+    /** Scope of the target resource */
+    solutionScope?: string;
+    /** State of resource */
+    state?: ResourceState;
+    /** Provisioning state of resource */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function targetPropertiesSerializer(item: TargetProperties): any;
+export declare function targetPropertiesDeserializer(item: any): TargetProperties;
+/** Deployment Status */
+export interface DeploymentStatus {
+    /** The lastModified of the Status */
+    lastModified?: Date;
+    /** Indicates if Instance is deployed */
+    deployed?: number;
+    /** The expected running job id */
+    expectedRunningJobId?: number;
+    /** The running job id */
+    runningJobId?: number;
+    /** Deployment status */
+    status?: string;
+    /** Status details */
+    statusDetails?: string;
+    /** Deployment Generation */
+    generation?: number;
+    /** Target resource statuses */
+    targetStatuses?: TargetStatus[];
+}
+export declare function deploymentStatusDeserializer(item: any): DeploymentStatus;
+export declare function targetStatusArrayDeserializer(result: Array<TargetStatus>): any[];
+/** Target Status */
+export interface TargetStatus {
+    /** Target name */
+    name?: string;
+    /** Target status */
+    status?: string;
+    /** Component statuses */
+    componentStatuses?: ComponentStatus[];
+}
+export declare function targetStatusDeserializer(item: any): TargetStatus;
+export declare function componentStatusArrayDeserializer(result: Array<ComponentStatus>): any[];
+/** Component Status */
+export interface ComponentStatus {
+    /** Component name */
+    name?: string;
+    /** Component status */
+    status?: string;
+}
+export declare function componentStatusDeserializer(item: any): ComponentStatus;
+/** Resource Type State */
+export declare enum KnownResourceState {
+    /** Resource is active */
+    Active = "active",
+    /** Resource is inactive */
+    Inactive = "inactive"
+}
+/**
+ * Resource Type State \
+ * {@link KnownResourceState} can be used interchangeably with ResourceState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **active**: Resource is active \
+ * **inactive**: Resource is inactive
+ */
+export type ResourceState = string;
+/** The type used for update operations of the Target. */
+export interface TargetUpdate {
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The resource-specific properties for this resource. */
+    properties?: TargetUpdateProperties;
+}
+export declare function targetUpdateSerializer(item: TargetUpdate): any;
+/** The updatable properties of the Target. */
+export interface TargetUpdateProperties {
+    /** Description of target */
+    description?: string;
+    /** Display name of target */
+    displayName?: string;
+    /** ArmId of Context */
+    contextId?: string;
+    /** target spec */
+    targetSpecification?: Record<string, any>;
+    /** List of capabilities */
+    capabilities?: string[];
+    /** Hierarchy Level */
+    hierarchyLevel?: string;
+    /** Scope of the target resource */
+    solutionScope?: string;
+    /** State of resource */
+    state?: ResourceState;
+}
+export declare function targetUpdatePropertiesSerializer(item: TargetUpdateProperties): any;
+/** The response of a Target list operation. */
+export interface _TargetListResult {
+    /** The Target items on this page */
+    value: Target[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _targetListResultDeserializer(item: any): _TargetListResult;
+export declare function targetArraySerializer(result: Array<Target>): any[];
+export declare function targetArrayDeserializer(result: Array<Target>): any[];
+/** Uninstall Solution Parameter */
+export interface UninstallSolutionParameter {
+    /** Solution Template ARM Id */
+    solutionTemplateId: string;
+    /** Solution Instance Name */
+    solutionInstanceName?: string;
+}
+export declare function uninstallSolutionParameterSerializer(item: UninstallSolutionParameter): any;
+/** Install Solution Parameter */
+export interface RemoveRevisionParameter {
+    /** Solution Template ARM Id */
+    solutionTemplateId: string;
+    /** Solution Version Name */
+    solutionVersion: string;
+}
+export declare function removeRevisionParameterSerializer(item: RemoveRevisionParameter): any;
+/** Solution Template Parameter */
+export interface SolutionTemplateParameter {
+    /** Solution Template Version ARM Id */
+    solutionTemplateVersionId: string;
+    /** Solution Instance Name */
+    solutionInstanceName?: string;
+    /** Solution Dependencies */
+    solutionDependencies?: SolutionDependencyParameter[];
+}
+export declare function solutionTemplateParameterSerializer(item: SolutionTemplateParameter): any;
+export declare function solutionDependencyParameterArraySerializer(result: Array<SolutionDependencyParameter>): any[];
+/** Solution Dependency Context */
+export interface SolutionDependencyParameter {
+    /** Solution Version Id */
+    solutionVersionId?: string;
+    /** Solution Template Id */
+    solutionTemplateId?: string;
+    /** Solution Template Version */
+    solutionTemplateVersion?: string;
+    /** Solution Instance Name */
+    solutionInstanceName?: string;
+    /** Target Id */
+    targetId?: string;
+    /** Solution dependencies */
+    dependencies?: SolutionDependencyParameter[];
+}
+export declare function solutionDependencyParameterSerializer(item: SolutionDependencyParameter): any;
+/** Resolved Configuration */
+export interface ResolvedConfiguration {
+    /** Resolved Configuration as string */
+    configuration: string;
+}
+export declare function resolvedConfigurationDeserializer(item: any): ResolvedConfiguration;
+/** Solution Version Parameter */
+export interface SolutionVersionParameter {
+    /** Solution Version ARM Id */
+    solutionVersionId: string;
+}
+export declare function solutionVersionParameterSerializer(item: SolutionVersionParameter): any;
+/** Update External Validation Status Parameter */
+export interface UpdateExternalValidationStatusParameter {
+    /** Solution Version Id */
+    solutionVersionId: string;
+    /** Error Details if any failure is there */
+    errorDetails?: ErrorDetail;
+    /** External validation id */
+    externalValidationId: string;
+    /** Validation Status of external validation */
+    validationStatus: ValidationStatus;
+}
+export declare function updateExternalValidationStatusParameterSerializer(item: UpdateExternalValidationStatusParameter): any;
+/** Solution Instance Validation Status */
+export declare enum KnownValidationStatus {
+    /** Solution Instance is valid */
+    Valid = "Valid",
+    /** Solution Instance is invalid */
+    Invalid = "Invalid"
+}
+/**
+ * Solution Instance Validation Status \
+ * {@link KnownValidationStatus} can be used interchangeably with ValidationStatus,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Valid**: Solution Instance is valid \
+ * **Invalid**: Solution Instance is invalid
+ */
+export type ValidationStatus = string;
+/** Dynamic Schema Version Resource */
+export interface DynamicSchemaVersion extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: SchemaVersionProperties;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function dynamicSchemaVersionSerializer(item: DynamicSchemaVersion): any;
+export declare function dynamicSchemaVersionDeserializer(item: any): DynamicSchemaVersion;
+/** The response of a DynamicSchemaVersion list operation. */
+export interface _DynamicSchemaVersionListResult {
+    /** The DynamicSchemaVersion items on this page */
+    value: DynamicSchemaVersion[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _dynamicSchemaVersionListResultDeserializer(item: any): _DynamicSchemaVersionListResult;
+export declare function dynamicSchemaVersionArraySerializer(result: Array<DynamicSchemaVersion>): any[];
+export declare function dynamicSchemaVersionArrayDeserializer(result: Array<DynamicSchemaVersion>): any[];
+/** Schema Reference Resource */
+export interface SchemaReference extends ExtensionResource {
+    /** The resource-specific properties for this resource. */
+    properties?: SchemaReferenceProperties;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function schemaReferenceDeserializer(item: any): SchemaReference;
+/** Schema Reference Properties */
+export interface SchemaReferenceProperties {
+    /** Schema Id of schema reference */
+    schemaId: string;
+    /** Provisioning state of resource */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function schemaReferencePropertiesDeserializer(item: any): SchemaReferenceProperties;
+/** The response of a SchemaReference list operation. */
+export interface _SchemaReferenceListResult {
+    /** The SchemaReference items on this page */
+    value: SchemaReference[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _schemaReferenceListResultDeserializer(item: any): _SchemaReferenceListResult;
+export declare function schemaReferenceArrayDeserializer(result: Array<SchemaReference>): any[];
+/** Solution Resource attached to a Target */
+export interface Solution extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: SolutionProperties;
+    extendedLocation?: ExtendedLocation;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function solutionSerializer(item: Solution): any;
+export declare function solutionDeserializer(item: any): Solution;
+/** Solution Properties */
+export interface SolutionProperties {
+    /** Solution template Id */
+    readonly solutionTemplateId?: string;
+    /** Display name of the solution */
+    readonly displayName?: string;
+    /** List of latest revisions for available solution template versions */
+    readonly availableSolutionTemplateVersions?: AvailableSolutionTemplateVersion[];
+    /** Provisioning state of resource */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function solutionPropertiesSerializer(item: SolutionProperties): any;
+export declare function solutionPropertiesDeserializer(item: any): SolutionProperties;
+export declare function availableSolutionTemplateVersionArrayDeserializer(result: Array<AvailableSolutionTemplateVersion>): any[];
+/** Available Solution template Version along with latest revision */
+export interface AvailableSolutionTemplateVersion {
+    /** Solution template Version */
+    solutionTemplateVersion: string;
+    /** Latest Configuration Revision */
+    latestConfigRevision: string;
+    /** Has this solution template version been configured */
+    isConfigured: boolean;
+}
+export declare function availableSolutionTemplateVersionDeserializer(item: any): AvailableSolutionTemplateVersion;
+/** The type used for update operations of the Solution. */
+export interface SolutionUpdate {
+    /** The resource-specific properties for this resource. */
+    properties?: SolutionUpdateProperties;
+}
+export declare function solutionUpdateSerializer(item: SolutionUpdate): any;
+/** The updatable properties of the Solution. */
+export interface SolutionUpdateProperties {
+}
+export declare function solutionUpdatePropertiesSerializer(item: SolutionUpdateProperties): any;
+/** The response of a Solution list operation. */
+export interface _SolutionListResult {
+    /** The Solution items on this page */
+    value: Solution[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _solutionListResultDeserializer(item: any): _SolutionListResult;
+export declare function solutionArraySerializer(result: Array<Solution>): any[];
+export declare function solutionArrayDeserializer(result: Array<Solution>): any[];
+/** Solution Template Version Resource. Contains configurations that use expressions which can be resolved hierarchically along with edge specifications. */
+export interface SolutionTemplateVersion extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: SolutionTemplateVersionProperties;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function solutionTemplateVersionSerializer(item: SolutionTemplateVersion): any;
+export declare function solutionTemplateVersionDeserializer(item: any): SolutionTemplateVersion;
+/** Solution Template Version Properties */
+export interface SolutionTemplateVersionProperties {
+    /** Config expressions for this solution version */
+    configurations: string;
+    /** App components spec */
+    specification: Record<string, any>;
+    /** Orchestrator type */
+    orchestratorType?: OrchestratorType;
+    /** Provisioning state of resource */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function solutionTemplateVersionPropertiesSerializer(item: SolutionTemplateVersionProperties): any;
+export declare function solutionTemplateVersionPropertiesDeserializer(item: any): SolutionTemplateVersionProperties;
+/** Available Orchestrator types */
+export declare enum KnownOrchestratorType {
+    /** Default type */
+    TO = "TO"
+}
+/**
+ * Available Orchestrator types \
+ * {@link KnownOrchestratorType} can be used interchangeably with OrchestratorType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **TO**: Default type
+ */
+export type OrchestratorType = string;
+/** The response of a SolutionTemplateVersion list operation. */
+export interface _SolutionTemplateVersionListResult {
+    /** The SolutionTemplateVersion items on this page */
+    value: SolutionTemplateVersion[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _solutionTemplateVersionListResultDeserializer(item: any): _SolutionTemplateVersionListResult;
+export declare function solutionTemplateVersionArraySerializer(result: Array<SolutionTemplateVersion>): any[];
+export declare function solutionTemplateVersionArrayDeserializer(result: Array<SolutionTemplateVersion>): any[];
+/** Bulk deploy solution parameter */
+export interface BulkDeploySolutionParameter {
+    /** Targets to which solution needs to be deployed */
+    targets: BulkDeployTargetDetails[];
+}
+export declare function bulkDeploySolutionParameterSerializer(item: BulkDeploySolutionParameter): any;
+export declare function bulkDeployTargetDetailsArraySerializer(result: Array<BulkDeployTargetDetails>): any[];
+/** Bulk deploy target details */
+export interface BulkDeployTargetDetails {
+    /** ArmId of Target Solution Version */
+    solutionVersionId: string;
+}
+export declare function bulkDeployTargetDetailsSerializer(item: BulkDeployTargetDetails): any;
+/** Bulk publish solution parameter */
+export interface BulkPublishSolutionParameter {
+    /** Targets to which solution needs to be published */
+    targets: BulkPublishTargetDetails[];
+    /** Name of the solution instance */
+    solutionInstanceName?: string;
+    /** Solution dependencies */
+    solutionDependencies?: SolutionDependencyParameter[];
+    /** Configuration of solution */
+    solutionConfiguration?: string;
+}
+export declare function bulkPublishSolutionParameterSerializer(item: BulkPublishSolutionParameter): any;
+export declare function bulkPublishTargetDetailsArraySerializer(result: Array<BulkPublishTargetDetails>): any[];
+/** Bulk publish target details */
+export interface BulkPublishTargetDetails {
+    /** ArmId of Target */
+    targetId: string;
+    /** Name of the solution instance */
+    solutionInstanceName?: string;
+    /** ArmId of Target Solution Version */
+    solutionVersionId?: string;
+    /** Configuration of solution */
+    solutionConfiguration?: string;
+}
+export declare function bulkPublishTargetDetailsSerializer(item: BulkPublishTargetDetails): any;
+/** Bulk publish solution parameter */
+export interface BulkReviewSolutionParameter {
+    /** Targets to which solution needs to be published */
+    targets: BulkReviewTargetDetails[];
+    /** Name of the solution instance */
+    solutionInstanceName?: string;
+    /** Solution dependencies */
+    solutionDependencies?: SolutionDependencyParameter[];
+    /** Configuration of solution */
+    solutionConfiguration?: string;
+}
+export declare function bulkReviewSolutionParameterSerializer(item: BulkReviewSolutionParameter): any;
+export declare function bulkReviewTargetDetailsArraySerializer(result: Array<BulkReviewTargetDetails>): any[];
+/** Bulk publish target details */
+export interface BulkReviewTargetDetails {
+    /** ArmId of Target */
+    targetId: string;
+    /** Name of the solution instance */
+    solutionInstanceName?: string;
+    /** Configuration of solution */
+    solutionConfiguration?: string;
+}
+export declare function bulkReviewTargetDetailsSerializer(item: BulkReviewTargetDetails): any;
+/** Solution Template Resource. Contains capabilities and operations for creating versions. */
+export interface SolutionTemplate extends TrackedResource {
+    /** The resource-specific properties for this resource. */
+    properties?: SolutionTemplateProperties;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function solutionTemplateSerializer(item: SolutionTemplate): any;
+export declare function solutionTemplateDeserializer(item: any): SolutionTemplate;
+/** Solution Template Properties */
+export interface SolutionTemplateProperties {
+    /** A unique identifier for the solution template, generated by the system */
+    readonly uniqueIdentifier?: string;
+    /** Description of Solution template */
+    description: string;
+    /** List of capabilities */
+    capabilities: string[];
+    /** Latest solution template version */
+    readonly latestVersion?: string;
+    /** State of resource */
+    state?: ResourceState;
+    /** Flag to enable external validation */
+    enableExternalValidation?: boolean;
+    /** Provisioning state of resource */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function solutionTemplatePropertiesSerializer(item: SolutionTemplateProperties): any;
+export declare function solutionTemplatePropertiesDeserializer(item: any): SolutionTemplateProperties;
+/** The type used for update operations of the SolutionTemplate. */
+export interface SolutionTemplateUpdate {
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The resource-specific properties for this resource. */
+    properties?: SolutionTemplateUpdateProperties;
+}
+export declare function solutionTemplateUpdateSerializer(item: SolutionTemplateUpdate): any;
+/** The updatable properties of the SolutionTemplate. */
+export interface SolutionTemplateUpdateProperties {
+    /** Description of Solution template */
+    description?: string;
+    /** List of capabilities */
+    capabilities?: string[];
+    /** State of resource */
+    state?: ResourceState;
+    /** Flag to enable external validation */
+    enableExternalValidation?: boolean;
+}
+export declare function solutionTemplateUpdatePropertiesSerializer(item: SolutionTemplateUpdateProperties): any;
+/** Solution Template Version With Update Type */
+export interface SolutionTemplateVersionWithUpdateType {
+    /** Update type */
+    updateType?: UpdateType;
+    /** Version to create */
+    version?: string;
+    /** Solution Template Version */
+    solutionTemplateVersion: SolutionTemplateVersion;
+}
+export declare function solutionTemplateVersionWithUpdateTypeSerializer(item: SolutionTemplateVersionWithUpdateType): any;
+/** The response of a SolutionTemplate list operation. */
+export interface _SolutionTemplateListResult {
+    /** The SolutionTemplate items on this page */
+    value: SolutionTemplate[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _solutionTemplateListResultDeserializer(item: any): _SolutionTemplateListResult;
+export declare function solutionTemplateArraySerializer(result: Array<SolutionTemplate>): any[];
+export declare function solutionTemplateArrayDeserializer(result: Array<SolutionTemplate>): any[];
+/** Instance Resource. Represents a deployment object. */
+export interface Instance extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: InstanceProperties;
+    extendedLocation?: ExtendedLocation;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function instanceSerializer(item: Instance): any;
+export declare function instanceDeserializer(item: any): Instance;
+/** Instance Properties */
+export interface InstanceProperties {
+    /** Solution version of instance */
+    solutionVersionId: string;
+    /** Target of instance */
+    targetId: string;
+    /** State of instance */
+    activeState?: ActiveState;
+    /** Reconciliation policy of instance */
+    reconciliationPolicy?: ReconciliationPolicyProperties;
+    /** Scope of instance */
+    solutionScope?: string;
+    /** Status of instance */
+    readonly status?: DeploymentStatus;
+    /** Deployment timestamp of instance */
+    readonly deploymentTimestampEpoch?: number;
+    /** Provisioning state of resource */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function instancePropertiesSerializer(item: InstanceProperties): any;
+export declare function instancePropertiesDeserializer(item: any): InstanceProperties;
+/** Instance State */
+export declare enum KnownActiveState {
+    /** Instance is active */
+    Active = "active",
+    /** Instance is inactive */
+    Inactive = "inactive"
+}
+/**
+ * Instance State \
+ * {@link KnownActiveState} can be used interchangeably with ActiveState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **active**: Instance is active \
+ * **inactive**: Instance is inactive
+ */
+export type ActiveState = string;
+/** Defines a ReconciliationPolicy */
+export interface ReconciliationPolicyProperties {
+    /** The state of the ReconciliationPolicy */
+    state: ReconciliationState;
+    /** Policy interval */
+    interval: string;
+}
+export declare function reconciliationPolicyPropertiesSerializer(item: ReconciliationPolicyProperties): any;
+export declare function reconciliationPolicyPropertiesDeserializer(item: any): ReconciliationPolicyProperties;
+/** Defines a state of the reconciliation policy. */
+export declare enum KnownReconciliationState {
+    /** Reconciliation is inactive */
+    Inactive = "inactive",
+    /** Reconciliation is active */
+    Active = "active"
+}
+/**
+ * Defines a state of the reconciliation policy. \
+ * {@link KnownReconciliationState} can be used interchangeably with ReconciliationState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **inactive**: Reconciliation is inactive \
+ * **active**: Reconciliation is active
+ */
+export type ReconciliationState = string;
+/** The response of a Instance list operation. */
+export interface _InstanceListResult {
+    /** The Instance items on this page */
+    value: Instance[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _instanceListResultDeserializer(item: any): _InstanceListResult;
+export declare function instanceArraySerializer(result: Array<Instance>): any[];
+export declare function instanceArrayDeserializer(result: Array<Instance>): any[];
+/** InstanceHistory Resource */
+export interface InstanceHistory extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: InstanceHistoryProperties;
+    extendedLocation?: ExtendedLocation;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function instanceHistoryDeserializer(item: any): InstanceHistory;
+/** Instance History Properties */
+export interface InstanceHistoryProperties {
+    /** Solution version of instance */
+    readonly solutionVersion: SolutionVersionSnapshot;
+    /** Target of instance */
+    readonly target: TargetSnapshot;
+    /** Scope of instance */
+    readonly solutionScope?: string;
+    /** State of instance */
+    activeState?: ActiveState;
+    /** Reconciliation policy of instance */
+    readonly reconciliationPolicy?: ReconciliationPolicyProperties;
+    /** Deployment Status of instance */
+    readonly status?: DeploymentStatus;
+    /** Provisioning state of resource */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function instanceHistoryPropertiesDeserializer(item: any): InstanceHistoryProperties;
+/** Solution Version Snapshot */
+export interface SolutionVersionSnapshot {
+    /** Solution version of instance */
+    solutionVersionId?: string;
+    /** App components spec */
+    specification?: Record<string, any>;
+}
+export declare function solutionVersionSnapshotDeserializer(item: any): SolutionVersionSnapshot;
+/** Target Snapshot */
+export interface TargetSnapshot {
+    /** Target of instance */
+    targetId?: string;
+    /** target spec */
+    targetSpecification?: Record<string, any>;
+    /** Scope of the target resource */
+    solutionScope?: string;
+}
+export declare function targetSnapshotDeserializer(item: any): TargetSnapshot;
+/** The response of a InstanceHistory list operation. */
+export interface _InstanceHistoryListResult {
+    /** The InstanceHistory items on this page */
+    value: InstanceHistory[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _instanceHistoryListResultDeserializer(item: any): _InstanceHistoryListResult;
+export declare function instanceHistoryArrayDeserializer(result: Array<InstanceHistory>): any[];
+/** Config Template Resource. Contains configuration expressions using the predefined expression language. */
+export interface ConfigTemplate extends TrackedResource {
+    /** The resource-specific properties for this resource. */
+    properties?: ConfigTemplateProperties;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function configTemplateSerializer(item: ConfigTemplate): any;
+export declare function configTemplateDeserializer(item: any): ConfigTemplate;
+/** Config Template Properties */
+export interface ConfigTemplateProperties {
+    /** Description of config template */
+    description: string;
+    /** Latest config template version */
+    readonly latestVersion?: string;
+    /** Provisioning state of resource */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function configTemplatePropertiesSerializer(item: ConfigTemplateProperties): any;
+export declare function configTemplatePropertiesDeserializer(item: any): ConfigTemplateProperties;
+/** The type used for update operations of the ConfigTemplate. */
+export interface ConfigTemplateUpdate {
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The resource-specific properties for this resource. */
+    properties?: ConfigTemplateUpdateProperties;
+}
+export declare function configTemplateUpdateSerializer(item: ConfigTemplateUpdate): any;
+/** The updatable properties of the ConfigTemplate. */
+export interface ConfigTemplateUpdateProperties {
+    /** Description of config template */
+    description?: string;
+}
+export declare function configTemplateUpdatePropertiesSerializer(item: ConfigTemplateUpdateProperties): any;
+/** Config Template Version With Update Type */
+export interface ConfigTemplateVersionWithUpdateType {
+    /** Update type */
+    updateType?: UpdateType;
+    /** Version to create */
+    version?: string;
+    /** Config Template Version */
+    configTemplateVersion: ConfigTemplateVersion;
+}
+export declare function configTemplateVersionWithUpdateTypeSerializer(item: ConfigTemplateVersionWithUpdateType): any;
+/** Config Template Version Resource */
+export interface ConfigTemplateVersion extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: ConfigTemplateVersionProperties;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function configTemplateVersionSerializer(item: ConfigTemplateVersion): any;
+export declare function configTemplateVersionDeserializer(item: any): ConfigTemplateVersion;
+/** Config Template Version Properties */
+export interface ConfigTemplateVersionProperties {
+    /** Configuration values */
+    configurations: string;
+    /** Provisioning state of resource */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function configTemplateVersionPropertiesSerializer(item: ConfigTemplateVersionProperties): any;
+export declare function configTemplateVersionPropertiesDeserializer(item: any): ConfigTemplateVersionProperties;
+/** The response of a ConfigTemplate list operation. */
+export interface _ConfigTemplateListResult {
+    /** The ConfigTemplate items on this page */
+    value: ConfigTemplate[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _configTemplateListResultDeserializer(item: any): _ConfigTemplateListResult;
+export declare function configTemplateArraySerializer(result: Array<ConfigTemplate>): any[];
+export declare function configTemplateArrayDeserializer(result: Array<ConfigTemplate>): any[];
+/** The response of a ConfigTemplateVersion list operation. */
+export interface _ConfigTemplateVersionListResult {
+    /** The ConfigTemplateVersion items on this page */
+    value: ConfigTemplateVersion[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _configTemplateVersionListResultDeserializer(item: any): _ConfigTemplateVersionListResult;
+export declare function configTemplateVersionArraySerializer(result: Array<ConfigTemplateVersion>): any[];
+export declare function configTemplateVersionArrayDeserializer(result: Array<ConfigTemplateVersion>): any[];
+/** Workflow Resource */
+export interface Workflow extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: WorkflowProperties;
+    extendedLocation?: ExtendedLocation;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function workflowSerializer(item: Workflow): any;
+export declare function workflowDeserializer(item: any): Workflow;
+/** Workflow Properties */
+export interface WorkflowProperties {
+    /** Workflow template Id */
+    readonly workflowTemplateId?: string;
+    /** Provisioning state of resource */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function workflowPropertiesSerializer(item: WorkflowProperties): any;
+export declare function workflowPropertiesDeserializer(item: any): WorkflowProperties;
+/** The response of a Workflow list operation. */
+export interface _WorkflowListResult {
+    /** The Workflow items on this page */
+    value: Workflow[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _workflowListResultDeserializer(item: any): _WorkflowListResult;
+export declare function workflowArraySerializer(result: Array<Workflow>): any[];
+export declare function workflowArrayDeserializer(result: Array<Workflow>): any[];
+/** Workflow Version Resource */
+export interface WorkflowVersion extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: WorkflowVersionProperties;
+    extendedLocation?: ExtendedLocation;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function workflowVersionSerializer(item: WorkflowVersion): any;
+export declare function workflowVersionDeserializer(item: any): WorkflowVersion;
+/** Workflow Version Properties */
+export interface WorkflowVersionProperties {
+    /** Revision number of resolved config for this workflow version */
+    readonly revision?: number;
+    /** Resolved configuration values */
+    readonly configuration?: string;
+    /** A list of stage specs */
+    stageSpec: StageSpec[];
+    /** Review id of resolved config for this workflow version */
+    readonly reviewId?: string;
+    /** State of workflow version */
+    readonly state?: State;
+    /** Execution specification */
+    specification?: Record<string, any>;
+    /** Provisioning state of resource */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function workflowVersionPropertiesSerializer(item: WorkflowVersionProperties): any;
+export declare function workflowVersionPropertiesDeserializer(item: any): WorkflowVersionProperties;
+export declare function stageSpecArraySerializer(result: Array<StageSpec>): any[];
+export declare function stageSpecArrayDeserializer(result: Array<StageSpec>): any[];
+/** Stage Properties */
+export interface StageSpec {
+    /** Name of Stage */
+    name: string;
+    /** Stage specification */
+    specification?: Record<string, any>;
+    /** List of tasks in the stage */
+    tasks?: TaskSpec[];
+    /** Task option for the stage */
+    taskOption?: TaskOption;
+}
+export declare function stageSpecSerializer(item: StageSpec): any;
+export declare function stageSpecDeserializer(item: any): StageSpec;
+export declare function taskSpecArraySerializer(result: Array<TaskSpec>): any[];
+export declare function taskSpecArrayDeserializer(result: Array<TaskSpec>): any[];
+/** Task Spec */
+export interface TaskSpec {
+    /** Name of Task */
+    name: string;
+    /** Target ARM id */
+    targetId?: string;
+    /** Task specification */
+    specification: Record<string, any>;
+}
+export declare function taskSpecSerializer(item: TaskSpec): any;
+export declare function taskSpecDeserializer(item: any): TaskSpec;
+/** Task Option Properties */
+export interface TaskOption {
+    /** Parallel worker numbers of the tasks */
+    concurrency?: number;
+    /** Error action for the tasks */
+    errorAction?: ErrorAction;
+}
+export declare function taskOptionSerializer(item: TaskOption): any;
+export declare function taskOptionDeserializer(item: any): TaskOption;
+/** Error Action Properties */
+export interface ErrorAction {
+    /** Error action mode */
+    mode?: ErrorActionMode;
+    /** Max tolerated failures */
+    maxToleratedFailures?: number;
+}
+export declare function errorActionSerializer(item: ErrorAction): any;
+export declare function errorActionDeserializer(item: any): ErrorAction;
+/** Error Action Mode */
+export declare enum KnownErrorActionMode {
+    /** Stop on any failure */
+    StopOnAnyFailure = "stopOnAnyFailure",
+    /** Stop after N cumulative failures */
+    StopOnNFailures = "stopOnNFailures",
+    /** Continue silently despite errors */
+    SilentlyContinue = "silentlyContinue"
+}
+/**
+ * Error Action Mode \
+ * {@link KnownErrorActionMode} can be used interchangeably with ErrorActionMode,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **stopOnAnyFailure**: Stop on any failure \
+ * **stopOnNFailures**: Stop after N cumulative failures \
+ * **silentlyContinue**: Continue silently despite errors
+ */
+export type ErrorActionMode = string;
+/** The response of a WorkflowVersion list operation. */
+export interface _WorkflowVersionListResult {
+    /** The WorkflowVersion items on this page */
+    value: WorkflowVersion[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _workflowVersionListResultDeserializer(item: any): _WorkflowVersionListResult;
+export declare function workflowVersionArraySerializer(result: Array<WorkflowVersion>): any[];
+export declare function workflowVersionArrayDeserializer(result: Array<WorkflowVersion>): any[];
+/** Execution Resource */
+export interface Execution extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: ExecutionProperties;
+    extendedLocation?: ExtendedLocation;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function executionSerializer(item: Execution): any;
+export declare function executionDeserializer(item: any): Execution;
+/** Execution Properties */
+export interface ExecutionProperties {
+    /** Workflow version of execution */
+    workflowVersionId: string;
+    /** Execution specification */
+    specification?: Record<string, any>;
+    /** Status of Execution */
+    readonly status?: ExecutionStatus;
+    /** Provisioning state of resource */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function executionPropertiesSerializer(item: ExecutionProperties): any;
+export declare function executionPropertiesDeserializer(item: any): ExecutionProperties;
+/** Execution Status */
+export interface ExecutionStatus {
+    /** The lastModified timestamp of the Status */
+    updateTime?: Date;
+    /** Deployment status */
+    status?: number;
+    /** status details */
+    statusMessage?: string;
+    /** target resource statuses */
+    stageHistory?: StageStatus[];
+}
+export declare function executionStatusDeserializer(item: any): ExecutionStatus;
+export declare function stageStatusArrayDeserializer(result: Array<StageStatus>): any[];
+/** Result of Stage execution */
+export interface StageStatus {
+    /** Deployment status */
+    status?: number;
+    /** Status message */
+    statusMessage?: string;
+    /** Current stage */
+    stage?: string;
+    /** Next stage */
+    nextstage?: string;
+    /** Error message */
+    errorMessage?: string;
+    /** whether this stage is active or inactive */
+    isActive?: ActiveState;
+    /** The inputs of the StageHistory, Inputs holds a key-value map of user-defined parameters for the initial stage */
+    inputs?: Record<string, any>;
+    /** The outputs of the StageHistory, it is different as the different input stages. */
+    outputs?: Record<string, any>;
+}
+export declare function stageStatusDeserializer(item: any): StageStatus;
+/** The response of a Execution list operation. */
+export interface _ExecutionListResult {
+    /** The Execution items on this page */
+    value: Execution[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _executionListResultDeserializer(item: any): _ExecutionListResult;
+export declare function executionArraySerializer(result: Array<Execution>): any[];
+export declare function executionArrayDeserializer(result: Array<Execution>): any[];
+/** A Diagnostic resource. */
+export interface Diagnostic extends TrackedResource {
+    /** The resource-specific properties for this resource. */
+    properties?: DiagnosticProperties;
+    extendedLocation?: ExtendedLocation;
+    /** If eTag is provided in the response body, it may also be provided as a header per the normal etag convention.  Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields. */
+    readonly eTag?: string;
+}
+export declare function diagnosticSerializer(item: Diagnostic): any;
+export declare function diagnosticDeserializer(item: any): Diagnostic;
+/** The properties of a Diagnostic resource. */
+export interface DiagnosticProperties {
+    /** The status of the last operation. */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function diagnosticPropertiesSerializer(item: DiagnosticProperties): any;
+export declare function diagnosticPropertiesDeserializer(item: any): DiagnosticProperties;
+/** The type used for update operations of the Diagnostic. */
+export interface DiagnosticUpdate {
+    /** The resource-specific properties for this resource. */
+    properties?: DiagnosticUpdateProperties;
+    /** Resource tags. */
+    tags?: Record<string, string>;
+}
+export declare function diagnosticUpdateSerializer(item: DiagnosticUpdate): any;
+/** The updatable properties of the Diagnostic. */
+export interface DiagnosticUpdateProperties {
+}
+export declare function diagnosticUpdatePropertiesSerializer(item: DiagnosticUpdateProperties): any;
+/** The response of a Diagnostic list operation. */
+export interface _DiagnosticListResult {
+    /** The Diagnostic items on this page */
+    value: Diagnostic[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _diagnosticListResultDeserializer(item: any): _DiagnosticListResult;
+export declare function diagnosticArraySerializer(result: Array<Diagnostic>): any[];
+export declare function diagnosticArrayDeserializer(result: Array<Diagnostic>): any[];
+/** Context Resource */
+export interface Context extends TrackedResource {
+    /** The resource-specific properties for this resource. */
+    properties?: ContextProperties;
+}
+export declare function contextSerializer(item: Context): any;
+export declare function contextDeserializer(item: any): Context;
+/** Context Properties */
+export interface ContextProperties {
+    /** List of Capabilities */
+    capabilities: Capability[];
+    /** List of Hierarchies */
+    hierarchies: Hierarchy[];
+    /** Provisioning state of resource */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function contextPropertiesSerializer(item: ContextProperties): any;
+export declare function contextPropertiesDeserializer(item: any): ContextProperties;
+export declare function capabilityArraySerializer(result: Array<Capability>): any[];
+export declare function capabilityArrayDeserializer(result: Array<Capability>): any[];
+/** Capability, to match in Solution Templates & Targets */
+export interface Capability {
+    /** Name of Capability */
+    name: string;
+    /** Description of Capability */
+    description: string;
+    /** State of resource */
+    state?: ResourceState;
+}
+export declare function capabilitySerializer(item: Capability): any;
+export declare function capabilityDeserializer(item: any): Capability;
+export declare function hierarchyArraySerializer(result: Array<Hierarchy>): any[];
+export declare function hierarchyArrayDeserializer(result: Array<Hierarchy>): any[];
+/** Hierarchy, to tag Sites / Hierarchy Provider nodes with what they represent */
+export interface Hierarchy {
+    /** Name of Hierarchy */
+    name: string;
+    /** Description of Hierarchy */
+    description: string;
+}
+export declare function hierarchySerializer(item: Hierarchy): any;
+export declare function hierarchyDeserializer(item: any): Hierarchy;
+/** The type used for update operations of the Context. */
+export interface ContextUpdate {
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The resource-specific properties for this resource. */
+    properties?: ContextUpdateProperties;
+}
+export declare function contextUpdateSerializer(item: ContextUpdate): any;
+/** The updatable properties of the Context. */
+export interface ContextUpdateProperties {
+    /** List of Capabilities */
+    capabilities?: Capability[];
+    /** List of Hierarchies */
+    hierarchies?: Hierarchy[];
+}
+export declare function contextUpdatePropertiesSerializer(item: ContextUpdateProperties): any;
+/** The response of a Context list operation. */
+export interface _ContextListResult {
+    /** The Context items on this page */
+    value: Context[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _contextListResultDeserializer(item: any): _ContextListResult;
+export declare function contextArraySerializer(result: Array<Context>): any[];
+export declare function contextArrayDeserializer(result: Array<Context>): any[];
+/** Site Reference Resource */
+export interface SiteReference extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: SiteReferenceProperties;
+}
+export declare function siteReferenceSerializer(item: SiteReference): any;
+export declare function siteReferenceDeserializer(item: any): SiteReference;
+/** Site Reference Properties */
+export interface SiteReferenceProperties {
+    /** Azure Resource ID for Site */
+    siteId: string;
+    /** Provisioning State */
+    readonly provisioningState?: ProvisioningState;
+}
+export declare function siteReferencePropertiesSerializer(item: SiteReferenceProperties): any;
+export declare function siteReferencePropertiesDeserializer(item: any): SiteReferenceProperties;
+/** The response of a SiteReference list operation. */
+export interface _SiteReferenceListResult {
+    /** The SiteReference items on this page */
+    value: SiteReference[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _siteReferenceListResultDeserializer(item: any): _SiteReferenceListResult;
+export declare function siteReferenceArraySerializer(result: Array<SiteReference>): any[];
+export declare function siteReferenceArrayDeserializer(result: Array<SiteReference>): any[];
+/** The available API versions. */
+export declare enum KnownVersions {
+    V20250601 = "2025-06-01",
+    V20250801 = "2025-08-01"
+}
+//# sourceMappingURL=models.d.ts.map