kinde_sdk 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8682cdbb9fc753d2d2709a6af5daa79bbf0e58277a11140e12b77726bd69d58e
+  data.tar.gz: bef3ea899737940e81b08de2341f4f588640339b85b7ed607320f10e447cfb5e
+SHA512:
+  metadata.gz: 71eb38523a787138251941b911893f4343f155db71c43dccc6b07946a12b7e67e589caeff5546ec793d5a9005ef84e68dc9ad13cb979737b57504bcc02d71127
+  data.tar.gz: 21b7c9219f45e7ecf2f7d7b8b4a2f549926c23b29553ba817d04db0b962f2ee4dda38e9f6de03042153a1072cbe28b62c4e92d3d5e6138ba106d624be13bfd0f

data/Gemfile

@@ -0,0 +1,15 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :development, :test do
+  gem "rake", "~> 13.0.1"
+  gem "pry-byebug"
+  gem "rubocop"
+  gem "rubocop-rake", require: false
+  gem "rubocop-rspec", require: false
+end
+
+group :test do
+  gem "webmock"
+end

data/Gemfile.lock

@@ -0,0 +1,119 @@
+PATH
+  remote: .
+  specs:
+    kinde_sdk (1.0.0)
+      faraday-follow_redirects
+      oauth2 (~> 2.0)
+      pkce_challenge
+      typhoeus (~> 1.0, >= 1.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.3)
+      public_suffix (>= 2.0.2, < 6.0)
+    ast (2.4.2)
+    byebug (11.1.3)
+    coderay (1.1.3)
+    crack (0.4.5)
+      rexml
+    diff-lcs (1.5.0)
+    ethon (0.16.0)
+      ffi (>= 1.15.0)
+    faraday (2.7.4)
+      faraday-net_http (>= 2.0, < 3.1)
+      ruby2_keywords (>= 0.0.4)
+    faraday-follow_redirects (0.3.0)
+      faraday (>= 1, < 3)
+    faraday-net_http (3.0.2)
+    ffi (1.15.5)
+    hashdiff (1.0.1)
+    hashie (5.0.0)
+    json (2.6.3)
+    jwt (2.7.0)
+    method_source (1.0.0)
+    multi_xml (0.6.0)
+    oauth2 (2.0.9)
+      faraday (>= 0.17.3, < 3.0)
+      jwt (>= 1.0, < 3.0)
+      multi_xml (~> 0.5)
+      rack (>= 1.2, < 4)
+      snaky_hash (~> 2.0)
+      version_gem (~> 1.1)
+    parallel (1.22.1)
+    parser (3.2.2.0)
+      ast (~> 2.4.1)
+    pkce_challenge (1.0.0)
+    pry (0.14.2)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-byebug (3.10.1)
+      byebug (~> 11.0)
+      pry (>= 0.13, < 0.15)
+    public_suffix (5.0.1)
+    rack (3.0.7)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.7.0)
+    rexml (3.2.5)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.1)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    rubocop (1.49.0)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.2.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.28.0)
+      parser (>= 3.2.1.0)
+    rubocop-capybara (2.17.1)
+      rubocop (~> 1.41)
+    rubocop-rake (0.6.0)
+      rubocop (~> 1.0)
+    rubocop-rspec (2.19.0)
+      rubocop (~> 1.33)
+      rubocop-capybara (~> 2.17)
+    ruby-progressbar (1.13.0)
+    ruby2_keywords (0.0.5)
+    snaky_hash (2.0.1)
+      hashie
+      version_gem (~> 1.1, >= 1.1.1)
+    typhoeus (1.4.0)
+      ethon (>= 0.9.0)
+    unicode-display_width (2.4.2)
+    version_gem (1.1.2)
+    webmock (3.18.1)
+      addressable (>= 2.8.0)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+
+PLATFORMS
+  arm64-darwin-21
+
+DEPENDENCIES
+  kinde_sdk!
+  pry-byebug
+  rake (~> 13.0.1)
+  rspec (~> 3.6, >= 3.6.0)
+  rubocop
+  rubocop-rake
+  rubocop-rspec
+  webmock
+
+BUNDLED WITH
+   2.3.16

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Kinde
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,342 @@
+# Kinde Ruby SDK 
+
+The Kinde Ruby SDK gem allows developers to integrate Kinde API into any ruby-based applications, Rails or non-Rails.
+The gem contains all the related oauth2 authorization, so you need only to integrate it properly.
+The gem contains 3 pre-built OAuth flows: **client credentials**, **authorization code** and **authorization code with PKCE code verifier**.
+
+## Register for Kinde
+
+If you haven’t already got a Kinde account, register for free [here](http://app.kinde.com/register) (no credit card required).
+
+You need a Kinde domain to get started, e.g. yourapp.kinde.com.
+
+## Installation
+
+Add this line into your Gemfile and run bundler:
+```
+gem 'kinde_sdk', git: 'https://github.com/kinde-oss/kinde-ruby-sdk.git', branch: 'main'
+```
+or install manually through gem command.
+
+## Getting started
+
+### Kinde configuration
+
+On the Kinde web app navigate to `Settings` in the left menu, then select `App keys` and find the `Callbacks` input field.
+
+Here you want to put in the callback URLs for your application, which should look something like this:
+
+- **Allowed callback URLs** - `http://localhost:3000/api/auth/kinde_callback`
+- **Allowed logout redirect URLs** - `http://localhost:3000`
+
+Make sure you press the Save button at the bottom of the page!
+
+_Note_: The `http://localhost:3000` is used as an example of local address, don't forget to add all the required addresses that you are going to use in any environments.
+
+### Environments
+
+If you would like to use our Environments feature as part of your development process. You will need to create them first within your Kinde account, see the guide here. 
+In this case you would use the Environment subdomain in the code block above.
+
+### Configuring your app
+
+In a basic scenario it requires several steps to be made:
+1. proper configuring of client credentials and domain
+2. external service authorization
+3. callback processing
+4. bearer token receiving
+5. Usage
+
+#### Integration
+The gem contains simple configurator which you can use whenever you want. For example, in a typical Rails-app it can be
+configured through initializer file:
+
+```ruby
+# domain, client_id/secret and callback defined somewhere in your settings
+
+KindeSdk.configure do |c|
+ c.domain = domain
+ c.client_id = client_id
+ c.client_secret = client_secret
+ c.callback_url = callback_url
+ c.logout_url = logout_url
+ # c.scope = 'openid offline email profile' # default value
+ # c.pkce_enabled = true                    # default value
+ # c.authorize_url = '/oauth2/auth'         # default value
+ # c.token_url = '/oauth2/token'            # default value
+ # c.debugging = false                      # default value
+ # c.business_name = nil                    # default value
+ c.logger = Rails.logger
+end
+```
+Snippet above contains all the possible configuration values.
+Here is detailed explanation on them:
+
+- `Domain` refers to your organization - for example, `your-biz.kinde.com`.
+- `Client id` and `Client secret` can be fetched from your Kinde application credentials in a setting section.
+- `Callback url` refers to your callback processing controller action. Remember that 
+the url must be defined in allowed callback urls of your kinde organization's [application config](#Kinde-configuration).
+- `Logout url` will be triggered after successful logout on kinde. Same as callback url, it should be 
+defined in allowed logout urls of your kinde organization's application config
+- `Scope` is an oauth special parameter which is used to limit some rights. Probably, you don't need to change in.
+- `PKCE enabled` is a flag that can turn off PKCE auth flow. By default it is activated to improve your security.
+- `Authorize url` and `Token url` are paths to oauth2 methods in kinde. You don't need to change it.
+- `Debugging` set to true start writing verbose request logs. Might be useful while developing your application.
+- `Business name` is a parameter which is used in requests building. By default it is extracted from your
+`domain` endpoint. For example, if your domain is `your-biz.kinde.com`, then business name will be set to`your-biz`.
+You don't need to change it in general.
+- `Logger` might be set to any kind of loggers you are using. By default it is set to `Rails.logger` if gem is used in
+rails application or `Logger.new(STDOUT)` if it is not a rails app.
+
+These variables can be handled with any system you want: .env files, settings.yml or any type of config files.
+For example, .env file (you can name variables by yourself):
+```
+KINDE_DOMAIN=https://example.kinde.com
+KINDE_CLIENT_ID=qwe
+KINDE_CLIENT_SECRET=wert
+KINDE_CALLBACK_URL=http://localhost:3000/callback
+KINDE_LOGOUT_URL=http://localhost:3000/logout_callback
+```
+
+can be used as:
+```ruby
+KindeSdk.configure do |c|
+ c.domain = ENV['KINDE_DOMAIN']
+ c.client_id = ENV['KINDE_CLIENT_ID']
+ # ....
+end
+```
+
+#### Login / Register
+The next step is to authorize you in the Kinde.
+For this, you need to acquire auth url by calling:
+```ruby
+KindeSdk.auth_url
+# => 
+{
+ url: "https://<domain>/oauth2/auth?client_id=<client_id>&code_challenge=<generated code>&code_challenge_method=S256&redirect_uri=<redirect_uri>&response_type=code&scope=openid+offline+email+profile&state=<random string>",
+ code_verifier: "<challenge verifier>"
+}
+```
+By default, gem uses PKCE verification flow - this means that in your auth url will be added special `code challenge` 
+param and the method returns verification string for the code, which should be used later in token acquiring request.
+You are free to disable PKCE by setting `pkce_enabled` to false in your configuration. 
+In this case, `KindeSdk.auth_url` will return only url itself:
+```ruby
+KindeSdk.auth_url
+# => {url: ......}
+```
+If you are about to use PCKE, our recommendation to save code verifier output somewhere near your later tokens output.
+
+You can put the link right in your web-application page or you can use it under the hood through redirection.
+After visiting the link you'll be redirected to Kinde's sign in/sign up form.
+And after authorizing in Kinde, you'll be redirected to callback url.
+
+#### Handle redirect
+Next step is to extract code from the callback redirection. Your callback endpoint should contain logic to call exchange method.
+Callback will be triggered with body, where will be code present. You are free to use the whole `params` object or to extract code from `params["code"]`.
+
+Next, it needs to be exchanged for the access and refresh tokens.
+`code` is the parameter which received in the callback endpoint, `code_verifier` (if PKCE enabled) should be used from previous step:  
+```ruby
+KindeSdk.fetch_tokens(code, code_verifier)
+# => 
+{"access_token"=>"eyJhbGciOiJSUzI1NiIsIm...",                                
+ "expires_in"=>86399,                             
+ "id_token"=>"eyJhbGciOiJSUz",
+ "refresh_token"=>"eyJhbGciOiJSUz",
+ "scope"=>"openid offline email profile",                               
+ "token_type"=>"bearer"}
+```
+
+This is your tokens - save the whole hash in your session, redis or any other storage and use it to build your client:
+```ruby
+# In case of preventing cookie overflow, you need to limit what exactly your are saving.
+# Here is the required minimum of params. But in general you are able save it wherever you want to. 
+# For example, in database, without any limiting.
+session[:kinde_auth] = KindeSdk.fetch_tokens(code).slice(:access_token, :refresh_token, :expires_at)
+# ...
+client = KindeSdk.client(session[:kinde_auth]["access_token"]) # => #<KindeSdk::Client:0x00007faf31e5ecb8> 
+```
+
+#### Token expiration and refreshing
+For proper refreshing you'll need to use `access_token`, `refresh_token` and probably `expires_in` if you want to know is your access token still actual.
+Use these two methods to work with refreshing:
+```ruby
+KindeSdk.token_expired?(session[:kinde_auth]) # => false
+KindeSdk.refresh_token(session[:kinde_auth]) # => {"access_token" => "qwe...", "refresh_token" => "fqw...", .....}
+```
+`KindeSdk#refresh_token` returns new token hash, so it needs to be updated in your storage.
+
+#### Audience
+An `audience` is the intended recipient of an access token - for example the API for your application.
+The audience argument can be passed to the Kinde `#auth_url` method to request an audience be added to the provided token:
+```ruby
+KindeSdk.auth_url(audience: "https://your-app.kinde.com/api")
+```
+For details on how to connect, see [Register an API](https://kinde.com/docs/developer-tools/register-an-api/)
+
+#### Overriding scope
+By default `KindeSdk` requests the following scopes:
+
+- profile
+- email
+- offline
+- openid
+
+You are able to change it - by configuring as mentioned at [Integration](#integration) or by direct param passing into `auth_url` method:
+```ruby
+KindeSdk.auth_url(scope: "openid offline")
+```
+
+#### Getting claims
+We have provided a helper to grab any claim from your id or access tokens. The helper defaults to access tokens:
+```ruby
+client = KindeSdk.client(session[:kinde_auth]["access_token"])
+client.get_claim("aud") #=> ['api.yourapp.com']
+client.get_claim("scp") #=> ["openid", "offline"]
+```
+
+#### User permissions
+After a user signs in and they are verified, the token return includes permissions for that user. 
+[User permissions](https://kinde.com/docs/user-management/user-permissions) are set in Kinde, 
+but you must also configure your application to unlock these functions.
+```
+permissions" => [
+    "create:todos",
+    "update:todos",
+    "read:todos",
+    "delete:todos",
+    "create:tasks",
+    "update:tasks",
+    "read:tasks",
+    "delete:tasks",
+]
+```
+We provide helper functions to more easily access permissions:
+```ruby
+client = KindeSdk.client(session[:kinde_auth]["access_token"])
+client.get_permission("create:todos") # => {org_code: "org_1234", is_granted: true}
+client.permission_granted?("create:todos") # => true
+client.permission_granted?("create:orders") # => false
+```
+
+#### Client usage
+API part is mounted in the `KindeSdk::Client` instance, so the short usage is just simple as:
+```ruby
+client.oauth.get_user
+client.users.create_user(args)
+client.organizations.get_organizations
+```
+The method name will be the same as API module from sdk without `-Api` part in the end.
+Alternatively, you can initialize each API module by yourself:
+```ruby
+# use initialized and configured api client
+api_client = KindeSdk.api_client(access_token)
+instance_client = KindeApi::UsersApi.new(api_client)
+instance_client.create_user(args)
+```
+
+#### Logout
+For logout you need to call:
+```ruby
+instance_client.logout
+# or
+KindeSdk.logout(access_token)
+```
+then clear your session or storage (delete your token) and redirect wherever you want to.
+If you configured logout redirect url correct (e.g. added in the admin panel allowed logout redirect), you can receive 
+a logout callback. Use it if it needs to perform some clean-ups or any other jobs.
+
+### Organizations
+#### Create an organization
+To have a new organization created within your application, you will need to run something like:
+```ruby
+client.organizations.create_organization(create_organization_request: {name: "new_org"})
+# or `client.organizations.create_organization` without name
+```
+
+### Sign up and sign in to organizations
+Kinde has a unique code for every organization. 
+If you want a user to sign into a particular organization, call the `#auth_url` method with `org_code` param passing:
+```ruby
+KindeSdk.auth_url(org_code: "org_1234", start_page: "registration") # to enforce new user creation form
+KindeSdk.auth_url(org_code: "org_1234") # to login by default
+```
+
+Following authentication, Kinde provides a json web token (jwt) to your application. 
+Along with the standard information we also include the `org_code` and the permissions for that organization (this is important as a user can belong to multiple organizations and have different permissions for each).
+
+Example of a returned token:
+```ruby
+[
+  {
+    "aud" => [],
+    "exp" => 1658475930,
+    "iat" => 1658472329,
+    "iss" => "https://your_subdomain.kinde.com",
+    "jti" => "123457890",
+    "org_code" => "org_1234",
+    "permissions" => ["read:todos", "create:todos"],
+    "scp" => [
+      "openid",
+      "profile",
+      "email",
+      "offline"
+    ],
+    "sub" => "kp:123457890"
+  }
+]
+```
+The `id_token` will also contain an array of organizations that a user belongs to - this is useful if you wanted to build out an organization switcher for example:
+```ruby
+client.get_claim("org_codes") # => ["org_1234", "org_5462"]
+```
+
+### API reference
+Detailed API reference described in [KindeSDK README](kinde-sdk/README.md) and underlying description docs.
+Here are some selected examples of usage.
+
+#### Getting user info
+
+```ruby
+KindeSdk.client(session[:kinde_auth]["access_token"]).oauth.get_user
+# => {id: ..., preferred_email: ..., provided_id: ..., last_name: ..., first_name: ...}
+```
+
+#### Management API
+These sections below are part of management API. It should be configured first at your Kinde account
+[Here is detailed note about it](https://kinde.notion.site/Management-API-via-client_credentials-240e6fa548c144828d4981ddbaa0f6b2),
+you need to add `Machine to Machine` (M2M) application and use another grant type for authorization:
+```ruby
+result = KindeSdk.client_credentials_access(
+  client_id: ENV["KINDE_MANAGEMENT_CLIENT_ID"],
+  client_secret: ENV["KINDE_MANAGEMENT_CLIENT_SECRET"]
+)
+# as an example of usage redis to save access token:
+$redis.set("kinde_m2m_token", result["access_token"], ex: result["expires_in"].to_i)
+```
+
+##### Organizations handling
+```ruby
+client = KindeSdk.client($redis.get("kinde_m2m_token"))
+# get organizations list:
+client.organizations.get_organizations
+# => {"code": "OK", "message": "Success", "next_token": "qweqweqwe", "organizations": [{"code": "org_casda123c", "name": "Default Organization", "is_default": true}]}
+
+# create new organization:
+client.organizations.create_organization(create_organization_request: {name: "new_org"})
+# this variant for more strict input params validation:
+# client.organizations.create_organization(create_organization_request: KindeApi::CreateOrganizationRequest.new(name: new_org_name))
+```
+
+#### Create new user
+```ruby
+client.users.create_user
+```
+
+#### Add organization users
+
+```ruby
+client.organizations.add_organization_users(code: "org_1111", users: ["kp:12311...."])
+```

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.pattern = ['spec/*_spec.rb', 'kinde_api/spec/*_spec.rb', 'kinde_api/spec/*/*_spec.rb']
+  end
+  task default: :spec
+end

data/kinde_api/.gitignore

@@ -0,0 +1,39 @@
+# Generated by: https://openapi-generator.tech
+#
+
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/kinde_api/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/kinde_api/README.md

@@ -0,0 +1,103 @@
+## Getting Started
+
+```ruby
+# Load the gem
+require 'kinde_api'
+
+# Setup authorization
+KindeApi.configure do |config|
+  # Configure Bearer authorization (JWT): kindeBearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+  # Configure a proc to get access tokens in lieu of the static access_token configuration
+  config.access_token_getter = -> { 'YOUR TOKEN GETTER PROC' } 
+end
+
+api_instance = KindeApi::ConnectedAppsApi.new
+key_code_ref = 'key_code_ref_example' # String | The unique key code reference of the connected app to authenticate against.
+user_id = 56 # Integer | The id of the user that needs to authenticate to the third-party connected app.
+
+begin
+  #Get Connected App URL
+  result = api_instance.get_connected_app_auth_url(key_code_ref, user_id)
+  p result
+rescue KindeApi::ApiError => e
+  puts "Exception when calling ConnectedAppsApi->get_connected_app_auth_url: #{e}"
+end
+
+```
+
+## Documentation for API Endpoints
+
+All URIs are relative to *https://app.kinde.com*
+
+Class | Method | HTTP request | Description
+------------ | ------------- | ------------- | -------------
+*KindeApi::ConnectedAppsApi* | [**get_connected_app_auth_url**](docs/ConnectedAppsApi.md#get_connected_app_auth_url) | **GET** /api/v1/connected_apps/auth_url | Get Connected App URL
+*KindeApi::ConnectedAppsApi* | [**get_connected_app_token**](docs/ConnectedAppsApi.md#get_connected_app_token) | **GET** /api/v1/connected_apps/token | Get Connected App Token
+*KindeApi::ConnectedAppsApi* | [**revoke_connected_app_token**](docs/ConnectedAppsApi.md#revoke_connected_app_token) | **POST** /api/v1/connected_apps/revoke | Revoke Connected App Token
+*KindeApi::EnvironmentsApi* | [**delete_environement_feature_flag_override**](docs/EnvironmentsApi.md#delete_environement_feature_flag_override) | **DELETE** /api/v1/environment/feature_flags/{feature_flag_key} | Delete environment feature flag override
+*KindeApi::EnvironmentsApi* | [**delete_environement_feature_flag_overrides**](docs/EnvironmentsApi.md#delete_environement_feature_flag_overrides) | **DELETE** /api/v1/environment/feature_flags/ | Delete all environment feature flag overrides
+*KindeApi::EnvironmentsApi* | [**update_environement_feature_flag_override**](docs/EnvironmentsApi.md#update_environement_feature_flag_override) | **PATCH** /api/v1/environment/feature_flags/{feature_flag_key} | Update environment feature flag override
+*KindeApi::FeatureFlagsApi* | [**create_feature_flag**](docs/FeatureFlagsApi.md#create_feature_flag) | **POST** /api/v1/feature_flags | Create a new feature flag
+*KindeApi::FeatureFlagsApi* | [**delete_feature_flag**](docs/FeatureFlagsApi.md#delete_feature_flag) | **DELETE** /api/v1/feature_flags/{feature_flag_key} | Delete a feature flag
+*KindeApi::FeatureFlagsApi* | [**update_feature_flag**](docs/FeatureFlagsApi.md#update_feature_flag) | **PUT** /api/v1/feature_flags/{feature_flag_key} | Update a feature flag
+*KindeApi::OAuthApi* | [**get_user**](docs/OAuthApi.md#get_user) | **GET** /oauth2/user_profile | Returns the details of the currently logged in user
+*KindeApi::OAuthApi* | [**get_user_profile_v2**](docs/OAuthApi.md#get_user_profile_v2) | **GET** /oauth2/v2/user_profile | Returns the details of the currently logged in user
+*KindeApi::OrganizationsApi* | [**add_organization_users**](docs/OrganizationsApi.md#add_organization_users) | **POST** /api/v1/organization/users | Assign Users to an Organization
+*KindeApi::OrganizationsApi* | [**create_organization**](docs/OrganizationsApi.md#create_organization) | **POST** /api/v1/organization | Create Organization
+*KindeApi::OrganizationsApi* | [**delete_organization_feature_flag_override**](docs/OrganizationsApi.md#delete_organization_feature_flag_override) | **DELETE** /api/v1/organizations/{org_code}/feature_flags/{feature_flag_key} | Delete organization feature flag override
+*KindeApi::OrganizationsApi* | [**delete_organization_feature_flag_overrides**](docs/OrganizationsApi.md#delete_organization_feature_flag_overrides) | **DELETE** /api/v1/organizations/{org_code}/feature_flags | Delete all organization feature flag overrides
+*KindeApi::OrganizationsApi* | [**get_organization**](docs/OrganizationsApi.md#get_organization) | **GET** /api/v1/organization | Get Organization
+*KindeApi::OrganizationsApi* | [**get_organization_users**](docs/OrganizationsApi.md#get_organization_users) | **GET** /api/v1/organization/users | List Organization Users
+*KindeApi::OrganizationsApi* | [**get_organizations**](docs/OrganizationsApi.md#get_organizations) | **GET** /api/v1/organizations | List Organizations
+*KindeApi::OrganizationsApi* | [**remove_organization_users**](docs/OrganizationsApi.md#remove_organization_users) | **PATCH** /api/v1/organization/users | Remove Users from an Organization
+*KindeApi::OrganizationsApi* | [**update_organization_feature_flag_override**](docs/OrganizationsApi.md#update_organization_feature_flag_override) | **PATCH** /api/v1/organizations/{org_code}/feature_flags/{feature_flag_key} | Update organization feature flag override
+*KindeApi::UsersApi* | [**add_organization_users**](docs/UsersApi.md#add_organization_users) | **POST** /api/v1/organization/users | Assign Users to an Organization
+*KindeApi::UsersApi* | [**create_user**](docs/UsersApi.md#create_user) | **POST** /api/v1/user | Create User
+*KindeApi::UsersApi* | [**deleteuser**](docs/UsersApi.md#deleteuser) | **DELETE** /api/v1/user | Delete User
+*KindeApi::UsersApi* | [**get_organization_users**](docs/UsersApi.md#get_organization_users) | **GET** /api/v1/organization/users | List Organization Users
+*KindeApi::UsersApi* | [**get_user_data**](docs/UsersApi.md#get_user_data) | **GET** /api/v1/user | Get User
+*KindeApi::UsersApi* | [**get_users**](docs/UsersApi.md#get_users) | **GET** /api/v1/users | List Users
+*KindeApi::UsersApi* | [**remove_organization_users**](docs/UsersApi.md#remove_organization_users) | **PATCH** /api/v1/organization/users | Remove Users from an Organization
+*KindeApi::UsersApi* | [**update_user**](docs/UsersApi.md#update_user) | **PATCH** /api/v1/user | Update User
+
+
+## Documentation for Models
+
+ - [KindeApi::AddOrganizationUsers200Response](docs/AddOrganizationUsers200Response.md)
+ - [KindeApi::AddOrganizationUsersRequest](docs/AddOrganizationUsersRequest.md)
+ - [KindeApi::ApiResult](docs/ApiResult.md)
+ - [KindeApi::ConnectedAppsAccessToken](docs/ConnectedAppsAccessToken.md)
+ - [KindeApi::ConnectedAppsAuthUrl](docs/ConnectedAppsAuthUrl.md)
+ - [KindeApi::CreateOrganization201Response](docs/CreateOrganization201Response.md)
+ - [KindeApi::CreateOrganizationRequest](docs/CreateOrganizationRequest.md)
+ - [KindeApi::CreateUser200Response](docs/CreateUser200Response.md)
+ - [KindeApi::CreateUserRequest](docs/CreateUserRequest.md)
+ - [KindeApi::CreateUserRequestIdentitiesInner](docs/CreateUserRequestIdentitiesInner.md)
+ - [KindeApi::CreateUserRequestIdentitiesInnerDetails](docs/CreateUserRequestIdentitiesInnerDetails.md)
+ - [KindeApi::CreateUserRequestProfile](docs/CreateUserRequestProfile.md)
+ - [KindeApi::Error](docs/Error.md)
+ - [KindeApi::ErrorResponse](docs/ErrorResponse.md)
+ - [KindeApi::GetOrganizationUsers200Response](docs/GetOrganizationUsers200Response.md)
+ - [KindeApi::GetOrganizations200Response](docs/GetOrganizations200Response.md)
+ - [KindeApi::GetUsers200Response](docs/GetUsers200Response.md)
+ - [KindeApi::Organization](docs/Organization.md)
+ - [KindeApi::OrganizationUser](docs/OrganizationUser.md)
+ - [KindeApi::RemoveOrganizationUsers200Response](docs/RemoveOrganizationUsers200Response.md)
+ - [KindeApi::RemoveOrganizationUsersRequest](docs/RemoveOrganizationUsersRequest.md)
+ - [KindeApi::SuccessResponse](docs/SuccessResponse.md)
+ - [KindeApi::UpdateUserRequest](docs/UpdateUserRequest.md)
+ - [KindeApi::User](docs/User.md)
+ - [KindeApi::UserIdentity](docs/UserIdentity.md)
+ - [KindeApi::UserIdentityResult](docs/UserIdentityResult.md)
+ - [KindeApi::UserProfile](docs/UserProfile.md)
+ - [KindeApi::UserProfileV2](docs/UserProfileV2.md)
+
+
+## Documentation for Authorization
+
+
+### kindeBearerAuth
+
+- **Type**: Bearer authentication (JWT)
+