import React from 'react';
import {render} from 'react-dom';
import InfiniteCalendar from 'react-infinite-calendar';
import 'react-infinite-calendar/styles.css';

const locale = {
  blank: 'Aucune date sélectionnée',
  headerFormat: 'dddd, D MMM',
  locale: require('date-fns/locale/fr'), // You need to pass in the date-fns locale for the language you want (unless it's EN)
  todayLabel: {
    long: "Aujourd'hui",
    short: 'Auj.',
  },
  weekdays: ['Dim', 'Lun', 'Mar', 'Mer', 'Jeu', 'Ven', 'Sam'],
  weekStartsOn: 1, // Start the week on Monday
};

// All props are optional, so this is the minimum setup you need
render(<InfiniteCalendar locale={locale} />, document.querySelector('#root'));

{'repo_name': 'clauderic/react-infinite-calendar', 'stars': '3607', 'repo_language': 'JavaScript', 'file_name': 'config.js', 'mime_type': 'text/x-java', 'hash': -6556190187916037164, 'source_dataset': 'data'}


.headroom {
    will-change: transform;
    background-color: inherit;
    @include transition($transition-base);
}
.headroom--pinned {
	@extend .position-fixed;
    transform: translateY(0%);
}
.headroom--unpinned {
	@extend .position-fixed;
    transform: translateY(-100%);
}

.headroom--not-top {
	padding-top: .5rem;
	padding-bottom: .5rem;
    background-color: theme-color("default") !important;
    box-shadow: 0 1px 10px rgba(130, 130, 134, 0.1);
}

{'repo_name': 'creativetimofficial/argon-design-system-react', 'stars': '282', 'repo_language': 'CSS', 'file_name': 'index.html', 'mime_type': 'text/html', 'hash': -7052734058072204486, 'source_dataset': 'data'}


import argparse
import os
import os.path as osp
import re
import sys
from multiprocessing import Pool

import cv2
import lmdb
import mmcv
import numpy as np

def main_extract_subimages(args):
    """A multi-thread tool to crop large images to sub-images for faster IO.

    It is used for DIV2K dataset.

    opt (dict): Configuration dict. It contains:
        n_thread (int): Thread number.
        compression_level (int):  CV_IMWRITE_PNG_COMPRESSION from 0 to 9.
            A higher value means a smaller size and longer compression time.
            Use 0 for faster CPU decompression. Default: 3, same in cv2.

        input_folder (str): Path to the input folder.
        save_folder (str): Path to save folder.
        crop_size (int): Crop size.
        step (int): Step for overlapped sliding window.
        thresh_size (int): Threshold size. Patches whose size is lower
            than thresh_size will be dropped.

    Usage:
        For each folder, run this script.
        Typically, there are four folders to be processed for DIV2K dataset.
            DIV2K_train_HR
            DIV2K_train_LR_bicubic/X2
            DIV2K_train_LR_bicubic/X3
            DIV2K_train_LR_bicubic/X4
        After process, each sub_folder should have the same number of
        subimages.
        Remember to modify opt configurations according to your settings.
    """

    opt = {}
    opt['n_thread'] = args.n_thread
    opt['compression_level'] = args.compression_level

    # HR images
    opt['input_folder'] = osp.join(args.data_root, 'DIV2K_train_HR')
    opt['save_folder'] = osp.join(args.data_root, 'DIV2K_train_HR_sub')
    opt['crop_size'] = args.crop_size
    opt['step'] = args.step
    opt['thresh_size'] = args.thresh_size
    extract_subimages(opt)

    for scale in [2, 3, 4]:
        opt['input_folder'] = osp.join(args.data_root,
                                       f'DIV2K_train_LR_bicubic/X{scale}')
        opt['save_folder'] = osp.join(args.data_root,
                                      f'DIV2K_train_LR_bicubic/X{scale}_sub')
        opt['crop_size'] = args.crop_size // scale
        opt['step'] = args.step // scale
        opt['thresh_size'] = args.thresh_size // scale
        extract_subimages(opt)

def extract_subimages(opt):
    """Crop images to subimages.

    Args:
        opt (dict): Configuration dict. It contains:
            input_folder (str): Path to the input folder.
            save_folder (str): Path to save folder.
            n_thread (int): Thread number.
    """
    input_folder = opt['input_folder']
    save_folder = opt['save_folder']
    if not osp.exists(save_folder):
        os.makedirs(save_folder)
        print(f'mkdir {save_folder} ...')
    else:
        print(f'Folder {save_folder} already exists. Exit.')
        sys.exit(1)

    img_list = list(mmcv.scandir(input_folder))
    img_list = [osp.join(input_folder, v) for v in img_list]

    prog_bar = mmcv.ProgressBar(len(img_list))
    pool = Pool(opt['n_thread'])
    for path in img_list:
        pool.apply_async(
            worker, args=(path, opt), callback=lambda arg: prog_bar.update())
    pool.close()
    pool.join()
    print('All processes done.')

def worker(path, opt):
    """Worker for each process.

    Args:
        path (str): Image path.
        opt (dict): Configuration dict. It contains:
            crop_size (int): Crop size.
            step (int): Step for overlapped sliding window.
            thresh_size (int): Threshold size. Patches whose size is smaller
                than thresh_size will be dropped.
            save_folder (str): Path to save folder.
            compression_level (int): for cv2.IMWRITE_PNG_COMPRESSION.

    Returns:
        process_info (str): Process information displayed in progress bar.
    """
    crop_size = opt['crop_size']
    step = opt['step']
    thresh_size = opt['thresh_size']
    img_name, extension = osp.splitext(osp.basename(path))

    # remove the x2, x3, x4 and x8 in the filename for DIV2K
    img_name = re.sub('x[2348]', '', img_name)

    img = mmcv.imread(path, flag='unchanged')

    if img.ndim == 2 or img.ndim == 3:
        h, w = img.shape[:2]
    else:
        raise ValueError(f'Image ndim should be 2 or 3, but got {img.ndim}')

    h_space = np.arange(0, h - crop_size + 1, step)
    if h - (h_space[-1] + crop_size) > thresh_size:
        h_space = np.append(h_space, h - crop_size)
    w_space = np.arange(0, w - crop_size + 1, step)
    if w - (w_space[-1] + crop_size) > thresh_size:
        w_space = np.append(w_space, w - crop_size)

    index = 0
    for x in h_space:
        for y in w_space:
            index += 1
            cropped_img = img[x:x + crop_size, y:y + crop_size, ...]
            cv2.imwrite(
                osp.join(opt['save_folder'],
                         f'{img_name}_s{index:03d}{extension}'), cropped_img,
                [cv2.IMWRITE_PNG_COMPRESSION, opt['compression_level']])
    process_info = f'Processing {img_name} ...'
    return process_info

def make_lmdb_for_div2k(data_root):
    """Create lmdb files for DIV2K dataset.

    Args:
        data_root (str): Data root path.

    Usage:
        Typically, there are four folders to be processed for DIV2K dataset.
            DIV2K_train_HR_sub
            DIV2K_train_LR_bicubic/X2_sub
            DIV2K_train_LR_bicubic/X3_sub
            DIV2K_train_LR_bicubic/X4_sub
        Remember to modify opt configurations according to your settings.
    """

    folder_paths = [
        osp.join(data_root, 'DIV2K_train_HR_sub'),
        osp.join(data_root, 'DIV2K_train_LR_bicubic/X2_sub'),
        osp.join(data_root, 'DIV2K_train_LR_bicubic/X3_sub'),
        osp.join(data_root, 'DIV2K_train_LR_bicubic/X4_sub')
    ]
    lmdb_paths = [
        osp.join(data_root, 'DIV2K_train_HR_sub.lmdb'),
        osp.join(data_root, 'DIV2K_train_LR_bicubic_X2_sub.lmdb'),
        osp.join(data_root, 'DIV2K_train_LR_bicubic_X3_sub.lmdb'),
        osp.join(data_root, 'DIV2K_train_LR_bicubic_X4_sub.lmdb')
    ]

    for folder_path, lmdb_path in zip(folder_paths, lmdb_paths):
        img_path_list, keys = prepare_keys_div2k(folder_path)
        make_lmdb(folder_path, lmdb_path, img_path_list, keys)

def prepare_keys_div2k(folder_path):
    """Prepare image path list and keys for DIV2K dataset.

    Args:
        folder_path (str): Folder path.

    Returns:
        list[str]: Image path list.
        list[str]: Key list.
    """
    print('Reading image path list ...')
    img_path_list = sorted(
        list(mmcv.scandir(folder_path, suffix='png', recursive=False)))
    keys = [img_path.split('.png')[0] for img_path in sorted(img_path_list)]

    return img_path_list, keys

def make_lmdb(data_path,
              lmdb_path,
              img_path_list,
              keys,
              batch=5000,
              compress_level=1,
              multiprocessing_read=False,
              n_thread=40):
    """Make lmdb.

    Contents of lmdb. The file structure is:
    example.lmdb
    ├── data.mdb
    ├── lock.mdb
    ├── meta_info.txt

    The data.mdb and lock.mdb are standard lmdb files and you can refer to
    https://lmdb.readthedocs.io/en/release/ for more details.

    The meta_info.txt is a specified txt file to record the meta information
    of our datasets. It will be automatically created when preparing
    datasets by our provided dataset tools.
    Each line in the txt file records 1)image name (with extension),
    2)image shape, and 3)compression level, separated by a white space.

    For example, the meta information could be:
    `000_00000000.png (720,1280,3) 1`, which means:
    1) image name (with extension): 000_00000000.png;
    2) image shape: (720,1280,3);
    3) compression level: 1

    We use the image name without extension as the lmdb key.

    If `multiprocessing_read` is True, it will read all the images to memory
    using multiprocessing. Thus, your server needs to have enough memory.

    Args:
        data_path (str): Data path for reading images.
        lmdb_path (str): Lmdb save path.
        img_path_list (str): Image path list.
        keys (str): Used for lmdb keys.
        batch (int): After processing batch images, lmdb commits.
            Default: 5000.
        compress_level (int): Compress level when encoding images. Default: 1.
        multiprocessing_read (bool): Whether use multiprocessing to read all
            the images to memory. Default: False.
        n_thread (int): For multiprocessing.
    """
    assert len(img_path_list) == len(keys), (
        'img_path_list and keys should have the same length, '
        f'but got {len(img_path_list)} and {len(keys)}')
    print(f'Create lmdb for {data_path}, save to {lmdb_path}...')
    print(f'Total images: {len(img_path_list)}')
    if not lmdb_path.endswith('.lmdb'):
        raise ValueError("lmdb_path must end with '.lmdb'.")
    if osp.exists(lmdb_path):
        print(f'Folder {lmdb_path} already exists. Exit.')
        sys.exit(1)

    if multiprocessing_read:
        # read all the images to memory (multiprocessing)
        dataset = {}  # use dict to keep the order for multiprocessing
        shapes = {}
        print(f'Read images with multiprocessing, #thread: {n_thread} ...')
        prog_bar = mmcv.ProgressBar(len(img_path_list))

        def callback(arg):
            """get the image data and update prog_bar."""
            key, dataset[key], shapes[key] = arg
            prog_bar.update()

        pool = Pool(n_thread)
        for path, key in zip(img_path_list, keys):
            pool.apply_async(
                read_img_worker,
                args=(osp.join(data_path, path), key, compress_level),
                callback=callback)
        pool.close()
        pool.join()
        print(f'Finish reading {len(img_path_list)} images.')

    # create lmdb environment
    # obtain data size for one image
    img = mmcv.imread(osp.join(data_path, img_path_list[0]), flag='unchanged')
    _, img_byte = cv2.imencode('.png', img,
                               [cv2.IMWRITE_PNG_COMPRESSION, compress_level])
    data_size_per_img = img_byte.nbytes
    print('Data size per image is: ', data_size_per_img)
    data_size = data_size_per_img * len(img_path_list)
    env = lmdb.open(lmdb_path, map_size=data_size * 10)

    # write data to lmdb
    prog_bar = mmcv.ProgressBar(len(img_path_list))
    txn = env.begin(write=True)
    txt_file = open(osp.join(lmdb_path, 'meta_info.txt'), 'w')
    for idx, (path, key) in enumerate(zip(img_path_list, keys)):
        prog_bar.update()
        key_byte = key.encode('ascii')
        if multiprocessing_read:
            img_byte = dataset[key]
            h, w, c = shapes[key]
        else:
            _, img_byte, img_shape = read_img_worker(
                osp.join(data_path, path), key, compress_level)
            h, w, c = img_shape

        txn.put(key_byte, img_byte)
        # write meta information
        txt_file.write(f'{key}.png ({h},{w},{c}) {compress_level}\n')
        if idx % batch == 0:
            txn.commit()
            txn = env.begin(write=True)
    txn.commit()
    env.close()
    txt_file.close()
    print('\nFinish writing lmdb.')

def read_img_worker(path, key, compress_level):
    """Read image worker

    Args:
        path (str): Image path.
        key (str): Image key.
        compress_level (int): Compress level when encoding images.

    Returns:
        str: Image key.
        byte: Image byte.
        tuple[int]: Image shape.
    """
    img = mmcv.imread(path, flag='unchanged')
    if img.ndim == 2:
        h, w = img.shape
        c = 1
    else:
        h, w, c = img.shape
    _, img_byte = cv2.imencode('.png', img,
                               [cv2.IMWRITE_PNG_COMPRESSION, compress_level])
    return (key, img_byte, (h, w, c))

def parse_args():
    parser = argparse.ArgumentParser(
        description='Prepare DIV2K dataset',
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser.add_argument('--data-root', help='dataset root')
    parser.add_argument(
        '--crop-size',
        nargs='?',
        default=480,
        help='cropped size for HR images')
    parser.add_argument(
        '--step', nargs='?', default=240, help='step size for HR images')
    parser.add_argument(
        '--thresh-size',
        nargs='?',
        default=0,
        help='threshold size for HR images')
    parser.add_argument(
        '--compression-level',
        nargs='?',
        default=3,
        help='compression level when save png images')
    parser.add_argument(
        '--n-thread',
        nargs='?',
        default=20,
        help='thread number when using multiprocessing')
    parser.add_argument(
        '--make-lmdb',
        action='store_true',
        help='whether to prepare lmdb files')
    args = parser.parse_args()
    return args

if __name__ == '__main__':
    args = parse_args()
    # extract subimages
    main_extract_subimages(args)
    # prepare lmdb files if necessary
    if args.make_lmdb:
        make_lmdb_for_div2k(args.data_root)

{'repo_name': 'open-mmlab/mmediting', 'stars': '1327', 'repo_language': 'Python', 'file_name': 'docs.txt', 'mime_type': 'text/plain', 'hash': -5555246044503154279, 'source_dataset': 'data'}


.axui-datagrid-autofit-helper {
  position: absolute;
  left: 0;
  top: 0;
  opacity: 0;
  table {
    table-layout: auto;
    width: auto;
    tr {
      td {
        white-space: nowrap;
        padding: 3px;
      }
    }
  }
}

{'repo_name': 'jsdevkr/axui-datagrid', 'stars': '123', 'repo_language': 'TypeScript', 'file_name': 'index.html', 'mime_type': 'text/html', 'hash': 330945593914804651, 'source_dataset': 'data'}


// /** @file
// PeiCore Localized Strings and Content
//
// Copyright (c) 2013 - 2018, Intel Corporation. All rights reserved.<BR>
//
// SPDX-License-Identifier: BSD-2-Clause-Patent
//
// **/

#string STR_PROPERTIES_MODULE_NAME
#language en-US
"Core PEI Services Module"

{'repo_name': 'tianocore/edk2', 'stars': '1775', 'repo_language': 'C', 'file_name': 'SerialPortInfoGuid.h', 'mime_type': 'text/x-c', 'hash': 8203979318167500118, 'source_dataset': 'data'}


#find if malloc_stats() is available
set ( _CHECK_MALLOC_STATS_PROG "
#include <malloc.h>
#ifdef __CLASSIC_C__
int main() {
	int ac;
	char*av[];
#else
int main(int ac, char*av[]){
#endif
	malloc_stats();
	return 0;
}" )

include ( CheckCXXSourceCompiles )
CHECK_CXX_SOURCE_COMPILES ( "${_CHECK_MALLOC_STATS_PROG}" HAVE_MALLOC_STATS )

{'repo_name': 'manticoresoftware/manticoresearch', 'stars': '428', 'repo_language': 'C++', 'file_name': 'CMakeLists.txt', 'mime_type': 'text/plain', 'hash': -2061369066876029949, 'source_dataset': 'data'}


<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. -->

<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="12.0">
  <PropertyGroup>
    <ProjectGuid>{EEE88C2A-45A0-4E48-A40A-431A4BA458D8}</ProjectGuid>
    <AssemblyName>WixToolset.Extensibility</AssemblyName>
    <OutputType>Library</OutputType>
    <RootNamespace>WixToolset.Extensibility</RootNamespace>
  </PropertyGroup>
  <ItemGroup>
    <Compile Include="AssemblyInfo.cs" />
    <Compile Include="BinderExtension.cs" />
    <Compile Include="BindFileWithPath.cs" />
    <Compile Include="BindPath.cs" />
    <Compile Include="BindStage.cs" />
    <Compile Include="CabinetBuildOption.cs" />
    <Compile Include="CompilerConstants.cs" />
    <Compile Include="CompilerExtension.cs" />
    <Compile Include="ComponentKeyPath.cs" />
    <Compile Include="DecompilerConstants.cs" />
    <Compile Include="DecompilerExtension.cs" />
    <Compile Include="ExtensionData.cs" />
    <Compile Include="ExtensionHelper.cs" />
    <Compile Include="IBinderCore.cs" />
    <Compile Include="IBinderExtension.cs" />
    <Compile Include="IBinderFileManager.cs" />
    <Compile Include="IBinderFileManagerCore.cs" />
    <Compile Include="ICompilerCore.cs" />
    <Compile Include="ICompilerExtension.cs" />
    <Compile Include="IDecompilerCore.cs" />
    <Compile Include="IDecompilerExtension.cs" />
    <Compile Include="Identifier.cs" />
    <Compile Include="IExtensionCommandLine.cs" />
    <Compile Include="IExtensionData.cs" />
    <Compile Include="IInspectorCore.cs" />
    <Compile Include="IInspectorExtension.cs" />
    <Compile Include="InspectorExtension.cs" />
    <Compile Include="IPreprocessorCore.cs" />
    <Compile Include="IPreprocessorExtension.cs" />
    <Compile Include="IUnbinderExtension.cs" />
    <Compile Include="PreprocessorExtension.cs" />
    <Compile Include="ResolvedCabinet.cs" />
  </ItemGroup>
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.Xml" />
    <Reference Include="System.Xml.Linq" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\WixToolset.Data\WixToolset.Data.csproj">
      <Project>{6a98499e-40ec-4335-9c31-96a2511d47c6}</Project>
      <Name>WixToolset.Data</Name>
    </ProjectReference>
  </ItemGroup>
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildProjectDirectory), wix.proj))\tools\WixBuild.targets" />
</Project>

{'repo_name': 'wixtoolset/wix4', 'stars': '372', 'repo_language': 'C#', 'file_name': 'SimpleMsi.wixproj', 'mime_type': 'text/xml', 'hash': -5543989692790278574, 'source_dataset': 'data'}


<?xml version="1.0"?>
<ZopeData>
  <record id="1" aka="AAAAAAAAAAE=">
    <pickle>
      <global name="WorklistDefinition" module="Products.DCWorkflow.Worklists"/>
    </pickle>
    <pickle>
      <dictionary>
        <item>
            <key> <string>actbox_category</string> </key>
            <value> <string>global</string> </value>
        </item>
        <item>
            <key> <string>actbox_name</string> </key>
            <value> <string>Tasks to Validate (%(count)s)</string> </value>
        </item>
        <item>
            <key> <string>actbox_url</string> </key>
            <value> <string encoding="cdata"><![CDATA[

task_module?simulation_state=draft&local_roles=%(local_roles)s&reset=1

]]></string> </value>
        </item>
        <item>
            <key> <string>description</string> </key>
            <value> <string>Tasks to Validate</string> </value>
        </item>
        <item>
            <key> <string>guard</string> </key>
            <value>
              <persistent> <string encoding="base64">AAAAAAAAAAI=</string> </persistent>
            </value>
        </item>
        <item>
            <key> <string>id</string> </key>
            <value> <string>1_draft_task</string> </value>
        </item>
        <item>
            <key> <string>var_matches</string> </key>
            <value>
              <persistent> <string encoding="base64">AAAAAAAAAAM=</string> </persistent>
            </value>
        </item>
      </dictionary>
    </pickle>
  </record>
  <record id="2" aka="AAAAAAAAAAI=">
    <pickle>
      <tuple>
        <global name="Guard" module="Products.DCWorkflow.Guard"/>
        <tuple/>
      </tuple>
    </pickle>
    <pickle>
      <dictionary>
        <item>
            <key> <string>roles</string> </key>
            <value>
              <tuple>
                <string>Owner</string>
              </tuple>
            </value>
        </item>
      </dictionary>
    </pickle>
  </record>
  <record id="3" aka="AAAAAAAAAAM=">
    <pickle>
      <tuple>
        <global name="PersistentMapping" module="Persistence.mapping"/>
        <tuple/>
      </tuple>
    </pickle>
    <pickle>
      <dictionary>
        <item>
            <key> <string>data</string> </key>
            <value>
              <dictionary>
                <item>
                    <key> <string>simulation_state</string> </key>
                    <value>
                      <tuple>
                        <string>draft</string>
                      </tuple>
                    </value>
                </item>
              </dictionary>
            </value>
        </item>
      </dictionary>
    </pickle>
  </record>
</ZopeData>

{'repo_name': 'Nexedi/erp5', 'stars': '116', 'repo_language': 'JavaScript', 'file_name': 'base_category_list.xml', 'mime_type': 'text/plain', 'hash': 5827165830959956050, 'source_dataset': 'data'}


// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

namespace System
{
    public partial class Lazy<T, TMetadata> : System.Lazy<T>
    {
        public Lazy(System.Func<T> valueFactory, TMetadata metadata) { }
        public Lazy(System.Func<T> valueFactory, TMetadata metadata, bool isThreadSafe) { }
        public Lazy(System.Func<T> valueFactory, TMetadata metadata, System.Threading.LazyThreadSafetyMode mode) { }
        public Lazy(TMetadata metadata) { }
        public Lazy(TMetadata metadata, bool isThreadSafe) { }
        public Lazy(TMetadata metadata, System.Threading.LazyThreadSafetyMode mode) { }
        public TMetadata Metadata { get { throw null; } }
    }
}
namespace System.ComponentModel.Composition
{
    public static partial class AttributedModelServices
    {
        public static System.ComponentModel.Composition.Primitives.ComposablePart AddExportedValue<T>(this System.ComponentModel.Composition.Hosting.CompositionBatch batch, string contractName, T exportedValue) { throw null; }
        public static System.ComponentModel.Composition.Primitives.ComposablePart AddExportedValue<T>(this System.ComponentModel.Composition.Hosting.CompositionBatch batch, T exportedValue) { throw null; }
        public static System.ComponentModel.Composition.Primitives.ComposablePart AddPart(this System.ComponentModel.Composition.Hosting.CompositionBatch batch, object attributedPart) { throw null; }
        public static void ComposeExportedValue<T>(this System.ComponentModel.Composition.Hosting.CompositionContainer container, string contractName, T exportedValue) { }
        public static void ComposeExportedValue<T>(this System.ComponentModel.Composition.Hosting.CompositionContainer container, T exportedValue) { }
        public static void ComposeParts(this System.ComponentModel.Composition.Hosting.CompositionContainer container, params object[] attributedParts) { }
        public static System.ComponentModel.Composition.Primitives.ComposablePart CreatePart(System.ComponentModel.Composition.Primitives.ComposablePartDefinition partDefinition, object attributedPart) { throw null; }
        public static System.ComponentModel.Composition.Primitives.ComposablePart CreatePart(object attributedPart) { throw null; }
        public static System.ComponentModel.Composition.Primitives.ComposablePart CreatePart(object attributedPart, System.Reflection.ReflectionContext reflectionContext) { throw null; }
        public static System.ComponentModel.Composition.Primitives.ComposablePartDefinition CreatePartDefinition(System.Type type, System.ComponentModel.Composition.Primitives.ICompositionElement origin) { throw null; }
        public static System.ComponentModel.Composition.Primitives.ComposablePartDefinition CreatePartDefinition(System.Type type, System.ComponentModel.Composition.Primitives.ICompositionElement origin, bool ensureIsDiscoverable) { throw null; }
        public static bool Exports(this System.ComponentModel.Composition.Primitives.ComposablePartDefinition part, System.Type contractType) { throw null; }
        public static bool Exports<T>(this System.ComponentModel.Composition.Primitives.ComposablePartDefinition part) { throw null; }
        public static string GetContractName(System.Type type) { throw null; }
        public static TMetadataView GetMetadataView<TMetadataView>(System.Collections.Generic.IDictionary<string, object> metadata) { throw null; }
        public static string GetTypeIdentity(System.Reflection.MethodInfo method) { throw null; }
        public static string GetTypeIdentity(System.Type type) { throw null; }
        public static bool Imports(this System.ComponentModel.Composition.Primitives.ComposablePartDefinition part, System.Type contractType) { throw null; }
        public static bool Imports(this System.ComponentModel.Composition.Primitives.ComposablePartDefinition part, System.Type contractType, System.ComponentModel.Composition.Primitives.ImportCardinality importCardinality) { throw null; }
        public static bool Imports<T>(this System.ComponentModel.Composition.Primitives.ComposablePartDefinition part) { throw null; }
        public static bool Imports<T>(this System.ComponentModel.Composition.Primitives.ComposablePartDefinition part, System.ComponentModel.Composition.Primitives.ImportCardinality importCardinality) { throw null; }
        public static System.ComponentModel.Composition.Primitives.ComposablePart SatisfyImportsOnce(this System.ComponentModel.Composition.ICompositionService compositionService, object attributedPart) { throw null; }
        public static System.ComponentModel.Composition.Primitives.ComposablePart SatisfyImportsOnce(this System.ComponentModel.Composition.ICompositionService compositionService, object attributedPart, System.Reflection.ReflectionContext reflectionContext) { throw null; }
    }
    [System.AttributeUsageAttribute(System.AttributeTargets.Assembly, AllowMultiple=false, Inherited=true)]
    public partial class CatalogReflectionContextAttribute : System.Attribute
    {
        public CatalogReflectionContextAttribute(System.Type reflectionContextType) { }
        public System.Reflection.ReflectionContext CreateReflectionContext() { throw null; }
    }
    public partial class ChangeRejectedException : System.ComponentModel.Composition.CompositionException
    {
        public ChangeRejectedException() { }
        public ChangeRejectedException(System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.CompositionError> errors) { }
        public ChangeRejectedException(string message) { }
        public ChangeRejectedException(string message, System.Exception innerException) { }
        public override string Message { get { throw null; } }
    }
    public partial class CompositionContractMismatchException : System.Exception
    {
        public CompositionContractMismatchException() { }
        protected CompositionContractMismatchException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
        public CompositionContractMismatchException(string message) { }
        public CompositionContractMismatchException(string message, System.Exception innerException) { }
    }
    public partial class CompositionError
    {
        public CompositionError(string message) { }
        public CompositionError(string message, System.ComponentModel.Composition.Primitives.ICompositionElement element) { }
        public CompositionError(string message, System.ComponentModel.Composition.Primitives.ICompositionElement element, System.Exception exception) { }
        public CompositionError(string message, System.Exception exception) { }
        public string Description { get { throw null; } }
        public System.ComponentModel.Composition.Primitives.ICompositionElement Element { get { throw null; } }
        public System.Exception Exception { get { throw null; } }
        public override string ToString() { throw null; }
    }
    public partial class CompositionException : System.Exception
    {
        public CompositionException() { }
        public CompositionException(System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.CompositionError> errors) { }
        public CompositionException(string message) { }
        public CompositionException(string message, System.Exception innerException) { }
        public System.Collections.ObjectModel.ReadOnlyCollection<System.ComponentModel.Composition.CompositionError> Errors { get { throw null; } }
        public override string Message { get { throw null; } }
    }
    public enum CreationPolicy
    {
        Any = 0,
        Shared = 1,
        NonShared = 2,
        NewScope = 3,
    }
    [System.AttributeUsageAttribute(System.AttributeTargets.Class | System.AttributeTargets.Field | System.AttributeTargets.Method | System.AttributeTargets.Property, AllowMultiple=true, Inherited=false)]
    public partial class ExportAttribute : System.Attribute
    {
        public ExportAttribute() { }
        public ExportAttribute(string contractName) { }
        public ExportAttribute(string contractName, System.Type contractType) { }
        public ExportAttribute(System.Type contractType) { }
        public string ContractName { get { throw null; } }
        public System.Type ContractType { get { throw null; } }
    }
    public partial class ExportFactory<T>
    {
        public ExportFactory(System.Func<System.Tuple<T, System.Action>> exportLifetimeContextCreator) { }
        public System.ComponentModel.Composition.ExportLifetimeContext<T> CreateExport() { throw null; }
        protected virtual bool OnFilterScopedCatalog(System.ComponentModel.Composition.Primitives.ComposablePartDefinition composablePartDefinition) { throw null; }
    }
    public partial class ExportFactory<T, TMetadata> : System.ComponentModel.Composition.ExportFactory<T>
    {
        public ExportFactory(System.Func<System.Tuple<T, System.Action>> exportLifetimeContextCreator, TMetadata metadata) : base (default(System.Func<System.Tuple<T, System.Action>>)) { }
        public TMetadata Metadata { get { throw null; } }
    }
    public sealed partial class ExportLifetimeContext<T> : System.IDisposable
    {
        public ExportLifetimeContext(T value, System.Action disposeAction) { }
        public T Value { get { throw null; } }
        public void Dispose() { }
    }
    [System.AttributeUsageAttribute(System.AttributeTargets.Class | System.AttributeTargets.Field | System.AttributeTargets.Interface | System.AttributeTargets.Method | System.AttributeTargets.Property, AllowMultiple=true, Inherited=false)]
    public sealed partial class ExportMetadataAttribute : System.Attribute
    {
        public ExportMetadataAttribute(string name, object value) { }
        public bool IsMultiple { get { throw null; } set { } }
        public string Name { get { throw null; } }
        public object Value { get { throw null; } }
    }
    public partial interface ICompositionService
    {
        void SatisfyImportsOnce(System.ComponentModel.Composition.Primitives.ComposablePart part);
    }
    [System.AttributeUsageAttribute(System.AttributeTargets.Field | System.AttributeTargets.Parameter | System.AttributeTargets.Property, AllowMultiple=false, Inherited=false)]
    public partial class ImportAttribute : System.Attribute
    {
        public ImportAttribute() { }
        public ImportAttribute(string contractName) { }
        public ImportAttribute(string contractName, System.Type contractType) { }
        public ImportAttribute(System.Type contractType) { }
        public bool AllowDefault { get { throw null; } set { } }
        public bool AllowRecomposition { get { throw null; } set { } }
        public string ContractName { get { throw null; } }
        public System.Type ContractType { get { throw null; } }
        public System.ComponentModel.Composition.CreationPolicy RequiredCreationPolicy { get { throw null; } set { } }
        public System.ComponentModel.Composition.ImportSource Source { get { throw null; } set { } }
    }
    public partial class ImportCardinalityMismatchException : System.Exception
    {
        public ImportCardinalityMismatchException() { }
        protected ImportCardinalityMismatchException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
        public ImportCardinalityMismatchException(string message) { }
        public ImportCardinalityMismatchException(string message, System.Exception innerException) { }
    }
    [System.AttributeUsageAttribute(System.AttributeTargets.Constructor, AllowMultiple=false, Inherited=false)]
    public partial class ImportingConstructorAttribute : System.Attribute
    {
        public ImportingConstructorAttribute() { }
    }
    [System.AttributeUsageAttribute(System.AttributeTargets.Field | System.AttributeTargets.Parameter | System.AttributeTargets.Property, AllowMultiple=false, Inherited=false)]
    public partial class ImportManyAttribute : System.Attribute
    {
        public ImportManyAttribute() { }
        public ImportManyAttribute(string contractName) { }
        public ImportManyAttribute(string contractName, System.Type contractType) { }
        public ImportManyAttribute(System.Type contractType) { }
        public bool AllowRecomposition { get { throw null; } set { } }
        public string ContractName { get { throw null; } }
        public System.Type ContractType { get { throw null; } }
        public System.ComponentModel.Composition.CreationPolicy RequiredCreationPolicy { get { throw null; } set { } }
        public System.ComponentModel.Composition.ImportSource Source { get { throw null; } set { } }
    }
    public enum ImportSource
    {
        Any = 0,
        Local = 1,
        NonLocal = 2,
    }
    [System.AttributeUsageAttribute(System.AttributeTargets.Class | System.AttributeTargets.Interface, AllowMultiple=true, Inherited=true)]
    public partial class InheritedExportAttribute : System.ComponentModel.Composition.ExportAttribute
    {
        public InheritedExportAttribute() { }
        public InheritedExportAttribute(string contractName) { }
        public InheritedExportAttribute(string contractName, System.Type contractType) { }
        public InheritedExportAttribute(System.Type contractType) { }
    }
    public partial interface IPartImportsSatisfiedNotification
    {
        void OnImportsSatisfied();
    }
    [System.AttributeUsageAttribute(System.AttributeTargets.Class, AllowMultiple=false, Inherited=true)]
    public sealed partial class MetadataAttributeAttribute : System.Attribute
    {
        public MetadataAttributeAttribute() { }
    }
    [System.AttributeUsageAttribute(System.AttributeTargets.Interface, AllowMultiple=false, Inherited=false)]
    public sealed partial class MetadataViewImplementationAttribute : System.Attribute
    {
        public MetadataViewImplementationAttribute(System.Type implementationType) { }
        public System.Type ImplementationType { get { throw null; } }
    }
    [System.AttributeUsageAttribute(System.AttributeTargets.Class, AllowMultiple=false, Inherited=false)]
    public sealed partial class PartCreationPolicyAttribute : System.Attribute
    {
        public PartCreationPolicyAttribute(System.ComponentModel.Composition.CreationPolicy creationPolicy) { }
        public System.ComponentModel.Composition.CreationPolicy CreationPolicy { get { throw null; } }
    }
    [System.AttributeUsageAttribute(System.AttributeTargets.Class, AllowMultiple=true, Inherited=false)]
    public sealed partial class PartMetadataAttribute : System.Attribute
    {
        public PartMetadataAttribute(string name, object value) { }
        public string Name { get { throw null; } }
        public object Value { get { throw null; } }
    }
    [System.AttributeUsageAttribute(System.AttributeTargets.Class, AllowMultiple=false, Inherited=false)]
    public sealed partial class PartNotDiscoverableAttribute : System.Attribute
    {
        public PartNotDiscoverableAttribute() { }
    }
}
namespace System.ComponentModel.Composition.Hosting
{
    public partial class AggregateCatalog : System.ComponentModel.Composition.Primitives.ComposablePartCatalog, System.ComponentModel.Composition.Hosting.INotifyComposablePartCatalogChanged
    {
        public AggregateCatalog() { }
        public AggregateCatalog(System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ComposablePartCatalog> catalogs) { }
        public AggregateCatalog(params System.ComponentModel.Composition.Primitives.ComposablePartCatalog[] catalogs) { }
        public System.Collections.Generic.ICollection<System.ComponentModel.Composition.Primitives.ComposablePartCatalog> Catalogs { get { throw null; } }
        public event System.EventHandler<System.ComponentModel.Composition.Hosting.ComposablePartCatalogChangeEventArgs> Changed { add { } remove { } }
        public event System.EventHandler<System.ComponentModel.Composition.Hosting.ComposablePartCatalogChangeEventArgs> Changing { add { } remove { } }
        protected override void Dispose(bool disposing) { }
        public override System.Collections.Generic.IEnumerator<System.ComponentModel.Composition.Primitives.ComposablePartDefinition> GetEnumerator() { throw null; }
        public override System.Collections.Generic.IEnumerable<System.Tuple<System.ComponentModel.Composition.Primitives.ComposablePartDefinition, System.ComponentModel.Composition.Primitives.ExportDefinition>> GetExports(System.ComponentModel.Composition.Primitives.ImportDefinition definition) { throw null; }
        protected virtual void OnChanged(System.ComponentModel.Composition.Hosting.ComposablePartCatalogChangeEventArgs e) { }
        protected virtual void OnChanging(System.ComponentModel.Composition.Hosting.ComposablePartCatalogChangeEventArgs e) { }
    }
    public partial class AggregateExportProvider : System.ComponentModel.Composition.Hosting.ExportProvider, System.IDisposable
    {
        public AggregateExportProvider(System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Hosting.ExportProvider> providers) { }
        public AggregateExportProvider(params System.ComponentModel.Composition.Hosting.ExportProvider[] providers) { }
        public System.Collections.ObjectModel.ReadOnlyCollection<System.ComponentModel.Composition.Hosting.ExportProvider> Providers { get { throw null; } }
        public void Dispose() { }
        protected virtual void Dispose(bool disposing) { }
        protected override System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.Export> GetExportsCore(System.ComponentModel.Composition.Primitives.ImportDefinition definition, System.ComponentModel.Composition.Hosting.AtomicComposition atomicComposition) { throw null; }
    }
    public partial class ApplicationCatalog : System.ComponentModel.Composition.Primitives.ComposablePartCatalog, System.ComponentModel.Composition.Primitives.ICompositionElement
    {
        public ApplicationCatalog() { }
        public ApplicationCatalog(System.ComponentModel.Composition.Primitives.ICompositionElement definitionOrigin) { }
        public ApplicationCatalog(System.Reflection.ReflectionContext reflectionContext) { }
        public ApplicationCatalog(System.Reflection.ReflectionContext reflectionContext, System.ComponentModel.Composition.Primitives.ICompositionElement definitionOrigin) { }
        string System.ComponentModel.Composition.Primitives.ICompositionElement.DisplayName { get { throw null; } }
        System.ComponentModel.Composition.Primitives.ICompositionElement System.ComponentModel.Composition.Primitives.ICompositionElement.Origin { get { throw null; } }
        protected override void Dispose(bool disposing) { }
        public override System.Collections.Generic.IEnumerator<System.ComponentModel.Composition.Primitives.ComposablePartDefinition> GetEnumerator() { throw null; }
        public override System.Collections.Generic.IEnumerable<System.Tuple<System.ComponentModel.Composition.Primitives.ComposablePartDefinition, System.ComponentModel.Composition.Primitives.ExportDefinition>> GetExports(System.ComponentModel.Composition.Primitives.ImportDefinition definition) { throw null; }
        public override string ToString() { throw null; }
    }
    public partial class AssemblyCatalog : System.ComponentModel.Composition.Primitives.ComposablePartCatalog, System.ComponentModel.Composition.Primitives.ICompositionElement
    {
        public AssemblyCatalog(System.Reflection.Assembly assembly) { }
        public AssemblyCatalog(System.Reflection.Assembly assembly, System.ComponentModel.Composition.Primitives.ICompositionElement definitionOrigin) { }
        public AssemblyCatalog(System.Reflection.Assembly assembly, System.Reflection.ReflectionContext reflectionContext) { }
        public AssemblyCatalog(System.Reflection.Assembly assembly, System.Reflection.ReflectionContext reflectionContext, System.ComponentModel.Composition.Primitives.ICompositionElement definitionOrigin) { }
        public AssemblyCatalog(string codeBase) { }
        public AssemblyCatalog(string codeBase, System.ComponentModel.Composition.Primitives.ICompositionElement definitionOrigin) { }
        public AssemblyCatalog(string codeBase, System.Reflection.ReflectionContext reflectionContext) { }
        public AssemblyCatalog(string codeBase, System.Reflection.ReflectionContext reflectionContext, System.ComponentModel.Composition.Primitives.ICompositionElement definitionOrigin) { }
        public System.Reflection.Assembly Assembly { get { throw null; } }
        string System.ComponentModel.Composition.Primitives.ICompositionElement.DisplayName { get { throw null; } }
        System.ComponentModel.Composition.Primitives.ICompositionElement System.ComponentModel.Composition.Primitives.ICompositionElement.Origin { get { throw null; } }
        protected override void Dispose(bool disposing) { }
        public override System.Collections.Generic.IEnumerator<System.ComponentModel.Composition.Primitives.ComposablePartDefinition> GetEnumerator() { throw null; }
        public override System.Collections.Generic.IEnumerable<System.Tuple<System.ComponentModel.Composition.Primitives.ComposablePartDefinition, System.ComponentModel.Composition.Primitives.ExportDefinition>> GetExports(System.ComponentModel.Composition.Primitives.ImportDefinition definition) { throw null; }
        public override string ToString() { throw null; }
    }
    public partial class AtomicComposition : System.IDisposable
    {
        public AtomicComposition() { }
        public AtomicComposition(System.ComponentModel.Composition.Hosting.AtomicComposition outerAtomicComposition) { }
        public void AddCompleteAction(System.Action completeAction) { }
        public void AddRevertAction(System.Action revertAction) { }
        public void Complete() { }
        public void Dispose() { }
        protected virtual void Dispose(bool disposing) { }
        public void SetValue(object key, object value) { }
        public bool TryGetValue<T>(object key, bool localAtomicCompositionOnly, out T value) { throw null; }
        public bool TryGetValue<T>(object key, out T value) { throw null; }
    }
    public partial class CatalogExportProvider : System.ComponentModel.Composition.Hosting.ExportProvider, System.IDisposable
    {
        public CatalogExportProvider(System.ComponentModel.Composition.Primitives.ComposablePartCatalog catalog) { }
        public CatalogExportProvider(System.ComponentModel.Composition.Primitives.ComposablePartCatalog catalog, bool isThreadSafe) { }
        public CatalogExportProvider(System.ComponentModel.Composition.Primitives.ComposablePartCatalog catalog, System.ComponentModel.Composition.Hosting.CompositionOptions compositionOptions) { }
        public System.ComponentModel.Composition.Primitives.ComposablePartCatalog Catalog { get { throw null; } }
        public System.ComponentModel.Composition.Hosting.ExportProvider SourceProvider { get { throw null; } set { } }
        public void Dispose() { }
        protected virtual void Dispose(bool disposing) { }
        protected override System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.Export> GetExportsCore(System.ComponentModel.Composition.Primitives.ImportDefinition definition, System.ComponentModel.Composition.Hosting.AtomicComposition atomicComposition) { throw null; }
    }
    public static partial class CatalogExtensions
    {
        public static System.ComponentModel.Composition.Hosting.CompositionService CreateCompositionService(this System.ComponentModel.Composition.Primitives.ComposablePartCatalog composablePartCatalog) { throw null; }
    }
    public partial class ComposablePartCatalogChangeEventArgs : System.EventArgs
    {
        public ComposablePartCatalogChangeEventArgs(System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ComposablePartDefinition> addedDefinitions, System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ComposablePartDefinition> removedDefinitions, System.ComponentModel.Composition.Hosting.AtomicComposition atomicComposition) { }
        public System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ComposablePartDefinition> AddedDefinitions { get { throw null; } }
        public System.ComponentModel.Composition.Hosting.AtomicComposition AtomicComposition { get { throw null; } }
        public System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ComposablePartDefinition> RemovedDefinitions { get { throw null; } }
    }
    public partial class ComposablePartExportProvider : System.ComponentModel.Composition.Hosting.ExportProvider, System.IDisposable
    {
        public ComposablePartExportProvider() { }
        public ComposablePartExportProvider(bool isThreadSafe) { }
        public ComposablePartExportProvider(System.ComponentModel.Composition.Hosting.CompositionOptions compositionOptions) { }
        public System.ComponentModel.Composition.Hosting.ExportProvider SourceProvider { get { throw null; } set { } }
        public void Compose(System.ComponentModel.Composition.Hosting.CompositionBatch batch) { }
        public void Dispose() { }
        protected virtual void Dispose(bool disposing) { }
        protected override System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.Export> GetExportsCore(System.ComponentModel.Composition.Primitives.ImportDefinition definition, System.ComponentModel.Composition.Hosting.AtomicComposition atomicComposition) { throw null; }
    }
    public partial class CompositionBatch
    {
        public CompositionBatch() { }
        public CompositionBatch(System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ComposablePart> partsToAdd, System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ComposablePart> partsToRemove) { }
        public System.Collections.ObjectModel.ReadOnlyCollection<System.ComponentModel.Composition.Primitives.ComposablePart> PartsToAdd { get { throw null; } }
        public System.Collections.ObjectModel.ReadOnlyCollection<System.ComponentModel.Composition.Primitives.ComposablePart> PartsToRemove { get { throw null; } }
        public System.ComponentModel.Composition.Primitives.ComposablePart AddExport(System.ComponentModel.Composition.Primitives.Export export) { throw null; }
        public void AddPart(System.ComponentModel.Composition.Primitives.ComposablePart part) { }
        public void RemovePart(System.ComponentModel.Composition.Primitives.ComposablePart part) { }
    }
    public static partial class CompositionConstants
    {
        public const string ExportTypeIdentityMetadataName = "ExportTypeIdentity";
        public const string GenericContractMetadataName = "System.ComponentModel.Composition.GenericContractName";
        public const string GenericParametersMetadataName = "System.ComponentModel.Composition.GenericParameters";
        public const string ImportSourceMetadataName = "System.ComponentModel.Composition.ImportSource";
        public const string IsGenericPartMetadataName = "System.ComponentModel.Composition.IsGenericPart";
        public const string PartCreationPolicyMetadataName = "System.ComponentModel.Composition.CreationPolicy";
    }
    public partial class CompositionContainer : System.ComponentModel.Composition.Hosting.ExportProvider, System.ComponentModel.Composition.ICompositionService, System.IDisposable
    {
        public CompositionContainer() { }
        public CompositionContainer(System.ComponentModel.Composition.Hosting.CompositionOptions compositionOptions, params System.ComponentModel.Composition.Hosting.ExportProvider[] providers) { }
        public CompositionContainer(params System.ComponentModel.Composition.Hosting.ExportProvider[] providers) { }
        public CompositionContainer(System.ComponentModel.Composition.Primitives.ComposablePartCatalog catalog, bool isThreadSafe, params System.ComponentModel.Composition.Hosting.ExportProvider[] providers) { }
        public CompositionContainer(System.ComponentModel.Composition.Primitives.ComposablePartCatalog catalog, System.ComponentModel.Composition.Hosting.CompositionOptions compositionOptions, params System.ComponentModel.Composition.Hosting.ExportProvider[] providers) { }
        public CompositionContainer(System.ComponentModel.Composition.Primitives.ComposablePartCatalog catalog, params System.ComponentModel.Composition.Hosting.ExportProvider[] providers) { }
        public System.ComponentModel.Composition.Primitives.ComposablePartCatalog Catalog { get { throw null; } }
        public System.Collections.ObjectModel.ReadOnlyCollection<System.ComponentModel.Composition.Hosting.ExportProvider> Providers { get { throw null; } }
        public void Compose(System.ComponentModel.Composition.Hosting.CompositionBatch batch) { }
        public void Dispose() { }
        protected virtual void Dispose(bool disposing) { }
        protected override System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.Export> GetExportsCore(System.ComponentModel.Composition.Primitives.ImportDefinition definition, System.ComponentModel.Composition.Hosting.AtomicComposition atomicComposition) { throw null; }
        public void ReleaseExport(System.ComponentModel.Composition.Primitives.Export export) { }
        public void ReleaseExports(System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.Export> exports) { }
        public void ReleaseExports<T>(System.Collections.Generic.IEnumerable<System.Lazy<T>> exports) { }
        public void ReleaseExports<T, TMetadataView>(System.Collections.Generic.IEnumerable<System.Lazy<T, TMetadataView>> exports) { }
        public void ReleaseExport<T>(System.Lazy<T> export) { }
        public void SatisfyImportsOnce(System.ComponentModel.Composition.Primitives.ComposablePart part) { }
    }
    [System.FlagsAttribute]
    public enum CompositionOptions
    {
        Default = 0,
        DisableSilentRejection = 1,
        IsThreadSafe = 2,
        ExportCompositionService = 4,
    }
    public partial class CompositionScopeDefinition : System.ComponentModel.Composition.Primitives.ComposablePartCatalog, System.ComponentModel.Composition.Hosting.INotifyComposablePartCatalogChanged
    {
        protected CompositionScopeDefinition() { }
        public CompositionScopeDefinition(System.ComponentModel.Composition.Primitives.ComposablePartCatalog catalog, System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Hosting.CompositionScopeDefinition> children) { }
        public CompositionScopeDefinition(System.ComponentModel.Composition.Primitives.ComposablePartCatalog catalog, System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Hosting.CompositionScopeDefinition> children, System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ExportDefinition> publicSurface) { }
        public virtual System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Hosting.CompositionScopeDefinition> Children { get { throw null; } }
        public virtual System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ExportDefinition> PublicSurface { get { throw null; } }
        public event System.EventHandler<System.ComponentModel.Composition.Hosting.ComposablePartCatalogChangeEventArgs> Changed { add { } remove { } }
        public event System.EventHandler<System.ComponentModel.Composition.Hosting.ComposablePartCatalogChangeEventArgs> Changing { add { } remove { } }
        protected override void Dispose(bool disposing) { }
        public override System.Collections.Generic.IEnumerator<System.ComponentModel.Composition.Primitives.ComposablePartDefinition> GetEnumerator() { throw null; }
        public override System.Collections.Generic.IEnumerable<System.Tuple<System.ComponentModel.Composition.Primitives.ComposablePartDefinition, System.ComponentModel.Composition.Primitives.ExportDefinition>> GetExports(System.ComponentModel.Composition.Primitives.ImportDefinition definition) { throw null; }
        protected virtual void OnChanged(System.ComponentModel.Composition.Hosting.ComposablePartCatalogChangeEventArgs e) { }
        protected virtual void OnChanging(System.ComponentModel.Composition.Hosting.ComposablePartCatalogChangeEventArgs e) { }
    }
    public partial class CompositionService : System.ComponentModel.Composition.ICompositionService, System.IDisposable
    {
        internal CompositionService() { }
        public void Dispose() { }
        public void SatisfyImportsOnce(System.ComponentModel.Composition.Primitives.ComposablePart part) { }
    }
    public partial class DirectoryCatalog : System.ComponentModel.Composition.Primitives.ComposablePartCatalog, System.ComponentModel.Composition.Hosting.INotifyComposablePartCatalogChanged, System.ComponentModel.Composition.Primitives.ICompositionElement
    {
        public DirectoryCatalog(string path) { }
        public DirectoryCatalog(string path, System.ComponentModel.Composition.Primitives.ICompositionElement definitionOrigin) { }
        public DirectoryCatalog(string path, System.Reflection.ReflectionContext reflectionContext) { }
        public DirectoryCatalog(string path, System.Reflection.ReflectionContext reflectionContext, System.ComponentModel.Composition.Primitives.ICompositionElement definitionOrigin) { }
        public DirectoryCatalog(string path, string searchPattern) { }
        public DirectoryCatalog(string path, string searchPattern, System.ComponentModel.Composition.Primitives.ICompositionElement definitionOrigin) { }
        public DirectoryCatalog(string path, string searchPattern, System.Reflection.ReflectionContext reflectionContext) { }
        public DirectoryCatalog(string path, string searchPattern, System.Reflection.ReflectionContext reflectionContext, System.ComponentModel.Composition.Primitives.ICompositionElement definitionOrigin) { }
        public string FullPath { get { throw null; } }
        public System.Collections.ObjectModel.ReadOnlyCollection<string> LoadedFiles { get { throw null; } }
        public string Path { get { throw null; } }
        public string SearchPattern { get { throw null; } }
        string System.ComponentModel.Composition.Primitives.ICompositionElement.DisplayName { get { throw null; } }
        System.ComponentModel.Composition.Primitives.ICompositionElement System.ComponentModel.Composition.Primitives.ICompositionElement.Origin { get { throw null; } }
        public event System.EventHandler<System.ComponentModel.Composition.Hosting.ComposablePartCatalogChangeEventArgs> Changed { add { } remove { } }
        public event System.EventHandler<System.ComponentModel.Composition.Hosting.ComposablePartCatalogChangeEventArgs> Changing { add { } remove { } }
        protected override void Dispose(bool disposing) { }
        public override System.Collections.Generic.IEnumerator<System.ComponentModel.Composition.Primitives.ComposablePartDefinition> GetEnumerator() { throw null; }
        public override System.Collections.Generic.IEnumerable<System.Tuple<System.ComponentModel.Composition.Primitives.ComposablePartDefinition, System.ComponentModel.Composition.Primitives.ExportDefinition>> GetExports(System.ComponentModel.Composition.Primitives.ImportDefinition definition) { throw null; }
        protected virtual void OnChanged(System.ComponentModel.Composition.Hosting.ComposablePartCatalogChangeEventArgs e) { }
        protected virtual void OnChanging(System.ComponentModel.Composition.Hosting.ComposablePartCatalogChangeEventArgs e) { }
        public void Refresh() { }
        public override string ToString() { throw null; }
    }
    public abstract partial class ExportProvider
    {
        protected ExportProvider() { }
        public event System.EventHandler<System.ComponentModel.Composition.Hosting.ExportsChangeEventArgs> ExportsChanged { add { } remove { } }
        public event System.EventHandler<System.ComponentModel.Composition.Hosting.ExportsChangeEventArgs> ExportsChanging { add { } remove { } }
        public T GetExportedValueOrDefault<T>() { throw null; }
        public T GetExportedValueOrDefault<T>(string contractName) { throw null; }
        public System.Collections.Generic.IEnumerable<T> GetExportedValues<T>() { throw null; }
        public System.Collections.Generic.IEnumerable<T> GetExportedValues<T>(string contractName) { throw null; }
        public T GetExportedValue<T>() { throw null; }
        public T GetExportedValue<T>(string contractName) { throw null; }
        public System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.Export> GetExports(System.ComponentModel.Composition.Primitives.ImportDefinition definition) { throw null; }
        public System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.Export> GetExports(System.ComponentModel.Composition.Primitives.ImportDefinition definition, System.ComponentModel.Composition.Hosting.AtomicComposition atomicComposition) { throw null; }
        public System.Collections.Generic.IEnumerable<System.Lazy<object, object>> GetExports(System.Type type, System.Type metadataViewType, string contractName) { throw null; }
        protected abstract System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.Export> GetExportsCore(System.ComponentModel.Composition.Primitives.ImportDefinition definition, System.ComponentModel.Composition.Hosting.AtomicComposition atomicComposition);
        public System.Collections.Generic.IEnumerable<System.Lazy<T>> GetExports<T>() { throw null; }
        public System.Collections.Generic.IEnumerable<System.Lazy<T>> GetExports<T>(string contractName) { throw null; }
        public System.Collections.Generic.IEnumerable<System.Lazy<T, TMetadataView>> GetExports<T, TMetadataView>() { throw null; }
        public System.Collections.Generic.IEnumerable<System.Lazy<T, TMetadataView>> GetExports<T, TMetadataView>(string contractName) { throw null; }
        public System.Lazy<T> GetExport<T>() { throw null; }
        public System.Lazy<T> GetExport<T>(string contractName) { throw null; }
        public System.Lazy<T, TMetadataView> GetExport<T, TMetadataView>() { throw null; }
        public System.Lazy<T, TMetadataView> GetExport<T, TMetadataView>(string contractName) { throw null; }
        protected virtual void OnExportsChanged(System.ComponentModel.Composition.Hosting.ExportsChangeEventArgs e) { }
        protected virtual void OnExportsChanging(System.ComponentModel.Composition.Hosting.ExportsChangeEventArgs e) { }
        public bool TryGetExports(System.ComponentModel.Composition.Primitives.ImportDefinition definition, System.ComponentModel.Composition.Hosting.AtomicComposition atomicComposition, out System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.Export> exports) { throw null; }
    }
    public partial class ExportsChangeEventArgs : System.EventArgs
    {
        public ExportsChangeEventArgs(System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ExportDefinition> addedExports, System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ExportDefinition> removedExports, System.ComponentModel.Composition.Hosting.AtomicComposition atomicComposition) { }
        public System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ExportDefinition> AddedExports { get { throw null; } }
        public System.ComponentModel.Composition.Hosting.AtomicComposition AtomicComposition { get { throw null; } }
        public System.Collections.Generic.IEnumerable<string> ChangedContractNames { get { throw null; } }
        public System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ExportDefinition> RemovedExports { get { throw null; } }
    }
    public partial class FilteredCatalog : System.ComponentModel.Composition.Primitives.ComposablePartCatalog, System.ComponentModel.Composition.Hosting.INotifyComposablePartCatalogChanged
    {
        public FilteredCatalog(System.ComponentModel.Composition.Primitives.ComposablePartCatalog catalog, System.Func<System.ComponentModel.Composition.Primitives.ComposablePartDefinition, bool> filter) { }
        public System.ComponentModel.Composition.Hosting.FilteredCatalog Complement { get { throw null; } }
        public event System.EventHandler<System.ComponentModel.Composition.Hosting.ComposablePartCatalogChangeEventArgs> Changed { add { } remove { } }
        public event System.EventHandler<System.ComponentModel.Composition.Hosting.ComposablePartCatalogChangeEventArgs> Changing { add { } remove { } }
        protected override void Dispose(bool disposing) { }
        public override System.Collections.Generic.IEnumerator<System.ComponentModel.Composition.Primitives.ComposablePartDefinition> GetEnumerator() { throw null; }
        public override System.Collections.Generic.IEnumerable<System.Tuple<System.ComponentModel.Composition.Primitives.ComposablePartDefinition, System.ComponentModel.Composition.Primitives.ExportDefinition>> GetExports(System.ComponentModel.Composition.Primitives.ImportDefinition definition) { throw null; }
        public System.ComponentModel.Composition.Hosting.FilteredCatalog IncludeDependencies() { throw null; }
        public System.ComponentModel.Composition.Hosting.FilteredCatalog IncludeDependencies(System.Func<System.ComponentModel.Composition.Primitives.ImportDefinition, bool> importFilter) { throw null; }
        public System.ComponentModel.Composition.Hosting.FilteredCatalog IncludeDependents() { throw null; }
        public System.ComponentModel.Composition.Hosting.FilteredCatalog IncludeDependents(System.Func<System.ComponentModel.Composition.Primitives.ImportDefinition, bool> importFilter) { throw null; }
        protected virtual void OnChanged(System.ComponentModel.Composition.Hosting.ComposablePartCatalogChangeEventArgs e) { }
        protected virtual void OnChanging(System.ComponentModel.Composition.Hosting.ComposablePartCatalogChangeEventArgs e) { }
    }
    public partial class ImportEngine : System.ComponentModel.Composition.ICompositionService, System.IDisposable
    {
        public ImportEngine(System.ComponentModel.Composition.Hosting.ExportProvider sourceProvider) { }
        public ImportEngine(System.ComponentModel.Composition.Hosting.ExportProvider sourceProvider, bool isThreadSafe) { }
        public ImportEngine(System.ComponentModel.Composition.Hosting.ExportProvider sourceProvider, System.ComponentModel.Composition.Hosting.CompositionOptions compositionOptions) { }
        public void Dispose() { }
        protected virtual void Dispose(bool disposing) { }
        public void PreviewImports(System.ComponentModel.Composition.Primitives.ComposablePart part, System.ComponentModel.Composition.Hosting.AtomicComposition atomicComposition) { }
        public void ReleaseImports(System.ComponentModel.Composition.Primitives.ComposablePart part, System.ComponentModel.Composition.Hosting.AtomicComposition atomicComposition) { }
        public void SatisfyImports(System.ComponentModel.Composition.Primitives.ComposablePart part) { }
        public void SatisfyImportsOnce(System.ComponentModel.Composition.Primitives.ComposablePart part) { }
    }
    public partial interface INotifyComposablePartCatalogChanged
    {
        event System.EventHandler<System.ComponentModel.Composition.Hosting.ComposablePartCatalogChangeEventArgs> Changed;
        event System.EventHandler<System.ComponentModel.Composition.Hosting.ComposablePartCatalogChangeEventArgs> Changing;
    }
    public static partial class ScopingExtensions
    {
        public static bool ContainsPartMetadataWithKey(this System.ComponentModel.Composition.Primitives.ComposablePartDefinition part, string key) { throw null; }
        public static bool ContainsPartMetadata<T>(this System.ComponentModel.Composition.Primitives.ComposablePartDefinition part, string key, T value) { throw null; }
        public static bool Exports(this System.ComponentModel.Composition.Primitives.ComposablePartDefinition part, string contractName) { throw null; }
        public static System.ComponentModel.Composition.Hosting.FilteredCatalog Filter(this System.ComponentModel.Composition.Primitives.ComposablePartCatalog catalog, System.Func<System.ComponentModel.Composition.Primitives.ComposablePartDefinition, bool> filter) { throw null; }
        public static bool Imports(this System.ComponentModel.Composition.Primitives.ComposablePartDefinition part, string contractName) { throw null; }
        public static bool Imports(this System.ComponentModel.Composition.Primitives.ComposablePartDefinition part, string contractName, System.ComponentModel.Composition.Primitives.ImportCardinality importCardinality) { throw null; }
    }
    public partial class TypeCatalog : System.ComponentModel.Composition.Primitives.ComposablePartCatalog, System.ComponentModel.Composition.Primitives.ICompositionElement
    {
        public TypeCatalog(System.Collections.Generic.IEnumerable<System.Type> types) { }
        public TypeCatalog(System.Collections.Generic.IEnumerable<System.Type> types, System.ComponentModel.Composition.Primitives.ICompositionElement definitionOrigin) { }
        public TypeCatalog(System.Collections.Generic.IEnumerable<System.Type> types, System.Reflection.ReflectionContext reflectionContext) { }
        public TypeCatalog(System.Collections.Generic.IEnumerable<System.Type> types, System.Reflection.ReflectionContext reflectionContext, System.ComponentModel.Composition.Primitives.ICompositionElement definitionOrigin) { }
        public TypeCatalog(params System.Type[] types) { }
        string System.ComponentModel.Composition.Primitives.ICompositionElement.DisplayName { get { throw null; } }
        System.ComponentModel.Composition.Primitives.ICompositionElement System.ComponentModel.Composition.Primitives.ICompositionElement.Origin { get { throw null; } }
        protected override void Dispose(bool disposing) { }
        public override System.Collections.Generic.IEnumerator<System.ComponentModel.Composition.Primitives.ComposablePartDefinition> GetEnumerator() { throw null; }
        public override string ToString() { throw null; }
    }
}
namespace System.ComponentModel.Composition.Primitives
{
    public abstract partial class ComposablePart
    {
        protected ComposablePart() { }
        public abstract System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ExportDefinition> ExportDefinitions { get; }
        public abstract System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ImportDefinition> ImportDefinitions { get; }
        public virtual System.Collections.Generic.IDictionary<string, object> Metadata { get { throw null; } }
        public virtual void Activate() { }
        public abstract object GetExportedValue(System.ComponentModel.Composition.Primitives.ExportDefinition definition);
        public abstract void SetImport(System.ComponentModel.Composition.Primitives.ImportDefinition definition, System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.Export> exports);
    }
    public abstract partial class ComposablePartCatalog : System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ComposablePartDefinition>, System.Collections.IEnumerable, System.IDisposable
    {
        protected ComposablePartCatalog() { }
        [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
        public virtual System.Linq.IQueryable<System.ComponentModel.Composition.Primitives.ComposablePartDefinition> Parts { get { throw null; } }
        public void Dispose() { }
        protected virtual void Dispose(bool disposing) { }
        public virtual System.Collections.Generic.IEnumerator<System.ComponentModel.Composition.Primitives.ComposablePartDefinition> GetEnumerator() { throw null; }
        public virtual System.Collections.Generic.IEnumerable<System.Tuple<System.ComponentModel.Composition.Primitives.ComposablePartDefinition, System.ComponentModel.Composition.Primitives.ExportDefinition>> GetExports(System.ComponentModel.Composition.Primitives.ImportDefinition definition) { throw null; }
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
    }
    public abstract partial class ComposablePartDefinition
    {
        protected ComposablePartDefinition() { }
        public abstract System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ExportDefinition> ExportDefinitions { get; }
        public abstract System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ImportDefinition> ImportDefinitions { get; }
        public virtual System.Collections.Generic.IDictionary<string, object> Metadata { get { throw null; } }
        public abstract System.ComponentModel.Composition.Primitives.ComposablePart CreatePart();
    }
    public partial class ComposablePartException : System.Exception
    {
        public ComposablePartException() { }
        protected ComposablePartException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
        public ComposablePartException(string message) { }
        public ComposablePartException(string message, System.ComponentModel.Composition.Primitives.ICompositionElement element) { }
        public ComposablePartException(string message, System.ComponentModel.Composition.Primitives.ICompositionElement element, System.Exception innerException) { }
        public ComposablePartException(string message, System.Exception innerException) { }
        public System.ComponentModel.Composition.Primitives.ICompositionElement Element { get { throw null; } }
        public override void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
    }
    public partial class ContractBasedImportDefinition : System.ComponentModel.Composition.Primitives.ImportDefinition
    {
        protected ContractBasedImportDefinition() { }
        public ContractBasedImportDefinition(string contractName, string requiredTypeIdentity, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, System.Type>> requiredMetadata, System.ComponentModel.Composition.Primitives.ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite, System.ComponentModel.Composition.CreationPolicy requiredCreationPolicy) { }
        public ContractBasedImportDefinition(string contractName, string requiredTypeIdentity, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, System.Type>> requiredMetadata, System.ComponentModel.Composition.Primitives.ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite, System.ComponentModel.Composition.CreationPolicy requiredCreationPolicy, System.Collections.Generic.IDictionary<string, object> metadata) { }
        public override System.Linq.Expressions.Expression<System.Func<System.ComponentModel.Composition.Primitives.ExportDefinition, bool>> Constraint { get { throw null; } }
        public virtual System.ComponentModel.Composition.CreationPolicy RequiredCreationPolicy { get { throw null; } }
        public virtual System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, System.Type>> RequiredMetadata { get { throw null; } }
        public virtual string RequiredTypeIdentity { get { throw null; } }
        public override bool IsConstraintSatisfiedBy(System.ComponentModel.Composition.Primitives.ExportDefinition exportDefinition) { throw null; }
        public override string ToString() { throw null; }
    }
    public partial class Export
    {
        protected Export() { }
        public Export(System.ComponentModel.Composition.Primitives.ExportDefinition definition, System.Func<object> exportedValueGetter) { }
        public Export(string contractName, System.Collections.Generic.IDictionary<string, object> metadata, System.Func<object> exportedValueGetter) { }
        public Export(string contractName, System.Func<object> exportedValueGetter) { }
        public virtual System.ComponentModel.Composition.Primitives.ExportDefinition Definition { get { throw null; } }
        public System.Collections.Generic.IDictionary<string, object> Metadata { get { throw null; } }
        public object Value { get { throw null; } }
        protected virtual object GetExportedValueCore() { throw null; }
    }
    public partial class ExportDefinition
    {
        protected ExportDefinition() { }
        public ExportDefinition(string contractName, System.Collections.Generic.IDictionary<string, object> metadata) { }
        public virtual string ContractName { get { throw null; } }
        public virtual System.Collections.Generic.IDictionary<string, object> Metadata { get { throw null; } }
        public override string ToString() { throw null; }
    }
    public partial class ExportedDelegate
    {
        protected ExportedDelegate() { }
        public ExportedDelegate(object instance, System.Reflection.MethodInfo method) { }
        public virtual System.Delegate CreateDelegate(System.Type delegateType) { throw null; }
    }
    public partial interface ICompositionElement
    {
        string DisplayName { get; }
        System.ComponentModel.Composition.Primitives.ICompositionElement Origin { get; }
    }
    public enum ImportCardinality
    {
        ZeroOrOne = 0,
        ExactlyOne = 1,
        ZeroOrMore = 2,
    }
    public partial class ImportDefinition
    {
        protected ImportDefinition() { }
        public ImportDefinition(System.Linq.Expressions.Expression<System.Func<System.ComponentModel.Composition.Primitives.ExportDefinition, bool>> constraint, string contractName, System.ComponentModel.Composition.Primitives.ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite) { }
        public ImportDefinition(System.Linq.Expressions.Expression<System.Func<System.ComponentModel.Composition.Primitives.ExportDefinition, bool>> constraint, string contractName, System.ComponentModel.Composition.Primitives.ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite, System.Collections.Generic.IDictionary<string, object> metadata) { }
        public virtual System.ComponentModel.Composition.Primitives.ImportCardinality Cardinality { get { throw null; } }
        public virtual System.Linq.Expressions.Expression<System.Func<System.ComponentModel.Composition.Primitives.ExportDefinition, bool>> Constraint { get { throw null; } }
        public virtual string ContractName { get { throw null; } }
        public virtual bool IsPrerequisite { get { throw null; } }
        public virtual bool IsRecomposable { get { throw null; } }
        public virtual System.Collections.Generic.IDictionary<string, object> Metadata { get { throw null; } }
        public virtual bool IsConstraintSatisfiedBy(System.ComponentModel.Composition.Primitives.ExportDefinition exportDefinition) { throw null; }
        public override string ToString() { throw null; }
    }
}
namespace System.ComponentModel.Composition.ReflectionModel
{
    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
    public partial struct LazyMemberInfo
    {
        private object _dummy;
        private int _dummyPrimitive;
        public LazyMemberInfo(System.Reflection.MemberInfo member) { throw null; }
        public LazyMemberInfo(System.Reflection.MemberTypes memberType, System.Func<System.Reflection.MemberInfo[]> accessorsCreator) { throw null; }
        public LazyMemberInfo(System.Reflection.MemberTypes memberType, params System.Reflection.MemberInfo[] accessors) { throw null; }
        public System.Reflection.MemberTypes MemberType { get { throw null; } }
        public override bool Equals(object obj) { throw null; }
        public System.Reflection.MemberInfo[] GetAccessors() { throw null; }
        public override int GetHashCode() { throw null; }
        public static bool operator ==(System.ComponentModel.Composition.ReflectionModel.LazyMemberInfo left, System.ComponentModel.Composition.ReflectionModel.LazyMemberInfo right) { throw null; }
        public static bool operator !=(System.ComponentModel.Composition.ReflectionModel.LazyMemberInfo left, System.ComponentModel.Composition.ReflectionModel.LazyMemberInfo right) { throw null; }
    }
    public static partial class ReflectionModelServices
    {
        public static System.ComponentModel.Composition.Primitives.ExportDefinition CreateExportDefinition(System.ComponentModel.Composition.ReflectionModel.LazyMemberInfo exportingMember, string contractName, System.Lazy<System.Collections.Generic.IDictionary<string, object>> metadata, System.ComponentModel.Composition.Primitives.ICompositionElement origin) { throw null; }
        public static System.ComponentModel.Composition.Primitives.ContractBasedImportDefinition CreateImportDefinition(System.ComponentModel.Composition.ReflectionModel.LazyMemberInfo importingMember, string contractName, string requiredTypeIdentity, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, System.Type>> requiredMetadata, System.ComponentModel.Composition.Primitives.ImportCardinality cardinality, bool isRecomposable, bool isPreRequisite, System.ComponentModel.Composition.CreationPolicy requiredCreationPolicy, System.Collections.Generic.IDictionary<string, object> metadata, bool isExportFactory, System.ComponentModel.Composition.Primitives.ICompositionElement origin) { throw null; }
        public static System.ComponentModel.Composition.Primitives.ContractBasedImportDefinition CreateImportDefinition(System.ComponentModel.Composition.ReflectionModel.LazyMemberInfo importingMember, string contractName, string requiredTypeIdentity, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, System.Type>> requiredMetadata, System.ComponentModel.Composition.Primitives.ImportCardinality cardinality, bool isRecomposable, System.ComponentModel.Composition.CreationPolicy requiredCreationPolicy, System.Collections.Generic.IDictionary<string, object> metadata, bool isExportFactory, System.ComponentModel.Composition.Primitives.ICompositionElement origin) { throw null; }
        public static System.ComponentModel.Composition.Primitives.ContractBasedImportDefinition CreateImportDefinition(System.ComponentModel.Composition.ReflectionModel.LazyMemberInfo importingMember, string contractName, string requiredTypeIdentity, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, System.Type>> requiredMetadata, System.ComponentModel.Composition.Primitives.ImportCardinality cardinality, bool isRecomposable, System.ComponentModel.Composition.CreationPolicy requiredCreationPolicy, System.ComponentModel.Composition.Primitives.ICompositionElement origin) { throw null; }
        public static System.ComponentModel.Composition.Primitives.ContractBasedImportDefinition CreateImportDefinition(System.Lazy<System.Reflection.ParameterInfo> parameter, string contractName, string requiredTypeIdentity, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, System.Type>> requiredMetadata, System.ComponentModel.Composition.Primitives.ImportCardinality cardinality, System.ComponentModel.Composition.CreationPolicy requiredCreationPolicy, System.Collections.Generic.IDictionary<string, object> metadata, bool isExportFactory, System.ComponentModel.Composition.Primitives.ICompositionElement origin) { throw null; }
        public static System.ComponentModel.Composition.Primitives.ContractBasedImportDefinition CreateImportDefinition(System.Lazy<System.Reflection.ParameterInfo> parameter, string contractName, string requiredTypeIdentity, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, System.Type>> requiredMetadata, System.ComponentModel.Composition.Primitives.ImportCardinality cardinality, System.ComponentModel.Composition.CreationPolicy requiredCreationPolicy, System.ComponentModel.Composition.Primitives.ICompositionElement origin) { throw null; }
        public static System.ComponentModel.Composition.Primitives.ComposablePartDefinition CreatePartDefinition(System.Lazy<System.Type> partType, bool isDisposalRequired, System.Lazy<System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ImportDefinition>> imports, System.Lazy<System.Collections.Generic.IEnumerable<System.ComponentModel.Composition.Primitives.ExportDefinition>> exports, System.Lazy<System.Collections.Generic.IDictionary<string, object>> metadata, System.ComponentModel.Composition.Primitives.ICompositionElement origin) { throw null; }
        public static System.ComponentModel.Composition.Primitives.ContractBasedImportDefinition GetExportFactoryProductImportDefinition(System.ComponentModel.Composition.Primitives.ImportDefinition importDefinition) { throw null; }
        public static System.ComponentModel.Composition.ReflectionModel.LazyMemberInfo GetExportingMember(System.ComponentModel.Composition.Primitives.ExportDefinition exportDefinition) { throw null; }
        public static System.ComponentModel.Composition.ReflectionModel.LazyMemberInfo GetImportingMember(System.ComponentModel.Composition.Primitives.ImportDefinition importDefinition) { throw null; }
        public static System.Lazy<System.Reflection.ParameterInfo> GetImportingParameter(System.ComponentModel.Composition.Primitives.ImportDefinition importDefinition) { throw null; }
        public static System.Lazy<System.Type> GetPartType(System.ComponentModel.Composition.Primitives.ComposablePartDefinition partDefinition) { throw null; }
        public static bool IsDisposalRequired(System.ComponentModel.Composition.Primitives.ComposablePartDefinition partDefinition) { throw null; }
        public static bool IsExportFactoryImportDefinition(System.ComponentModel.Composition.Primitives.ImportDefinition importDefinition) { throw null; }
        public static bool IsImportingParameter(System.ComponentModel.Composition.Primitives.ImportDefinition importDefinition) { throw null; }
        public static bool TryMakeGenericPartDefinition(System.ComponentModel.Composition.Primitives.ComposablePartDefinition partDefinition, System.Collections.Generic.IEnumerable<System.Type> genericParameters, out System.ComponentModel.Composition.Primitives.ComposablePartDefinition specialization) { throw null; }
    }
}

{'repo_name': 'dotnet/standard', 'stars': '2989', 'repo_language': 'C#', 'file_name': 'packages.config', 'mime_type': 'text/xml', 'hash': 1725999295970912086, 'source_dataset': 'data'}


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

        <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
        <title>Rgaa30 Test.11-10-8 NMI 01</title>

Rgaa30 Test.11-10-8 NMI 01

 Chaque indication du type de donnée et/ou de format réalisée grâce à la propriété ARIA
                aria-label doit être accompagnée d'une indication visuelle explicite dans l’étiquette (balise
                label) ou dans un passage de texte lié au champ par la propriété ARIA
                aria-describedby ou
                aria-labelledby, cette règle est-elle respectée ?

                 NMI.

{'repo_name': 'Asqatasun/Asqatasun', 'stars': '202', 'repo_language': 'Java', 'file_name': 'main.yml', 'mime_type': 'text/plain', 'hash': 6260710679667207818, 'source_dataset': 'data'}


/*
 * Copyright (c) 2007 Henric Jungheim <software@henric.info>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/*
 * NIST SP 800-90 CTR_DRBG (Random Number Generator)
 */

#ifndef NIST_CTR_DRBG_H
#define NIST_CTR_DRBG_H

#ifndef NIST_CONFIG_H
#include "nist_config.h"
#endif

#define NIST_BLOCK_SEEDLEN			(NIST_BLOCK_KEYLEN + NIST_BLOCK_OUTLEN)
#define NIST_BLOCK_SEEDLEN_BYTES	(NIST_BLOCK_SEEDLEN / 8)
#define NIST_BLOCK_SEEDLEN_INTS		(NIST_BLOCK_SEEDLEN_BYTES / sizeof(int))

#ifndef NIST_KEY_ALIGNMENT
#define NIST_KEY_ALIGNMENT
#endif

typedef struct {
	unsigned int reseed_counter;
	NIST_Key ctx;
	unsigned int V[NIST_BLOCK_OUTLEN_INTS];
} NIST_KEY_ALIGNMENT NIST_CTR_DRBG;

int
nist_ctr_initialize(void);

int
nist_ctr_drbg_generate(NIST_CTR_DRBG* drbg,
	void* output_string, int output_string_length,
	const void* additional_input, int additional_input_length);

int
nist_ctr_drbg_reseed(NIST_CTR_DRBG* drbg,
	const void* entropy_input, int entropy_input_length,
	const void* additional_input, int additional_input_length);

int
nist_ctr_drbg_instantiate(NIST_CTR_DRBG* drbg,
	const void* entropy_input, int entropy_input_length,
	const void* nonce, int nonce_length,
	const void* personalization_string, int personalization_string_length);

int
nist_ctr_drbg_destroy(NIST_CTR_DRBG* );

void
nist_dump_simple_hex(const void* data, int length);

void
nist_dump_hex(const void* data, int length);

void
nist_dump_named_hex(const char* name, const void* data, int length);

void
nist_dump_ctr_drbg(const NIST_CTR_DRBG* drbg);

void
nist_dump_block_ctx(const NIST_Key* ctx);

#ifdef NIST_ZEROIZE
#define nist_zeroize(p, s) memset(p, 0, s)
#else
#define nist_zeroize(p, s) do { } while(0)
#endif

/*
 * The test vectors will indicate failure if the
 * byte ordering is set incorrectly.
 * Pretending to be little endian will improve performance
 * slightly but should not have an impact on
 * security (a byte-swapped nonce is still a nonce).
 */

#ifndef NIST_HTONL
#if defined(NIST_IS_LITTLE_ENDIAN)
#define NIST_HTONL(x) nist_htonl(x)
static __inline unsigned int nist_htonl(unsigned int x)
{
	return
		((((x) & 0xff000000) >> 24) |
		 (((x) & 0x00ff0000) >>  8) |
		 (((x) & 0x0000ff00) <<  8) |
		 (((x) & 0x000000ff) << 24));
}
#elif defined(NIST_IS_BIG_ENDIAN)
#define NIST_HTONL(x) (x)
#else
#error "Define NIST_HTONL or define NIST_IS_{BIG|LITTLE}_ENDIAN."
#endif
#endif /* NIST_HTONL */

#ifndef NIST_NTOHL
/* BE->H and H->BE are usually the same. */
#define NIST_NTOHL(x) NIST_HTONL(x)
#endif /* NIST_NTOHL */

#endif /* NIST_CTR_DRBG_H */

{'repo_name': 'tbuktu/libntru', 'stars': '155', 'repo_language': 'C', 'file_name': 'test_hash.c', 'mime_type': 'text/x-c', 'hash': 967494672610418051, 'source_dataset': 'data'}


fileFormatVersion: 2
guid: 734fb490c79cd2649b1af5f418540e94
MonoImporter:
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData:

{'repo_name': 'Wenzil/UnityConsole', 'stars': '122', 'repo_language': 'C#', 'file_name': 'Console.prefab.meta', 'mime_type': 'text/plain', 'hash': -3406641349678075501, 'source_dataset': 'data'}


/*
 *
 *  Copyright 2013 Netflix, Inc.
 *
 *     Licensed under the Apache License, Version 2.0 (the "License");
 *     you may not use this file except in compliance with the License.
 *     You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 *     Unless required by applicable law or agreed to in writing, software
 *     distributed under the License is distributed on an "AS IS" BASIS,
 *     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *     See the License for the specific language governing permissions and
 *     limitations under the License.
 *
 */
package com.netflix.ice.common;

public enum ConsolidateType {
    hourly(3600000L),
    daily(24*3600000L),
    weekly(24*7*3600000L),
    monthly(-1);

    public final long millis;

    private ConsolidateType(long millis) {
        this.millis = millis;
    }
}

{'repo_name': 'Teevity/ice', 'stars': '2702', 'repo_language': 'Java', 'file_name': 'setenv.sh', 'mime_type': 'text/plain', 'hash': -6424109061743054154, 'source_dataset': 'data'}


import alt from '../alt';
import regHubUtil from '../utils/RegHubUtil';

class RepositoryActions {
  recommended () {
    this.dispatch({});
    regHubUtil.recommended();
  }

  search (query, page = 1) {
    this.dispatch({query, page});
    regHubUtil.search(query, page);
  }

  repos () {
    this.dispatch({});
    regHubUtil.repos();
  }
}

export default alt.createActions(RepositoryActions);

{'repo_name': 'docker/kitematic', 'stars': '11759', 'repo_language': 'JavaScript', 'file_name': 'config.yml', 'mime_type': 'text/plain', 'hash': -7875223841289996094, 'source_dataset': 'data'}


//
// Code (inline and block)
// --------------------------------------------------

// Inline and block code styles
code,
kbd,
pre,
samp {
  font-family: $font-family-monospace;
}

// Inline code
code {
  padding: 2px 4px;
  font-size: 90%;
  color: $code-color;
  background-color: $code-bg;
  border-radius: $border-radius-base;
}

// User input typically entered via keyboard
kbd {
  padding: 2px 4px;
  font-size: 90%;
  color: $kbd-color;
  background-color: $kbd-bg;
  border-radius: $border-radius-small;
  box-shadow: inset 0 -1px 0 rgba(0,0,0,.25);

  kbd {
    padding: 0;
    font-size: 100%;
    font-weight: bold;
    box-shadow: none;
  }
}

// Blocks of code
pre {
  display: block;
  padding: (($line-height-computed - 1) / 2);
  margin: 0 0 ($line-height-computed / 2);
  font-size: ($font-size-base - 1); // 14px to 13px
  line-height: $line-height-base;
  word-break: break-all;
  word-wrap: break-word;
  color: $pre-color;
  background-color: $pre-bg;
  border: 1px solid $pre-border-color;
  border-radius: $border-radius-base;

  // Account for some code outputs that place code tags in pre tags
  code {
    padding: 0;
    font-size: inherit;
    color: inherit;
    white-space: pre-wrap;
    background-color: transparent;
    border-radius: 0;
  }
}

// Enable scrollable blocks of code
.pre-scrollable {
  max-height: $pre-scrollable-max-height;
  overflow-y: scroll;
}

{'repo_name': 'kyokidG/html-templates', 'stars': '141', 'repo_language': 'HTML', 'file_name': 'main.js', 'mime_type': 'text/html', 'hash': -1452073333190516563, 'source_dataset': 'data'}


"""
   ASTEVAL provides a numpy-aware, safe(ish) "eval" function

   Emphasis is on mathematical expressions, and so numpy ufuncs
   are used if available.  Symbols are held in the Interpreter
   symbol table 'symtable':  a simple dictionary supporting a
   simple, flat namespace.

   Expressions can be compiled into ast node for later evaluation,
   using the values in the symbol table current at evaluation time.

   version: 0.9.13
   last update: 2018-Sept-29
   License:  MIT
   Author:  Matthew Newville <newville@cars.uchicago.edu>
            Center for Advanced Radiation Sources,
            The University of Chicago
"""

from .asteval import Interpreter
from .astutils import (NameFinder, valid_symbol_name,
                       make_symbol_table, get_ast_names)
from ._version import get_versions

__all__ = ['Interpreter', 'NameFinder', 'valid_symbol_name',
           'make_symbol_table', 'get_ast_names']

__version__ = get_versions()['version']
del get_versions

{'repo_name': 'sectalks/sectalks', 'stars': '247', 'repo_language': 'HTML', 'file_name': 'README.md', 'mime_type': 'text/x-python', 'hash': -118911427294794821, 'source_dataset': 'data'}


EinsteinPy - Making Einstein possible in Python
===============================================

.. image:: https://einsteinpy.org/img/wordmark.png
   :target: https://einsteinpy.org/
   :alt: EinsteinPy logo
   :width: 675px
   :align: center

**EinsteinPy** is an open source pure Python package dedicated to problems arising
in General Relativity and gravitational physics, such as geodesics plotting for
Schwarzschild, Kerr and Kerr Newman space-time model, calculation of Schwarzschild
radius, calculation of Event Horizon and Ergosphere for Kerr space-time. Symbolic
Manipulations of various tensors like Metric, Riemann, Ricci and Christoffel Symbols
is also possible using the library. EinsteinPy also features Hypersurface Embedding of
Schwarzschild space-time, which will soon lead to modelling of Gravitational Lensing!
It is released under the MIT license.

View `source code`_ of EinsteinPy!

.. _`source code`: https://github.com/einsteinpy/einsteinpy

Key features of EinsteinPy are:

* Geometry analysis and trajectory calculation in vacuum solutions of Einstein's field equations

 * Schwarzschild space-time
 * Kerr space-time
 * Kerr-Newman space-time

* Various utilities related to above geometry models

 * Schwarzschild Radius
 * Event horizon and ergosphere for Kerr black hole
 * Maxwell Tensor and electromagnetic potential in Kerr-Newman space-time
 * And much more!

* Symbolic Calculation of various quantities

 * Christoffel Symbols
 * Riemann Curvature Tensor
 * Ricci Tensor
 * Index uppering and lowering!
 * Simplification of symbolic expressions

* Geodesic Plotting

 * Static Plotting using Matplotlib
 * Interactive 2D plotting
 * Environment aware plotting!

* Coordinate conversion with unit handling

 * Spherical/Cartesian Coordinates
 * Boyer-Lindquist/Cartesian Coordinates

* Hypersurface Embedding of Schwarzschild Space-Time

* Shadow cast by an thin emission disk around a Schwarzschild Black Hole

And more to come!

Einsteinpy is developed by an open community. Release
announcements and general discussion take place on our `mailing list`_
and `chat`_.

.. _`mailing list`: https://groups.io/g/einsteinpy-dev
.. _`chat`: https://riot.im/app/#/room/#einsteinpy:matrix.org

.. include:: form.rst

The `source code`_, `issue tracker`_ and `wiki`_ are hosted on GitHub, and all
contributions and feedback are more than welcome. You can test EinsteinPy in your
browser using binder, a cloud Jupyter notebook server:

.. image:: https://img.shields.io/badge/launch-binder-e66581.svg?style=flat-square
   :target: https://beta.mybinder.org/v2/gh/einsteinpy/einsteinpy/master?filepath=index.ipynb

.. _`source code`: https://github.com/einsteinpy/einsteinpy
.. _`issue tracker`: https://github.com/einsteinpy/einsteinpy/issues
.. _`wiki`: https://github.com/einsteinpy/einsteinpy/wiki/

EinsteinPy works on recent versions of Python and is released under
the MIT license, hence allowing commercial use of the library.

.. code-block:: python

    from einsteinpy.plotting import GeodesicPlotter
    from einsteinpy.examples import perihelion
    a = GeodesicPlotter()
    a.plot(perihelion())
    a.show()

.. figure:: _static/perihelion.png
   :align: center
   :figwidth: 650px
   :alt: Advancement of perihelion in Schwarzschild space-time

Contents
--------

.. toctree::
    :maxdepth: 2

    getting_started
    user_guide
    metric
    jupyter
    changelog
    dev_guide
    api/index
    codeofconduct

{'repo_name': 'einsteinpy/einsteinpy', 'stars': '250', 'repo_language': 'Python', 'file_name': 'config.yml', 'mime_type': 'text/plain', 'hash': -2326456253336188617, 'source_dataset': 'data'}