text: # coding=utf-8
  # *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
  # *** Do not edit by hand unless you're certain you know what you are doing! ***
  
  import warnings
  import pulumi
  import pulumi.runtime
  from typing import Any, Mapping, Optional, Sequence, Union, overload
  from .. import _utilities
  
  __all__ = [
      'ActionHttpRunAfterArgs',
      'IntegrationAccountAgreementGuestIdentityArgs',
      'IntegrationAccountAgreementHostIdentityArgs',
      'IntegrationAccountBatchConfigurationReleaseCriteriaArgs',
      'IntegrationAccountBatchConfigurationReleaseCriteriaRecurrenceArgs',
      'IntegrationAccountBatchConfigurationReleaseCriteriaRecurrenceScheduleArgs',
      'IntegrationAccountBatchConfigurationReleaseCriteriaRecurrenceScheduleMonthlyArgs',
      'IntegrationAccountCertificateKeyVaultKeyArgs',
      'IntegrationAccountPartnerBusinessIdentityArgs',
      'TriggerRecurrenceScheduleArgs',
  ]
  
  @pulumi.input_type
  class ActionHttpRunAfterArgs:
      def __init__(__self__, *,
                   action_name: pulumi.Input[str],
                   action_result: pulumi.Input[str]):
          """
          :param pulumi.Input[str] action_name: Specifies the name of the precedent HTTP Action.
          :param pulumi.Input[str] action_result: Specifies the expected result of the precedent HTTP Action, only after which the current HTTP Action will be triggered. Possible values include `Succeeded`, `Failed`, `Skipped` and `TimedOut`.
          """
          pulumi.set(__self__, "action_name", action_name)
          pulumi.set(__self__, "action_result", action_result)
  
      @property
      @pulumi.getter(name="actionName")
      def action_name(self) -> pulumi.Input[str]:
          """
          Specifies the name of the precedent HTTP Action.
          """
          return pulumi.get(self, "action_name")
  
      @action_name.setter
      def action_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "action_name", value)
  
      @property
      @pulumi.getter(name="actionResult")
      def action_result(self) -> pulumi.Input[str]:
          """
          Specifies the expected result of the precedent HTTP Action, only after which the current HTTP Action will be triggered. Possible values include `Succeeded`, `Failed`, `Skipped` and `TimedOut`.
          """
          return pulumi.get(self, "action_result")
  
      @action_result.setter
      def action_result(self, value: pulumi.Input[str]):
          pulumi.set(self, "action_result", value)
  
  
  @pulumi.input_type
  class IntegrationAccountAgreementGuestIdentityArgs:
      def __init__(__self__, *,
                   qualifier: pulumi.Input[str],
                   value: pulumi.Input[str]):
          """
          :param pulumi.Input[str] qualifier: The authenticating body that provides unique guest identities to organizations.
          :param pulumi.Input[str] value: The value that identifies the documents that your logic apps receive.
          """
          pulumi.set(__self__, "qualifier", qualifier)
          pulumi.set(__self__, "value", value)
  
      @property
      @pulumi.getter
      def qualifier(self) -> pulumi.Input[str]:
          """
          The authenticating body that provides unique guest identities to organizations.
          """
          return pulumi.get(self, "qualifier")
  
      @qualifier.setter
      def qualifier(self, value: pulumi.Input[str]):
          pulumi.set(self, "qualifier", value)
  
      @property
      @pulumi.getter
      def value(self) -> pulumi.Input[str]:
          """
          The value that identifies the documents that your logic apps receive.
          """
          return pulumi.get(self, "value")
  
      @value.setter
      def value(self, value: pulumi.Input[str]):
          pulumi.set(self, "value", value)
  
  
  @pulumi.input_type
  class IntegrationAccountAgreementHostIdentityArgs:
      def __init__(__self__, *,
                   qualifier: pulumi.Input[str],
                   value: pulumi.Input[str]):
          """
          :param pulumi.Input[str] qualifier: The authenticating body that provides unique host identities to organizations.
          :param pulumi.Input[str] value: The value that identifies the documents that your logic apps receive.
          """
          pulumi.set(__self__, "qualifier", qualifier)
          pulumi.set(__self__, "value", value)
  
      @property
      @pulumi.getter
      def qualifier(self) -> pulumi.Input[str]:
          """
          The authenticating body that provides unique host identities to organizations.
          """
          return pulumi.get(self, "qualifier")
  
      @qualifier.setter
      def qualifier(self, value: pulumi.Input[str]):
          pulumi.set(self, "qualifier", value)
  
      @property
      @pulumi.getter
      def value(self) -> pulumi.Input[str]:
          """
          The value that identifies the documents that your logic apps receive.
          """
          return pulumi.get(self, "value")
  
      @value.setter
      def value(self, value: pulumi.Input[str]):
          pulumi.set(self, "value", value)
  
  
  @pulumi.input_type
  class IntegrationAccountBatchConfigurationReleaseCriteriaArgs:
      def __init__(__self__, *,
                   batch_size: Optional[pulumi.Input[int]] = None,
                   message_count: Optional[pulumi.Input[int]] = None,
                   recurrence: Optional[pulumi.Input['IntegrationAccountBatchConfigurationReleaseCriteriaRecurrenceArgs']] = None):
          """
          :param pulumi.Input[int] batch_size: The batch size in bytes for the Logic App Integration Batch Configuration.
          :param pulumi.Input[int] message_count: The message count for the Logic App Integration Batch Configuration.
          :param pulumi.Input['IntegrationAccountBatchConfigurationReleaseCriteriaRecurrenceArgs'] recurrence: A `recurrence` block as documented below.
          """
          if batch_size is not None:
              pulumi.set(__self__, "batch_size", batch_size)
          if message_count is not None:
              pulumi.set(__self__, "message_count", message_count)
          if recurrence is not None:
              pulumi.set(__self__, "recurrence", recurrence)
  
      @property
      @pulumi.getter(name="batchSize")
      def batch_size(self) -> Optional[pulumi.Input[int]]:
          """
          The batch size in bytes for the Logic App Integration Batch Configuration.
          """
          return pulumi.get(self, "batch_size")
  
      @batch_size.setter
      def batch_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "batch_size", value)
  
      @property
      @pulumi.getter(name="messageCount")
      def message_count(self) -> Optional[pulumi.Input[int]]:
          """
          The message count for the Logic App Integration Batch Configuration.
          """
          return pulumi.get(self, "message_count")
  
      @message_count.setter
      def message_count(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "message_count", value)
  
      @property
      @pulumi.getter
      def recurrence(self) -> Optional[pulumi.Input['IntegrationAccountBatchConfigurationReleaseCriteriaRecurrenceArgs']]:
          """
          A `recurrence` block as documented below.
          """
          return pulumi.get(self, "recurrence")
  
      @recurrence.setter
      def recurrence(self, value: Optional[pulumi.Input['IntegrationAccountBatchConfigurationReleaseCriteriaRecurrenceArgs']]):
          pulumi.set(self, "recurrence", value)
  
  
  @pulumi.input_type
  class IntegrationAccountBatchConfigurationReleaseCriteriaRecurrenceArgs:
      def __init__(__self__, *,
                   frequency: pulumi.Input[str],
                   interval: pulumi.Input[int],
                   end_time: Optional[pulumi.Input[str]] = None,
                   schedule: Optional[pulumi.Input['IntegrationAccountBatchConfigurationReleaseCriteriaRecurrenceScheduleArgs']] = None,
                   start_time: Optional[pulumi.Input[str]] = None,
                   time_zone: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] frequency: The frequency of the schedule. Possible values are `Day`, `Hour`, `Minute`, `Month`, `Second`, `Week` and `Year`.
          :param pulumi.Input[int] interval: The number of `frequency`s between runs.
          :param pulumi.Input[str] end_time: The end time of the schedule, formatted as an RFC3339 string.
          :param pulumi.Input['IntegrationAccountBatchConfigurationReleaseCriteriaRecurrenceScheduleArgs'] schedule: A `schedule` block as documented below.
          :param pulumi.Input[str] start_time: The start time of the schedule, formatted as an RFC3339 string.
          :param pulumi.Input[str] time_zone: The timezone of the start/end time.
          """
          pulumi.set(__self__, "frequency", frequency)
          pulumi.set(__self__, "interval", interval)
          if end_time is not None:
              pulumi.set(__self__, "end_time", end_time)
          if schedule is not None:
              pulumi.set(__self__, "schedule", schedule)
          if start_time is not None:
              pulumi.set(__self__, "start_time", start_time)
          if time_zone is not None:
              pulumi.set(__self__, "time_zone", time_zone)
  
      @property
      @pulumi.getter
      def frequency(self) -> pulumi.Input[str]:
          """
          The frequency of the schedule. Possible values are `Day`, `Hour`, `Minute`, `Month`, `Second`, `Week` and `Year`.
          """
          return pulumi.get(self, "frequency")
  
      @frequency.setter
      def frequency(self, value: pulumi.Input[str]):
          pulumi.set(self, "frequency", value)
  
      @property
      @pulumi.getter
      def interval(self) -> pulumi.Input[int]:
          """
          The number of `frequency`s between runs.
          """
          return pulumi.get(self, "interval")
  
      @interval.setter
      def interval(self, value: pulumi.Input[int]):
          pulumi.set(self, "interval", value)
  
      @property
      @pulumi.getter(name="endTime")
      def end_time(self) -> Optional[pulumi.Input[str]]:
          """
          The end time of the schedule, formatted as an RFC3339 string.
          """
          return pulumi.get(self, "end_time")
  
      @end_time.setter
      def end_time(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "end_time", value)
  
      @property
      @pulumi.getter
      def schedule(self) -> Optional[pulumi.Input['IntegrationAccountBatchConfigurationReleaseCriteriaRecurrenceScheduleArgs']]:
          """
          A `schedule` block as documented below.
          """
          return pulumi.get(self, "schedule")
  
      @schedule.setter
      def schedule(self, value: Optional[pulumi.Input['IntegrationAccountBatchConfigurationReleaseCriteriaRecurrenceScheduleArgs']]):
          pulumi.set(self, "schedule", value)
  
      @property
      @pulumi.getter(name="startTime")
      def start_time(self) -> Optional[pulumi.Input[str]]:
          """
          The start time of the schedule, formatted as an RFC3339 string.
          """
          return pulumi.get(self, "start_time")
  
      @start_time.setter
      def start_time(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "start_time", value)
  
      @property
      @pulumi.getter(name="timeZone")
      def time_zone(self) -> Optional[pulumi.Input[str]]:
          """
          The timezone of the start/end time.
          """
          return pulumi.get(self, "time_zone")
  
      @time_zone.setter
      def time_zone(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "time_zone", value)
  
  
  @pulumi.input_type
  class IntegrationAccountBatchConfigurationReleaseCriteriaRecurrenceScheduleArgs:
      def __init__(__self__, *,
                   hours: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
                   minutes: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
                   month_days: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
                   monthlies: Optional[pulumi.Input[Sequence[pulumi.Input['IntegrationAccountBatchConfigurationReleaseCriteriaRecurrenceScheduleMonthlyArgs']]]] = None,
                   week_days: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          :param pulumi.Input[Sequence[pulumi.Input[int]]] hours: A list containing a single item, which specifies the Hour interval at which this recurrence should be triggered.
          :param pulumi.Input[Sequence[pulumi.Input[int]]] minutes: A list containing a single item which specifies the Minute interval at which this recurrence should be triggered.
          :param pulumi.Input[Sequence[pulumi.Input[int]]] month_days: A list of days of the month that the job should execute on.
          :param pulumi.Input[Sequence[pulumi.Input['IntegrationAccountBatchConfigurationReleaseCriteriaRecurrenceScheduleMonthlyArgs']]] monthlies: A `monthly` block as documented below.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] week_days: A list of days of the week that the job should execute on. Possible values are `Sunday`, `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday` and `Saturday`.
          """
          if hours is not None:
              pulumi.set(__self__, "hours", hours)
          if minutes is not None:
              pulumi.set(__self__, "minutes", minutes)
          if month_days is not None:
              pulumi.set(__self__, "month_days", month_days)
          if monthlies is not None:
              pulumi.set(__self__, "monthlies", monthlies)
          if week_days is not None:
              pulumi.set(__self__, "week_days", week_days)
  
      @property
      @pulumi.getter
      def hours(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
          """
          A list containing a single item, which specifies the Hour interval at which this recurrence should be triggered.
          """
          return pulumi.get(self, "hours")
  
      @hours.setter
      def hours(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
          pulumi.set(self, "hours", value)
  
      @property
      @pulumi.getter
      def minutes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
          """
          A list containing a single item which specifies the Minute interval at which this recurrence should be triggered.
          """
          return pulumi.get(self, "minutes")
  
      @minutes.setter
      def minutes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
          pulumi.set(self, "minutes", value)
  
      @property
      @pulumi.getter(name="monthDays")
      def month_days(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
          """
          A list of days of the month that the job should execute on.
          """
          return pulumi.get(self, "month_days")
  
      @month_days.setter
      def month_days(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
          pulumi.set(self, "month_days", value)
  
      @property
      @pulumi.getter
      def monthlies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IntegrationAccountBatchConfigurationReleaseCriteriaRecurrenceScheduleMonthlyArgs']]]]:
          """
          A `monthly` block as documented below.
          """
          return pulumi.get(self, "monthlies")
  
      @monthlies.setter
      def monthlies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['IntegrationAccountBatchConfigurationReleaseCriteriaRecurrenceScheduleMonthlyArgs']]]]):
          pulumi.set(self, "monthlies", value)
  
      @property
      @pulumi.getter(name="weekDays")
      def week_days(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          A list of days of the week that the job should execute on. Possible values are `Sunday`, `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday` and `Saturday`.
          """
          return pulumi.get(self, "week_days")
  
      @week_days.setter
      def week_days(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "week_days", value)
  
  
  @pulumi.input_type
  class IntegrationAccountBatchConfigurationReleaseCriteriaRecurrenceScheduleMonthlyArgs:
      def __init__(__self__, *,
                   week: pulumi.Input[int],
                   weekday: pulumi.Input[str]):
          """
          :param pulumi.Input[int] week: The occurrence of the week within the month.
          :param pulumi.Input[str] weekday: The day of the occurrence. Possible values are `Sunday`, `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday` and `Saturday`.
          """
          pulumi.set(__self__, "week", week)
          pulumi.set(__self__, "weekday", weekday)
  
      @property
      @pulumi.getter
      def week(self) -> pulumi.Input[int]:
          """
          The occurrence of the week within the month.
          """
          return pulumi.get(self, "week")
  
      @week.setter
      def week(self, value: pulumi.Input[int]):
          pulumi.set(self, "week", value)
  
      @property
      @pulumi.getter
      def weekday(self) -> pulumi.Input[str]:
          """
          The day of the occurrence. Possible values are `Sunday`, `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday` and `Saturday`.
          """
          return pulumi.get(self, "weekday")
  
      @weekday.setter
      def weekday(self, value: pulumi.Input[str]):
          pulumi.set(self, "weekday", value)
  
  
  @pulumi.input_type
  class IntegrationAccountCertificateKeyVaultKeyArgs:
      def __init__(__self__, *,
                   key_name: pulumi.Input[str],
                   key_vault_id: pulumi.Input[str],
                   key_version: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] key_name: The name of Key Vault Key.
          :param pulumi.Input[str] key_vault_id: The ID of the Key Vault.
          :param pulumi.Input[str] key_version: The version of Key Vault Key.
          """
          pulumi.set(__self__, "key_name", key_name)
          pulumi.set(__self__, "key_vault_id", key_vault_id)
          if key_version is not None:
              pulumi.set(__self__, "key_version", key_version)
  
      @property
      @pulumi.getter(name="keyName")
      def key_name(self) -> pulumi.Input[str]:
          """
          The name of Key Vault Key.
          """
          return pulumi.get(self, "key_name")
  
      @key_name.setter
      def key_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "key_name", value)
  
      @property
      @pulumi.getter(name="keyVaultId")
      def key_vault_id(self) -> pulumi.Input[str]:
          """
          The ID of the Key Vault.
          """
          return pulumi.get(self, "key_vault_id")
  
      @key_vault_id.setter
      def key_vault_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "key_vault_id", value)
  
      @property
      @pulumi.getter(name="keyVersion")
      def key_version(self) -> Optional[pulumi.Input[str]]:
          """
          The version of Key Vault Key.
          """
          return pulumi.get(self, "key_version")
  
      @key_version.setter
      def key_version(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "key_version", value)
  
  
  @pulumi.input_type
  class IntegrationAccountPartnerBusinessIdentityArgs:
      def __init__(__self__, *,
                   qualifier: pulumi.Input[str],
                   value: pulumi.Input[str]):
          """
          :param pulumi.Input[str] qualifier: The authenticating body that provides unique business identities to organizations.
          :param pulumi.Input[str] value: The value that identifies the documents that your logic apps receive.
          """
          pulumi.set(__self__, "qualifier", qualifier)
          pulumi.set(__self__, "value", value)
  
      @property
      @pulumi.getter
      def qualifier(self) -> pulumi.Input[str]:
          """
          The authenticating body that provides unique business identities to organizations.
          """
          return pulumi.get(self, "qualifier")
  
      @qualifier.setter
      def qualifier(self, value: pulumi.Input[str]):
          pulumi.set(self, "qualifier", value)
  
      @property
      @pulumi.getter
      def value(self) -> pulumi.Input[str]:
          """
          The value that identifies the documents that your logic apps receive.
          """
          return pulumi.get(self, "value")
  
      @value.setter
      def value(self, value: pulumi.Input[str]):
          pulumi.set(self, "value", value)
  
  
  @pulumi.input_type
  class TriggerRecurrenceScheduleArgs:
      def __init__(__self__, *,
                   at_these_hours: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
                   at_these_minutes: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
                   on_these_days: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          :param pulumi.Input[Sequence[pulumi.Input[int]]] at_these_hours: Specifies a list of hours when the trigger should run. Valid values are between 0 and 23.
          :param pulumi.Input[Sequence[pulumi.Input[int]]] at_these_minutes: Specifies a list of minutes when the trigger should run. Valid values are between 0 and 59.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] on_these_days: Specifies a list of days when the trigger should run. Valid values include `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday`, `Saturday`, and `Sunday`.
          """
          if at_these_hours is not None:
              pulumi.set(__self__, "at_these_hours", at_these_hours)
          if at_these_minutes is not None:
              pulumi.set(__self__, "at_these_minutes", at_these_minutes)
          if on_these_days is not None:
              pulumi.set(__self__, "on_these_days", on_these_days)
  
      @property
      @pulumi.getter(name="atTheseHours")
      def at_these_hours(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
          """
          Specifies a list of hours when the trigger should run. Valid values are between 0 and 23.
          """
          return pulumi.get(self, "at_these_hours")
  
      @at_these_hours.setter
      def at_these_hours(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
          pulumi.set(self, "at_these_hours", value)
  
      @property
      @pulumi.getter(name="atTheseMinutes")
      def at_these_minutes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
          """
          Specifies a list of minutes when the trigger should run. Valid values are between 0 and 59.
          """
          return pulumi.get(self, "at_these_minutes")
  
      @at_these_minutes.setter
      def at_these_minutes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
          pulumi.set(self, "at_these_minutes", value)
  
      @property
      @pulumi.getter(name="onTheseDays")
      def on_these_days(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          Specifies a list of days when the trigger should run. Valid values include `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday`, `Saturday`, and `Sunday`.
          """
          return pulumi.get(self, "on_these_days")
  
      @on_these_days.setter
      def on_these_days(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "on_these_days", value)
  
  
  