SSI Kit

 by walt.id

Use digital identity

[![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=walt-id_waltid-ssikit&metric=security_rating)](https://sonarcloud.io/dashboard?id=walt-id_waltid-ssikit)
[![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=walt-id_waltid-ssikit&metric=vulnerabilities)](https://sonarcloud.io/dashboard?id=walt-id_waltid-ssikit)
[![Reliability Rating](https://sonarcloud.io/api/project_badges/measure?project=walt-id_waltid-ssikit&metric=reliability_rating)](https://sonarcloud.io/dashboard?id=walt-id_waltid-ssikit)
[![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=walt-id_waltid-ssikit&metric=sqale_rating)](https://sonarcloud.io/dashboard?id=walt-id_waltid-ssikit)
[![Lines of Code](https://sonarcloud.io/api/project_badges/measure?project=walt-id_waltid-ssikit&metric=ncloc)](https://sonarcloud.io/dashboard?id=walt-id_waltid-ssikit)
[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=walt-id_waltid-ssikit-examples&metric=alert_status)](https://sonarcloud.io/dashboard?id=walt-id_waltid-ssikit)

[![CI/CD Workflow for walt.id SSI Kit](https://github.com/walt-id/waltid-ssikit/actions/workflows/build.yml/badge.svg?branch=master)](https://github.com/walt-id/waltid-ssikit/actions/workflows/build.yml)

## Discontinuation Notice

**Important:** Please be informed that, beginning from December 2023, the SSI Kit will no longer receive new features. Furthermore, the SSI Kit is planned for discontinuation by the end of Q3 2024.

However, all functionalities offered by the SSI Kit will be integrated into our new libraries, APIs, and apps in the walt.id [identity repo](https://github.com/walt-id/waltid-identity). Giving you more modularity, flexibility and ease-of-use to build end-to-end digital identity and wallet solutions.

For any clarification or queries, feel free to [contact us](https://walt.id/discord) as we aim to make this transition as smooth as possible.

## Getting Started

- [CLI | Command Line Interface](https://docs.walt.id/v/ssikit/getting-started/cli-command-line-interface) - Try out the functions of the SSI Kit locally.
- [REST Api](https://docs.walt.id/v/ssikit/getting-started/rest-apis) - Use the functions of the SSI Kit via an REST api.
- [Maven/Gradle Dependency](https://docs.walt.id/v/ssikit/getting-started/dependency-jvm) - Use the functions of the SSI Kit directly in a Kotlin/Java project.
- [Example Projects](https://github.com/walt-id/waltid-ssikit-examples) - Demonstrate how to use the SSI Kit in any Kotlin/Java app

Check out the **[Official Documentation](https://docs.walt.id/v/ssikit)**, to dive deeper into the architecture and configuration options available.

## What is the SSI Kit?

A **library** written in Kotlin/Java **to manage Keys, DIDs and VCs**. Functions can be used via **Maven/Gradle** or a **REST api**.

### Features
- **Key Management** generation, import/export
- **Decentralized Identifier (DID)** operations (create, register, update, deactivate)
- **Verifiable Credential (VC)** operations (issue, present, verify)
- **EBSI/ESSIF** related Use Cases (onboarding, VC exchange, etc.)

#### For EBSI
- **Onboarding EBSI/ESSIF** onboarding a natural person/legal entity including the DID creation and registration
- **Enable Trusted Issuer** process for entitling a legal entity to become a Trusted Issuer in the ESSIF ecosystem.
- **Credential Issuance** protocols and data formats for issuing W3C credentials from a Trusted Issuer to a natural person.
- **Credential Verification** verification facilities in order to determine the validity of a W3C Verifiable Credential aligned with EBSI/ESSIF standards.

## Example

- Creating W3C Decentralized Identifiers
- Issuing/verifying W3C Verifiable Credentials in JSON_LD and JWT format

```kotlin
fun main() {
    // Load services
    ServiceMatrix("service-matrix.properties")

    // Create DIDs
    val issuerDid = DidService.create(DidMethod.ebsi)
    val holderDid = DidService.create(DidMethod.key)

    // Issue VC with LD_PROOF and JWT format (for show-casing both formats)
    val vcJson = Signatory.getService().issue(
        templateIdOrFilename = "VerifiableId",
        config = ProofConfig(issuerDid = issuerDid, subjectDid = holderDid, proofType = ProofType.LD_PROOF)
    )
    val vcJwt = Signatory.getService().issue(
        templateIdOrFilename = "Europass",
        config = ProofConfig(issuerDid = issuerDid, subjectDid = holderDid, proofType = ProofType.JWT)
    )

    // Present VC in JSON-LD and JWT format (for show-casing both formats)
    val vpJson = Custodian.getService().createPresentation(listOf(vcJson), holderDid)
    val vpJwt = Custodian.getService().createPresentation(listOf(vcJwt), holderDid)

    // Verify VPs, using Signature, JsonSchema and a custom policy
    val resJson = Auditor.getService().verify(vpJson, listOf(SignaturePolicy(), JsonSchemaPolicy()))
    val resJwt = Auditor.getService().verify(vpJwt, listOf(SignaturePolicy(), JsonSchemaPolicy()))

    println("JSON verification result: ${resJson.policyResults}")
    println("JWT verification result:  ${resJwt.policyResults}")
}
```

## Join the community

* Connect and get the latest updates: Discord | Newsletter | YouTube | Twitter
* Get help, request features and report bugs: GitHub Discussions

## Standards & Specifications

- [EBSI Wallet Conformance](https://api-conformance.ebsi.eu/docs/wallet-conformance)
- [Verifiable Credentials Data Model 1.0](https://www.w3.org/TR/vc-data-model/)
- [OpenID for Verifiable Credentials](https://openid.net/openid4vc/)
- [Decentralized Identifiers (DIDs) v1.0](https://w3c.github.io/did-core/)
- [DID Method Rubric](https://w3c.github.io/did-rubric/)
- [did:web Decentralized Identifier Method Specification](https://w3c-ccg.github.io/did-method-web/)
- [The did:key Method v0.7](https://w3c-ccg.github.io/did-method-key/)

## License

**Licensed under the [Apache License, Version 2.0](https://github.com/walt-id/waltid-ssikit/blob/master/LICENSE).**

## Funded & supported by


# Lawnicons

[![Build debug APK](https://github.com/LawnchairLauncher/lawnicons/actions/workflows/build_debug_apk.yml/badge.svg)](https://github.com/LawnchairLauncher/lawnicons/actions/workflows/build_debug_apk.yml)
[![Build release APK](https://github.com/LawnchairLauncher/lawnicons/actions/workflows/build_release_apk.yml/badge.svg)](https://github.com/LawnchairLauncher/lawnicons/actions/workflows/build_release_apk.yml)
[![Discord](https://img.shields.io/discord/803299970169700402?label=server&logo=discord)](https://discord.gg/lawnchair-803299970169700402)
[![License is Apache 2](https://img.shields.io/github/license/LawnchairLauncher/lawnicons)](LICENSE)

**Lawnicons** is an icon pack developed by the Lawnchair team and supported by our community.
Originally an addon for Lawnchair 12 Alpha 5 and above to implement themed icons, it can now be used on many launchers.

Lawnicons is best used [on Lawnchair 12.1 or Lawnchair 14 Beta 2](https://github.com/LawnchairLauncher/lawnchair/releases). You can enable themed icons on Lawnchair by going to `Home Settings → General → Icon Style → Themed Icons → "Home screen" or "Home screen and App Drawer"`.

## Download
See [the Releases section](https://github.com/LawnchairLauncher/lawnicons/releases) for the latest stable build. For development builds with new icons, go to [nightly.link](https://nightly.link/LawnchairLauncher/lawnicons/workflows/build_debug_apk/develop/Debug%20APK).

## Contributing
Please see [the Lawnicons guidelines](CONTRIBUTING.md) for information on contributing icons or code, it will save you time.

Android developers can find tasks [in our issues](https://github.com/LawnchairLauncher/lawnicons/issues).
Anyone who is interested in making icons can fulfill [the popular icon requests](https://docs.google.com/spreadsheets/d/1AXc9EDXA6udZeGROtB5nuABjM33VluGY_V24tIzHaKc/edit?resourcekey#gid=651079103).

Need help? [Join us on Discord](https://discord.gg/3x8qNWxgGZ).

## Requesting icons
Please use **Lawnicons 2.10+**: `Open Lawnicons → Tap "Request icons" → Submit the response`.

You can also use [the icon request form](https://forms.gle/xt7sJhgWEasuo9TR9). If a previously added icon has a design change, create [an issue](https://github.com/LawnchairLauncher/lawnicons/issues).


# Readium Kotlin Toolkit

[Readium Mobile](https://github.com/readium/mobile) is a toolkit for ebooks, audiobooks and comics written in Swift & Kotlin.

:point_up: **Take a look at the [guide to get started](docs/guides/getting-started.md).** A [Test App](test-app) demonstrates how to integrate the Readium Kotlin toolkit in your own reading app.

:question: **Find documentation and API reference at [readium.org/kotlin-toolkit](https://readium.org/kotlin-toolkit)**.

## Minimum Requirements

| Readium | Android min SDK | Android compile SDK | Kotlin compiler (✻) | Gradle (✻) |
|---------|-----------------|---------------------|---------------------|------------|
| 3.0.0   | 21              | 34                  | 1.9.24              | 8.6.0      |
| 2.3.0   | 21              | 33                  | 1.7.10              | 6.9.3      |

✻ Only required if you integrate Readium as a submodule instead of using Maven Central.

## Setting Up Readium

Readium modules are distributed with [Maven Central](https://search.maven.org/search?q=g:org.readium.kotlin-toolkit). Make sure that you have the `$readium_version` property set in your root `build.gradle`, then add the Maven Central and JCenter repositories.

```groovy
buildscript {
    ext.readium_version = '3.0.0-beta.1'
}

allprojects {
    repositories {
        jcenter()
        mavenCentral()
    }
}
```

Then, add the dependencies to the Readium modules you need in your app's `build.gradle`.

```groovy
dependencies {
    implementation "org.readium.kotlin-toolkit:readium-shared:$readium_version"
    implementation "org.readium.kotlin-toolkit:readium-streamer:$readium_version"
    implementation "org.readium.kotlin-toolkit:readium-navigator:$readium_version"
    implementation "org.readium.kotlin-toolkit:readium-opds:$readium_version"
    implementation "org.readium.kotlin-toolkit:readium-lcp:$readium_version"
}
```

### Using a local Git clone

You may prefer to use a local Git clone if you want to contribute to Readium, or if you are using your own fork.

First, add the repository as a Git submodule of your app repository, then checkout the desired branch or tag:

```sh
git submodule add https://github.com/readium/kotlin-toolkit.git
```

Make sure you have Jetifier enabled in your `gradle.properties` file:

```properties
android.enableJetifier=true
```

Then, include the Readium build to your project's `settings.gradle` file. The Readium dependencies will automatically build against the local sources.

```groovy
// Provide the path to the Git submodule.
includeBuild 'kotlin-toolkit'
```

:warning: When importing Readium locally, you will need to use the same version of the Android Gradle Plugin in your project.

### Building with Readium LCP

Using the toolkit with Readium LCP requires additional dependencies, including the binary `liblcp` provided by EDRLab. [Contact EDRLab](mailto:contact@edrlab.org) to request your private `liblcp` and the setup instructions.


# Tchap Android

Tchap Android is an Android Matrix Client provided by [DINUM](https://tchap.beta.gouv.fr/). The app can be run on every Android devices with Android OS Lollipop and more (API 21).

[<img src="resources/img/google-play-badge.png" alt="Get it on Google Play" height="60">](https://play.google.com/store/apps/details?id=fr.gouv.tchap.a)

# New Android SDK

Tchap is based on [Element](https://github.com/element-hq/element-android) with a new Android [SDK](https://github.com/matrix-org/matrix-android-sdk2) fully written in Kotlin. In order to make the early development as fast as possible, Tchap and the new SDK currently share the same git repository.

# Releases to app stores

There is some delay between when a release is created and when it appears in the app stores (Google Play Store). Here are some of the reasons:

* Not all versioned releases that appear on GitHub are considered stable. Each release is first considered beta: this continues for at least two days. If the release is stable (no serious issues or crashes are reported), then it is released as a production release in Google Play Store.
* Each release on the Google Play Store undergoes review by Google before it comes out. This can take an unpredictable amount of time. In some cases it has taken several weeks.

If you would like to receive releases more quickly (bearing in mind that they may not be stable) you have a number of options:

1. [Sign up to receive beta releases](https://play.google.com/apps/testing/fr.gouv.tchap.a) via the Google Play Store.
2. Install a [release APK](https://github.com/tchapgouv/tchap-android/releases) directly - download the relevant .apk file. Note: These are not the store versions, so you may have to uninstall the previous Tchap version before. Take care to properly logout and export your encrypted keys before.

## Contributing

Please refer to [CONTRIBUTING.md](https://github.com/tchapgouv/tchap-android/blob/develop/CONTRIBUTING.md) if you want to contribute on the Tchap Android project!

Come chat with the community in the dedicated Matrix [room](https://matrix.to/#/#element-android:matrix.org).

Also [this documentation](./docs/_developer_onboarding.md) can hopefully help developers to start working on the project.

## Triaging issues

Issues are triaged by community members and the Android App Team, following the [triage process](https://github.com/element-hq/element-meta/wiki/Triage-process).

We use [issue labels](https://github.com/element-hq/element-meta/wiki/Issue-labelling) to sort all incoming issues.


![build](https://github.com/industrial-data-space/trusted-connector/workflows/build/badge.svg)

The _Trusted Connector_ is a Spring Boot-based platform for the Industrial Internet of Things (IIoT). It supports Docker and trust|me as containerization environments and provides the following features:

* Message routing and conversion between protocols with Apache Camel
* _Apps_ in isolated containers
* Data flow- and data usage control
* An Apache Camel component for secure communication and remote attestation between Connectors.

The _Trusted Connector_ has acquired the IDS_ready label. _Trusted Connector_ is a composite of the Core Container and the overall system. Please see the online documentation for details.

![IDS_ready](https://github.com/industrial-data-space/trusted-connector-documentation/blob/master/docs/assets/img/IDS-ready-component.jpg?raw=true)

# How to build & run

Please see the [Github documentation page](https://industrial-data-space.github.io/trusted-connector-documentation/docs/dev_core/)

# How to contribute

Please refer to the [contribution guide](https://github.com/industrial-data-space/trusted-connector/blob/develop/.github/CONTRIBUTING.md)

# Project structure

├── __camel-influxdb__ Influx DB adapter for Apache Camel. (optional. It is not included in the assembly by default)

├── __camel-processors__ _Apache Camel Processors for IDS Multipart, contract negotiation and other IDS-specific message types_

├── __ids-acme__ _ACME 2 client for retrieving TLS certificates for the web console UI_

├── __ids-api__ _Internal APIs of all IDS connector modules._

├── __ids-connector__ _Central subproject for TC Spring Boot build and configurations_

├── __ids-container-manager__ _Management interface to the underlying container management layer (trustme or docker)_

├── __ids-dataflow-control__ _LUCON data flow policy framework_

├── __ids-infomodel-manager__ _Provides the IDS information model_

├── __ids-route-manager__ _Management interface to the underlying message router (Apache Camel)

├── __ids-settings__ _Manages connector configuration_

├── __ids-webconsole__ _Management UI for the connector. Is contained in default assembly but could be moved out of it, if a smaller code base is desired_


# Nadel: A distributed GraphQL engine

Nadel is a Kotlin library to combine several GraphQL services together. This is achieved by combining several underlying
GraphQL services (schemas) into one schema (overall schema).

The main purpose of this library is to power a GraphQL gateway which serves as the entry point for executing requests
across different services while presenting one GraphQL API.

![Nadel GraphQL Gateway](docs/nadel-graphql-gateway.png)

## Features

- Compatible with Java codebases.
- Directive based approach. Existing GraphQL tooling will continue to work.
- Flexible GraphQL transform API. Modify fields and service call responses programmatically using the API.
- Explicit overall schema design: if a schema member is not declared in the `.nadel` file it is not exposed.
- Hydration: resolves references to other objects by calling other services.
- Batching: hydration calls can be automatically batched with a configurable max batch size per call.
- Field rename: fields can be given new names in the context of the exposed schema.
- Type rename: types can be given new names in the context of the exposed schema.
- Dynamic service resolution: _ability to_ programmatically decide which service is called for a top level field.

## Example

Let's assume we have two services: "Issues" and "Users". One has exposes issues and one has users. An `Issue` has a
reference to its author `User`.

This is the schema for the Issues service:

```graphql
type Query {
    issues: [Issue]
}
type Issue {
    id: ID
    authorId: ID
}
```

And this is the Users service:

```graphql
type Query {
    users(ids: [ID]): [User]
}
type User {
    id: ID
    fullName: String
}
```

You can define a combined Nadel schema as follows.

```graphql
# In Issue.nadel
type Query {
    issues: [Issue]
}
type Issue {
    id: ID
    author: User @hydrated(
        # This fetches users in batches
        field: "users"
        arguments: [{ name: "ids" value: "$source.authorId" }]
        inputIdentifiedBy: [{ sourceId: "authorId" resultId: "id" }]
    )
}

# In User.nadel
type Query {
    users(ids: [ID]): [User]
}
type User {
    id: ID
    name: String @renamed(from: "fullName")
}
```

The result is a new GraphQL API which combines the two services in one and has the following schema:

```graphql
type Query {
    issues: [Issue]
    users(ids: [ID]): [User]
}
type Issue {
    id: ID
    authors: [User]
}
type User {
    id: ID
    name: String
}
```

The outside world does not know about the transformations applied by Nadel. It can simply query the data and Nadel will
handle the rest e.g. under the hood Nadel will invoke Users for `users` data if `Issue.author` is requested for.

You can visit
our [test fixtures folder](https://github.com/atlassian-labs/nadel/tree/master/test/src/test/resources/fixtures) for
many more examples.

# Dev setup

In order to run the tests from `EngineTests` in IntelliJ you need to have the KoTest plugin installed.

[Understanding Nadel](./docs/Primer.MD).


:toc:
:toc-placement: preamble
:toclevels: 1
:showtitle:

:plugin_major: 6

= Json Schema to Data Class Gradle plugin

image:https://img.shields.io/github/v/release/jsonschema2dataclass/js2d-gradle[GitHub release (latest by date)]

// Need some preamble to get TOC:
{empty}

== Introduction

This plugin is aiming to take raw JSON or YAML raw files or schemas and convert definitions to Java POJOs
(Plain Old Java Object).

At the moment of writing documentation, it uses
https://github.com/joelittlejohn/jsonschema2pojo[jsonschema2pojo] 1.2.1 library to generate classes.

The `org.jsonschema2dataclass` plugin feature highlight:

* Full support and testing for wide version range of versions of Java, Gradle and AGP
including task caching, proper hooking and other features.
+
Currently, it's Java 1.8 to 19, Gradle 6.0 to 7.6 and AGP 3, 4 and 7.
Additionally, plugin has beta support for Gradle 8.0 and AGP 8.

* Possibility natively write Gradle scripts in Groovy and Kotlin DSLs.
* Support for projects written in Kotlin and Groovy and which are using Lombok.
* Possibility to run multiple executions withing a single project.
+
This is important for some use cases to generate different sets of models within a single project.
* Some parameters are more human-writable and using native features provided by Gradle.
+
--
.Few examples
** `propertyWordDelimiters` is array of chars in `jsonschema2pojo`, which is not easy to write and support.
** `org.jsonschema2dataclass` uses Gradle-provided structures for all configuration parameters.
--
* Plugin is not tied to the library interface and could provide more maintainable configuration presentation
and wider feature range when needed.

Please note, that JSON schema constrains can be quite poorly translated to JSR305 and in most cases
can't replace Json Schema Validation.
I suggest to use a Json Schema Validation library when possible like one
https://github.com/networknt/json-schema-validator[by NetworkNT].

== Usage and migration information for {plugin_major}.x

Usage and migration documentation is located in separate documents.

* xref:docs/usage/basic_{plugin_major}.adoc[Basic usage for {plugin_major}.x]
* xref:docs/usage/parameters_{plugin_major}.adoc[Parameters for {plugin_major}.x]
* xref:docs/migration/migration_{plugin_major}.adoc[Migration guide for {plugin_major}.x]

== Usage and migration information for all versions

Usage and migration documentation is located in separate documents.

* xref:docs/usage/index.adoc[Usage documentation for all versions]
* xref:docs/migration/migration.adoc[Migration guides for all versions]


# WFA Measurement System

**Table of Contents**

*   [Purpose](#purpose)
*   [System Overview](#system-overview)
*   [Repository Structure](#repository-structure)
    *   [Services and Daemons](#servers-and-daemons)
    *   [Common Directories](#common-directories)
*   [Developer Guide](#developer-guide)
*   [Documentation](#documentation)
    *   [Dependencies](#dependencies)
*   [Contributing](#contributing)

## Purpose

Implementation of a privacy centric system for cross publisher, cross media ads
measurement through secure multiparty computations.

## System Overview

At a high level the system requires at least three independent deployments, one
controller and two secure multiparty computation nodes, each operating its own
microservices and storage instances. In order to make precise statements about
the system architecture we introduce the following terms.

The *Kingdom* is a single deployment that allows advertisers to configure
reports, requests the data and computations required to generate those reports,
and makes the completed reports accessible to advertisers.

The *Duchies* are at least two separate deployments each operated by an
independent organization. The Duchies store the encrypted data and perform the
computations required to generate the reports. Each Duchy holds part of the
private key required to decrypt the data. Therefore all Duchies must participate
in order to perform a computation and decrypt the result. For additional
security the Duchies should be multi-cloud with at least one Duchy deploying to
a different cloud provider than the others.

The system operates as follows. For more detail see the references linked in the
[Documentation](#documentation) section.

1.  Advertisers configure reports that may span a variety of campaigns,
    publishers, and forms of media.
1.  The Kingdom determines which data are required to generate these reports and
    compiles a list of requisitions for the various publishers. The Kingdom
    tracks which of the requisitions are open and which are fulfilled.
1.  Publishers invoke an API on the Duchy to obtain a list of open requisitions.
    The Duchy proxies to the Kingdom to retrieve the list. The requisitions
    specify which data are required from the publisher in order to generate the
    reports.
1.  To fulfill the requisitions publishers compute *sketches* similar to those
    used in the HyperLogLog algorithm for cardinality and frequency estimation.
    In practice we do not use HyperLogLog itself due to issues preserving user
    privacy that are beyond the scope of this discussion. Publishers encrypt
    these sketches using the combined public key of all the Duchies. Publishers
    send the encrypted sketches to a Duchy which stores them and informs the
    Kingdom that the requisition for that data is fulfilled. The encrypted
    sketches required for a particular report may be distributed across multiple
    Duchies.
1.  The Kingdom determines which pending computations have all necessary
    requisitions fulfilled and are therefore ready to run. The Duchies poll the
    Kingdom at regular intervals to claim this work. Each computation has a
    Primary Duchy assigned and a deterministic order of computation.
1.  For each computation all Duchies fetch the required encrypted sketches,
    interleave noise into them, and send them to the Primary Duchy. The Primary
    Duchy writes these sketches to its storage instance as they arrive.
1.  Once the Primary Duchy receives all required encrypted noised sketches it
    combines them. Computation then follows the predetermined order making two
    rounds through the Duchies. Each round ends with the Primary Duchy.
1.  During the first round each Duchy shuffles the sketches to destroy
    information that could be reconstructed from knowing the register indices.
1.  During the second round the Duchies each use their piece of the private key
    to decrypt the results. The Primary Duchy sends the final results back to
    the Kingdom.

## Repository Structure

```
.
├── build  ## Stuff specific to the build system
├── imports  ## Build aliases for external dependencies
│   ├── java
│   └── kotlin
├── src  ## All source code
│   ├── main  ## Source code for production deployments
│   │   ├── cc  ## Crypto library
│   │   ├── kotlin  ## Business Logic, Services, Daemons, DB accessors
│   │   └── proto  ## Service and config definitions
│   └── test  ## Source code for testing code in //src/main/
└── tools
```

Source code packages are grouped by language under the `//src` directory, where
`//src/main` is the code for a production deployment and `//src/test` is code
for unit tests and integration tests of the code under `//src/main`.

The majority of the code is written in Kotlin in the `org.wfanet.measurement`
package. The largest exception is the code to do cryptographic operations, which
is written in C++ with a Java JNI wrapper.

The `//imports` directory contains Bazel build aliases for external
dependencies. No source code, third party or otherwise, is contained in the
imports directory. The alias for a dependency will be in a directory like its
package name. Roughly speaking, the directory structure of the import mirrors
the directory structure of the imported package.

For example, the alias for Java Protobuf
(`@com_google_protobuf//:protobuf_java`) is in
`//imports/java/com/google/protobuf/BUILD.bazel` because the Java package is
`com.google.protobuf`.

The `docker` and `k8s` directories contain schemas and configuration.

### Servers and Daemons

Servers and daemons are both long running jobs deployed to Kubernetes. A key
difference is whether or not they accept RPC communication from other binaries.
In short, a server is a gRPC endpoint, where a daemon is not.

*   Services are defined in proto3 in the `//src/main/proto` directory.
*   Public APIs are defined in `wfa-measurement-proto`, another GitHub
    repository. **TODO: Add link to other GitHub repository.**

```
//src/main/kotlin/org/wfanet/measurement/
├── duchy  ## Duchy specific code
│   ├── daemon  ## Base implementations of daemons run in a Duchy
│   ├── service  ## Base implementations of services run by a Duchy
│   │   └── system  ## Services used within the measurement system
│   └── deploy  ## Deployable artifacts
│       ├── common  ## Servers and daemons that deploy on any cloud
│       ├── gcloud  ## Artifacts specific to Google Cloud deployment
│       └── testing  ## Servers and daemons for testing
└── kingdom  ## Kingdom specific code
    ├── daemon  ## Base implementations of daemons run by the Kingdom
    ├── service  ## Base implementations of services run by the Kingdom
    │   ├── api  ## Public facing services
    │   ├── internal  ## Services used within the Kingdom
    │   └── system  ## Services used within the measurement system
    └── deploy  ## Deployable artifacts
        ├── common  ## Servers and daemons that deploy on any cloud
        └── gcloud  ## Artifacts specific to Google Cloud deployment
```

### Common Directories

Throughout the code there are directories named `common`. These contain code
which is common to multiple packages under the same parent directory. As an
example, `//foo/common` contains code that may be used by other packages under
`//foo`, so `//foo/bar` and `//foo/baz`. The code is not common to packages
under a different parent, i.e. `//foo/common` should not be used by `//bar`.

### Testing Directories Under `//src/main`

In this repository packages under `//src/test` do not depend on other packages
in `//src/test`. As a result test infrastructure code used to test multiple
packages is in a test-only package in `//src/main`. One benefit of such a
structure is that the test infrastructure can also be tested the same way as
production code.

## Developer Guide

   *  [Dev Standards](docs/dev-standards.md)
   *  [Building](docs/building.md)

## Documentation

There is a lot that goes into the design of the system. Too much to cover in
this README alone. More details are covered in:

*   [A System Design for Privacy-Preserving Reach and Frequency Estimation](https://research.google/pubs/pub49526/)
*   [Privacy-Preserving Secure Cardinality and Frequency Estimation](https://research.google/pubs/pub49177/)

### Differential Privacy

This project makes wide use of the data protection technique known as differential privacy.  So we have also included some useful introductions to said topic.

*   [Differential Privacy from the Ground Up](docs/do_intro/differential_privacy_from_the_ground_up.pdf)
*   [Introduction to Differential Privacy (Slides)](docs/dp_intro/intro_to_differential_privacy_slides.pdf)
*   [Differential Privacy and Randomized Response](docs/dp_intro/differential_privacy_and_randomized_response.pdf)

### Technologies

*   [Bazel](https://bazel.build/)
*   [Docker](https://www.docker.com/)
*   [gRPC](https://grpc.io/)
*   [Kubernetes (k8s)](https://kubernetes.io/)

## Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md)


# sphinx-kotlin

## Cloning
This repository uses git submodules (for the time being). When cloning the repository, run:
```
git clone --recursive https://github.com/stakwork/sphinx-kotlin.git
```

If you've already cloned the repository, run:
```
git checkout master
git pull
git submodule update --init
```

In order to keep the submodules updated when pulling the latest code, run:
```
git pull --recurse-submodules
```

To update only the submodules, run:
```
git submodule update
```

## Building The App
See [HERE](./docs/NOTIFICATIONS.md) to enable building Sphinx with FirebaseMessaging
See [HERE](./docs/GIPHY.md) to enable building Sphinx with the Giphy SDK
See [HERE](./docs/YOUTUBE.md) to enable building Sphinx with the YouTube Player API

Checkout branch `master`:
```bash
git checkout master
git pull --recurse-submodule
```

The Application module to build is located at `sphinx/application/sphinx`. To Build, you can either:
 - Use Android Studio
 - From command line via: `./gradlew :sphinx:application:sphinx:build`

For more detailed instructions, see [HERE](./docs/RELEASING.md#building-a-release)


# Apollo Kotlin

[![GitHub license](https://img.shields.io/badge/license-MIT-lightgrey.svg?maxAge=2592000)](https://raw.githubusercontent.com/apollographql/apollo-kotlin/main/LICENSE)
[![Join the community](https://img.shields.io/discourse/status?label=Join%20the%20community&server=https%3A%2F%2Fcommunity.apollographql.com)](http://community.apollographql.com/new-topic?category=Help&tags=mobile,client)
[![Slack](https://img.shields.io/static/v1?label=kotlinlang&message=apollo-kotlin&color=15a2f5&logo=slack)](https://app.slack.com/client/T09229ZC6/C01A6KM1SBZ)
[![Discord](https://img.shields.io/discord/1022972389463687228.svg?color=7389D8&labelColor=6A7EC2&logo=discord&logoColor=ffffff&style=flat-square)](https://discord.com/invite/graphos)
[![CI](https://img.shields.io/github/actions/workflow/status/apollographql/apollo-kotlin/push.yml?branch=main)](https://github.com/apollographql/apollo-kotlin/actions/workflows/push.yml?query=branch%3Amain)
[![Maven Central](https://img.shields.io/maven-central/v/com.apollographql.apollo3/apollo-api)](https://repo1.maven.org/maven2/com/apollographql/apollo3/)
[![Gradle Plugin](https://img.shields.io/gradle-plugin-portal/v/com.apollographql.apollo3)](https://plugins.gradle.org/plugin/com.apollographql.apollo3)
[![OSS Snapshots](https://img.shields.io/nexus/s/com.apollographql.apollo3/apollo-api?server=https%3A%2F%2Fs01.oss.sonatype.org&label=oss-snapshots)](https://s01.oss.sonatype.org/content/repositories/snapshots/com/apollographql/apollo3/)
[![Revved up by Develocity](https://img.shields.io/badge/Revved%20up%20by-Develocity-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.apollographql.com/scans)

| ☑  Apollo Clients User Survey |
| :----- |
| What do you like best about Apollo Kotlin? What needs to be improved? Please tell us by taking a [one-minute survey](https://docs.google.com/forms/d/e/1FAIpQLSczNDXfJne3ZUOXjk9Ursm9JYvhTh1_nFTDfdq3XBAFWCzplQ/viewform?usp=pp_url&entry.1170701325=Apollo+Kotlin&entry.204965213=Readme). Your responses will help us understand Apollo Kotlin usage and allow us to serve you better. |

Apollo Kotlin (formerly Apollo Android) is a GraphQL client that generates Kotlin and Java models from GraphQL operations.

Apollo Kotlin executes operations against a GraphQL server and returns results as operation-specific Kotlin types. This means you don't have to deal with parsing JSON, or passing around `Map`s and making clients cast values to the right type manually. You also don't have to write model types yourself, because these are generated from the GraphQL definitions your app uses.

Because generated types are operation-specific, you can only access data that you actually specify as part of an operation. If you don't ask for a particular field in an operation, you can't access the corresponding property on the returned data structure.

This library is designed primarily with Android in mind, but you can use it in any Kotlin (including multiplatform) and Java app.

## Features

* Kotlin Multiplatform and Java code generation
* Queries, Mutations and Subscriptions
* Reflection-free parsing
* Normalized cache
* Custom scalar types
* HTTP cache
* Auto Persisted Queries
* Query batching
* File uploads
* Fake models for tests
* AppSync and graphql-ws websockets
* GraphQL AST parser
* Plugin for Android Studio and IntelliJ

## Multiplatform

Apollo Kotlin is a [Kotlin Multiplatform](https://kotlinlang.org/docs/multiplatform.html) project.

Here's the current matrix of supported features per platform:

|                                                      | `jvm` | `Apple¹` | `js` | `wasmJs` | `linuxX64` |
|------------------------------------------------------|:-----:|:--------:|:----:|:--------:|:----------:|
| `apollo-api` (models)                                |   ✅   |    ✅     |  ✅   |    ✅     |     ✅      |
| `apollo-runtime` (network, query batching, apq, ...) |   ✅   |    ✅     |  ✅   |    ✅     |     🚫      |
| `apollo-normalized-cache`                            |   ✅   |    ✅     |  ✅   |    ✅     |     🚫      |
| `apollo-adapters`                                    |   ✅   |    ✅     |  ✅   |    ✅     |     🚫      |
| `apollo-normalized-cache-sqlite`                     |   ✅   |    ✅     |  🚫   |    🚫     |     🚫      |
| `apollo-http-cache`                                  |   ✅   |    🚫     |  🚫   |    🚫     |     🚫      |

¹: Apple currently includes:

- `macosX64`
- `macosArm64`
- `iosArm64`
- `iosX64`
- `iosSimulatorArm64`
- `watchosArm32`
- `watchosArm64`
- `watchosSimulatorArm64`
- `tvosArm64`
- `tvosX64`
- `tvosSimulatorArm64`

## Maintainers

* [martinbonnin](https://github.com/martinbonnin)
* [BoD](https://github.com/BoD)
* [@bignimbus](https://github.com/bignimbus)

## Documentation

Check [the project website](https://www.apollographql.com/docs/android/) for in depth documentation.

## Getting started

If you are new to GraphQL, check out [the tutorial](https://www.apollographql.com/docs/android/tutorial/00-introduction/) that will guide you through building an Android app using Apollo.

If you'd like to add Apollo Kotlin to an existing project, follow these steps:

Add the plugin to your `build.gradle.kts`:

```kotlin
plugins {
  id("com.apollographql.apollo3") version "4.0.0-beta.7"
}
```

Add the runtime dependency:

```kotlin
dependencies {
  implementation("com.apollographql.apollo3:apollo-runtime:4.0.0-beta.7")
}
```

Set the package name to use for the generated models:

```kotlin
apollo {
  service("service") {
    packageName.set("com.example")
  }
}
```

Apollo Kotlin supports three types of files:
- `.graphqls` schema files: describes the types in your backend using the GraphQL syntax.
- `.json` schema files: describes the types in your backend using the Json syntax.
- `.graphql` executable files: describes your queries and operations in the GraphQL syntax.

By default, Apollo Kotlin requires a schema in your module's `src/main/graphql` directory. You can download a schema using introspection with the `./gradlew downloadApolloSchema` task. Sometimes introspection is disabled and you will have to ask your backend team to provide a schema. Copy this schema to your module:

```
cp ${schema} ${module}/src/main/graphql/
```

Write a query in a `${module}/src/main/graphql/HeroQuery.graphql` file:

```graphql
query HeroQuery($id: String!) {
  hero(id: $id) {
    id
    name
    appearsIn
  }
}
```

Build your project. This will generate a `HeroQuery` class that you can use with an instance of `ApolloClient`:

```kotlin
  // Create a client
  val apolloClient = ApolloClient.Builder()
      .serverUrl("https://example.com/graphql")
      .build()

  // Execute your query. This will suspend until the response is received.
  val response = apolloClient.query(HeroQuery(id = "1")).execute()

  println("Hero.name=${response.data?.hero?.name}")
```

**To learn more about other Apollo Kotlin APIs:**

* Execute your first [mutation](https://www.apollographql.com/docs/kotlin/essentials/mutations/)
* Handle [custom scalar types](https://www.apollographql.com/docs/kotlin/essentials/custom-scalars/)
* Factor common patterns using [fragments](https://www.apollographql.com/docs/kotlin/essentials/fragments/)

## Requirements

Some platforms have specific runtime requirements:

* JVM 8+
* Android API level 21+ (`apollo-http-cache` and `apollo-adapters` require enabling [core library desugaring](https://developer.android.com/studio/write/java8-support#library-desugaring) on Android API levels < 26)
* iOS 13+

At build time, it requires:

* Gradle 8.0+
* Kotlin 1.9+ for JVM projects
* Kotlin 2.0+ for native, JS, and Wasm projects

## Proguard / R8 configuration

As the code generated by Apollo Kotlin doesn't use any reflection, it can safely be optimized / obfuscated by Proguard or R8, so no particular exclusions need to be configured.

## Android Studio / IntelliJ plugin

A [plugin for Android Studio and IntelliJ](https://plugins.jetbrains.com/plugin/20645-apollo-graphql) is available to help you work with Apollo Kotlin, providing automatic code generation, integration with the [GraphQL IntelliJ Plugin](https://plugins.jetbrains.com/plugin/8097-js-graphql), navigation to GraphQL definitions, migration helpers, and more.

Installation instructions and more information can be found [here](https://github.com/apollographql/apollo-kotlin/tree/main/intellij-plugin).

## Releases

The latest version is [![Maven Central](https://img.shields.io/maven-central/v/com.apollographql.apollo3/apollo-api)](https://repo1.maven.org/maven2/com/apollographql/apollo3/)

Check the [changelog](https://github.com/apollographql/apollo-kotlin/releases) for the release history.

Releases are hosted on [Maven Central](https://repo1.maven.org/maven2/com/apollographql/apollo3/). The plugin is additionally hosted on the [Gradle Plugin Portal](https://plugins.gradle.org/plugin/com.apollographql.apollo3)

```kotlin
plugins {
  id("com.apollographql.apollo3") version "4.0.0-beta.7"
}

repositories {
  mavenCentral()
}

dependencies {
  implementation("com.apollographql.apollo3:apollo-runtime:4.0.0-beta.7")

  // Optional: if you want to use the normalized cache
  implementation("com.apollographql.apollo3:apollo-normalized-cache-sqlite:4.0.0-beta.7")
  // Optional: if you just want the generated models and parsers and write your own HTTP code/cache code, you can remove apollo-runtime
  // and use apollo-api instead
  implementation("com.apollographql.apollo3:apollo-api:4.0.0-beta.7")
}
```

## Snapshots

Latest development changes are available in Sonatype's snapshots repository:

```kotlin
// build.gradle.kts
repositories {
  maven {
    url = uri("https://s01.oss.sonatype.org/content/repositories/snapshots/")
  }
  mavenCentral()
  // other repositories...
}

// settings.gradle.kts
pluginManagement {
  repositories {
    maven {
      url = uri("https://s01.oss.sonatype.org/content/repositories/snapshots/")
    }
    gradlePluginPortal()
    mavenCentral()
    // other repositories...
  }
}
```

And then use the `4.0.0-beta.8-SNAPSHOT` version for the plugin and libraries.

These snapshots are updated on each push to `main`.

Weekly snapshots for the Android Studio / IntelliJ plugin [are also available](tree/main/intellij-plugin#weekly-snapshots).

## Stability of different artifacts

Apollo Kotlin is very modular and publishes several artifacts.

* Artifacts ending with `-incubating` are not finalized yet and subject to change any time.
* Other artifacts observe [Semantic Versioning](https://semver.org/).
    * No breaking change should be introduced in minor or patch releases except for symbols annotated with `@ApolloExperimental` that are subject to change at any time.
    * Deprecated symbols may be removed in the next major release. We strongly recommend removing deprecated usages before migrating to the next major version.

## Contributing

If you'd like to contribute, please see [Contributing.md](https://github.com/apollographql/apollo-kotlin/blob/main/CONTRIBUTING.md).

## Community integrations

* If you're using the [Maven](https://maven.apache.org/) build tool, [apollo-client-maven-plugin](https://github.com/aoudiamoncef/apollo-client-maven-plugin) is a Maven plugin that calls the Apollo Kotlin compiler to generate your Java/Kotlin sources.
* If you're using [Absinthe Phoenix subscriptions](https://hexdocs.pm/absinthe_phoenix/readme.html), [kotlin-phoenix](https://github.com/ajacquierbret/kotlin-phoenix) has a [PhoenixNetworkTransport](https://github.com/ajacquierbret/kotlin-phoenix/blob/main/kotlinphoenix-adapters/src/commonMain/kotlin/io/github/ajacquierbret/kotlinphoenix/adapters/apollo/PhoenixNetworkTransport.kt) that you can use together with `ApolloClient` ([doc](https://github.com/ajacquierbret/kotlin-phoenix/tree/main/kotlinphoenix-adapters))

## Additional resources

- [Confetti](https://github.com/joreilly/Confetti): A Kotlin Multiplatform conference app using Apollo Kotlin, SwiftUI and Jetpack Compose.
- [MortyComposeKMM](https://github.com/joreilly/MortyComposeKMM): A Kotlin Multiplatform Github template using Apollo Kotlin, SwiftUI and Jetpack Compose.
- [A journey to Kotlin multiplatform](https://www.youtube.com/watch?v=GN6LHrqyimI): how the project was moved to Kotlin multiplatform, talk given at Kotliners in June 2020.
- [#125, Fragmented Podcast](http://fragmentedpodcast.com/episodes/125/): Why's and How's about Apollo Kotlin and the entire journey.
- [GraphQL.org](http://graphql.org) for an introduction and reference to GraphQL itself.
- [apollographql.com](http://www.apollographql.com/) to learn about Apollo open-source and commercial tools.
- [The Apollo blog](https://www.apollographql.com/blog/) for long-form articles about GraphQL, feature announcements for Apollo, and guest articles from the community.
- [The Apollo Twitter account](https://twitter.com/apollographql) for in-the-moment news.

## Who is Apollo?

[Apollo](https://apollographql.com/) builds open-source software and a graph platform to unify GraphQL across your apps and services. We help you ship faster with:

* [Apollo Studio](https://www.apollographql.com/studio/develop/) – A free, end-to-end platform for managing your GraphQL lifecycle. Track your GraphQL schemas in a hosted registry to create a source of truth for everything in your graph. Studio provides an IDE (Apollo Explorer) so you can explore data, collaborate on queries, observe usage, and safely make schema changes.
* [Apollo Federation](https://www.apollographql.com/apollo-federation) – The industry-standard open architecture for building a distributed graph. Use Apollo’s gateway to compose a unified graph from multiple subgraphs, determine a query plan, and route requests across your services.
* [Apollo Client](https://www.apollographql.com/apollo-client/) – The most popular GraphQL client for the web. Apollo also builds and maintains [Apollo iOS](https://github.com/apollographql/apollo-ios) and [Apollo Kotlin](https://github.com/apollographql/apollo-kotlin).
* [Apollo Server](https://www.apollographql.com/docs/apollo-server/) – A production-ready JavaScript GraphQL server that connects to any microservice, API, or database. Compatible with all popular JavaScript frameworks and deployable in serverless environments.

## Learn how to build with Apollo

Check out the [Odyssey](https://odyssey.apollographql.com/) learning platform, the perfect place to start your GraphQL journey with videos and interactive code challenges. Join the [Apollo Community](https://community.apollographql.com/) to interact with and get technical help from the GraphQL community.


Visit [the gitbook](https://kotlin-jdsl.gitbook.io/docs/) for more information.

# Kotlin JDSL

Kotlin JDSL is a Kotlin library that makes query building and execution easy. You can create queries using your own
classes and Kotlin's built-in functions without an annotation processor, and easily execute them in your library.

## Requirements

- Java 8 or later if you are a user.
- Kotlin 1.7 or later if you are a user.

## How to reach us

- Join [our Discord server](https://discord.gg/7FH8c6npmg) to chat with us.
- Ask a question or start a discussion at [the discussion forum](https://github.com/line/kotlin-jdsl/discussions).
- File an issue in [the issue tracker](https://github.com/line/kotlin-jdsl/issues) to report a bug or suggest an idea.

## Hall of fame

See [the complete list of our contributors](https://github.com/line/kotlin-jdsl/contributors).


**Orbit Compose**

[![Kiwi.com library](https://img.shields.io/badge/Kiwi.com-library-00A991)](https://code.kiwi.com)
[![CI Build](https://img.shields.io/github/actions/workflow/status/kiwicom/orbit-compose/build.yml?branch=main)](https://github.com/kiwicom/orbit-compose/actions/workflows/build.yml)
[![GitHub release](https://img.shields.io/github/v/release/kiwicom/orbit-compose)](https://github.com/kiwicom/orbit-compose/releases)
[![Maven release](https://img.shields.io/maven-metadata/v?metadataUrl=https%3A%2F%2Frepo1.maven.org%2Fmaven2%2Fkiwi%2Forbit%2Fcompose%2Fui%2Fmaven-metadata.xml)](https://search.maven.org/search?q=g:kiwi.orbit.compose)
[![Compose 1.6](https://img.shields.io/badge/Compose-1.6-00A991)](https://developer.android.com/jetpack/androidx/releases/compose-kotlin)
[![Compose M3 1.2](https://img.shields.io/badge/Compose%20M3-1.2-00A991)](https://developer.android.com/jetpack/androidx/releases/compose-material3)

## About Orbit

[Orbit](https://orbit.kiwi) is an open-source design system that aims to bring order and consistency to
Kiwi.com products as well as the processes behind building them. It elevates the user experience and increases
the speed and efficiency of how we design and build products.

This library allows developers to implement Orbit in a project
using [Jetpack Compose](https://developer.android.com/jetpack/compose) for Android.

Orbit Compose builds upon Material 3 library. If you need an integration with Material 2, see
[Theming chapter](https://github.com/kiwicom/orbit-compose/blob/main/docs/02-foundation/04-color/theming.md).

## Setup

We publish our releases in [Maven Central](https://search.maven.org/search?q=g:kiwi.orbit.compose). To use
this library, you can add the following dependencies to your **Gradle file**:

```
implementation("kiwi.orbit.compose:ui:<version>")
implementation("kiwi.orbit.compose:icons:<version>")
implementation("kiwi.orbit.compose:illustrations:<version>")
```

## How to use?

In order to use one of Orbit's components, simply add them to your Composable function.

```kotlin
@Composable
fun MyScreen() {
    Column(
        verticalArrangement = Arrangement.spacedBy(8.dp),
        modifier = Modifier.padding(16.dp)
    ) {
        val maxWidth = Modifier.fillMaxWidth()

        ButtonPrimary(onClick = {}, maxWidth) {
            Text("This is an Orbit primary button")
        }

        Spacer(modifier = Modifier.padding(4.dp))

        AlertCritical(
            title = { Text("Alert title") },
            content = { Text("Content description") },
            actions = {
                ButtonPrimary(onClick = {}) { Text("Primary") }
                ButtonSecondary(onClick = {}) { Text("Secondary") }
            },
        )
    }
}
```

Colors, typography, and other foundational elements can be used by accessing the `OrbitTheme` object:

```kotlin
Text("Title 1", emphasis = ContentEmphasis.Minor)
Text("Big title in Title 1 style", style = OrbitTheme.typography.title1)
Text("Check your typography styles!", color = OrbitTheme.colors.warning.normal)
```

![Orbit Button and Alert component](./docs/readme/button_and_alert.png)

![Orbit typography and colors](./docs/readme/styled_text.png)

### Icons and Illustrations

Icons and illustrations can be accessed in the same way, with the corresponding `Icons` and `Illustrations`
objects:

```kotlin
Image(painter = Illustrations.AppKiwi, contentDescription = "app_kiwi")
```

## Documentation

You can check out our component Catalog by downloading and installing
our [showcase application](https://play.google.com/store/apps/details?id=kiwi.orbit.compose.catalog) from Google
Play.

The [API documentation](https://kiwicom.github.io/orbit-compose/) lists
all possible types and composables in our library.

## Contributing

Read our [contributing guidelines](./contributing.md) to see how you can participate in this project.

## Feedback

Any feedback you have for us is appreciated. If you have any suggestions about what we can do, do not hesitate
to [report the issue](https://github.com/kiwicom/orbit-compose/issues) and we'll take a look at it.


Trikot is a framework that helps building Kotlin Multiplatform applications.
iOS, Android and Web are the primary targets.

# Trikot / Kotlin Multiplatform libraries

## Table of contents

- [Modules](#modules)
- [Samples](#samples)
- [License](#license)

## Modules

| Module                                                                             | Description                                                         |
| ---------------------------------------------------------------------------------- | ------------------------------------------------------------------- |
| [trikot.foundation](./trikot-foundation)                                           | Foundation classes and building blocks                              |
| [trikot.streams](./trikot-streams)                                                 | Reactive streams                                                    |
| [trikot.datasources](./trikot-datasources)                                         | Cascading data access layers abstraction.                           |
| [trikot.http](./trikot-http)                                                       | Multiplatform http client with native platform implementations.     |
| [trikot.graphql](./trikot-graphql)                                                 | GraphQL query client built over trikot.http and trikot.datasources. |
| [trikot.analytics](./trikot-analytics)                                             | Android and iOS analytics providers.                                |
| [trikot.bluetooth](./trikot-bluetooth)                                             | Android and iOS bluetooth.                                          |
| [trikot.kword](./trikot-kword)                                                     | i18N with code generation for string keys.                          |
| [trikot.viewmodels](./trikot-viewmodels)                                           | ViewModels for imperative frameworks (Android views and UIKit).     |
| [trikot.viewmodels.declarative](./trikot-viewmodels-declarative)                   | ViewModels for declarative framework (Jetpack compose and SwiftUI). |
| [trikot.viewmodels.declarative-flow](./trikot-viewmodels-declarative-flow)         | ViewModels for declarative framework (Jetpack compose and SwiftUI). |
| [trikot.viewmodels.declarative-compiler](./trikot-viewmodels-declarative-compiler) | Gradle plugin to generate declarative Viewmodels boilerplate code.  |

## Getting started

To start a new Kotlin Multiplatform project, we suggest using our _ready-to-run_ [kmp-boilerplate](https://github.com/mirego/kmp-boilerplate) template on which you can add all the specific dependencies you need for your project.

### Samples

Here are our samples specific to this module:

- [trikot.kword](./trikot-kword/sample)
- [trikot.viewmodel samples](./trikot-viewmodels/sample)
- [trikot.viewmodel.declarative samples](./trikot-viewmodels-declarative/sample)
- [trikot.viewmodel.declarative-flow samples](./trikot-viewmodels-declarative-flow/sample)

## License

Trikot is © 2018-2022 [Mirego](https://www.mirego.com) and may be freely distributed under the [New BSD license](http://opensource.org/licenses/BSD-3-Clause). See the [`LICENSE.md`](LICENSE.md) file.

## About Mirego

[Mirego](https://www.mirego.com) is a team of passionate people who believe that work is a place where you can innovate and have fun. We’re a team of [talented people](https://life.mirego.com) who imagine and build beautiful Web and mobile applications. We come together to share ideas and [change the world](http://www.mirego.org).

We also [love open-source software](https://open.mirego.com) and we try to give back to the community as much as we can.


![WalletConnect V2](/docs/walletconnect-banner.svg)

# **WalletConnect - Kotlin**

The communications protocol for web3, WalletConnect brings the ecosystem together by enabling hundreds of wallets and apps to securely connect and interact. This repository contains Kotlin implementation of
WalletConnect v2 protocols for Android applications.

####

## BOM Instructions:
To help manage compatible dependencies stay in sync, we've introduced a [BOM](https://docs.gradle.org/current/userguide/platforms.html#sub:bom_import) to the Kotlin SDK. With this, you only need to update the BOM version to get the latest SDKs. Just add the BOM as a dependency and then list the SDKs you want to include into your project.

### example build.gradle.kts
```kotlin
dependencies {
    implementation(platform("com.walletconnect:android-bom:{BOM version}"))
    implementation("com.walletconnect:android-core")
    implementation("com.walletconnect:web3wallet")
}
```

## SDK Chart

| BOM                                                                                | [Core SDK](core/android) | [Sign SDK](protocol/sign) | [Auth SDK](protocol/auth) | [Chat SDK](protocol/chat) | [Notify SDK](protocol/notify) | [web3wallet](product/web3wallet) | [web3modal](product/web3modal) | [WalletConnectModal](product/walletconnectmodal) |
|-----------------------------------------------------------------------------------------|--------------------------|---------------------------|---------------------------|---------------------------|:------------------------------|----------------------------------|--------------------------------|--------------------------------------------------|
| 1.32.1                                                                                | 1.32.0                   | 2.32.0                    | 1.28.3                    | 1.0.0.beta30              | 1.3.4                         | 1.32.1                           | 1.5.4                          | 1.5.4                                            |
| 1.31.3                                                                                | 1.31.2                   | 2.31.2                    | 1.28.2                    | 1.0.0.beta30              | 1.3.2                         | 1.31.2                           | 1.5.2                          | 1.5.2                                            |
| 1.31.1                                                                                | 1.31.1                   | 2.31.1                    | 1.28.1                    | 1.0.0.beta26              | 1.3.1                         | 1.31.1                           | 1.5.1                          | 1.5.1                                            |
| 1.31.0<sup>[**](https://gist.github.com/TalhaAli00/7b9e1cadf19b9dc5141cd033aa4e6172)    | 1.31.0                   | 2.31.0                    | 1.28.0                    | 1.0.0.beta25              | 1.3.0                         | 1.31.0                           | 1.5.0                          | 1.5.0                                            |
| 1.30.0                                                                                | 1.30.0                   | 2.30.0                    | 1.27.0                    | 1.0.0.beta25              | 1.2.0                         | 1.30.0                           | 1.4.0                          | 1.4.0                                            |
| 1.23.0                                                                                | 1.28.0                   | 2.26.0                    | 1.26.0                    | 1.0.0.beta25              | 1.1.0                         | 1.21.0                           | 1.3.0                          | 1.3.0                                            |
| 1.22.2                                                                                | 1.27.2                   | 2.25.2                    | 1.25.2                    | 1.0.0.beta25              | 1.0.2                         | 1.20.2                           | 1.2.2                          | 1.2.2                                            |
| 1.22.1                                                                                | 1.27.0                   | 2.25.0                    | 1.25.0                    | 1.0.0.beta23              | 1.0.0                         | 1.20.0                           | 1.2.1                          | 1.2.0                                            |
| 1.22.0                                                                                | 1.27.0                   | 2.25.0                    | 1.25.0                    | 1.0.0.beta23              | 1.0.0                         | 1.20.0                           | 1.2.0                          | 1.2.0                                            |
| 1.21.1                                                                                | 1.26.0                   | 2.24.0                    | 1.24.0                    | 1.0.0.beta23              | 1.0.0-beta04                  | 1.19.0                           | 1.1.1                          | 1.1.1                                            |
| 1.21.0                                                                                | 1.26.0                   | 2.24.0                    | 1.24.0                    | 1.0.0.beta23              | 1.0.0-beta04                  | 1.19.0                           | 1.1.0                          | 1.1.0                                            |
| 1.20.0                                                                                | 1.25.0                   | 2.23.0                    | 1.23.0                    | 1.0.0.beta22              | 1.0.0-beta03                  | 1.18.0                           | 1.0.0                          | 1.0.0-beta02                                     |
| 1.19.1                                                                                | 1.24.0                   | 2.22.0                    | 1.22.0                    | 1.0.0.beta21              | 1.0.0-beta02                  | 1.17.0                           | 1.0.0-beta02                   | 1.0.0-beta01                                     |
| 1.19.0                                                                                | 1.24.0                   | 2.22.0                    | 1.22.0                    | 1.0.0.beta21              | 1.0.0-beta02                  | 1.17.0                           | 1.0.0-beta01                   | 1.0.0-beta01                                     |
| 1.18.0                                                                                | 1.23.0                   | 2.21.0                    | 1.21.0                    | 1.0.0.beta20              | 1.0.0-beta01                  | 1.16.0                           | 1.0.0-alpha11                  | 1.0.0-alpha07                                    |
| 1.17.2                                                                                | 1.22.1                   | 2.20.1                    | 1.20.1                    | 1.0.0.beta19              | 1.0.0-alpha05                 | 1.15.1                           | 1.0.0-alpha10                  | 1.0.0-alpha06                                    |
| 1.17.1                                                                                | 1.22.0                   | 2.20.0                    | 1.20.0                    | 1.0.0.beta18              | 1.0.0-alpha04                 | 1.15.0                           | 1.0.0-alpha09                  | 1.0.0-alpha05                                    |
| 1.17.0                                                                                | 1.22.0                   | 2.20.0                    | 1.20.0                    | 1.0.0.beta18              | 1.0.0-alpha03                 | 1.15.0                           | 1.0.0-alpha09                  | 1.0.0-alpha05                                    |
| 1.16.0                                                                                | 1.21.0                   | 2.19.0                    | 1.19.0                    | 1.0.0.beta17              | 1.0.0-alpha02                 | 1.14.0                           |                                | 1.0.0-alpha04                                    |
| 1.15.0                                                                                | 1.20.0                   | 2.18.0                    | 1.18.0                    | 1.0.0-beta16              |                               | 1.13.0                           |                                | 1.0.0-alpha03                                    |
| 1.14.0                                                                                | 1.19.0                   | 2.17.0                    | 1.17.0                    | 1.0.0-beta15              |                               | 1.12.0                           |                                | 1.0.0-alpha02                                    |
| 1.13.1                                                                                | 1.18.0                   | 2.16.0                    | 1.16.0                    | 1.0.0-beta14              |                               | 1.11.0                           |                                | 1.0.0-alpha01                                    |
| 1.12.0                                                                                | 1.17.0                   | 2.15.0                    | 1.15.0                    | 1.0.0-beta13              |                               | 1.10.0                           |                                |                                                  |
| 1.11.1                                                                                | 1.16.1                   | 2.14.1                    | 1.14.1                    | 1.0.0-beta12              |                               | 1.9.1                            |                                |                                                  |
| 1.11.0                                                                                | 1.16.0                   | 2.14.0                    | 1.14.0                    | 1.0.0-beta11              |                               | 1.9.0                            |                                |                                                  |
| 1.10.0                                                                                | 1.15.0                   | 2.13.0                    | 1.13.0                    | 1.0.0-beta10              |                               | 1.8.0                            |                                |                                                  |
| 1.9.3                                                                                | 1.14.3                   | 2.12.3                    | 1.12.3                    | 1.0.0-beta09              |                               | 1.7.3                            |                                |                                                  |
| 1.9.2                                                                                | 1.14.2                   | 2.12.2                    | 1.12.2                    | 1.0.0-beta08              |                               | 1.7.2                            |                                |                                                  |
| 1.9.1                                                                                | 1.14.1                   | 2.12.1                    | 1.12.1                    | 1.0.0-beta07              |                               | 1.7.1                            |                                |                                                  |
| 1.9.0<sup>[**](https://github.com/WalletConnect/WalletConnectKotlinV2/issues/821)</sup> | 1.14.0                   | 2.12.0                    | 1.12.0                    | 1.0.0-beta06              |                               | 1.7.0                            |                                |                                                  |
| 1.8.0                                                                                | 1.13.0                   | 2.11.0                    | 1.11.0                    | 1.0.0-beta05              |                               | 1.6.0                            |                                |                                                  |
| 1.7.0                                                                                | 1.12.0                   | 2.10.0                    | 1.10.0                    | 1.0.0-beta04              |                               | 1.5.0                            |                                |                                                  |
| 1.6.1                                                                                | 1.11.1                   | 2.9.1                     | 1.9.1                     | 1.0.0-beta03              |                               | 1.4.1                            |                                |                                                  |
| 1.6.0                                                                                | 1.11.0                   | 2.9.0                     | 1.9.0                     | 1.0.0-beta02              |                               | 1.4.0                            |                                |                                                  |
| 1.5.0                                                                                | 1.10.0                   | 2.8.0                     | 1.8.0                     | 1.0.0-beta01              |                               | 1.3.0                            |                                |                                                  |
| 1.4.1                                                                                | 1.9.1                    | 2.7.1                     | 1.7.1                     | 1.0.0-alpha09             |                               | 1.2.1                            |                                |                                                  |
| 1.3.0                                                                                | 1.8.0                    | 2.6.0                     | 1.6.0                     | 1.0.0-alpha07             |                               | 1.1.0                            |                                |                                                  |
| 1.2.0                                                                                | 1.7.0                    | 2.5.0                     | 1.5.0                     | 1.0.0-alpha06             |                               | 1.0.0                            |                                |                                                  |
| 1.1.1                                                                                | 1.6.0                    | 2.4.0                     | 1.4.0                     | 1.0.0-alpha05             |                               |                                  |                                |                                                  |
| 1.0.1                                                                                | 1.5.0                    | 2.3.1                     | 1.3.0                     | 1.0.0-alpha04             |                               |                                  |                                |                                                  |
|                                                                                | 1.4.0                    | 2.2.0                     | 1.2.0                     | 1.0.0-alpha03             |                               |                                  |                                |                                                  |
|                                                                                | 1.3.0                    | 2.1.0                     | 1.1.0                     | 1.0.0-alpha02             |                               |                                  |                                |                                                  |
|                                                                                | 1.2.0                    |                           |                           | 1.0.0-alpha01             |                               |                                  |                                |                                                  |
|                                                                                | 1.1.0                    | 2.0.0                     | 1.0.0                     |                           |                               |                                  |                                |                                                  |
|                                                                                | 1.0.0                    | 2.0.0-rc.5                | 1.0.0-alpha01             |                           |                               |                                  |                                |                                                  |

## License
WalletConnect v2 is released under the Apache 2.0 license. [See LICENSE](/LICENSE) for details.


# Mapbox Maps SDK for React Native

|  [![npm version](https://badge.fury.io/js/%40rnmapbox%2Fmaps.svg)](https://badge.fury.io/js/%40rnmapbox%2Fmaps)  | [![iOS & Android Build](https://github.com/rnmapbox/maps/actions/workflows/on-push.yml/badge.svg?branch=main)](https://github.com/rnmapbox/maps/actions/workflows/on-push.yml?branch=main)  |
|---|---|

_A community-supported, open-source React Native library for building maps with the [Mapbox Maps SDK for iOS](https://www.mapbox.com/ios-sdk/) and [Mapbox Maps SDK for Android](https://www.mapbox.com/android-sdk/)_

---
## News & Discussions
#### → Call for additional maintainers [discussion thread](https://github.com/rnmapbox/maps/discussions/1551)

---

---

### Supported Implementations
At the moment we support Mapbox (v10) and Mapbox (v11) beta.
We default to Mapbox (v10).

_See [iOS](ios/install.md) & [Android](android/install.md) setup guide for using v11 beta_

## Prerequisite

1. Please [Sign Up to Mapbox](https://account.mapbox.com/auth/signup/) to get the Mapbox Access Token.

## Dependencies

- [node](https://nodejs.org)
- [npm](https://www.npmjs.com/)
- [React Native](https://facebook.github.io/react-native/) (0.70+, older versions from 0.64+ might or might not work)

## Installation

Check our [Installation instructions](https://rnmapbox.github.io/docs/install)

### Getting Started
For more information, check out our [Getting Started](/docs/GettingStarted.md) section

## Run Project
Before you run your project be sure you have completed the Installation Guides for Android or iOS.

### Run iOS Simulator
```sh
# Run with yarn
yarn run ios

# or Run with NPM
npm run ios
```

### Run Android Emulator
```sh
# Run with yarn
yarn run android

# or Run with NPM
npm run android
```

## Adding a map
```js
import React from 'react';
import { StyleSheet, View } from 'react-native';
import Mapbox from '@rnmapbox/maps';

Mapbox.setAccessToken('<YOUR_ACCESSTOKEN>');

const App = () => {
  return (
    <View style={styles.page}>
      <View style={styles.container}>
        <Mapbox.MapView style={styles.map} />
      </View>
    </View>
  );
}

export default App;

const styles = StyleSheet.create({
  page: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
  },
  container: {
    height: 300,
    width: 300,
  },
  map: {
    flex: 1
  }
});
```
---
## Documentation

### Components

- [MapView](/docs/MapView.md)
- [StyleImport](/docs/StyleImport.md)
- [Light](/docs/Light.md)
- [StyleSheet](/docs/StyleSheet.md)
- [PointAnnotation](/docs/PointAnnotation.md)
- [MarkerView](/docs/MarkerView.md)
- [Callout](/docs/Callout.md)
- [Camera](docs/Camera.md)
- [UserLocation](docs/UserLocation.md)
- [LocationPuck](docs/LocationPuck.md)
- [Images](docs/Images.md)
- [Image](docs/Image.md)
- [Models](docs/Models.md)

### Sources

- [VectorSource](/docs/VectorSource.md)
- [ShapeSource](/docs/ShapeSource.md)
- [RasterSource](/docs/RasterSource.md)
- [RasterDemSource](/docs/RasterDemSource.md)

### Layers

- [BackgroundLayer](/docs/BackgroundLayer.md)
- [CircleLayer](/docs/CircleLayer.md)
- [FillExtrusionLayer](/docs/FillExtrusionLayer.md)
- [FillLayer](/docs/FillLayer.md)
- [LineLayer](/docs/LineLayer.md)
- [RasterLayer](/docs/RasterLayer.md)
- [SymbolLayer](/docs/SymbolLayer.md)
- [HeatmapLayer](/docs/HeatmapLayer.md)
- [SkyLayer](/docs/SkyLayer.md)
- [ModelLayer](/docs/ModelLayer.md)

### Terrain

- [Terrain](/docs/Terrain.md)
- [Atmosphere](/docs/Atmosphere.md)

### Offline

- [OfflineManager](/docs/OfflineManager.md)
- [SnapshotManager](/docs/snapshotManager.md)

### Misc

- [Mapbox](/docs/Mapbox.md)
- [CustomHttpHeaders](/docs/CustomHttpHeaders.md)
- [Logger](/docs/Logger.md)

## Expo Support

This package is not available in the [Expo Go](https://expo.io/client) app. Learn how you can use it with [custom dev clients](/plugin/install.md).

## Testing with Jest

This library provides some mocks which are necessary for running tests.

Example:

```json
"jest": {
  "preset": "react-native",
  "setupFilesAfterEnv": ["@rnmapbox/maps/setup-jest"],
  "transformIgnorePatterns": [
      "node_modules/(?!(...|@rnmapbox))"
  ]
}
```
---
## Sponsors

Help drive this repo forward - be a sponsor. Add a comment [here](https://github.com/rnmapbox/maps/discussions/1551) to discuss your sponsorship.

  Scout To Hunt

Terrain Dance

---
## Developer Group

Have a question or need some help? Join our [Gitter developer group](https://gitter.im/rnmapbox/Lobby)!


 🚀 Groceries Store

 [![Android CI](https://github.com/hieuwu/android-groceries-store/actions/workflows/app-build.yml/badge.svg?branch=main)](https://github.com/hieuwu/android-groceries-store/actions/workflows/app-build.yml)
[![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=hieuwu_android-groceries-store&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=hieuwu_android-groceries-store)

![Groceries Store](https://user-images.githubusercontent.com/43868345/233767546-ba25566b-7926-4140-82fe-12346a1f357e.png)

[![SonarCloud](https://sonarcloud.io/images/project_badges/sonarcloud-black.svg)](https://sonarcloud.io/summary/new_code?id=ARK-Builders_arklib-android)

[Download on Google Play Store](https://play.google.com/store/apps/details?id=com.hieuwu.groceriesstore)

## 👋 About
Groceries Store is a project to help people order grocery online. The main purpose of this project is to demonstrate modern Android development skills in real production environment, reduce the learning curve when jump into Android development world.

## 🎨 UI Design & Architecture

**Design**
- [Groceries Store Design](https://www.figma.com/file/exhlJtkLIcHvfxd8SDja3T/Online-Groceries-App-UI-(Community)?node-id=1%3A2)
- Background vector created by freepik - www.freepik.com
- Food vector created by terdpongvector - www.freepik.com

**Architecture**
- [Use Case](https://proandroiddev.com/why-you-need-use-cases-interactors-142e8a6fe576)
- [Clean Architecture](https://medium.com/@dmilicic/a-detailed-guide-on-developing-android-apps-using-the-clean-architecture-pattern-d38d71e94029)
- [MVVM Architecture](https://medium.com/swlh/understanding-mvvm-architecture-in-android-aa66f7e1a70b)

## 🛠 Libraries
- [Glide](https://github.com/bumptech/glide) - Loading images.
- [Timber](https://github.com/JakeWharton/timber) - Logging.
- [Retrofit2](https://github.com/square/retrofit) - Construct the REST APIs and paging network data.
- [Moshi](https://github.com/square/moshi/) - A modern JSON library for Kotlin and Java.
- [Hilt](https://dagger.dev/hilt/) for dependency injection.
- JetPack
  - Lifecycle - dispose of observing data when lifecycle state changes.
  - ViewModel - UI related data holder, lifecycle aware.
  - Room Persistence - construct a database using the abstract layer.

## ⚙ Setup

#### Android Studio
Android Studio Bumblebee or later
SDK 23 or later

#### Supabase
See [Supabase Wiki](https://github.com/hieuwu/android-groceries-store/wiki)
Database Schema:

## 🎯 Find this repository useful? :heart:
Support it by joining __[stargazers](https://github.com/hieuwu/android-groceries-store/stargazers)__ for this repository. :star:

Also, __[follow me](https://github.com/hieuwu)__ on GitHub for my next creations! 🤩

## 👨💻 Contributors ✨

[![All Contributors](https://img.shields.io/badge/all_contributors-7-orange.svg?style=flat-square)](#contributors-)

Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

Saurabh Patel
💻

Aditya Gupta
🎨 💻 💡

Dmitriy
💻

Devendra Varma
💻

Amartya
🎨

NLC
🎨 💻

Fredrik Henricsson
💻

This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!


# ArchGuard backend

[![CI](https://github.com/archguard/archguard/actions/workflows/ci.yaml/badge.svg)](https://github.com/archguard/archguard/actions/workflows/ci.yaml)
[![codecov](https://codecov.io/gh/archguard/archguard/branch/master/graph/badge.svg?token=QS5H866CWH)](https://codecov.io/gh/archguard/archguard)
[![GitHub release](https://img.shields.io/github/v/release/archguard/archguard?logo=git&logoColor=white)](https://github.com/archguard/archguard/releases)
[![languages](https://img.shields.io/badge/language-kotlin-blueviolet?logo=kotlin&logoColor=white)](https://www.kotlincn.net/)
[![Java support](https://img.shields.io/badge/Java-12+-green?logo=java&logoColor=white)](https://openjdk.java.net/)
[![License](https://img.shields.io/github/license/archguard/archguard?color=4D7A97&logo=opensourceinitiative&logoColor=white)](https://opensource.org/licenses/MIT)
[![Gitpod Ready-to-Code](https://img.shields.io/badge/Gitpod-ready--to--code-green?label=gitpod&logo=gitpod&logoColor=white)](https://gitpod.io/#https://github.com/archguard/archguard)
![Maven Central](https://img.shields.io/maven-central/v/org.archguard.scanner/scanner_core)

> ArchGuard is an architecture governance tool that can analysis architecture in container, component, code level, database, create architecture fitness functions, and test for architecture rules.

Chinese: ArchGuard 是一个针对于微服务（分布式场景）下的架构工作台/治理工具。它可以帮助架构师、开发人员进行架构自助，自定义架构的洞察、
分析系统间的远程服务依赖情况、数据库依赖、API 依赖等。并根据一些架构治理模型，对现有系统提出改进建议。

- Document: [https://archguard.org/](https://archguard.org/)
- Roadmap: [Roadmap](https://github.com/archguard/archguard/discussions/5)
- Contribute: [Contribute to Archguard](https://archguard.org/contribution)
- SubProjects:
    - [ArchGuard Frontend](https://github.com/archguard/archguard-frontend)
    - [Chapi](https://github.com/modernizing/chapi) source code analysis
    - [ArchGuard Co-mate](https://github.com/unit-mesh/co-mate) an AI-powered architecture copilot, design and governance tools.
- Architecture:

![Architecture](https://archguard.org/architecture.svg)

特性（Features）：

- **设计态**
  - 架构设计、分析与治理 DSL
  - Feakin: [https://github.com/feakin/fklang](https://github.com/feakin/fklang)
- **开发态**
  - 架构扫描
    - 扫描配置
    - 插件化规则定制
    - 规则化治理：Code Smell, Test Code Smell, SQL Smell, API Smell, Documentation Smell, etc.
  - 架构可视化
    - 基于 C4 模型的可视化分析
      - 上下文：API 服务地图（API 生产者支持语言：Java、Kotlin、C#，API 消费者支持语言：TypeScript/JavaScript、Kotlin、Java 等）
      - 容器分析。数据库地图（支持 MyBatis、JDBI、JPA）
      - 组件分析
      - 代码分析：支持级别模块、包、类、方法四个级别。
    - 高级分析 + 可视化
      - 系统不稳定性模块分析。
      - 容器间：精准测试/变化分析
  - 架构指标（单体DONE，分布式DOING）
    - 体量维度：过大的组件
    - 耦合维度：枢纽组件，过深调用，循环依赖
    - 内聚维度：霰弹式修改
    - 冗余维度：冗余元素，过度泛化
    - 质量维度：测试保护
  - 代码分析
    - CLOCO：代码复杂度 [#79](https://github.com/archguard/archguard/issues/79)
    - SCA 分析
    - OpenAPI 分析
    - Architecture analysis
- **运行态**
  - APM（TODO）
- **架构工作台**

Features：

- **Design State**
  - Architecture Design, Analysis and Governance DSL
  - Feakin: [https://github.com/feakin/fklang](https://github.com/feakin/fklang)
- **Development state**
  - Schema scan
    - Scan configuration
    - Plug-in rule customization
    - Rule-based governance: Code Smell, Test Code Smell, SQL Smell, API Smell, Documentation Smell, etc.
  - Architecture visualization
    - Visual analysis based on C4 model
      - Context: API service map (API producer supported languages: Java, Kotlin, C#, API consumer supported languages: TypeScript/JavaScript, Kotlin, Java, etc.)
      - Container analysis. Database map (support MyBatis, JDBI, JPA)
      - Component analysis
      - Code analysis: supports four levels of modules, packages, classes, and methods.
    - Advanced Analysis + Visualization
      - System instability module analysis.
      - Between containers: precise testing/variation analysis
  - Architecture metrics (single DONE, distributed DOING)
    - Volume dimension: oversize components
    - Coupling dimension: hub components, too deep calls, circular dependencies
    - Cohesive Dimension: Shotgun Modification
    - Redundant dimensions: redundant elements, overgeneralization
    - Quality dimension: test protection
    - Continuous Integration
  - External analysis
    - CLOCO: Code Complexity [#79](https://github.com/archguard/archguard/issues/79)
    - SCA analysis
    - OpenAPI analysis
    - Architecture analysis
- **Running state**
  - APM (TODO)
- **Architecture Workbench**

Screenshots:

Languages parse by [Chapi](https://github.com/modernizing/chapi)

| Features/Languages  | Java | Python | Go | Kotlin | TypeScript | C  | C# | Scala | C++ |
|---------------------|------|--------|----|--------|------------|----|----|-------|-----|
| http api decl       | ✅    | 🆕     | 🆕 | ✅      | ✅          | 🆕 | ✅  | 🆕    | 🆕  |
| syntax parse        | ✅    | ✅      | ✅  | ✅      | ✅          | ✅  | ✅  | ✅     | 🆕  |
| function call       | ✅    | 🆕     | ✅  | ✅      | ✅          |    |    |       |     |
| arch/package        | ✅    |        |    | ✅      | ✅          | 🆕 | ✅  | ✅     |     |
| real world validate | ✅    |        |    |        | ✅          |    |    |       |     |

## Custom Backend

case example:

- [https://github.com/unit-mesh/co-unit](https://github.com/unit-mesh/co-unit) by Rust language

use [Scanner CLI](./scanner_cli) you can customize your backend. For more detail, see in: [ArchGuardHttpClient](scanner_cli/src/main/kotlin/org/archguard/scanner/ctl/client/ArchGuardHttpClient.kt)

HTTP examples:

```http request
POST http://127.0.0.1:8765/scanner/:systemId/reporting/class-items

POST http://127.0.0.1:8765/scanner/:systemId/reporting/openapi

POST http://127.0.0.1:8765/scanner/:systemId/reporting/container-services

POST http://127.0.0.1:8765/scanner/:systemId/reporting/datamap-relations

...
```

### Chat

关注我们：

欢迎加入我们：

（PS：如果群满，请添加微信 `phodal02`，并注明 ArchGuard）

## Thanks

JetBrains support:

![JetBrains Logo (Main) logo](https://resources.jetbrains.com/storage/products/company/brand/logos/jb_beam.svg)

License
---

This code is distributed under the MIT license. See `LICENSE` in this directory.


Horologist is a group of libraries that aim to supplement Wear OS developers with features that are
commonly required by developers but not yet available.

## Maintained Versions

The currently maintained branches of Horologist are.

| Version | Branch        | Min SDK (Wear) | Kotlin/JDK | Description |
| ------- | ------------- | -------------- | ----------- | ----------- |
| 0.5.x   | release-0.5.x | 25             | 1.9.x / 11 | Wear Compose 1.3.x, Compose 1.6.x, Media3 and some betas of Androidx. |
| 0.6.x   | main      | 26             | 1.9.x / 11 | Wear Compose 1.4.x, Compose 1.7.x and generally latest relevant alphas of Androidx. |
| 0.7.x   | main (future)      | 26             | 2.0.x / 17 | Wear Compose 1.5.x, Compose 1.8.x and generally latest relevant alphas of Androidx. |

Maintenance branches will not delete existing APIs and they should remain stable. However
the main branch will actively update to incorporate new API guidance, removing or changing
APIs.

---

## 🎵 Media

Horologist provides the Media Toolkit: a set of libraries to build Media apps on Wear OS and a
sample app that you can run to see the toolkit in action.

The toolkit includes:

- [horologist-media-ui](https://google.github.io/horologist/media-ui): common media UI components and screens like `PlayerScreen`.
- [horologist-media](https://google.github.io/horologist/media): domain model for Media related functionality. Provides an
  abstraction
  to the UI module (`horologist-media-ui`) that is agnostic to the Player implementation.
- [horologist-media-data](https://google.github.io/horologist/media-data): implementation of the domain module (`horologist-media`)
  using [Media3](https://developer.android.com/jetpack/androidx/releases/media3).
- [horologist-media3-backend](https://google.github.io/horologist/media3-backend): Player on top of Media3 including
  functionalities
  such as avoiding playing music on the watch speaker.
- [media sample](https://google.github.io/horologist/media-sample): sample app to listen to downloaded music.

Player Screen | Browse Screen | Entity Screen
:------------:|:-------------:|:-------------:
 |  |

## 📅 Composables

High quality prebuilt composables, such as Time and Date pickers.

- [horologist-composables](https://google.github.io/horologist/composables)

DatePicker             |  TimePickerWith12HourClock |  TimePicker
:-------------------------:|:-------------------------:|:-------------------------:
  |   |

SegmentedProgressIndicator | SquareSegmentedProgressIndicator
:----------------------------------------------------------------------------------------------------------------------------------------------:|:-------------------------:
 |

## 📐 Compose Layout

Layout related functionality such as a Navigation Aware Scaffold.

- [horologist-compose-layout](https://google.github.io/horologist/compose-layout)

|                                                             fillMaxRectangle()                                                             |
|:------------------------------------------------------------------------------------------------------------------------------------------:|
|   |

## 🔲 Compose Material

Opinionated implementation of the components of
the [Wear Material Compose library](https://developer.android.com/jetpack/androidx/releases/wear-compose)
, based on the specifications
of [Wear Material Design Kit](https://developer.android.com/design/ui/wear/guides/foundations/download)
.

- [horologist-compose-material](https://google.github.io/horologist/compose-material)

## 🔊 Audio and UI

Domain model for Audio related functionality. Volume Control, Output switching.
Subscribing to a Flow of changes in audio or output.

- [horologist-audio](https://google.github.io/horologist/audio)
- [horologist-audio-ui](https://google.github.io/horologist/audio-ui)

|                                                          VolumeScreen                                                          |
|:------------------------------------------------------------------------------------------------------------------------------:|
|  |

## 🔐 Auth

Libraries to help developers to build apps following
the [Sign-In guidelines for Wear OS](https://developer.android.com/training/wearables/design/sign-in)
.

- [horologist-auth-composables](https://google.github.io/horologist/auth-composables): composable screens for authentication use
  cases, with no dependency on the `auth-data` library.
- [horologist-auth-ui](https://google.github.io/horologist/auth-ui): composable screens for authentication use cases, with integration
  with the `auth-data` library
- [horologist-auth-data](https://google.github.io/horologist/auth-data): implementation for Wear apps for most of the authentication
  methods listed in
  the [Authentication on wearables](https://developer.android.com/training/wearables/apps/auth-wear)
  guide.
- [horologist-auth-data-phone](https://google.github.io/horologist/auth-data-phone): implementation for Mobile apps for some of the
  authentication methods provided by the `auth-data` library.
- [sample wear](https://google.github.io/horologist/auth-sample-apps/#wear-sample): sample wear app to authenticate using different methods.
- [sample phone](https://google.github.io/horologist/auth-sample-apps/#phone-sample): sample phone app to authenticate using different methods.

## DataLayer

The Horologist DataLayer library, provide common abstractions on top of the
[Wearable DataLayer](https://developer.android.com/training/wearables/data/data-layer).
It includes libraries to build
[prompts on the phone](https://google.github.io/horologist/datalayer-phone-ui/) to improve
engagement with the correspondent Wear app and a
[sample](https://google.github.io/horologist/datalayer-sample/) to see the prompts in actions.
Find guidance in the project [documentation](https://google.github.io/horologist/datalayer/).

## ☰ Tiles

Kotlin coroutines flavoured TileService.

[horologist-tiles](https://google.github.io/horologist/tiles)

---

## Why the name?

The name mirrors the [Accompanist](https://github.com/google/accompanist) name, and is also Watch
related.

https://en.wiktionary.org/wiki/horologist

> horologist (Noun)
> Someone who makes or repairs timepieces, watches or clocks.

## Contributions

Please contribute! We will gladly review any pull requests submitted.
Make sure to read the [Contributing](CONTRIBUTING.md) page to know what our expectations of
contributions are.

## License

```
Copyright 2023 The Android Open Source Project

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

    https://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.
```


slack-gradle-plugin
===================

### [slackhq.github.io/slack-gradle-plugin](https://slackhq.github.io/slack-gradle-plugin)

License
--------

    Copyright 2022 Slack Technologies, LLC

    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.


# Adoptium API

**NOTICE:** [AdoptOpenJDK API v3](https://github.com/AdoptOpenJDK/openjdk-api-v3/blob/master/README.md) has been deprecated as part of the move to Eclipse Foundation and rebrand to Adoptium.

## Overview

The Adoptium API provides a way to consume JSON information about the Adoptium Temurin releases and nightly builds.
Sign up to the [`#api` Slack channel](https://adoptium.net/slack/) where major API updates will be announced, and visit [adoptium.net](https://adoptium.net) to find out more about the community.

## Usage

The API is documented using Swagger.  The Swagger documentation can be viewed at: [api.adoptium.net/swagger-ui](https://api.adoptium.net/swagger-ui).
The Open API spec for this can be viewed at: [api.adoptium.net/openapi](https://api.adoptium.net/openapi)

For more information, including example queries, please look at the [API cookbook](https://github.com/adoptium/api.adoptium.net/blob/main/docs/cookbook.adoc).

## Who's using the Adoptium API?

The Adoptium API (and its predecessor at AdoptOpenJDK) has served over 200 million downloads by a wide variety consumers, from individuals to organizations.

Check the [Download Statistics Dashboard](https://dash.adoptium.net/) for the latest numbers.

The following list highlights a small subset of consumers and their use-cases:

- [Adoptium Website](https://adoptium.net/) - the API drives the release listings on the AdoptOpenJDK website allowing individuals to download the JDK distribution of their choice.
- [Gradle](https://docs.gradle.org/) - the Gradle project defaults to use the API for its [toolchains](https://docs.gradle.org/current/userguide/toolchains.html#sec:provisioning) feature.
- [Update Watcher for Adoptium & AdoptOpenJDK](https://github.com/tushev/aojdk-updatewatcher) - uses the API to automatically manage the JDK installations on an individual's machine.

## Version Bump

When a new version of Java is released, the version at [Versions.kt](adoptium-models-parent/adoptium-api-v3-models/src/main/kotlin/net/adoptium/api/v3/models/Versions.kt),
or by setting the property `LATEST_JAVA_VERSION` on the deployment.

## Development

To learn more about how we build & run the API, check out [CONTRIBUTING.md](CONTRIBUTING.md) and the [FAQs](FAQ.md).