/** 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): any[]; export declare function errorDetailArrayDeserializer(result: Array): any[]; export declare function errorAdditionalInfoArrayDeserializer(result: Array): 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): any[]; export declare function dynamicSchemaArrayDeserializer(result: Array): 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; /** 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; } 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): any[]; export declare function schemaArrayDeserializer(result: Array): 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): any[]; export declare function schemaVersionArrayDeserializer(result: Array): 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; /** 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): any[]; export declare function solutionDependencyArrayDeserializer(result: Array): 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): any[]; export declare function solutionVersionArrayDeserializer(result: Array): 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): 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): 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; /** 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): 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): 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; /** 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; /** 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): any[]; export declare function targetArrayDeserializer(result: Array): 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): 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): any[]; export declare function dynamicSchemaVersionArrayDeserializer(result: Array): 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): 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): 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): any[]; export declare function solutionArrayDeserializer(result: Array): 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; /** 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): any[]; export declare function solutionTemplateVersionArrayDeserializer(result: Array): 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): 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): 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): 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; /** 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): any[]; export declare function solutionTemplateArrayDeserializer(result: Array): 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): any[]; export declare function instanceArrayDeserializer(result: Array): 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; } export declare function solutionVersionSnapshotDeserializer(item: any): SolutionVersionSnapshot; /** Target Snapshot */ export interface TargetSnapshot { /** Target of instance */ targetId?: string; /** target spec */ targetSpecification?: Record; /** 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): 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; /** 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): any[]; export declare function configTemplateArrayDeserializer(result: Array): 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): any[]; export declare function configTemplateVersionArrayDeserializer(result: Array): 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): any[]; export declare function workflowArrayDeserializer(result: Array): 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; /** 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): any[]; export declare function stageSpecArrayDeserializer(result: Array): any[]; /** Stage Properties */ export interface StageSpec { /** Name of Stage */ name: string; /** Stage specification */ specification?: Record; /** 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): any[]; export declare function taskSpecArrayDeserializer(result: Array): any[]; /** Task Spec */ export interface TaskSpec { /** Name of Task */ name: string; /** Target ARM id */ targetId?: string; /** Task specification */ specification: Record; } 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): any[]; export declare function workflowVersionArrayDeserializer(result: Array): 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; /** 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): 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; /** The outputs of the StageHistory, it is different as the different input stages. */ outputs?: Record; } 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): any[]; export declare function executionArrayDeserializer(result: Array): 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; } 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): any[]; export declare function diagnosticArrayDeserializer(result: Array): 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): any[]; export declare function capabilityArrayDeserializer(result: Array): 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): any[]; export declare function hierarchyArrayDeserializer(result: Array): 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; /** 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): any[]; export declare function contextArrayDeserializer(result: Array): 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): any[]; export declare function siteReferenceArrayDeserializer(result: Array): any[]; /** The available API versions. */ export declare enum KnownVersions { V20250601 = "2025-06-01", V20250801 = "2025-08-01" } //# sourceMappingURL=models.d.ts.map