text:
# - Try to find ffmpeg
# Once done this will define
#
#  FFMPEG_FOUND - system has ffmpeg
#  FFMPEG_INCLUDE_DIR - Include directory necessary for using the ffmpeg headers
#  FFMPEG_LIBRARIES - Link these to use ffmpeg
#  FFMPEG_DEFINITIONS - Compiler switches required for using ffmpeg

# Copyright (c) 2006, Matthias Kretz, <kretz@kde.org>
# Copyright (c) 2008, Alexander Neundorf, <neundorf@kde.org>
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.

if (FFMPEG_LIBRARIES)

  # in cache already
  set(FFMPEG_FOUND TRUE)

else (FFMPEG_LIBRARIES)

if (NOT WIN32)
   # use pkg-config to get the directories and then use these values
   # in the FIND_PATH() and FIND_LIBRARY() calls
   find_package(PkgConfig)
   pkg_check_modules(PC_LIBAVCODEC libavcodec)
   set(FFMPEG_DEFINITIONS ${PC_LIBAVCODEC_CFLAGS_OTHER})

endif (NOT WIN32)

  #
  # #include <libXXXX/XXXX.h> is the new style for FFMPEG headers
  # This has been verified at least since 0.4.9
  # Please do not change to the old format, since this will break for
  # people who are using newer versions. Instead, upgrade your ffmpeg
  # installation.
  #
  find_path(FFMPEG_INCLUDE_DIR libavcodec/avcodec.h
    HINTS
    ${PC_LIBAVCODEC_INCLUDEDIR}
    ${PC_LIBAVCODEC_INCLUDE_DIRS}
  )

  # also search for the old style include dir, just for the purpose
  # of giving a useful error message if an old libavcodec is installed
  # and the user might wonder why it is not found
  find_path(FFMPEG_INCLUDE_DIR_OLD_STYLE ffmpeg/avcodec.h
    HINTS
    ${PC_LIBAVCODEC_INCLUDEDIR}
    ${PC_LIBAVCODEC_INCLUDE_DIRS}
  )

  find_library(AVCODEC_LIBRARIES NAMES avcodec
    HINTS
    ${PC_LIBAVCODEC_LIBDIR}
    ${PC_LIBAVCODEC_LIBRARY_DIRS}
  )

  find_library(AVFORMAT_LIBRARIES NAMES avformat
    HINTS
    ${PC_LIBAVCODEC_LIBDIR}
    ${PC_LIBAVCODEC_LIBRARY_DIRS}
  )

  find_library(AVUTIL_LIBRARIES NAMES avutil
    HINTS
    ${PC_LIBAVCODEC_LIBDIR}
    ${PC_LIBAVCODEC_LIBRARY_DIRS}
  )

  set(FFMPEG_LIBRARIES )
  if (AVCODEC_LIBRARIES)
    set(FFMPEG_LIBRARIES ${FFMPEG_LIBRARIES} ${AVCODEC_LIBRARIES})
  endif (AVCODEC_LIBRARIES)

  if (AVFORMAT_LIBRARIES)
    set(FFMPEG_LIBRARIES ${FFMPEG_LIBRARIES} ${AVFORMAT_LIBRARIES})
  endif (AVFORMAT_LIBRARIES)

  if (AVUTIL_LIBRARIES)
    set(FFMPEG_LIBRARIES ${FFMPEG_LIBRARIES} ${AVUTIL_LIBRARIES})
  endif (AVUTIL_LIBRARIES)

  if (FFMPEG_LIBRARIES  AND  FFMPEG_INCLUDE_DIR)
     set(FFMPEG_FOUND TRUE)
  endif (FFMPEG_LIBRARIES  AND  FFMPEG_INCLUDE_DIR)

  if (FFMPEG_FOUND)
    if (NOT FFmpeg_FIND_QUIETLY)
      message(STATUS "Found FFMPEG: ${FFMPEG_LIBRARIES} ${FFMPEG_INCLUDE_DIR}")
    endif (NOT FFmpeg_FIND_QUIETLY)
  else (FFMPEG_FOUND)
    # only an old libavcodec was found ?
    if (FFMPEG_INCLUDE_DIR_OLD_STYLE  AND NOT  FFMPEG_INCLUDE_DIR  AND NOT  FFmpeg_FIND_QUIETLY)
      message(STATUS "Found old version of libavcodec, but a newer version is required.")
    endif (FFMPEG_INCLUDE_DIR_OLD_STYLE  AND NOT  FFMPEG_INCLUDE_DIR  AND NOT  FFmpeg_FIND_QUIETLY)

    if (FFmpeg_FIND_REQUIRED)
      message(FATAL_ERROR "Could NOT find FFMPEG")
    else (FFmpeg_FIND_REQUIRED)
      if (NOT FFmpeg_FIND_QUIETLY)
        message(STATUS "Could NOT find FFMPEG")
      endif (NOT FFmpeg_FIND_QUIETLY)
    endif (FFmpeg_FIND_REQUIRED)
  endif (FFMPEG_FOUND)

  mark_as_advanced(AVCODEC_LIBRARIES
                   AVFORMAT_LIBRARIES
                   AVUTIL_LIBRARIES
                   FFMPEG_INCLUDE_DIR
                   FFMPEG_INCLUDE_DIR_OLD_STYLE)

endif (FFMPEG_LIBRARIES)# AND FFMPEG_DEFINITIONS)

repository: istex/popplonode

repo_name: istex/popplonode

gha_license_id: MIT

extension: cmake


text:
@article{ASNetal2019,
  abstract={Quantification and modelling of curvilinear structures in 2D and 3D images is a common challenge in a wide range of biomedical applications. Image enhancement is a crucial pre-processing step for curvilinear structure quantification. Many of the existing state-of-the-art enhancement approaches still suffer from contrast variations and noise. In this paper, we propose to address such problems via the use of a multiscale image processing approach, called Multiscale Top-Hat Tensor (MTHT). MTHT produces a better quality enhancement of curvilinear structures in low contrast and noisy images compared with other approaches in a range of 2D and 3D biomedical images. The proposed approach combines multiscale morphological filtering with a local tensor representation of curvilinear structure. The MTHT approach is validated on 2D and 3D synthetic and real images, and is also compared to the state-of-the-art curvilinear structure enhancement approaches. The obtained results demonstrate that the proposed approach provides high-quality curvilinear structure enhancement, allowing high accuracy segmentation and quantification in a wide range of 2D and 3D image datasets.},
  title={The Multiscale Top-Hat Tensor Enables Specific Enhancement of Curvilinear Structures in 2D and 3D Images},
  author={Alharbi, Shuaa S and Sazak, {\c{C}}i{\u{g}}dem and Nelson, Carl J and Alhasson, Haifa F and Obara, Boguslaw},
  journal={Methods},
  year={2019},
  publisher={Elsevier},
  archiveprefix = {arXiv},
  primaryclass = {cs.CV},
  eprint = {1709.05097},
  doi = {10.1016/j.ymeth.2019.05.025}
}

license: MIT

license_type: permissive

branch_name: refs/heads/master

extension: bib


text:
@inproceedings{trc19,
  title = {Targeted Mismatch Adversarial Attack: Query with a Flower to Retrieve the Tower},
  author = {Tolias, Giorgos and Radenovic, Filip and Chum, Ondrej},
  booktitle = {ICCV},
  year = {2019}
}


text:
export IMAGE_BASENAME = "nylon-mini"

NYLON_BASE = "base-files base-passwd busybox \
	dropbear \
	miniinit \
	modutils-collateral \
	modutils-initscripts \
	netbase \
	wireless-tools"

DEPENDS = "virtual/kernel modutils \
	${NYLON_BASE} ${BOOTSTRAP_EXTRA_DEPENDS}"

RDEPENDS = "kernel \
	${NYLON_BASE} ${BOOTSTRAP_EXTRA_RDEPENDS}"

export IPKG_INSTALL = "${RDEPENDS}"

IMAGE_LINGUAS = ""

inherit image_ipk
LICENSE = "MIT"

repository: Terentyev/familiar-linux

repo_name: Terentyev/familiar-linux

extension: bb


text:
package api

import (
	"net/http"
	"testing"
)

func TestShouldCollect(t *testing.T) {
	r, _ := http.NewRequest("GET", "/", nil)
	r.Header.Add("User-Agent", "Mozilla/1.0")
	r.Header.Add("Referer", "http://usefathom.com/")
	if v := shouldCollect(r); v != false {
		t.Errorf("Expected %#v, got %#v", true, false)
	}
}

func TestParsePathname(t *testing.T) {
	if v := parsePathname("/"); v != "/" {
		t.Errorf("error parsing pathname. expected %#v, got %#v", "/", v)
	}

	if v := parsePathname("about"); v != "/about" {
		t.Errorf("error parsing pathname. expected %#v, got %#v", "/about", v)
	}
	if v := parsePathname("about/"); v != "/about" {
		t.Errorf("error parsing pathname. expected %#v, got %#v", "/about", v)
	}
}

func TestParseHostname(t *testing.T) {
	e := "https://usefathom.com"
	if v := parseHostname("https://usefathom.com"); v != e {
		t.Errorf("error parsing hostname. expected %#v, got %#v", e, v)
	}

	e = "http://usefathom.com"
	if v := parseHostname("http://usefathom.com"); v != e {
		t.Errorf("error parsing hostname. expected %#v, got %#v", e, v)
	}
}

repository: usefathom/fathom

repo_name: usefathom/fathom

gha_language: Go

extension: go


text:
@article{bilman2020,
author = "Bilman, Deniz and Ling, Liming and Miller, Peter D.",
doi = "10.1215/00127094-2019-0066",
fjournal = "Duke Mathematical Journal",
journal = "Duke Math. J.",
month = "03",
number = "4",
pages = "671--760",
publisher = "Duke University Press",
title = "Extreme superposition: Rogue waves of infinite order and the Painlevé-III hierarchy",
url = "https://doi.org/10.1215/00127094-2019-0066",
volume = "169",
year = "2020"
}

repository: bilman/academic-kickstart

repo_name: bilman/academic-kickstart


text:
SUMMARY = "Case insensitive derivable dictionary"
HOMEPAGE = "https://github.com/coldfix/pydicti"
LICENSE = "WTFPL"
LIC_FILES_CHKSUM = "file://COPYING;md5=389a9e29629d1f05e115f8f05c283df5"

SRC_URI[sha256sum] = "63e0756ff27a335e92916ff40be589a21a58894b3a93099edf0f3cbf695690dc"

inherit pypi setuptools3

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded

gha_language: BitBake


text:
@inproceedings{otani_rethinking_2019,
 abstract = {Video summarization is a technique to create a short skim of the original video while preserving the main stories/content. There exists a substantial interest in automatizing this process due to the rapid growth of the available material. The recent progress has been facilitated by public benchmark datasets, which enable easy and fair comparison of methods. Currently the established evaluation protocol is to compare the generated summary with respect to a set of reference summaries provided by the dataset. In this paper, we will provide in-depth assessment of this pipeline using two popular benchmark datasets. Surprisingly, we observe that randomly generated summaries achieve comparable or better performance to the state-of-the-art. In some cases, the random summaries outperform even the human generated summaries in leave-one-out experiments. Moreover, it turns out that the video segmentation, which is often considered as a fixed pre-processing method, has the most significant impact on the performance measure. Based on our observations, we propose alternative approaches for assessing the importance scores as well as an intuitive visualization of correlation between the estimated scoring and human annotations.},
 author = {Otani, Mayu and Nakashima, Yuta and Rahtu, Esa and Heikkilä, Janne},
 booktitle = {Proc. IEEE Conference on Computer Vision and Pattern Recognition},
 file = {arXiv.org Snapshot:/Users/n-yuta/Zotero/storage/LECA54YP/1903.html:text/html;arXiv\:1903.11328 PDF:/Users/n-yuta/Zotero/storage/NDZIA2SU/Otani et al. - 2019 - Rethinking the Evaluation of Video Summaries.pdf:application/pdf},
 keywords = {Computer Science - Computer Vision and Pattern Recognition},
 month = {June},
 note = {arXiv: 1903.11328},
 pages = {7596--7604},
 title = {Rethinking the evaluation of video summaries},
 url = {http://arxiv.org/abs/1903.11328},
 urldate = {2019-04-30},
 year = {2019}
}


text:
SUMMARY = "Library tasked with managing, extracting and handling media art caches"

LICENSE = "LGPL-2.0-or-later & GPL-2.0-or-later"
LIC_FILES_CHKSUM = "file://COPYING.LESSER;md5=4fbd65380cdd255951079008b364516c \
                    file://libmediaart/extract.c;endline=18;md5=dff2b6328ab067b5baadc135f9876c36 \
                    file://tests/mediaarttest.c;endline=18;md5=067106eaa1f7a9d918759a096667f18e"

DEPENDS = "glib-2.0 gdk-pixbuf"

GNOMEBASEBUILDCLASS = "meson"

inherit gnomebase gobject-introspection vala features_check

SRC_URI = "${GNOME_MIRROR}/libmediaart/1.9/libmediaart-${PV}.tar.xz"
SRC_URI[sha256sum] = "07def5a42c482ae71d3e1f77a4d0fdc337f74226059a65284d6d5a241f0e9cd6"

S = "${WORKDIR}/libmediaart-${PV}"

# gobject-introspection is mandatory and cannot be configured
REQUIRED_DISTRO_FEATURES = "gobject-introspection-data"
GIR_MESON_OPTION = ""

EXTRA_OEMESON = "-Dimage_library=gdk-pixbuf"


text:
CUDA_PKG = "${BPN}"

require cuda-shared-binaries.inc

MAINSUM = "a7eb2f26db67c3823f9cb02db46d9728e907dca96dcb260a62448f064ac491d1"
MAINSUM:x86-64 = "b535748064852dd9dbff0f70ce70bf2046f869be97e6e818be451a04b1cb8be5"

BBCLASSEXTEND = "native nativesdk"

repository: lfdmn/meta-tegra

repo_name: lfdmn/meta-tegra


text:
@article{Raman2007Hallmarks,
 abstract = {Mycolic acids, which render unique qualities to mycobacteria, are known to be important for mycobacterial growth, survival, and pathogenicity. It is of interest to understand the evolutionary origins of the mycolic acid pathway (MAP), as well as the common minimum principles critical for generating the capability of mycolic acid biosynthesis. The recent curation of a comprehensive model of the MAP in Mycobacterium tuberculosis and the availability of a large number of genome sequences make it feasible to carry out detailed sequence and phylogenetic analyses, to address these questions. A comprehensive phylogenetic pathway profile analysis was carried out for 318 fully sequenced bacterial genomes, for each of the proteins present in the MAP. The organisms were clustered on the basis of co-occurrence of the MAP proteins in their proteome, while the proteins were clustered on the basis of their phylogenetic profiles. The MAP proteins were also searched against the nonredundant sequence database, to identify similar proteins from other phyla. The pathway profiles indicate that four proteins and certain protein domains stand out as more characteristic to mycolate producing organisms. Further analysis leads to the identification of the desaturases DesA1 and DesA2 and certain domains of Fas and Pks13 as hallmarks of the pathway. The roles of these proteins in some other organisms, as well as the distribution of these proteins across all known genome sequences are also briefly discussed. The clustering of organisms, carried out to group organisms with similar profiles, provides a means of obtaining finer classification as compared to the standard taxonomic method. The results indicate that the MAP and hence the capacity of mycolic acid production in mycobacteria is an example of an emergent property that has come about by recruiting enzymes from unrelated pathways in plants, presumably through lateral gene transfer. The understanding of the hallmarks of mycolic acid biosynthesis will also find application in evaluating drug targets. Proteins 2007. o̧pyright 2007 Wiley-Liss, Inc.},
 added-at = {2018-12-02T16:09:07.000+0100},
 address = {Bioinformatics Centre and Supercomputer Education and Research Centre, Indian Institute of Science, Bangalore 560012, India},
 author = {Raman, Karthik and Rajagopalan, Preethi and Chandra, Nagasuma},
 biburl = {https://www.bibsonomy.org/bibtex/27bc667b3440d2fd8fd4027d9362f5cc6/karthikraman},
 citeulike-article-id = {6590463},
 citeulike-linkout-0 = {http://dx.doi.org/10.1002/prot.21591},
 citeulike-linkout-1 = {http://www3.interscience.wiley.com/cgi-bin/abstract/114285245/ABSTRACT},
 doi = {10.1002/prot.21591},
 interhash = {082b9fa12e5161e2255c2454ff21f5d7},
 intrahash = {7bc667b3440d2fd8fd4027d9362f5cc6},
 issn = {1097-0134},
 journal = {Proteins: Structure, Function, and Bioinformatics},
 keywords = {comparative_analysis mtb myown sequence_analysis},
 number = {2},
 pages = {358--368},
 posted-at = {2012-02-07 09:25:27},
 priority = {2},
 timestamp = {2019-02-10T16:15:28.000+0100},
 title = {Hallmarks of mycolic acid biosynthesis: A comparative genomics study},
 url = {http://dx.doi.org/10.1002/prot.21591},
 volume = {69},
 year = {2007}
}

repository: karthikraman/ramanlab-home

repo_name: karthikraman/ramanlab-home


text:
DESCRIPTION = "pytest plugin for generating html reports from test results"
DEPENDS += "${PYTHON_PN}-setuptools-scm-native"

LICENSE = "MPL-2.0"
LIC_FILES_CHKSUM = "file://LICENSE;md5=5d425c8f3157dbf212db2ec53d9e5132"

SRC_URI[sha256sum] = "c4e2f4bb0bffc437f51ad2174a8a3e71df81bbc2f6894604e604af18fbe687c3"

PYPI_PACKAGE = "pytest-html"

inherit pypi python_setuptools_build_meta

DEPENDS += "python3-setuptools-scm-git-archive-native"

RDEPENDS:${PN} += " \
    ${PYTHON_PN}-pytest \
"

BBCLASSEXTEND = "native nativesdk"


text:
DESCRIPTION = "A tool for automatically generating Makefiles."
LICENSE = "GPL"
HOMEPAGE = "http://www.gnu.org/software/automake/"
SECTION = "devel"
PR = "r0"

SRC_URI = "\
  ${GNU_MIRROR}/automake/automake-${PV}.tar.bz2 \
  ${@['file://path_prog_fixes.patch;patch=1', ''][bb.data.inherits_class('native', d)]} \
"
S = "${WORKDIR}/automake-${PV}"

FILESDIR = "${@os.path.dirname(bb.data.getVar('FILE',d,1))}/automake-${PV}"

inherit autotools

export AUTOMAKE = "${@bb.which('automake', bb.data.getVar('PATH', d, 1))}"
FILES_${PN} += "${datadir}/automake* ${datadir}/aclocal*"

require automake.inc

do_install () {
	oe_runmake 'DESTDIR=${D}' install
	install -d ${D}${datadir}
	if [ ! -e ${D}${datadir}/aclocal ]; then
		ln -sf aclocal-1.10 ${D}${datadir}/aclocal
	fi
	if [ ! -e ${D}${datadir}/automake ]; then
		ln -sf automake-1.10 ${D}${datadir}/automake
	fi
}


text:
package patzer

import (
	"bufio"
	"fmt"
	"os"
)

type UCI struct {
}

func (u *UCI) Loop() {
	reader := bufio.NewScanner(os.Stdin)

	for reader.Scan() {
		ln := reader.Text()
		fmt.Printf("%d, %s\n", len(ln), ln)
	}

	if err := reader.Err(); err != nil {
		fmt.Printf("%s\n", err)
	}
}

repository: dfrezell/patzer

repo_name: dfrezell/patzer


text:
# header-only library

include(vcpkg_common_functions)

vcpkg_from_github(
    OUT_SOURCE_PATH SOURCE_PATH
    REPO rigtorp/SPSCQueue
    REF 5165a08ac4474c77c636050332eca6ebfdd53533
    SHA512 30cd60711f816e6003a5b114c48bd12da449cb7b0f19aa58dd57e3abc3e5200847c3eb492627b4013f57eec11d5d6f0a11fedbcb21dd8dd5c44682c49456e4e1
    HEAD_REF master
)

file(COPY
    ${SOURCE_PATH}/include/rigtorp/SPSCQueue.h
    DESTINATION ${CURRENT_PACKAGES_DIR}/include/rigtorp
)

# Handle copyright
configure_file(${SOURCE_PATH}/LICENSE ${CURRENT_PACKAGES_DIR}/share/${PORT}/copyright COPYONLY)

repository: JackBoos/vcpkg

repo_name: JackBoos/vcpkg

gha_license_id: NOASSERTION


text:
SUMMARY = "Firmware packages for the RB2 Robotics platform"

inherit packagegroup

RRECOMMENDS:${PN} += " \
    firmware-qcom-rb2 \
    ${@bb.utils.contains('DISTRO_FEATURES', 'opengl', 'linux-firmware-qcom-adreno-a630 linux-firmware-qcom-qrb4210-adreno', '', d)} \
    ${@bb.utils.contains('DISTRO_FEATURES', 'wifi', 'linux-firmware-ath10k linux-firmware-qcom-qrb4210-wifi', '', d)} \
    linux-firmware-lt9611uxc \
    linux-firmware-qcom-qrb4210-audio \
    linux-firmware-qcom-qrb4210-compute \
    linux-firmware-qcom-qrb4210-modem \
    linux-firmware-qcom-venus-6.0 \
"


text:
@article{Bertone:2004pz,
    author = "Bertone, Gianfranco and Hooper, Dan and Silk, Joseph",
    title = "{Particle Dark Matter: Evidence, Candidates and Constraints}",
    eprint = "hep-ph/0404175",
    archivePrefix = "arXiv",
    reportNumber = "FERMILAB-PUB-04-047-A",
    doi = "10.1016/j.physrep.2004.08.031",
    journal = "Phys. Rept.",
    volume = "405",
    pages = "279--390",
    year = "2005"
}

@article{Bertone:2018krk,
    author = "Bertone, Gianfranco and Tait, M. P., Tim",
    title = "{A new Era in the Search for Dark Matter}",
    eprint = "1810.01668",
    archivePrefix = "arXiv",
    primaryClass = "astro-ph.CO",
    doi = "10.1038/s41586-018-0542-z",
    journal = "Nature",
    volume = "562",
    number = "7725",
    pages = "51--56",
    year = "2018"
}

@article{Catena:2019gfa,
    author = "Catena, Riccardo and Emken, Timon and Spaldin, Nicola A. and Tarantino, Walter",
    title = "{Atomic Responses to General Dark Matter-Electron Interactions}",
    eprint = "1912.08204",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    doi = "10.1103/PhysRevResearch.2.033195",
    journal = "Phys. Rev. Res.",
    volume = "2",
    number = "3",
    pages = "033195",
    year = "2020"
}

@article{Catena:2021qsr,
    author = "Catena, Riccardo and Emken, Timon and Matas, Marek and Spaldin, Nicola A. and Urdshals, Einar",
    title = "{Crystal responses to general Dark Matter-Electron Interactions}",
    eprint = "2105.02233",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    doi = "10.1103/PhysRevResearch.3.033149",
    journal = "Phys. Rev. Res.",
    volume = "3",
    number = "3",
    pages = "033149",
    year = "2021"
}

@article{DelNobile:2021icc,
    author = "Del Nobile, Eugenio",
    title = "{Appendiciario -- A Hands-on Manual on the Theory of Direct Dark Matter Detection}",
    eprint = "2104.12785",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    month = "4",
    year = "2021"
}

@article{Drukier:1986tm,
    author = "Drukier, A. K. and Freese, Katherine and Spergel, D. N.",
    title = "{Detecting Cold Dark Matter Candidates}",
    doi = "10.1103/PhysRevD.33.3495",
    journal = "Phys. Rev. D",
    volume = "33",
    pages = "3495--3508",
    year = "1986"
}

@article{Emken:2021lgc,
    author = "Emken, Timon",
    title = "{Solar Reflection of Light Dark Matter with Heavy Mediators}",
    eprint = "2102.12483",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    month = "2",
    year = "2021"
}

@software{Emken2021,
  author = {Emken, Timon},
  title = {{Dark Matter Simulation Code for Underground Scatterings - Sun Edition~(DaMaSCUS-SUN) [Code, v0.1.0]}},
  year         = {2021},
  publisher    = {Zenodo},
  version      = {v0.1.0},
  doi          = {DOI:10.5281/zenodo.4559874},
  url          = {https://doi.org/10.5281/zenodo.4559874},
  howpublished={Astrophysics Source Code Library record \href{https://ascl.net/2102.018}{[ascl:2102.018]}. The code can be found under \url{https://github.com/temken/damascus-sun}.}
}

@article{Essig:2011nj,
    author = "Essig, Rouven and Mardon, Jeremy and Volansky, Tomer",
    title = "{Direct Detection of Sub-GeV Dark Matter}",
    eprint = "1108.5383",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    reportNumber = "SLAC-PUB-14538",
    doi = "10.1103/PhysRevD.85.076007",
    journal = "Phys. Rev. D",
    volume = "85",
    pages = "076007",
    year = "2012"
}

@article{Essig:2015cda,
    author = "Essig, Rouven and Fernandez-Serra, Marivi and Mardon, Jeremy and Soto, Adrian and Volansky, Tomer and Yu, Tien-Tien",
    title = "{Direct Detection of Sub-GeV Dark Matter with Semiconductor Targets}",
    eprint = "1509.01598",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    doi = "10.1007/JHEP05(2016)046",
    journal = "Journal for High Energy Physics",
    volume = "05",
    pages = "046",
    year = "2016"
}

@article{GAMBIT:2018eea,
    author = "Athron, Peter and others",
    collaboration = "GAMBIT",
    title = "{Global Analyses of Higgs Portal Singlet Dark Matter Models using GAMBIT}",
    eprint = "1808.10465",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    reportNumber = "ADP-18-22/T1070, COEPP-MN-18-6, DESY-18-141, TTK-18-34, gambit-physics, gambit-physics-2018",
    doi = "10.1140/epjc/s10052-018-6513-6",
    journal = "Eur. Phys. J. C",
    volume = "79",
    number = "1",
    pages = "38",
    year = "2019"
}

@article{GAMBITDarkMatterWorkgroup:2017fax,
    author = "Bringmann, Torsten and others",
    collaboration = "GAMBIT Dark Matter Workgroup",
    title = "{DarkBit: A GAMBIT Module for Computing Dark Matter Observables and Likelihoods}",
    eprint = "1705.07920",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    reportNumber = "DESY-17-235, NORDITA-2017-076, gambit-code-2017",
    doi = "10.1140/epjc/s10052-017-5155-4",
    journal = "Eur. Phys. J. C",
    volume = "77",
    number = "12",
    pages = "831",
    year = "2017"
}

@article{Goodman:1984dc,
    author = "Goodman, Mark W. and Witten, Edward",
    editor = "Srednicki, M. A.",
    title = "{Detectability of Certain Dark Matter Candidates}",
    reportNumber = "Print-85-0030 (PRINCETON)",
    doi = "10.1103/PhysRevD.31.3059",
    journal = "Phys. Rev. D",
    volume = "31",
    pages = "3059",
    year = "1985"
}

@article{Griffin:2019mvc,
    author = "Griffin, Sin\'ead M. and Inzani, Katherine and Trickle, Tanner and Zhang, Zhengkang and Zurek, Kathryn M.",
    title = "{Multichannel Direct Detection of Light Dark Matter: Target Comparison}",
    eprint = "1910.10716",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    doi = "10.1103/PhysRevD.101.055004",
    journal = "Phys. Rev. D",
    volume = "101",
    number = "5",
    pages = "055004",
    year = "2020"
}

@article{Griffin:2021znd,
    author = "Griffin, Sin\'ead M. and Inzani, Katherine and Trickle, Tanner and Zhang, Zhengkang and Zurek, Kathryn M.",
    title = "{Extended Calculation of Dark Matter-Electron Scattering in Crystal Targets}",
    eprint = "2105.05253",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    doi = "10.1103/PhysRevD.104.095015",
    journal = "Phys. Rev. D",
    volume = "104",
    number = "9",
    pages = "095015",
    year = "2021"
}

@article{Jeong:2021bpl,
    author = "Jeong, Injun and Kang, Sunghyun and Scopel, Stefano and Tomar, Gaurav",
    title = "{WimPyDD: an Object-oriented Python Code for the Calculation of WIMP Direct Detection Signals}",
    eprint = "2106.06207",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    reportNumber = "CQUeST-2021-0663, TUM-HEP 1343/21",
    month = "6",
    year = "2021"
}

@article{Kopp:2009et,
    author = "Kopp, Joachim and Niro, Viviana and Schwetz, Thomas and Zupan, Jure",
    title = "{DAMA/LIBRA and Leptonically Interacting Dark Matter}",
    eprint = "0907.3159",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    reportNumber = "CERN-PH-TH-2009-116",
    doi = "10.1103/PhysRevD.80.083502",
    journal = "Phys. Rev. D",
    volume = "80",
    pages = "083502",
    year = "2009"
}

@article{Lewin:1995rx,
    author = "Lewin, J. D. and Smith, P. F.",
    title = "{Review of Mathematics, Numerical Factors, and Corrections for Dark Matter Experiments based on Elastic Nuclear Recoil}",
    reportNumber = "RAL-TR-95-024",
    doi = "10.1016/S0927-6505(96)00047-3",
    journal = "Astropart. Phys.",
    volume = "6",
    pages = "87--112",
    year = "1996"
}

@article{Wasserman:1986hh,
    author = "Wasserman, I.",
    editor = "Srednicki, M. A.",
    title = "{Possibility of Detecting Heavy Neutral Fermions in the Galaxy}",
    doi = "10.1103/PhysRevD.33.2071",
    journal = "Phys. Rev. D",
    volume = "33",
    pages = "2071--2078",
    year = "1986"
}

repository: temken/obscura

repo_name: temken/obscura

branch_name: refs/heads/main


text:
package v20210808preview

import (
	"context"
	"reflect"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

type ActionRuleProperties struct {
	Actions     []interface{} `pulumi:"actions"`
	Conditions  []Condition   `pulumi:"conditions"`
	Description *string       `pulumi:"description"`
	Enabled     *bool         `pulumi:"enabled"`
	Schedule    *Schedule     `pulumi:"schedule"`
	Scopes      []string      `pulumi:"scopes"`
}

type ActionRulePropertiesInput interface {
	pulumi.Input

	ToActionRulePropertiesOutput() ActionRulePropertiesOutput
	ToActionRulePropertiesOutputWithContext(context.Context) ActionRulePropertiesOutput
}

type ActionRulePropertiesArgs struct {
	Actions     pulumi.ArrayInput       `pulumi:"actions"`
	Conditions  ConditionArrayInput     `pulumi:"conditions"`
	Description pulumi.StringPtrInput   `pulumi:"description"`
	Enabled     pulumi.BoolPtrInput     `pulumi:"enabled"`
	Schedule    SchedulePtrInput        `pulumi:"schedule"`
	Scopes      pulumi.StringArrayInput `pulumi:"scopes"`
}

func (ActionRulePropertiesArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ActionRuleProperties)(nil)).Elem()
}

func (i ActionRulePropertiesArgs) ToActionRulePropertiesOutput() ActionRulePropertiesOutput {
	return i.ToActionRulePropertiesOutputWithContext(context.Background())
}

func (i ActionRulePropertiesArgs) ToActionRulePropertiesOutputWithContext(ctx context.Context) ActionRulePropertiesOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ActionRulePropertiesOutput)
}

func (i ActionRulePropertiesArgs) ToActionRulePropertiesPtrOutput() ActionRulePropertiesPtrOutput {
	return i.ToActionRulePropertiesPtrOutputWithContext(context.Background())
}

func (i ActionRulePropertiesArgs) ToActionRulePropertiesPtrOutputWithContext(ctx context.Context) ActionRulePropertiesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ActionRulePropertiesOutput).ToActionRulePropertiesPtrOutputWithContext(ctx)
}

type ActionRulePropertiesPtrInput interface {
	pulumi.Input

	ToActionRulePropertiesPtrOutput() ActionRulePropertiesPtrOutput
	ToActionRulePropertiesPtrOutputWithContext(context.Context) ActionRulePropertiesPtrOutput
}

type actionRulePropertiesPtrType ActionRulePropertiesArgs

func ActionRulePropertiesPtr(v *ActionRulePropertiesArgs) ActionRulePropertiesPtrInput {
	return (*actionRulePropertiesPtrType)(v)
}

func (*actionRulePropertiesPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ActionRuleProperties)(nil)).Elem()
}

func (i *actionRulePropertiesPtrType) ToActionRulePropertiesPtrOutput() ActionRulePropertiesPtrOutput {
	return i.ToActionRulePropertiesPtrOutputWithContext(context.Background())
}

func (i *actionRulePropertiesPtrType) ToActionRulePropertiesPtrOutputWithContext(ctx context.Context) ActionRulePropertiesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ActionRulePropertiesPtrOutput)
}

type ActionRulePropertiesOutput struct{ *pulumi.OutputState }

func (ActionRulePropertiesOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ActionRuleProperties)(nil)).Elem()
}

func (o ActionRulePropertiesOutput) ToActionRulePropertiesOutput() ActionRulePropertiesOutput {
	return o
}

func (o ActionRulePropertiesOutput) ToActionRulePropertiesOutputWithContext(ctx context.Context) ActionRulePropertiesOutput {
	return o
}

func (o ActionRulePropertiesOutput) ToActionRulePropertiesPtrOutput() ActionRulePropertiesPtrOutput {
	return o.ToActionRulePropertiesPtrOutputWithContext(context.Background())
}

func (o ActionRulePropertiesOutput) ToActionRulePropertiesPtrOutputWithContext(ctx context.Context) ActionRulePropertiesPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ActionRuleProperties) *ActionRuleProperties {
		return &v
	}).(ActionRulePropertiesPtrOutput)
}

func (o ActionRulePropertiesOutput) Actions() pulumi.ArrayOutput {
	return o.ApplyT(func(v ActionRuleProperties) []interface{} { return v.Actions }).(pulumi.ArrayOutput)
}

func (o ActionRulePropertiesOutput) Conditions() ConditionArrayOutput {
	return o.ApplyT(func(v ActionRuleProperties) []Condition { return v.Conditions }).(ConditionArrayOutput)
}

func (o ActionRulePropertiesOutput) Description() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ActionRuleProperties) *string { return v.Description }).(pulumi.StringPtrOutput)
}

func (o ActionRulePropertiesOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v ActionRuleProperties) *bool { return v.Enabled }).(pulumi.BoolPtrOutput)
}

func (o ActionRulePropertiesOutput) Schedule() SchedulePtrOutput {
	return o.ApplyT(func(v ActionRuleProperties) *Schedule { return v.Schedule }).(SchedulePtrOutput)
}

func (o ActionRulePropertiesOutput) Scopes() pulumi.StringArrayOutput {
	return o.ApplyT(func(v ActionRuleProperties) []string { return v.Scopes }).(pulumi.StringArrayOutput)
}

type ActionRulePropertiesPtrOutput struct{ *pulumi.OutputState }

func (ActionRulePropertiesPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ActionRuleProperties)(nil)).Elem()
}

func (o ActionRulePropertiesPtrOutput) ToActionRulePropertiesPtrOutput() ActionRulePropertiesPtrOutput {
	return o
}

func (o ActionRulePropertiesPtrOutput) ToActionRulePropertiesPtrOutputWithContext(ctx context.Context) ActionRulePropertiesPtrOutput {
	return o
}

func (o ActionRulePropertiesPtrOutput) Elem() ActionRulePropertiesOutput {
	return o.ApplyT(func(v *ActionRuleProperties) ActionRuleProperties {
		if v != nil {
			return *v
		}
		var ret ActionRuleProperties
		return ret
	}).(ActionRulePropertiesOutput)
}

func (o ActionRulePropertiesPtrOutput) Actions() pulumi.ArrayOutput {
	return o.ApplyT(func(v *ActionRuleProperties) []interface{} {
		if v == nil {
			return nil
		}
		return v.Actions
	}).(pulumi.ArrayOutput)
}

func (o ActionRulePropertiesPtrOutput) Conditions() ConditionArrayOutput {
	return o.ApplyT(func(v *ActionRuleProperties) []Condition {
		if v == nil {
			return nil
		}
		return v.Conditions
	}).(ConditionArrayOutput)
}

func (o ActionRulePropertiesPtrOutput) Description() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ActionRuleProperties) *string {
		if v == nil {
			return nil
		}
		return v.Description
	}).(pulumi.StringPtrOutput)
}

func (o ActionRulePropertiesPtrOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ActionRuleProperties) *bool {
		if v == nil {
			return nil
		}
		return v.Enabled
	}).(pulumi.BoolPtrOutput)
}

func (o ActionRulePropertiesPtrOutput) Schedule() SchedulePtrOutput {
	return o.ApplyT(func(v *ActionRuleProperties) *Schedule {
		if v == nil {
			return nil
		}
		return v.Schedule
	}).(SchedulePtrOutput)
}

func (o ActionRulePropertiesPtrOutput) Scopes() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *ActionRuleProperties) []string {
		if v == nil {
			return nil
		}
		return v.Scopes
	}).(pulumi.StringArrayOutput)
}

type ActionRulePropertiesResponse struct {
	Actions     []interface{}       `pulumi:"actions"`
	Conditions  []ConditionResponse `pulumi:"conditions"`
	Description *string             `pulumi:"description"`
	Enabled     *bool               `pulumi:"enabled"`
	Schedule    *ScheduleResponse   `pulumi:"schedule"`
	Scopes      []string            `pulumi:"scopes"`
}

type ActionRulePropertiesResponseInput interface {
	pulumi.Input

	ToActionRulePropertiesResponseOutput() ActionRulePropertiesResponseOutput
	ToActionRulePropertiesResponseOutputWithContext(context.Context) ActionRulePropertiesResponseOutput
}

type ActionRulePropertiesResponseArgs struct {
	Actions     pulumi.ArrayInput           `pulumi:"actions"`
	Conditions  ConditionResponseArrayInput `pulumi:"conditions"`
	Description pulumi.StringPtrInput       `pulumi:"description"`
	Enabled     pulumi.BoolPtrInput         `pulumi:"enabled"`
	Schedule    ScheduleResponsePtrInput    `pulumi:"schedule"`
	Scopes      pulumi.StringArrayInput     `pulumi:"scopes"`
}

func (ActionRulePropertiesResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ActionRulePropertiesResponse)(nil)).Elem()
}

func (i ActionRulePropertiesResponseArgs) ToActionRulePropertiesResponseOutput() ActionRulePropertiesResponseOutput {
	return i.ToActionRulePropertiesResponseOutputWithContext(context.Background())
}

func (i ActionRulePropertiesResponseArgs) ToActionRulePropertiesResponseOutputWithContext(ctx context.Context) ActionRulePropertiesResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ActionRulePropertiesResponseOutput)
}

func (i ActionRulePropertiesResponseArgs) ToActionRulePropertiesResponsePtrOutput() ActionRulePropertiesResponsePtrOutput {
	return i.ToActionRulePropertiesResponsePtrOutputWithContext(context.Background())
}

func (i ActionRulePropertiesResponseArgs) ToActionRulePropertiesResponsePtrOutputWithContext(ctx context.Context) ActionRulePropertiesResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ActionRulePropertiesResponseOutput).ToActionRulePropertiesResponsePtrOutputWithContext(ctx)
}

type ActionRulePropertiesResponsePtrInput interface {
	pulumi.Input

	ToActionRulePropertiesResponsePtrOutput() ActionRulePropertiesResponsePtrOutput
	ToActionRulePropertiesResponsePtrOutputWithContext(context.Context) ActionRulePropertiesResponsePtrOutput
}

type actionRulePropertiesResponsePtrType ActionRulePropertiesResponseArgs

func ActionRulePropertiesResponsePtr(v *ActionRulePropertiesResponseArgs) ActionRulePropertiesResponsePtrInput {
	return (*actionRulePropertiesResponsePtrType)(v)
}

func (*actionRulePropertiesResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ActionRulePropertiesResponse)(nil)).Elem()
}

func (i *actionRulePropertiesResponsePtrType) ToActionRulePropertiesResponsePtrOutput() ActionRulePropertiesResponsePtrOutput {
	return i.ToActionRulePropertiesResponsePtrOutputWithContext(context.Background())
}

func (i *actionRulePropertiesResponsePtrType) ToActionRulePropertiesResponsePtrOutputWithContext(ctx context.Context) ActionRulePropertiesResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ActionRulePropertiesResponsePtrOutput)
}

type ActionRulePropertiesResponseOutput struct{ *pulumi.OutputState }

func (ActionRulePropertiesResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ActionRulePropertiesResponse)(nil)).Elem()
}

func (o ActionRulePropertiesResponseOutput) ToActionRulePropertiesResponseOutput() ActionRulePropertiesResponseOutput {
	return o
}

func (o ActionRulePropertiesResponseOutput) ToActionRulePropertiesResponseOutputWithContext(ctx context.Context) ActionRulePropertiesResponseOutput {
	return o
}

func (o ActionRulePropertiesResponseOutput) ToActionRulePropertiesResponsePtrOutput() ActionRulePropertiesResponsePtrOutput {
	return o.ToActionRulePropertiesResponsePtrOutputWithContext(context.Background())
}

func (o ActionRulePropertiesResponseOutput) ToActionRulePropertiesResponsePtrOutputWithContext(ctx context.Context) ActionRulePropertiesResponsePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ActionRulePropertiesResponse) *ActionRulePropertiesResponse {
		return &v
	}).(ActionRulePropertiesResponsePtrOutput)
}

func (o ActionRulePropertiesResponseOutput) Actions() pulumi.ArrayOutput {
	return o.ApplyT(func(v ActionRulePropertiesResponse) []interface{} { return v.Actions }).(pulumi.ArrayOutput)
}

func (o ActionRulePropertiesResponseOutput) Conditions() ConditionResponseArrayOutput {
	return o.ApplyT(func(v ActionRulePropertiesResponse) []ConditionResponse { return v.Conditions }).(ConditionResponseArrayOutput)
}

func (o ActionRulePropertiesResponseOutput) Description() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ActionRulePropertiesResponse) *string { return v.Description }).(pulumi.StringPtrOutput)
}

func (o ActionRulePropertiesResponseOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v ActionRulePropertiesResponse) *bool { return v.Enabled }).(pulumi.BoolPtrOutput)
}

func (o ActionRulePropertiesResponseOutput) Schedule() ScheduleResponsePtrOutput {
	return o.ApplyT(func(v ActionRulePropertiesResponse) *ScheduleResponse { return v.Schedule }).(ScheduleResponsePtrOutput)
}

func (o ActionRulePropertiesResponseOutput) Scopes() pulumi.StringArrayOutput {
	return o.ApplyT(func(v ActionRulePropertiesResponse) []string { return v.Scopes }).(pulumi.StringArrayOutput)
}

type ActionRulePropertiesResponsePtrOutput struct{ *pulumi.OutputState }

func (ActionRulePropertiesResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ActionRulePropertiesResponse)(nil)).Elem()
}

func (o ActionRulePropertiesResponsePtrOutput) ToActionRulePropertiesResponsePtrOutput() ActionRulePropertiesResponsePtrOutput {
	return o
}

func (o ActionRulePropertiesResponsePtrOutput) ToActionRulePropertiesResponsePtrOutputWithContext(ctx context.Context) ActionRulePropertiesResponsePtrOutput {
	return o
}

func (o ActionRulePropertiesResponsePtrOutput) Elem() ActionRulePropertiesResponseOutput {
	return o.ApplyT(func(v *ActionRulePropertiesResponse) ActionRulePropertiesResponse {
		if v != nil {
			return *v
		}
		var ret ActionRulePropertiesResponse
		return ret
	}).(ActionRulePropertiesResponseOutput)
}

func (o ActionRulePropertiesResponsePtrOutput) Actions() pulumi.ArrayOutput {
	return o.ApplyT(func(v *ActionRulePropertiesResponse) []interface{} {
		if v == nil {
			return nil
		}
		return v.Actions
	}).(pulumi.ArrayOutput)
}

func (o ActionRulePropertiesResponsePtrOutput) Conditions() ConditionResponseArrayOutput {
	return o.ApplyT(func(v *ActionRulePropertiesResponse) []ConditionResponse {
		if v == nil {
			return nil
		}
		return v.Conditions
	}).(ConditionResponseArrayOutput)
}

func (o ActionRulePropertiesResponsePtrOutput) Description() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ActionRulePropertiesResponse) *string {
		if v == nil {
			return nil
		}
		return v.Description
	}).(pulumi.StringPtrOutput)
}

func (o ActionRulePropertiesResponsePtrOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ActionRulePropertiesResponse) *bool {
		if v == nil {
			return nil
		}
		return v.Enabled
	}).(pulumi.BoolPtrOutput)
}

func (o ActionRulePropertiesResponsePtrOutput) Schedule() ScheduleResponsePtrOutput {
	return o.ApplyT(func(v *ActionRulePropertiesResponse) *ScheduleResponse {
		if v == nil {
			return nil
		}
		return v.Schedule
	}).(ScheduleResponsePtrOutput)
}

func (o ActionRulePropertiesResponsePtrOutput) Scopes() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *ActionRulePropertiesResponse) []string {
		if v == nil {
			return nil
		}
		return v.Scopes
	}).(pulumi.StringArrayOutput)
}

type AddActionGroups struct {
	ActionGroupIds []string `pulumi:"actionGroupIds"`
	ActionType     string   `pulumi:"actionType"`
}

type AddActionGroupsInput interface {
	pulumi.Input

	ToAddActionGroupsOutput() AddActionGroupsOutput
	ToAddActionGroupsOutputWithContext(context.Context) AddActionGroupsOutput
}

type AddActionGroupsArgs struct {
	ActionGroupIds pulumi.StringArrayInput `pulumi:"actionGroupIds"`
	ActionType     pulumi.StringInput      `pulumi:"actionType"`
}

func (AddActionGroupsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AddActionGroups)(nil)).Elem()
}

func (i AddActionGroupsArgs) ToAddActionGroupsOutput() AddActionGroupsOutput {
	return i.ToAddActionGroupsOutputWithContext(context.Background())
}

func (i AddActionGroupsArgs) ToAddActionGroupsOutputWithContext(ctx context.Context) AddActionGroupsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AddActionGroupsOutput)
}

type AddActionGroupsOutput struct{ *pulumi.OutputState }

func (AddActionGroupsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AddActionGroups)(nil)).Elem()
}

func (o AddActionGroupsOutput) ToAddActionGroupsOutput() AddActionGroupsOutput {
	return o
}

func (o AddActionGroupsOutput) ToAddActionGroupsOutputWithContext(ctx context.Context) AddActionGroupsOutput {
	return o
}

func (o AddActionGroupsOutput) ActionGroupIds() pulumi.StringArrayOutput {
	return o.ApplyT(func(v AddActionGroups) []string { return v.ActionGroupIds }).(pulumi.StringArrayOutput)
}

func (o AddActionGroupsOutput) ActionType() pulumi.StringOutput {
	return o.ApplyT(func(v AddActionGroups) string { return v.ActionType }).(pulumi.StringOutput)
}

type AddActionGroupsResponse struct {
	ActionGroupIds []string `pulumi:"actionGroupIds"`
	ActionType     string   `pulumi:"actionType"`
}

type AddActionGroupsResponseInput interface {
	pulumi.Input

	ToAddActionGroupsResponseOutput() AddActionGroupsResponseOutput
	ToAddActionGroupsResponseOutputWithContext(context.Context) AddActionGroupsResponseOutput
}

type AddActionGroupsResponseArgs struct {
	ActionGroupIds pulumi.StringArrayInput `pulumi:"actionGroupIds"`
	ActionType     pulumi.StringInput      `pulumi:"actionType"`
}

func (AddActionGroupsResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AddActionGroupsResponse)(nil)).Elem()
}

func (i AddActionGroupsResponseArgs) ToAddActionGroupsResponseOutput() AddActionGroupsResponseOutput {
	return i.ToAddActionGroupsResponseOutputWithContext(context.Background())
}

func (i AddActionGroupsResponseArgs) ToAddActionGroupsResponseOutputWithContext(ctx context.Context) AddActionGroupsResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AddActionGroupsResponseOutput)
}

type AddActionGroupsResponseOutput struct{ *pulumi.OutputState }

func (AddActionGroupsResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AddActionGroupsResponse)(nil)).Elem()
}

func (o AddActionGroupsResponseOutput) ToAddActionGroupsResponseOutput() AddActionGroupsResponseOutput {
	return o
}

func (o AddActionGroupsResponseOutput) ToAddActionGroupsResponseOutputWithContext(ctx context.Context) AddActionGroupsResponseOutput {
	return o
}

func (o AddActionGroupsResponseOutput) ActionGroupIds() pulumi.StringArrayOutput {
	return o.ApplyT(func(v AddActionGroupsResponse) []string { return v.ActionGroupIds }).(pulumi.StringArrayOutput)
}

func (o AddActionGroupsResponseOutput) ActionType() pulumi.StringOutput {
	return o.ApplyT(func(v AddActionGroupsResponse) string { return v.ActionType }).(pulumi.StringOutput)
}

type Condition struct {
	Field    *string  `pulumi:"field"`
	Operator *string  `pulumi:"operator"`
	Values   []string `pulumi:"values"`
}

type ConditionInput interface {
	pulumi.Input

	ToConditionOutput() ConditionOutput
	ToConditionOutputWithContext(context.Context) ConditionOutput
}

type ConditionArgs struct {
	Field    pulumi.StringPtrInput   `pulumi:"field"`
	Operator pulumi.StringPtrInput   `pulumi:"operator"`
	Values   pulumi.StringArrayInput `pulumi:"values"`
}

func (ConditionArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Condition)(nil)).Elem()
}

func (i ConditionArgs) ToConditionOutput() ConditionOutput {
	return i.ToConditionOutputWithContext(context.Background())
}

func (i ConditionArgs) ToConditionOutputWithContext(ctx context.Context) ConditionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ConditionOutput)
}

type ConditionArrayInput interface {
	pulumi.Input

	ToConditionArrayOutput() ConditionArrayOutput
	ToConditionArrayOutputWithContext(context.Context) ConditionArrayOutput
}

type ConditionArray []ConditionInput

func (ConditionArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]Condition)(nil)).Elem()
}

func (i ConditionArray) ToConditionArrayOutput() ConditionArrayOutput {
	return i.ToConditionArrayOutputWithContext(context.Background())
}

func (i ConditionArray) ToConditionArrayOutputWithContext(ctx context.Context) ConditionArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ConditionArrayOutput)
}

type ConditionOutput struct{ *pulumi.OutputState }

func (ConditionOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Condition)(nil)).Elem()
}

func (o ConditionOutput) ToConditionOutput() ConditionOutput {
	return o
}

func (o ConditionOutput) ToConditionOutputWithContext(ctx context.Context) ConditionOutput {
	return o
}

func (o ConditionOutput) Field() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Condition) *string { return v.Field }).(pulumi.StringPtrOutput)
}

func (o ConditionOutput) Operator() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Condition) *string { return v.Operator }).(pulumi.StringPtrOutput)
}

func (o ConditionOutput) Values() pulumi.StringArrayOutput {
	return o.ApplyT(func(v Condition) []string { return v.Values }).(pulumi.StringArrayOutput)
}

type ConditionArrayOutput struct{ *pulumi.OutputState }

func (ConditionArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]Condition)(nil)).Elem()
}

func (o ConditionArrayOutput) ToConditionArrayOutput() ConditionArrayOutput {
	return o
}

func (o ConditionArrayOutput) ToConditionArrayOutputWithContext(ctx context.Context) ConditionArrayOutput {
	return o
}

func (o ConditionArrayOutput) Index(i pulumi.IntInput) ConditionOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) Condition {
		return vs[0].([]Condition)[vs[1].(int)]
	}).(ConditionOutput)
}

type ConditionResponse struct {
	Field    *string  `pulumi:"field"`
	Operator *string  `pulumi:"operator"`
	Values   []string `pulumi:"values"`
}

type ConditionResponseInput interface {
	pulumi.Input

	ToConditionResponseOutput() ConditionResponseOutput
	ToConditionResponseOutputWithContext(context.Context) ConditionResponseOutput
}

type ConditionResponseArgs struct {
	Field    pulumi.StringPtrInput   `pulumi:"field"`
	Operator pulumi.StringPtrInput   `pulumi:"operator"`
	Values   pulumi.StringArrayInput `pulumi:"values"`
}

func (ConditionResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ConditionResponse)(nil)).Elem()
}

func (i ConditionResponseArgs) ToConditionResponseOutput() ConditionResponseOutput {
	return i.ToConditionResponseOutputWithContext(context.Background())
}

func (i ConditionResponseArgs) ToConditionResponseOutputWithContext(ctx context.Context) ConditionResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ConditionResponseOutput)
}

type ConditionResponseArrayInput interface {
	pulumi.Input

	ToConditionResponseArrayOutput() ConditionResponseArrayOutput
	ToConditionResponseArrayOutputWithContext(context.Context) ConditionResponseArrayOutput
}

type ConditionResponseArray []ConditionResponseInput

func (ConditionResponseArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ConditionResponse)(nil)).Elem()
}

func (i ConditionResponseArray) ToConditionResponseArrayOutput() ConditionResponseArrayOutput {
	return i.ToConditionResponseArrayOutputWithContext(context.Background())
}

func (i ConditionResponseArray) ToConditionResponseArrayOutputWithContext(ctx context.Context) ConditionResponseArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ConditionResponseArrayOutput)
}

type ConditionResponseOutput struct{ *pulumi.OutputState }

func (ConditionResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ConditionResponse)(nil)).Elem()
}

func (o ConditionResponseOutput) ToConditionResponseOutput() ConditionResponseOutput {
	return o
}

func (o ConditionResponseOutput) ToConditionResponseOutputWithContext(ctx context.Context) ConditionResponseOutput {
	return o
}

func (o ConditionResponseOutput) Field() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ConditionResponse) *string { return v.Field }).(pulumi.StringPtrOutput)
}

func (o ConditionResponseOutput) Operator() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ConditionResponse) *string { return v.Operator }).(pulumi.StringPtrOutput)
}

func (o ConditionResponseOutput) Values() pulumi.StringArrayOutput {
	return o.ApplyT(func(v ConditionResponse) []string { return v.Values }).(pulumi.StringArrayOutput)
}

type ConditionResponseArrayOutput struct{ *pulumi.OutputState }

func (ConditionResponseArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ConditionResponse)(nil)).Elem()
}

func (o ConditionResponseArrayOutput) ToConditionResponseArrayOutput() ConditionResponseArrayOutput {
	return o
}

func (o ConditionResponseArrayOutput) ToConditionResponseArrayOutputWithContext(ctx context.Context) ConditionResponseArrayOutput {
	return o
}

func (o ConditionResponseArrayOutput) Index(i pulumi.IntInput) ConditionResponseOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ConditionResponse {
		return vs[0].([]ConditionResponse)[vs[1].(int)]
	}).(ConditionResponseOutput)
}

type DailyRecurrence struct {
	EndTime        string `pulumi:"endTime"`
	RecurrenceType string `pulumi:"recurrenceType"`
	StartTime      string `pulumi:"startTime"`
}

type DailyRecurrenceInput interface {
	pulumi.Input

	ToDailyRecurrenceOutput() DailyRecurrenceOutput
	ToDailyRecurrenceOutputWithContext(context.Context) DailyRecurrenceOutput
}

type DailyRecurrenceArgs struct {
	EndTime        pulumi.StringInput `pulumi:"endTime"`
	RecurrenceType pulumi.StringInput `pulumi:"recurrenceType"`
	StartTime      pulumi.StringInput `pulumi:"startTime"`
}

func (DailyRecurrenceArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DailyRecurrence)(nil)).Elem()
}

func (i DailyRecurrenceArgs) ToDailyRecurrenceOutput() DailyRecurrenceOutput {
	return i.ToDailyRecurrenceOutputWithContext(context.Background())
}

func (i DailyRecurrenceArgs) ToDailyRecurrenceOutputWithContext(ctx context.Context) DailyRecurrenceOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DailyRecurrenceOutput)
}

type DailyRecurrenceOutput struct{ *pulumi.OutputState }

func (DailyRecurrenceOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DailyRecurrence)(nil)).Elem()
}

func (o DailyRecurrenceOutput) ToDailyRecurrenceOutput() DailyRecurrenceOutput {
	return o
}

func (o DailyRecurrenceOutput) ToDailyRecurrenceOutputWithContext(ctx context.Context) DailyRecurrenceOutput {
	return o
}

func (o DailyRecurrenceOutput) EndTime() pulumi.StringOutput {
	return o.ApplyT(func(v DailyRecurrence) string { return v.EndTime }).(pulumi.StringOutput)
}

func (o DailyRecurrenceOutput) RecurrenceType() pulumi.StringOutput {
	return o.ApplyT(func(v DailyRecurrence) string { return v.RecurrenceType }).(pulumi.StringOutput)
}

func (o DailyRecurrenceOutput) StartTime() pulumi.StringOutput {
	return o.ApplyT(func(v DailyRecurrence) string { return v.StartTime }).(pulumi.StringOutput)
}

type DailyRecurrenceResponse struct {
	EndTime        string `pulumi:"endTime"`
	RecurrenceType string `pulumi:"recurrenceType"`
	StartTime      string `pulumi:"startTime"`
}

type DailyRecurrenceResponseInput interface {
	pulumi.Input

	ToDailyRecurrenceResponseOutput() DailyRecurrenceResponseOutput
	ToDailyRecurrenceResponseOutputWithContext(context.Context) DailyRecurrenceResponseOutput
}

type DailyRecurrenceResponseArgs struct {
	EndTime        pulumi.StringInput `pulumi:"endTime"`
	RecurrenceType pulumi.StringInput `pulumi:"recurrenceType"`
	StartTime      pulumi.StringInput `pulumi:"startTime"`
}

func (DailyRecurrenceResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DailyRecurrenceResponse)(nil)).Elem()
}

func (i DailyRecurrenceResponseArgs) ToDailyRecurrenceResponseOutput() DailyRecurrenceResponseOutput {
	return i.ToDailyRecurrenceResponseOutputWithContext(context.Background())
}

func (i DailyRecurrenceResponseArgs) ToDailyRecurrenceResponseOutputWithContext(ctx context.Context) DailyRecurrenceResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DailyRecurrenceResponseOutput)
}

type DailyRecurrenceResponseOutput struct{ *pulumi.OutputState }

func (DailyRecurrenceResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DailyRecurrenceResponse)(nil)).Elem()
}

func (o DailyRecurrenceResponseOutput) ToDailyRecurrenceResponseOutput() DailyRecurrenceResponseOutput {
	return o
}

func (o DailyRecurrenceResponseOutput) ToDailyRecurrenceResponseOutputWithContext(ctx context.Context) DailyRecurrenceResponseOutput {
	return o
}

func (o DailyRecurrenceResponseOutput) EndTime() pulumi.StringOutput {
	return o.ApplyT(func(v DailyRecurrenceResponse) string { return v.EndTime }).(pulumi.StringOutput)
}

func (o DailyRecurrenceResponseOutput) RecurrenceType() pulumi.StringOutput {
	return o.ApplyT(func(v DailyRecurrenceResponse) string { return v.RecurrenceType }).(pulumi.StringOutput)
}

func (o DailyRecurrenceResponseOutput) StartTime() pulumi.StringOutput {
	return o.ApplyT(func(v DailyRecurrenceResponse) string { return v.StartTime }).(pulumi.StringOutput)
}

type MonthlyRecurrence struct {
	DaysOfMonth    []int   `pulumi:"daysOfMonth"`
	EndTime        *string `pulumi:"endTime"`
	RecurrenceType string  `pulumi:"recurrenceType"`
	StartTime      *string `pulumi:"startTime"`
}

type MonthlyRecurrenceInput interface {
	pulumi.Input

	ToMonthlyRecurrenceOutput() MonthlyRecurrenceOutput
	ToMonthlyRecurrenceOutputWithContext(context.Context) MonthlyRecurrenceOutput
}

type MonthlyRecurrenceArgs struct {
	DaysOfMonth    pulumi.IntArrayInput  `pulumi:"daysOfMonth"`
	EndTime        pulumi.StringPtrInput `pulumi:"endTime"`
	RecurrenceType pulumi.StringInput    `pulumi:"recurrenceType"`
	StartTime      pulumi.StringPtrInput `pulumi:"startTime"`
}

func (MonthlyRecurrenceArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*MonthlyRecurrence)(nil)).Elem()
}

func (i MonthlyRecurrenceArgs) ToMonthlyRecurrenceOutput() MonthlyRecurrenceOutput {
	return i.ToMonthlyRecurrenceOutputWithContext(context.Background())
}

func (i MonthlyRecurrenceArgs) ToMonthlyRecurrenceOutputWithContext(ctx context.Context) MonthlyRecurrenceOutput {
	return pulumi.ToOutputWithContext(ctx, i).(MonthlyRecurrenceOutput)
}

type MonthlyRecurrenceOutput struct{ *pulumi.OutputState }

func (MonthlyRecurrenceOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*MonthlyRecurrence)(nil)).Elem()
}

func (o MonthlyRecurrenceOutput) ToMonthlyRecurrenceOutput() MonthlyRecurrenceOutput {
	return o
}

func (o MonthlyRecurrenceOutput) ToMonthlyRecurrenceOutputWithContext(ctx context.Context) MonthlyRecurrenceOutput {
	return o
}

func (o MonthlyRecurrenceOutput) DaysOfMonth() pulumi.IntArrayOutput {
	return o.ApplyT(func(v MonthlyRecurrence) []int { return v.DaysOfMonth }).(pulumi.IntArrayOutput)
}

func (o MonthlyRecurrenceOutput) EndTime() pulumi.StringPtrOutput {
	return o.ApplyT(func(v MonthlyRecurrence) *string { return v.EndTime }).(pulumi.StringPtrOutput)
}

func (o MonthlyRecurrenceOutput) RecurrenceType() pulumi.StringOutput {
	return o.ApplyT(func(v MonthlyRecurrence) string { return v.RecurrenceType }).(pulumi.StringOutput)
}

func (o MonthlyRecurrenceOutput) StartTime() pulumi.StringPtrOutput {
	return o.ApplyT(func(v MonthlyRecurrence) *string { return v.StartTime }).(pulumi.StringPtrOutput)
}

type MonthlyRecurrenceResponse struct {
	DaysOfMonth    []int   `pulumi:"daysOfMonth"`
	EndTime        *string `pulumi:"endTime"`
	RecurrenceType string  `pulumi:"recurrenceType"`
	StartTime      *string `pulumi:"startTime"`
}

type MonthlyRecurrenceResponseInput interface {
	pulumi.Input

	ToMonthlyRecurrenceResponseOutput() MonthlyRecurrenceResponseOutput
	ToMonthlyRecurrenceResponseOutputWithContext(context.Context) MonthlyRecurrenceResponseOutput
}

type MonthlyRecurrenceResponseArgs struct {
	DaysOfMonth    pulumi.IntArrayInput  `pulumi:"daysOfMonth"`
	EndTime        pulumi.StringPtrInput `pulumi:"endTime"`
	RecurrenceType pulumi.StringInput    `pulumi:"recurrenceType"`
	StartTime      pulumi.StringPtrInput `pulumi:"startTime"`
}

func (MonthlyRecurrenceResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*MonthlyRecurrenceResponse)(nil)).Elem()
}

func (i MonthlyRecurrenceResponseArgs) ToMonthlyRecurrenceResponseOutput() MonthlyRecurrenceResponseOutput {
	return i.ToMonthlyRecurrenceResponseOutputWithContext(context.Background())
}

func (i MonthlyRecurrenceResponseArgs) ToMonthlyRecurrenceResponseOutputWithContext(ctx context.Context) MonthlyRecurrenceResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(MonthlyRecurrenceResponseOutput)
}

type MonthlyRecurrenceResponseOutput struct{ *pulumi.OutputState }

func (MonthlyRecurrenceResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*MonthlyRecurrenceResponse)(nil)).Elem()
}

func (o MonthlyRecurrenceResponseOutput) ToMonthlyRecurrenceResponseOutput() MonthlyRecurrenceResponseOutput {
	return o
}

func (o MonthlyRecurrenceResponseOutput) ToMonthlyRecurrenceResponseOutputWithContext(ctx context.Context) MonthlyRecurrenceResponseOutput {
	return o
}

func (o MonthlyRecurrenceResponseOutput) DaysOfMonth() pulumi.IntArrayOutput {
	return o.ApplyT(func(v MonthlyRecurrenceResponse) []int { return v.DaysOfMonth }).(pulumi.IntArrayOutput)
}

func (o MonthlyRecurrenceResponseOutput) EndTime() pulumi.StringPtrOutput {
	return o.ApplyT(func(v MonthlyRecurrenceResponse) *string { return v.EndTime }).(pulumi.StringPtrOutput)
}

func (o MonthlyRecurrenceResponseOutput) RecurrenceType() pulumi.StringOutput {
	return o.ApplyT(func(v MonthlyRecurrenceResponse) string { return v.RecurrenceType }).(pulumi.StringOutput)
}

func (o MonthlyRecurrenceResponseOutput) StartTime() pulumi.StringPtrOutput {
	return o.ApplyT(func(v MonthlyRecurrenceResponse) *string { return v.StartTime }).(pulumi.StringPtrOutput)
}

type RemoveAllActionGroups struct {
	ActionType string `pulumi:"actionType"`
}

type RemoveAllActionGroupsInput interface {
	pulumi.Input

	ToRemoveAllActionGroupsOutput() RemoveAllActionGroupsOutput
	ToRemoveAllActionGroupsOutputWithContext(context.Context) RemoveAllActionGroupsOutput
}

type RemoveAllActionGroupsArgs struct {
	ActionType pulumi.StringInput `pulumi:"actionType"`
}

func (RemoveAllActionGroupsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RemoveAllActionGroups)(nil)).Elem()
}

func (i RemoveAllActionGroupsArgs) ToRemoveAllActionGroupsOutput() RemoveAllActionGroupsOutput {
	return i.ToRemoveAllActionGroupsOutputWithContext(context.Background())
}

func (i RemoveAllActionGroupsArgs) ToRemoveAllActionGroupsOutputWithContext(ctx context.Context) RemoveAllActionGroupsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RemoveAllActionGroupsOutput)
}

type RemoveAllActionGroupsOutput struct{ *pulumi.OutputState }

func (RemoveAllActionGroupsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RemoveAllActionGroups)(nil)).Elem()
}

func (o RemoveAllActionGroupsOutput) ToRemoveAllActionGroupsOutput() RemoveAllActionGroupsOutput {
	return o
}

func (o RemoveAllActionGroupsOutput) ToRemoveAllActionGroupsOutputWithContext(ctx context.Context) RemoveAllActionGroupsOutput {
	return o
}

func (o RemoveAllActionGroupsOutput) ActionType() pulumi.StringOutput {
	return o.ApplyT(func(v RemoveAllActionGroups) string { return v.ActionType }).(pulumi.StringOutput)
}

type RemoveAllActionGroupsResponse struct {
	ActionType string `pulumi:"actionType"`
}

type RemoveAllActionGroupsResponseInput interface {
	pulumi.Input

	ToRemoveAllActionGroupsResponseOutput() RemoveAllActionGroupsResponseOutput
	ToRemoveAllActionGroupsResponseOutputWithContext(context.Context) RemoveAllActionGroupsResponseOutput
}

type RemoveAllActionGroupsResponseArgs struct {
	ActionType pulumi.StringInput `pulumi:"actionType"`
}

func (RemoveAllActionGroupsResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RemoveAllActionGroupsResponse)(nil)).Elem()
}

func (i RemoveAllActionGroupsResponseArgs) ToRemoveAllActionGroupsResponseOutput() RemoveAllActionGroupsResponseOutput {
	return i.ToRemoveAllActionGroupsResponseOutputWithContext(context.Background())
}

func (i RemoveAllActionGroupsResponseArgs) ToRemoveAllActionGroupsResponseOutputWithContext(ctx context.Context) RemoveAllActionGroupsResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RemoveAllActionGroupsResponseOutput)
}

type RemoveAllActionGroupsResponseOutput struct{ *pulumi.OutputState }

func (RemoveAllActionGroupsResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RemoveAllActionGroupsResponse)(nil)).Elem()
}

func (o RemoveAllActionGroupsResponseOutput) ToRemoveAllActionGroupsResponseOutput() RemoveAllActionGroupsResponseOutput {
	return o
}

func (o RemoveAllActionGroupsResponseOutput) ToRemoveAllActionGroupsResponseOutputWithContext(ctx context.Context) RemoveAllActionGroupsResponseOutput {
	return o
}

func (o RemoveAllActionGroupsResponseOutput) ActionType() pulumi.StringOutput {
	return o.ApplyT(func(v RemoveAllActionGroupsResponse) string { return v.ActionType }).(pulumi.StringOutput)
}

type Schedule struct {
	EffectiveFrom  *string       `pulumi:"effectiveFrom"`
	EffectiveUntil *string       `pulumi:"effectiveUntil"`
	Recurrences    []interface{} `pulumi:"recurrences"`
	TimeZone       *string       `pulumi:"timeZone"`
}

type ScheduleInput interface {
	pulumi.Input

	ToScheduleOutput() ScheduleOutput
	ToScheduleOutputWithContext(context.Context) ScheduleOutput
}

type ScheduleArgs struct {
	EffectiveFrom  pulumi.StringPtrInput `pulumi:"effectiveFrom"`
	EffectiveUntil pulumi.StringPtrInput `pulumi:"effectiveUntil"`
	Recurrences    pulumi.ArrayInput     `pulumi:"recurrences"`
	TimeZone       pulumi.StringPtrInput `pulumi:"timeZone"`
}

func (ScheduleArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Schedule)(nil)).Elem()
}

func (i ScheduleArgs) ToScheduleOutput() ScheduleOutput {
	return i.ToScheduleOutputWithContext(context.Background())
}

func (i ScheduleArgs) ToScheduleOutputWithContext(ctx context.Context) ScheduleOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ScheduleOutput)
}

func (i ScheduleArgs) ToSchedulePtrOutput() SchedulePtrOutput {
	return i.ToSchedulePtrOutputWithContext(context.Background())
}

func (i ScheduleArgs) ToSchedulePtrOutputWithContext(ctx context.Context) SchedulePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ScheduleOutput).ToSchedulePtrOutputWithContext(ctx)
}

type SchedulePtrInput interface {
	pulumi.Input

	ToSchedulePtrOutput() SchedulePtrOutput
	ToSchedulePtrOutputWithContext(context.Context) SchedulePtrOutput
}

type schedulePtrType ScheduleArgs

func SchedulePtr(v *ScheduleArgs) SchedulePtrInput {
	return (*schedulePtrType)(v)
}

func (*schedulePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**Schedule)(nil)).Elem()
}

func (i *schedulePtrType) ToSchedulePtrOutput() SchedulePtrOutput {
	return i.ToSchedulePtrOutputWithContext(context.Background())
}

func (i *schedulePtrType) ToSchedulePtrOutputWithContext(ctx context.Context) SchedulePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SchedulePtrOutput)
}

type ScheduleOutput struct{ *pulumi.OutputState }

func (ScheduleOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Schedule)(nil)).Elem()
}

func (o ScheduleOutput) ToScheduleOutput() ScheduleOutput {
	return o
}

func (o ScheduleOutput) ToScheduleOutputWithContext(ctx context.Context) ScheduleOutput {
	return o
}

func (o ScheduleOutput) ToSchedulePtrOutput() SchedulePtrOutput {
	return o.ToSchedulePtrOutputWithContext(context.Background())
}

func (o ScheduleOutput) ToSchedulePtrOutputWithContext(ctx context.Context) SchedulePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v Schedule) *Schedule {
		return &v
	}).(SchedulePtrOutput)
}

func (o ScheduleOutput) EffectiveFrom() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Schedule) *string { return v.EffectiveFrom }).(pulumi.StringPtrOutput)
}

func (o ScheduleOutput) EffectiveUntil() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Schedule) *string { return v.EffectiveUntil }).(pulumi.StringPtrOutput)
}

func (o ScheduleOutput) Recurrences() pulumi.ArrayOutput {
	return o.ApplyT(func(v Schedule) []interface{} { return v.Recurrences }).(pulumi.ArrayOutput)
}

func (o ScheduleOutput) TimeZone() pulumi.StringPtrOutput {
	return o.ApplyT(func(v Schedule) *string { return v.TimeZone }).(pulumi.StringPtrOutput)
}

type SchedulePtrOutput struct{ *pulumi.OutputState }

func (SchedulePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**Schedule)(nil)).Elem()
}

func (o SchedulePtrOutput) ToSchedulePtrOutput() SchedulePtrOutput {
	return o
}

func (o SchedulePtrOutput) ToSchedulePtrOutputWithContext(ctx context.Context) SchedulePtrOutput {
	return o
}

func (o SchedulePtrOutput) Elem() ScheduleOutput {
	return o.ApplyT(func(v *Schedule) Schedule {
		if v != nil {
			return *v
		}
		var ret Schedule
		return ret
	}).(ScheduleOutput)
}

func (o SchedulePtrOutput) EffectiveFrom() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Schedule) *string {
		if v == nil {
			return nil
		}
		return v.EffectiveFrom
	}).(pulumi.StringPtrOutput)
}

func (o SchedulePtrOutput) EffectiveUntil() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Schedule) *string {
		if v == nil {
			return nil
		}
		return v.EffectiveUntil
	}).(pulumi.StringPtrOutput)
}

func (o SchedulePtrOutput) Recurrences() pulumi.ArrayOutput {
	return o.ApplyT(func(v *Schedule) []interface{} {
		if v == nil {
			return nil
		}
		return v.Recurrences
	}).(pulumi.ArrayOutput)
}

func (o SchedulePtrOutput) TimeZone() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *Schedule) *string {
		if v == nil {
			return nil
		}
		return v.TimeZone
	}).(pulumi.StringPtrOutput)
}

type ScheduleResponse struct {
	EffectiveFrom  *string       `pulumi:"effectiveFrom"`
	EffectiveUntil *string       `pulumi:"effectiveUntil"`
	Recurrences    []interface{} `pulumi:"recurrences"`
	TimeZone       *string       `pulumi:"timeZone"`
}

type ScheduleResponseInput interface {
	pulumi.Input

	ToScheduleResponseOutput() ScheduleResponseOutput
	ToScheduleResponseOutputWithContext(context.Context) ScheduleResponseOutput
}

type ScheduleResponseArgs struct {
	EffectiveFrom  pulumi.StringPtrInput `pulumi:"effectiveFrom"`
	EffectiveUntil pulumi.StringPtrInput `pulumi:"effectiveUntil"`
	Recurrences    pulumi.ArrayInput     `pulumi:"recurrences"`
	TimeZone       pulumi.StringPtrInput `pulumi:"timeZone"`
}

func (ScheduleResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ScheduleResponse)(nil)).Elem()
}

func (i ScheduleResponseArgs) ToScheduleResponseOutput() ScheduleResponseOutput {
	return i.ToScheduleResponseOutputWithContext(context.Background())
}

func (i ScheduleResponseArgs) ToScheduleResponseOutputWithContext(ctx context.Context) ScheduleResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ScheduleResponseOutput)
}

func (i ScheduleResponseArgs) ToScheduleResponsePtrOutput() ScheduleResponsePtrOutput {
	return i.ToScheduleResponsePtrOutputWithContext(context.Background())
}

func (i ScheduleResponseArgs) ToScheduleResponsePtrOutputWithContext(ctx context.Context) ScheduleResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ScheduleResponseOutput).ToScheduleResponsePtrOutputWithContext(ctx)
}

type ScheduleResponsePtrInput interface {
	pulumi.Input

	ToScheduleResponsePtrOutput() ScheduleResponsePtrOutput
	ToScheduleResponsePtrOutputWithContext(context.Context) ScheduleResponsePtrOutput
}

type scheduleResponsePtrType ScheduleResponseArgs

func ScheduleResponsePtr(v *ScheduleResponseArgs) ScheduleResponsePtrInput {
	return (*scheduleResponsePtrType)(v)
}

func (*scheduleResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ScheduleResponse)(nil)).Elem()
}

func (i *scheduleResponsePtrType) ToScheduleResponsePtrOutput() ScheduleResponsePtrOutput {
	return i.ToScheduleResponsePtrOutputWithContext(context.Background())
}

func (i *scheduleResponsePtrType) ToScheduleResponsePtrOutputWithContext(ctx context.Context) ScheduleResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ScheduleResponsePtrOutput)
}

type ScheduleResponseOutput struct{ *pulumi.OutputState }

func (ScheduleResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ScheduleResponse)(nil)).Elem()
}

func (o ScheduleResponseOutput) ToScheduleResponseOutput() ScheduleResponseOutput {
	return o
}

func (o ScheduleResponseOutput) ToScheduleResponseOutputWithContext(ctx context.Context) ScheduleResponseOutput {
	return o
}

func (o ScheduleResponseOutput) ToScheduleResponsePtrOutput() ScheduleResponsePtrOutput {
	return o.ToScheduleResponsePtrOutputWithContext(context.Background())
}

func (o ScheduleResponseOutput) ToScheduleResponsePtrOutputWithContext(ctx context.Context) ScheduleResponsePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ScheduleResponse) *ScheduleResponse {
		return &v
	}).(ScheduleResponsePtrOutput)
}

func (o ScheduleResponseOutput) EffectiveFrom() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ScheduleResponse) *string { return v.EffectiveFrom }).(pulumi.StringPtrOutput)
}

func (o ScheduleResponseOutput) EffectiveUntil() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ScheduleResponse) *string { return v.EffectiveUntil }).(pulumi.StringPtrOutput)
}

func (o ScheduleResponseOutput) Recurrences() pulumi.ArrayOutput {
	return o.ApplyT(func(v ScheduleResponse) []interface{} { return v.Recurrences }).(pulumi.ArrayOutput)
}

func (o ScheduleResponseOutput) TimeZone() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ScheduleResponse) *string { return v.TimeZone }).(pulumi.StringPtrOutput)
}

type ScheduleResponsePtrOutput struct{ *pulumi.OutputState }

func (ScheduleResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ScheduleResponse)(nil)).Elem()
}

func (o ScheduleResponsePtrOutput) ToScheduleResponsePtrOutput() ScheduleResponsePtrOutput {
	return o
}

func (o ScheduleResponsePtrOutput) ToScheduleResponsePtrOutputWithContext(ctx context.Context) ScheduleResponsePtrOutput {
	return o
}

func (o ScheduleResponsePtrOutput) Elem() ScheduleResponseOutput {
	return o.ApplyT(func(v *ScheduleResponse) ScheduleResponse {
		if v != nil {
			return *v
		}
		var ret ScheduleResponse
		return ret
	}).(ScheduleResponseOutput)
}

func (o ScheduleResponsePtrOutput) EffectiveFrom() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ScheduleResponse) *string {
		if v == nil {
			return nil
		}
		return v.EffectiveFrom
	}).(pulumi.StringPtrOutput)
}

func (o ScheduleResponsePtrOutput) EffectiveUntil() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ScheduleResponse) *string {
		if v == nil {
			return nil
		}
		return v.EffectiveUntil
	}).(pulumi.StringPtrOutput)
}

func (o ScheduleResponsePtrOutput) Recurrences() pulumi.ArrayOutput {
	return o.ApplyT(func(v *ScheduleResponse) []interface{} {
		if v == nil {
			return nil
		}
		return v.Recurrences
	}).(pulumi.ArrayOutput)
}

func (o ScheduleResponsePtrOutput) TimeZone() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ScheduleResponse) *string {
		if v == nil {
			return nil
		}
		return v.TimeZone
	}).(pulumi.StringPtrOutput)
}

type SystemDataResponse struct {
	CreatedAt          *string `pulumi:"createdAt"`
	CreatedBy          *string `pulumi:"createdBy"`
	CreatedByType      *string `pulumi:"createdByType"`
	LastModifiedAt     *string `pulumi:"lastModifiedAt"`
	LastModifiedBy     *string `pulumi:"lastModifiedBy"`
	LastModifiedByType *string `pulumi:"lastModifiedByType"`
}

type SystemDataResponseInput interface {
	pulumi.Input

	ToSystemDataResponseOutput() SystemDataResponseOutput
	ToSystemDataResponseOutputWithContext(context.Context) SystemDataResponseOutput
}

type SystemDataResponseArgs struct {
	CreatedAt          pulumi.StringPtrInput `pulumi:"createdAt"`
	CreatedBy          pulumi.StringPtrInput `pulumi:"createdBy"`
	CreatedByType      pulumi.StringPtrInput `pulumi:"createdByType"`
	LastModifiedAt     pulumi.StringPtrInput `pulumi:"lastModifiedAt"`
	LastModifiedBy     pulumi.StringPtrInput `pulumi:"lastModifiedBy"`
	LastModifiedByType pulumi.StringPtrInput `pulumi:"lastModifiedByType"`
}

func (SystemDataResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*SystemDataResponse)(nil)).Elem()
}

func (i SystemDataResponseArgs) ToSystemDataResponseOutput() SystemDataResponseOutput {
	return i.ToSystemDataResponseOutputWithContext(context.Background())
}

func (i SystemDataResponseArgs) ToSystemDataResponseOutputWithContext(ctx context.Context) SystemDataResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SystemDataResponseOutput)
}

func (i SystemDataResponseArgs) ToSystemDataResponsePtrOutput() SystemDataResponsePtrOutput {
	return i.ToSystemDataResponsePtrOutputWithContext(context.Background())
}

func (i SystemDataResponseArgs) ToSystemDataResponsePtrOutputWithContext(ctx context.Context) SystemDataResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SystemDataResponseOutput).ToSystemDataResponsePtrOutputWithContext(ctx)
}

type SystemDataResponsePtrInput interface {
	pulumi.Input

	ToSystemDataResponsePtrOutput() SystemDataResponsePtrOutput
	ToSystemDataResponsePtrOutputWithContext(context.Context) SystemDataResponsePtrOutput
}

type systemDataResponsePtrType SystemDataResponseArgs

func SystemDataResponsePtr(v *SystemDataResponseArgs) SystemDataResponsePtrInput {
	return (*systemDataResponsePtrType)(v)
}

func (*systemDataResponsePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**SystemDataResponse)(nil)).Elem()
}

func (i *systemDataResponsePtrType) ToSystemDataResponsePtrOutput() SystemDataResponsePtrOutput {
	return i.ToSystemDataResponsePtrOutputWithContext(context.Background())
}

func (i *systemDataResponsePtrType) ToSystemDataResponsePtrOutputWithContext(ctx context.Context) SystemDataResponsePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SystemDataResponsePtrOutput)
}

type SystemDataResponseOutput struct{ *pulumi.OutputState }

func (SystemDataResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SystemDataResponse)(nil)).Elem()
}

func (o SystemDataResponseOutput) ToSystemDataResponseOutput() SystemDataResponseOutput {
	return o
}

func (o SystemDataResponseOutput) ToSystemDataResponseOutputWithContext(ctx context.Context) SystemDataResponseOutput {
	return o
}

func (o SystemDataResponseOutput) ToSystemDataResponsePtrOutput() SystemDataResponsePtrOutput {
	return o.ToSystemDataResponsePtrOutputWithContext(context.Background())
}

func (o SystemDataResponseOutput) ToSystemDataResponsePtrOutputWithContext(ctx context.Context) SystemDataResponsePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v SystemDataResponse) *SystemDataResponse {
		return &v
	}).(SystemDataResponsePtrOutput)
}

func (o SystemDataResponseOutput) CreatedAt() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SystemDataResponse) *string { return v.CreatedAt }).(pulumi.StringPtrOutput)
}

func (o SystemDataResponseOutput) CreatedBy() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SystemDataResponse) *string { return v.CreatedBy }).(pulumi.StringPtrOutput)
}

func (o SystemDataResponseOutput) CreatedByType() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SystemDataResponse) *string { return v.CreatedByType }).(pulumi.StringPtrOutput)
}

func (o SystemDataResponseOutput) LastModifiedAt() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SystemDataResponse) *string { return v.LastModifiedAt }).(pulumi.StringPtrOutput)
}

func (o SystemDataResponseOutput) LastModifiedBy() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SystemDataResponse) *string { return v.LastModifiedBy }).(pulumi.StringPtrOutput)
}

func (o SystemDataResponseOutput) LastModifiedByType() pulumi.StringPtrOutput {
	return o.ApplyT(func(v SystemDataResponse) *string { return v.LastModifiedByType }).(pulumi.StringPtrOutput)
}

type SystemDataResponsePtrOutput struct{ *pulumi.OutputState }

func (SystemDataResponsePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**SystemDataResponse)(nil)).Elem()
}

func (o SystemDataResponsePtrOutput) ToSystemDataResponsePtrOutput() SystemDataResponsePtrOutput {
	return o
}

func (o SystemDataResponsePtrOutput) ToSystemDataResponsePtrOutputWithContext(ctx context.Context) SystemDataResponsePtrOutput {
	return o
}

func (o SystemDataResponsePtrOutput) Elem() SystemDataResponseOutput {
	return o.ApplyT(func(v *SystemDataResponse) SystemDataResponse {
		if v != nil {
			return *v
		}
		var ret SystemDataResponse
		return ret
	}).(SystemDataResponseOutput)
}

func (o SystemDataResponsePtrOutput) CreatedAt() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *SystemDataResponse) *string {
		if v == nil {
			return nil
		}
		return v.CreatedAt
	}).(pulumi.StringPtrOutput)
}

func (o SystemDataResponsePtrOutput) CreatedBy() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *SystemDataResponse) *string {
		if v == nil {
			return nil
		}
		return v.CreatedBy
	}).(pulumi.StringPtrOutput)
}

func (o SystemDataResponsePtrOutput) CreatedByType() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *SystemDataResponse) *string {
		if v == nil {
			return nil
		}
		return v.CreatedByType
	}).(pulumi.StringPtrOutput)
}

func (o SystemDataResponsePtrOutput) LastModifiedAt() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *SystemDataResponse) *string {
		if v == nil {
			return nil
		}
		return v.LastModifiedAt
	}).(pulumi.StringPtrOutput)
}

func (o SystemDataResponsePtrOutput) LastModifiedBy() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *SystemDataResponse) *string {
		if v == nil {
			return nil
		}
		return v.LastModifiedBy
	}).(pulumi.StringPtrOutput)
}

func (o SystemDataResponsePtrOutput) LastModifiedByType() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *SystemDataResponse) *string {
		if v == nil {
			return nil
		}
		return v.LastModifiedByType
	}).(pulumi.StringPtrOutput)
}

type WeeklyRecurrence struct {
	DaysOfWeek     []string `pulumi:"daysOfWeek"`
	EndTime        *string  `pulumi:"endTime"`
	RecurrenceType string   `pulumi:"recurrenceType"`
	StartTime      *string  `pulumi:"startTime"`
}

type WeeklyRecurrenceInput interface {
	pulumi.Input

	ToWeeklyRecurrenceOutput() WeeklyRecurrenceOutput
	ToWeeklyRecurrenceOutputWithContext(context.Context) WeeklyRecurrenceOutput
}

type WeeklyRecurrenceArgs struct {
	DaysOfWeek     pulumi.StringArrayInput `pulumi:"daysOfWeek"`
	EndTime        pulumi.StringPtrInput   `pulumi:"endTime"`
	RecurrenceType pulumi.StringInput      `pulumi:"recurrenceType"`
	StartTime      pulumi.StringPtrInput   `pulumi:"startTime"`
}

func (WeeklyRecurrenceArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*WeeklyRecurrence)(nil)).Elem()
}

func (i WeeklyRecurrenceArgs) ToWeeklyRecurrenceOutput() WeeklyRecurrenceOutput {
	return i.ToWeeklyRecurrenceOutputWithContext(context.Background())
}

func (i WeeklyRecurrenceArgs) ToWeeklyRecurrenceOutputWithContext(ctx context.Context) WeeklyRecurrenceOutput {
	return pulumi.ToOutputWithContext(ctx, i).(WeeklyRecurrenceOutput)
}

type WeeklyRecurrenceOutput struct{ *pulumi.OutputState }

func (WeeklyRecurrenceOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*WeeklyRecurrence)(nil)).Elem()
}

func (o WeeklyRecurrenceOutput) ToWeeklyRecurrenceOutput() WeeklyRecurrenceOutput {
	return o
}

func (o WeeklyRecurrenceOutput) ToWeeklyRecurrenceOutputWithContext(ctx context.Context) WeeklyRecurrenceOutput {
	return o
}

func (o WeeklyRecurrenceOutput) DaysOfWeek() pulumi.StringArrayOutput {
	return o.ApplyT(func(v WeeklyRecurrence) []string { return v.DaysOfWeek }).(pulumi.StringArrayOutput)
}

func (o WeeklyRecurrenceOutput) EndTime() pulumi.StringPtrOutput {
	return o.ApplyT(func(v WeeklyRecurrence) *string { return v.EndTime }).(pulumi.StringPtrOutput)
}

func (o WeeklyRecurrenceOutput) RecurrenceType() pulumi.StringOutput {
	return o.ApplyT(func(v WeeklyRecurrence) string { return v.RecurrenceType }).(pulumi.StringOutput)
}

func (o WeeklyRecurrenceOutput) StartTime() pulumi.StringPtrOutput {
	return o.ApplyT(func(v WeeklyRecurrence) *string { return v.StartTime }).(pulumi.StringPtrOutput)
}

type WeeklyRecurrenceResponse struct {
	DaysOfWeek     []string `pulumi:"daysOfWeek"`
	EndTime        *string  `pulumi:"endTime"`
	RecurrenceType string   `pulumi:"recurrenceType"`
	StartTime      *string  `pulumi:"startTime"`
}

type WeeklyRecurrenceResponseInput interface {
	pulumi.Input

	ToWeeklyRecurrenceResponseOutput() WeeklyRecurrenceResponseOutput
	ToWeeklyRecurrenceResponseOutputWithContext(context.Context) WeeklyRecurrenceResponseOutput
}

type WeeklyRecurrenceResponseArgs struct {
	DaysOfWeek     pulumi.StringArrayInput `pulumi:"daysOfWeek"`
	EndTime        pulumi.StringPtrInput   `pulumi:"endTime"`
	RecurrenceType pulumi.StringInput      `pulumi:"recurrenceType"`
	StartTime      pulumi.StringPtrInput   `pulumi:"startTime"`
}

func (WeeklyRecurrenceResponseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*WeeklyRecurrenceResponse)(nil)).Elem()
}

func (i WeeklyRecurrenceResponseArgs) ToWeeklyRecurrenceResponseOutput() WeeklyRecurrenceResponseOutput {
	return i.ToWeeklyRecurrenceResponseOutputWithContext(context.Background())
}

func (i WeeklyRecurrenceResponseArgs) ToWeeklyRecurrenceResponseOutputWithContext(ctx context.Context) WeeklyRecurrenceResponseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(WeeklyRecurrenceResponseOutput)
}

type WeeklyRecurrenceResponseOutput struct{ *pulumi.OutputState }

func (WeeklyRecurrenceResponseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*WeeklyRecurrenceResponse)(nil)).Elem()
}

func (o WeeklyRecurrenceResponseOutput) ToWeeklyRecurrenceResponseOutput() WeeklyRecurrenceResponseOutput {
	return o
}

func (o WeeklyRecurrenceResponseOutput) ToWeeklyRecurrenceResponseOutputWithContext(ctx context.Context) WeeklyRecurrenceResponseOutput {
	return o
}

func (o WeeklyRecurrenceResponseOutput) DaysOfWeek() pulumi.StringArrayOutput {
	return o.ApplyT(func(v WeeklyRecurrenceResponse) []string { return v.DaysOfWeek }).(pulumi.StringArrayOutput)
}

func (o WeeklyRecurrenceResponseOutput) EndTime() pulumi.StringPtrOutput {
	return o.ApplyT(func(v WeeklyRecurrenceResponse) *string { return v.EndTime }).(pulumi.StringPtrOutput)
}

func (o WeeklyRecurrenceResponseOutput) RecurrenceType() pulumi.StringOutput {
	return o.ApplyT(func(v WeeklyRecurrenceResponse) string { return v.RecurrenceType }).(pulumi.StringOutput)
}

func (o WeeklyRecurrenceResponseOutput) StartTime() pulumi.StringPtrOutput {
	return o.ApplyT(func(v WeeklyRecurrenceResponse) *string { return v.StartTime }).(pulumi.StringPtrOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*ActionRulePropertiesInput)(nil)).Elem(), ActionRulePropertiesArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ActionRulePropertiesPtrInput)(nil)).Elem(), ActionRulePropertiesArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ActionRulePropertiesResponseInput)(nil)).Elem(), ActionRulePropertiesResponseArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ActionRulePropertiesResponsePtrInput)(nil)).Elem(), ActionRulePropertiesResponseArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AddActionGroupsInput)(nil)).Elem(), AddActionGroupsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AddActionGroupsResponseInput)(nil)).Elem(), AddActionGroupsResponseArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ConditionInput)(nil)).Elem(), ConditionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ConditionArrayInput)(nil)).Elem(), ConditionArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ConditionResponseInput)(nil)).Elem(), ConditionResponseArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ConditionResponseArrayInput)(nil)).Elem(), ConditionResponseArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*DailyRecurrenceInput)(nil)).Elem(), DailyRecurrenceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DailyRecurrenceResponseInput)(nil)).Elem(), DailyRecurrenceResponseArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*MonthlyRecurrenceInput)(nil)).Elem(), MonthlyRecurrenceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*MonthlyRecurrenceResponseInput)(nil)).Elem(), MonthlyRecurrenceResponseArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RemoveAllActionGroupsInput)(nil)).Elem(), RemoveAllActionGroupsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RemoveAllActionGroupsResponseInput)(nil)).Elem(), RemoveAllActionGroupsResponseArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ScheduleInput)(nil)).Elem(), ScheduleArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*SchedulePtrInput)(nil)).Elem(), ScheduleArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ScheduleResponseInput)(nil)).Elem(), ScheduleResponseArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ScheduleResponsePtrInput)(nil)).Elem(), ScheduleResponseArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*SystemDataResponseInput)(nil)).Elem(), SystemDataResponseArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*SystemDataResponsePtrInput)(nil)).Elem(), SystemDataResponseArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*WeeklyRecurrenceInput)(nil)).Elem(), WeeklyRecurrenceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*WeeklyRecurrenceResponseInput)(nil)).Elem(), WeeklyRecurrenceResponseArgs{})
	pulumi.RegisterOutputType(ActionRulePropertiesOutput{})
	pulumi.RegisterOutputType(ActionRulePropertiesPtrOutput{})
	pulumi.RegisterOutputType(ActionRulePropertiesResponseOutput{})
	pulumi.RegisterOutputType(ActionRulePropertiesResponsePtrOutput{})
	pulumi.RegisterOutputType(AddActionGroupsOutput{})
	pulumi.RegisterOutputType(AddActionGroupsResponseOutput{})
	pulumi.RegisterOutputType(ConditionOutput{})
	pulumi.RegisterOutputType(ConditionArrayOutput{})
	pulumi.RegisterOutputType(ConditionResponseOutput{})
	pulumi.RegisterOutputType(ConditionResponseArrayOutput{})
	pulumi.RegisterOutputType(DailyRecurrenceOutput{})
	pulumi.RegisterOutputType(DailyRecurrenceResponseOutput{})
	pulumi.RegisterOutputType(MonthlyRecurrenceOutput{})
	pulumi.RegisterOutputType(MonthlyRecurrenceResponseOutput{})
	pulumi.RegisterOutputType(RemoveAllActionGroupsOutput{})
	pulumi.RegisterOutputType(RemoveAllActionGroupsResponseOutput{})
	pulumi.RegisterOutputType(ScheduleOutput{})
	pulumi.RegisterOutputType(SchedulePtrOutput{})
	pulumi.RegisterOutputType(ScheduleResponseOutput{})
	pulumi.RegisterOutputType(ScheduleResponsePtrOutput{})
	pulumi.RegisterOutputType(SystemDataResponseOutput{})
	pulumi.RegisterOutputType(SystemDataResponsePtrOutput{})
	pulumi.RegisterOutputType(WeeklyRecurrenceOutput{})
	pulumi.RegisterOutputType(WeeklyRecurrenceResponseOutput{})
}


text:
@article{pmid28430902,
 author = {Niiranen, T. J.  and McCabe, E. L.  and Larson, M. G.  and Henglin, M.  and Lakdawala, N. K.  and Vasan, R. S.  and Cheng, S. },
 journal = {Eur. Heart J.},
 keywords = {intarticle},
 month = {Aug},
 number = {29},
 pages = {2300--2308},
 title = {Risk for hypertension crosses generations in the community: a multi-generational cohort study},
 volume = {38},
 year = {2017}
}

repository: hypertensioncenter/academic-kickstart

repo_name: hypertensioncenter/academic-kickstart

gha_language: TeX


text:
DESCRIPTION = "GPE frontend for libfsi-client"
LICENSE = "gpl"

inherit gpe

SRC_URI = "http://dominion.kabel.utwente.nl/koen/pda/files/gpe-fsi.tar.bz2"
PR = "r1"

DEPENDS = "libgpewidget fsi-client gtk+"
SECTION = "gpe"

S ="${WORKDIR}/gpe-fsi"

do_compile() {
        oe_runmake all
}

do_install() {
        install -d ${D}${bindir}
        install -d ${D}${libdir}
	install -d ${D}/usr/share/applications
	install -d ${D}/usr/share/pixmaps/
	install gpe-fsi ${D}${bindir}
	install gpe-fsi.desktop ${D}/usr/share/applications/
	install gpe-fsi.png ${D}/usr/share/pixmaps/
}

SRC_URI[md5sum] = "e485b0c8424dc9666078d482d22447da"
SRC_URI[sha256sum] = "6a7455e4a066d5ecd9520feb9cd7bb1a7ecfe267faef32cd04a97b5c1738f8ec"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
@article{Moncrieff2015-zn,
 abstract = {The distribution of South African biomes is expected to be
drastically altered as a result of climatic change and increasing
atmospheric CO2 in the 21st century. Developing the capacity to
anticipate change is of critical importance if we are to mitigate
and efficiently adapt to the reorganization of South African
vegetation cover. Dynamic Vegetation Models (DVMs) simulate the
distribution and functioning of plant functional types (PFTs) and
their interactions. Outputs include biome distribution maps,
assessments of carbon cycling and the quantification of plant
productivity, all of which can be produced for past, present and
future conditions. DVMs were originally conceived of as analogs
to general circulation models (GCMs) and applied globally, but to
be unbiased globally necessitates choosing parameters and
representing processes that may not be regionally appropriate.
Models populated with a modified suite of PFTs and parameterized
appropriately for local conditions are better suited to studies
concerned with vegetation dynamics and global change impacts at
the country or continent-scale. In their current form DGVMs do
not include the plant types and key processes of many South
African biomes. Therefore, while projections of global change
impacts are available for biomes dominated by forest trees,
savanna trees and grasses, little can be learned about some of
our most biodiverse and threatened biomes, particularly the
Fynbos and Thicket biomes, and the Succulent Karoo. We outline
the limitations of existing DVMs and improvements required before
reliable projections of global change impacts on South African
biomes can be produced. Reparameterization of some PFTs and fire
models could easily be achieved, and would lead to large
improvements in model simulations. However, there remain numerous
processes and facets of the ecology of South African vegetation
that will limit the applicability of DVMs in their current form.},
 author = {Moncrieff, G R and Scheiter, S and Slingsby, J A and Higgins, S I},
 journal = {S. Afr. J. Bot.},
 keywords = {Biome; Dynamic Global Vegetation Model (DGVM); Dynamic Vegetation
Model (DVM); Plant functional type (PFT); CO; Fynbos; Global
change},
 month = {November},
 pages = {16--23},
 title = {Understanding global change impacts on South African biomes using
Dynamic Vegetation Models},
 volume = {101},
 year = {2015}
}

repository: SAEON/academic-kickstart

repo_name: SAEON/academic-kickstart


text:
@article{aumann1995a,
  title = {BACKWARD INDUCTION AND COMMON KNOWLEDGE OF RATIONALITY},
  language = {eng},
  publisher = {ACADEMIC PRESS INC JNL-COMP SUBSCRIPTIONS},
  journal = {Games and Economic Behavior},
  volume = {8},
  number = {1},
  pages = {6-19},
  year = {1995},
  issn = {10902473, 08998256},
  abstract = {We formulate precisely and prove the proposition that if common knowledge of rationality obtains in a game of perfect information, then the backward induction outcome is reached.  (C) 1995 Academic Press, Inc.},
  doi = {10.1016/S0899-8256(05)80015-6},
  author = {Aumann, Robert J.}
}

@article{benthem2001a,
  title = {Games in Dynamic-Epistemic Logic},
  language = {und},
  publisher = {Blackwell Publishers},
  journal = {Bulletin of Economic Research},
  volume = {53},
  number = {4},
  pages = {219-248},
  year = {2001},
  issn = {14678586, 03073378},
  abstract = {The author discusses games of both perfect and imperfect information at two levels of structural detail: players’ local actions, and their global powers for determining outcomes of the game. Matching logical languages are proposed for both. In particular, at the ‘action level’, imperfect information games naturally model a combined ‘dynamic-epistemic language’ – and correspondences are found between special axioms in this language and particular modes of playing games with their information dynamics. At the ‘outcome level’, the paper presents suitable notions of game equivalence, and some simple representation results.},
  author = {van Benthem, J.}
}

@book{fagin1995a,
  title = {Reasoning about knowledge},
  language = {eng},
  publisher = {MIT Press,},
  pages = {13+477 s.},
  year = {1995},
  isbn = {0262061627},
  author = {Fagin, R. and Halpern, J.Y. and Moses, Y. and Vardi, M.Y.}
}

@incollection{ferguson1991,
  doi = {10.1007/978-94-011-3760-7_3},
  url = {http://dx.doi.org/10.1007/978-94-011-3760-7_3},
  year  = {1991},
  publisher = {Springer Nature},
  pages = {15--28},
  author = {Christopher P. Ferguson and Thomas S. Ferguson},
  title = {Models for the Game of Liar's Dice},
  booktitle = {Theory and Decision Library}
}

repository: Andefar/LiarsDice

repo_name: Andefar/LiarsDice


text:
DESCRIPTION = "HP Linux Imaging and Printing"
LICENSE = "GPL, MIT, BSD"

# currently, we build a stripped down version that only includes IJS
# and components required to implement a minimal printing system
# for embedded systems.

SRC_URI = "${SOURCEFORGE_MIRROR}/${PN}/${PN}-${PV}.tar.gz \
	"

PR = "r1"
DEFAULT_PREFERENCE = "-1"

inherit autotools

EXTRA_OECONF = ' \
                BUILD_SYS="" HOST_SYS="" \
		--enable-hpijs-install \
                --disable-network-build \
                --disable-doc-build \
                --disable-pp-build \
                --disable-scan-build \
                --disable-gui-build \
                --disable-fax-build \
                --disable-dbus-build \
                --disable-foomatic-drv-install \
                --disable-foomatic-rip-hplip-install \
               '

# needed by python checks in configure
EXTRA_OEMAKE = 'BUILD_SYS="" HOST_SYS=""'

PACKAGES += "${PN}-ppd ${PN}-cups ${PN}-backend ${PN}-filter"
RDEPENDS_${PN} += "python-syslog python-pprint python-compression python-shell python-xml python-unixadmin python-html python-resource python-terminal"

# need to snag the debug file or OE will fail on backend package
FILES_${PN}-dbg += "\
     ${libdir}/cups/backend/.debug \
     ${libdir}/python2.6/site-packages/.debug \
     ${libdir}/cups/filter/.debug "

FILES_${PN}-ppd = "\
     ${datadir}/ppd"

FILES_${PN}-cups = "\
     ${datadir}/cups"

FILES_${PN}-backend = "\
     ${libdir}/cups/backend"

FILES_${PN}-filter = "\
     ${libdir}/cups/filter"

FILES_${PN} += "\
     ${libdir}/python2.6/site-packages/*.so"

SRC_URI[md5sum] = "96c36e3baf35e93cf9436a772f0c9ef4"
SRC_URI[sha256sum] = "3ee0e68a613d2b966dcb6df9fd8e074c4c3e590249e61c0d792de3373b84fdeb"


text:
DESCRIPTION = "Date and time manipulation routines."
SECTION = "libs"
LICENSE = "Artistic|GPLv1+"
PR = "r3"

RDEPENDS_${PN} = "perl-module-test-more \
            perl-module-io-file \
            perl-module-carp"

SRC_URI = "http://search.cpan.org/CPAN/authors/id/S/SB/SBECK/Date-Manip-${PV}.tar.gz"

S = "${WORKDIR}/Date-Manip-${PV}"

inherit cpan

BBCLASSEXTEND="native"

SRC_URI[md5sum] = "16c343329bad644b17f4f8ec5fb243cf"
SRC_URI[sha256sum] = "b61f4f0e3e580723ca7f5c0e1952922c101875535bff04afd772fbd3f193e22a"


text:
@article{melymcb-0190,
 author = {Scalise, O.H. and Gianotti, R.D. and Zarragoicoechea, G.J. and Rodríguez, A.E.},
 document_type = {Article},
 doi = {10.1063/1.456807},
 journal = {The Journal of Chemical Physics},
 note = {cited By 3},
 number = {7},
 pages = {4273-4277},
 source = {Scopus},
 title = {Azeotropic states in the CO<inf>2</inf>-C<inf>2</inf>H<inf>6</inf> mixture from the hard sphere Lennard-Jones quadrupolar molecular model},
 url = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-36549092089&doi=10.1063%2f1.456807&partnerID=40&md5=6c6e65f1f476c82a3880aef8d463be9d},
 volume = {91},
 year = {1989}
}


text:
# Copyright (C) 2020 Cliff Brake <cbrake@bec-systems.com>
# Released under the MIT license (see COPYING.MIT for the terms)

SUMMARY = "Simple IOT Framework application"
HOMEPAGE = "http://simpleiot.org"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://LICENSE;md5=3b83ef96387f14655fc854ddc3c6bd57"
SECTION = "apps"

DEPENDS = "go-native elm-binary-native nodejs-native"

inherit systemd update-rc.d goarch

SRCREV = "001d31df13c6a36ba9beca199c9c30a83f24ef0c"
PV = "0.0.34+git${SRCPV}"

BRANCH ?= "master"

SRC_URI = "git://github.com/simpleiot/simpleiot;branch=${BRANCH} \
           "
S = "${WORKDIR}/git"

GOPATH = "${TMPDIR}/work-shared/go"

CGO_ENABLED:x86-64 = "0"
export CGO_ENABLED

INITSCRIPT_NAME = "siot"
INITSCRIPT_PARAMS = "start 99 5 . stop 20 6 ."

do_configure() {
    export GOPATH=${GOPATH}
    export GOFLAGS="-modcacherw"
    go install github.com/benbjohnson/genesis/...
}

do_compile() {
    export GOPATH=${GOPATH}
    export GOARCH=${TARGET_GOARCH}
    export PATH=${GOPATH}/bin:$PATH
    export GOFLAGS="-modcacherw"
    . ${S}/envsetup.sh
    # FIXME: get elm cache in ~/.elm moved to work-shared
    rm -rf frontend/elm-stuff
    siot_setup
    siot_build
}

do_install() {
    install -D -m 0755 ${S}/siot ${D}${bindir}/siot
    if ${@bb.utils.contains('DISTRO_FEATURES', 'systemd', 'true', 'false', d)}; then
        install -D -m 0644 ${S}/contrib/siot.service ${D}${systemd_unitdir}/system/siot.service
    else
        install -D -m 0755 ${S}/contrib/siot.init ${D}${sysconfdir}/init.d/siot
    fi
}

SYSTEMD_SERVICE:${PN} = "siot.service"

INSANE_SKIP:${PN} += "ldflags already-stripped"