prow-authority 3.6.3

package/src/v1/routes/v1-router.ts

@@ -0,0 +1,50 @@
+import { Router } from 'express';
+import adminRouter from './admin/admin-router';
+import identityTokenRouter from './auth/identity-token-router';
+import organizationTokenRouter from './auth/organization-token-router';
+import publicOrganizationRouter from './organizations/public-organization-router';
+import publicPolicyRouter from './policies/public-policy-router';
+import publicServiceRouter from './services/public-service-router';
+import serviceRouter from './services/service-router';
+import publicUserRouter from './users/public-user-router';
+import billingRouter from './billing/billing-router';
+
+
+class V1Router {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly init = () => {
+    // admin scope
+    this.router.use(`/admin`, adminRouter);
+
+    // public scope: services and licenses
+    this.router.use(`/services`, publicServiceRouter);
+
+    // public scope: policies
+    this.router.use(`/policies`, publicPolicyRouter);
+
+    // user authentication and scope
+    this.router.use(`/auth/identity`, identityTokenRouter);
+    this.router.use(`/user`, publicUserRouter);
+
+    // organization authentication and scope
+    this.router.use(`/auth/organization`, organizationTokenRouter);
+    this.router.use(`/organization`, publicOrganizationRouter);
+
+    // service scope
+    this.router.use(`/service`, serviceRouter);
+
+    // billing scope
+    this.router.use(`/billing`, billingRouter);
+  };
+}
+
+const v1Router = (new V1Router()).router;
+export default v1Router;
+
+

package/src/v1/schemas/admin/accounting-seat-schemas.ts

@@ -0,0 +1,22 @@
+import { Formats } from "@beseif-solutions/utility-functions/dist/utils/date-utils";
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+
+export const addAccountingSeatSchema = Schema.object({
+  organization: Schema.requiredNumber(),
+  invoice: Schema.requiredNumber(),
+  date: Schema.requiredDate({ strict: false, format: Formats.ISO }),
+  amount: Schema.requiredNumber(),
+  done: Schema.requiredBool(),
+  metadata: Schema.object(),
+  internal: Schema.object(),
+});
+
+export const updateAccountingSeatSchema = Schema.object({
+  organization: Schema.number(),
+  invoice: Schema.number(),
+  date: Schema.date({ strict: false, format: Formats.ISO }),
+  amount: Schema.number(),
+  done: Schema.bool(),
+  metadata: Schema.object(),
+  internal: Schema.object(),
+});

package/src/v1/schemas/admin/billing-cycle-schemas.ts

@@ -0,0 +1,20 @@
+import { Formats } from "@beseif-solutions/utility-functions/dist/utils/date-utils";
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+
+export const addBillingCycleSchema = Schema.object({
+  organization: Schema.requiredNumber(),
+  trial: Schema.requiredBool(),
+  start_date: Schema.requiredDate({ strict: false, format: Formats.ISO }),
+  end_date: Schema.requiredDate({ strict: false, format: Formats.ISO }),
+  metadata: Schema.object(),
+  internal: Schema.object(),
+});
+
+export const updateBillingCycleSchema = Schema.object({
+  organization: Schema.number(),
+  trial: Schema.bool(),
+  start_date: Schema.date({ strict: false, format: Formats.ISO }),
+  end_date: Schema.date({ strict: false, format: Formats.ISO }),
+  metadata: Schema.object(),
+  internal: Schema.object(),
+});

package/src/v1/schemas/admin/invoice-schemas.ts

@@ -0,0 +1,41 @@
+import { Formats } from "@beseif-solutions/utility-functions/dist/utils/date-utils";
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import { InvoiceStatus } from "../../types/admin/invoice-types";
+
+const conceptSchema = Schema.object({
+  name: Schema.requiredString(),
+  description: Schema.requiredString(),
+  price: Schema.requiredNumber(),
+});
+
+export const addInvoiceSchema = Schema.object({
+  organization: Schema.requiredNumber(),
+  date: Schema.requiredDate({ strict: false, format: Formats.ISO }),
+  tax_code: Schema.requiredString(),
+  tax_percentage: Schema.requiredNumber(),
+  concepts: Schema.requiredArray({ items: conceptSchema, min: 1 }),
+  billing: Schema.requiredObject(),
+  status: Schema.requiredString({ valid: Object.values(InvoiceStatus) }),
+  invoice: Schema.string({ allow: [null] }),
+  number: Schema.string({ allow: [null] }),
+  payment: Schema.string({ allow: [null] }),
+  method: Schema.number({ allow: [null] }),
+  metadata: Schema.object(),
+  internal: Schema.object(),
+});
+
+export const updateInvoiceSchema = Schema.object({
+  organization: Schema.number(),
+  date: Schema.date({ strict: false, format: Formats.ISO }),
+  tax_code: Schema.string(),
+  tax_percentage: Schema.number(),
+  concepts: Schema.array({ items: conceptSchema }),
+  billing: Schema.object(),
+  status: Schema.string({ valid: Object.values(InvoiceStatus) }),
+  invoice: Schema.string({ allow: [null] }),
+  number: Schema.string({ allow: [null] }),
+  payment: Schema.string({ allow: [null] }),
+  method: Schema.number({ allow: [null] }),
+  metadata: Schema.object(),
+  internal: Schema.object(),
+});

package/src/v1/schemas/admin/license-limit-schemas.ts

@@ -0,0 +1,25 @@
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+
+export const addLicenseLimitSchema = Schema.object({
+  license: Schema.requiredNumber(),
+  name: Schema.requiredString({ max: 100 }),
+  limit: Schema.requiredNumber(),
+  period: Schema.requiredString({ valid: [`monthly`, `lifetime`] }),
+  monthly_price_abs: Schema.requiredNumber(),
+  annual_price_abs: Schema.requiredNumber(),
+  overconsume_monthly_price_per_unit: Schema.requiredNumber().allow(null),
+  overconsume_annual_price_per_unit: Schema.requiredNumber().allow(null),
+  metadata: Schema.object(),
+});
+
+export const updateLicenseLimitSchema = Schema.object({
+  license: Schema.number(),
+  name: Schema.string({ max: 100 }),
+  limit: Schema.number(),
+  period: Schema.string({ valid: [`monthly`, `lifetime`] }),
+  monthly_price_abs: Schema.number(),
+  annual_price_abs: Schema.number(),
+  overconsume_monthly_price_per_unit: Schema.number().allow(null),
+  overconsume_annual_price_per_unit: Schema.number().allow(null),
+  metadata: Schema.object(),
+});

package/src/v1/schemas/admin/license-schemas.ts

@@ -0,0 +1,30 @@
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import { LicenseType } from "../../types/admin/license-types";
+
+export const addLicenseSchema = Schema.object({
+  service: Schema.requiredNumber(),
+  type: Schema.requiredString({ valid: Object.values(LicenseType) }),
+  associated: Schema.number(),
+  properties: Schema.requiredObject({
+    name: Schema.requiredString(),
+    description: Schema.requiredString(),
+  }),
+  data: Schema.requiredObject(),
+  public: Schema.requiredBool(),
+  enabled: Schema.requiredBool(),
+  metadata: Schema.object(),
+});
+
+export const updateLicenseSchema = Schema.object({
+  service: Schema.number(),
+  type: Schema.string({ valid: Object.values(LicenseType) }),
+  associated: Schema.number(),
+  properties: Schema.object({
+    name: Schema.string(),
+    description: Schema.string(),
+  }),
+  data: Schema.object(),
+  public: Schema.bool(),
+  enabled: Schema.bool(),
+  metadata: Schema.object(),
+});

package/src/v1/schemas/admin/organization-license-limit-schemas.ts

@@ -0,0 +1,29 @@
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+
+export const addOrganizationLicenseLimitSchema = Schema.object({
+  organization: Schema.requiredNumber(),
+  license: Schema.requiredNumber(),
+  name: Schema.requiredString({ max: 100 }),
+  limit: Schema.requiredNumber(),
+  period: Schema.requiredString({ valid: [`monthly`, `lifetime`] }),
+  monthly_price_abs: Schema.requiredNumber(),
+  annual_price_abs: Schema.requiredNumber(),
+  overconsume: Schema.requiredBool(),
+  overconsume_monthly_price_per_unit: Schema.requiredNumber().allow(null),
+  overconsume_annual_price_per_unit: Schema.requiredNumber().allow(null),
+  metadata: Schema.object(),
+});
+
+export const updateOrganizationLicenseLimitSchema = Schema.object({
+  organization: Schema.number(),
+  license: Schema.number(),
+  name: Schema.string({ max: 100 }),
+  limit: Schema.number(),
+  period: Schema.string({ valid: [`monthly`, `lifetime`] }),
+  monthly_price_abs: Schema.number(),
+  annual_price_abs: Schema.number(),
+  overconsume: Schema.bool(),
+  overconsume_monthly_price_per_unit: Schema.number().allow(null),
+  overconsume_annual_price_per_unit: Schema.number().allow(null),
+  metadata: Schema.object(),
+});

package/src/v1/schemas/admin/organization-license-schemas.ts

@@ -0,0 +1,43 @@
+import { Formats } from "@beseif-solutions/utility-functions/dist/utils/date-utils";
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import { LicenseType } from "../../types/admin/license-types";
+
+export const addOrganizationLicenseSchema = Schema.object({
+  organization: Schema.requiredNumber(),
+  service: Schema.requiredNumber(),
+  type: Schema.requiredString({ valid: Object.values(LicenseType) }),
+  associated: Schema.number(),
+  original: Schema.requiredNumber(),
+  billing: Schema.requiredString({ valid: [`monthly`, `annual`, `lifetime`] }),
+  properties: Schema.requiredObject({
+    name: Schema.requiredString(),
+    description: Schema.requiredString(),
+  }),
+  data: Schema.requiredObject(),
+  start_date: Schema.requiredDate({ strict: false, format: Formats.ISO }),
+  end_date: Schema.requiredDate({ strict: false, format: Formats.ISO, allow: [null] }),
+  metadata: Schema.object(),
+  internal: Schema.object({
+    notified: Schema.bool().allow(null),
+  }),
+});
+
+export const updateOrganizationLicenseSchema = Schema.object({
+  organization: Schema.number(),
+  service: Schema.number(),
+  type: Schema.string({ valid: Object.values(LicenseType) }),
+  associated: Schema.number(),
+  original: Schema.number(),
+  billing: Schema.string({ valid: [`monthly`, `annual`, `lifetime`] }),
+  properties: Schema.object({
+    name: Schema.string(),
+    description: Schema.string(),
+  }),
+  data: Schema.object(),
+  start_date: Schema.date({ strict: false, format: Formats.ISO }),
+  end_date: Schema.date({ strict: false, format: Formats.ISO, allow: [null] }),
+  metadata: Schema.object(),
+  internal: Schema.object({
+    notified: Schema.bool().allow(null),
+  }),
+});

package/src/v1/schemas/admin/organization-schemas.ts

@@ -0,0 +1,67 @@
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import { OrganizationStatus } from "../../types/admin/organization-types";
+
+export const addOrganizationSchema = Schema.object({
+  properties: Schema.requiredObject({
+    name: Schema.requiredString(),
+    activity: Schema.string(),
+    image: Schema.string({ allow: [null] }),
+    cover: Schema.string({ allow: [null] }),
+  }),
+  billing: Schema.object({
+    name: Schema.requiredString(),
+    document: Schema.requiredString(),
+    email: Schema.email(),
+    phone: Schema.string(),
+    address: Schema.object({
+      address: Schema.requiredString(),
+      city: Schema.requiredString(),
+      zip: Schema.requiredString(),
+      province: Schema.requiredString(),
+      country: Schema.requiredString(),
+    }),
+    individual: Schema.bool(),
+  }),
+  preferences: Schema.requiredObject({
+    timezone: Schema.requiredString(),
+  }),
+  status: Schema.requiredString({ valid: Object.values(OrganizationStatus) }),
+  metadata: Schema.object(),
+  internal: Schema.object({
+    customer: Schema.string(),
+    services: Schema.object(),
+  }),
+});
+
+export const updateOrganizationSchema = (deletion = false) => Schema.object({
+  properties: Schema.object({
+    name: Schema.string(),
+    activity: Schema.string(),
+    image: Schema.string({ allow: [null] }),
+    cover: Schema.string({ allow: [null] }),
+  }),
+  billing: Schema.object({
+    name: Schema.string(),
+    document: Schema.string(),
+    email: Schema.email(),
+    phone: Schema.string(),
+    address: Schema.object({
+      address: Schema.string(),
+      city: Schema.string(),
+      zip: Schema.string(),
+      province: Schema.string(),
+      country: Schema.string(),
+    }),
+    individual: Schema.bool(),
+  }),
+  preferences: Schema.object({
+    timezone: Schema.string(),
+  }),
+  status: Schema.string({ valid: deletion ? [`deleted`] : Object.values(OrganizationStatus) }),
+  metadata: Schema.object(),
+  internal: Schema.object({
+    customer: Schema.string(),
+    services: Schema.object(),
+    deleted_date: Schema.string(),
+  }).unknown(),
+});

package/src/v1/schemas/admin/organization-usage-schemas.ts

@@ -0,0 +1,15 @@
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+
+export const addOrganizationUsageSchema = Schema.object({
+  organization: Schema.requiredNumber(),
+  service: Schema.requiredNumber(),
+  name: Schema.requiredString(),
+  count: Schema.requiredNumber(),
+});
+
+export const updateOrganizationUsageSchema = Schema.object({
+  organization: Schema.number(),
+  service: Schema.number(),
+  name: Schema.string(),
+  count: Schema.number(),
+});

package/src/v1/schemas/admin/payment-method-schemas.ts

@@ -0,0 +1,40 @@
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import { PaymentMethodType } from "../../types/admin/payment-method-types";
+
+export const addPaymentMethodSchema = Schema.object({
+  organization: Schema.requiredNumber(),
+  type: Schema.requiredString({ valid: Object.values(PaymentMethodType) }),
+  properties: Schema.requiredObject({
+    alias: Schema.string({ allow: [null] }),
+    name: Schema.requiredString(),
+    brand: Schema.string(),
+    country: Schema.string(),
+    exp_year: Schema.number(),
+    exp_month: Schema.number(),
+  }),
+  enabled: Schema.requiredBool(),
+  metadata: Schema.object(),
+  internal: Schema.object({
+    payment_method_id: Schema.requiredString(),
+    fingerprint: Schema.string(),
+  }),
+});
+
+export const updatePaymentMethodSchema = Schema.object({
+  organization: Schema.number(),
+  type: Schema.string({ valid: Object.values(PaymentMethodType) }),
+  properties: Schema.object({
+    alias: Schema.string({ allow: [null] }),
+    name: Schema.string(),
+    brand: Schema.string({ allow: [null] }),
+    country: Schema.string({ allow: [null] }),
+    exp_year: Schema.number({ allow: [null] }),
+    exp_month: Schema.number({ allow: [null] }),
+  }),
+  enabled: Schema.bool(),
+  metadata: Schema.object(),
+  internal: Schema.object({
+    payment_method_id: Schema.string(),
+    fingerprint: Schema.string(),
+  }),
+});

package/src/v1/schemas/admin/policy-schemas.ts

@@ -0,0 +1,31 @@
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+
+export const addPolicySchema = Schema.object({
+  name: Schema.requiredString({ min: 1, max: 100 }),
+  metadata: Schema.object(),
+  internal: Schema.object(),
+});
+
+export const updatePolicySchema = Schema.object({
+  name: Schema.string({ min: 1, max: 100 }),
+  metadata: Schema.object(),
+  internal: Schema.object(),
+});
+
+export const addPolicyVersionSchema = Schema.object({
+  policy: Schema.requiredNumber({ min: 1 }),
+  version: Schema.requiredString({ min: 1, max: 20 }),
+  url: Schema.requiredString({ min: 1, max: 255 }),
+  effective_date: Schema.string(),
+  metadata: Schema.object(),
+  internal: Schema.object(),
+});
+
+export const updatePolicyVersionSchema = Schema.object({
+  policy: Schema.number({ min: 1 }),
+  version: Schema.string({ min: 1, max: 20 }),
+  url: Schema.string({ min: 1, max: 255 }),
+  effective_date: Schema.string(),
+  metadata: Schema.object(),
+  internal: Schema.object(),
+});

package/src/v1/schemas/admin/service-notification-schemas.ts

@@ -0,0 +1,23 @@
+import { Schema } from '@beseif-solutions/utility-functions/dist/utils/validation-utils';
+
+
+export const addServiceNotificationSchema = Schema.object({
+  service: Schema.requiredNumber(),
+  event: Schema.requiredString(),
+  template: Schema.requiredString(),
+  scope: Schema.requiredObject(),
+  default: Schema.bool(),
+  enabled: Schema.bool(),
+  metadata: Schema.object(),
+});
+
+
+export const updateServiceNotificationSchema = Schema.object({
+  service: Schema.number(),
+  event: Schema.string(),
+  template: Schema.string(),
+  scope: Schema.object(),
+  default: Schema.bool(),
+  enabled: Schema.bool(),
+  metadata: Schema.object(),
+});

package/src/v1/schemas/admin/service-schemas.ts

@@ -0,0 +1,56 @@
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+
+const authoritySchema = Schema.object({
+  host: Schema.string(),
+  user: Schema.object({
+    information: Schema.string(),
+    // created: Schema.string(),
+    deleted: Schema.string(),
+  }).allow(null),
+  organization: Schema.object({
+    information: Schema.string(),
+    created: Schema.string(),
+    modified: Schema.string(),
+    deleted: Schema.string(),
+  }).allow(null),
+});
+
+export const addServiceSchema = Schema.object({
+  properties: Schema.requiredObject({
+    name: Schema.requiredString(),
+    description: Schema.requiredString(),
+    home: Schema.string(),
+    image: Schema.requiredString(),
+  }),
+  preferences: Schema.requiredObject({
+    // TODO
+  }),
+  metadata: Schema.object(),
+  internal: Schema.requiredObject()
+    .concat(authoritySchema),
+});
+
+export const updateServiceSchema = Schema.object({
+  token: Schema.bool(),
+  properties: Schema.object({
+    name: Schema.string(),
+    description: Schema.string(),
+    home: Schema.string({ allow: [null] }),
+    image: Schema.string(),
+  }),
+  preferences: Schema.object({
+    // TODO
+  }),
+  enabled: Schema.bool(),
+  metadata: Schema.object(),
+  internal: Schema.object()
+    .concat(authoritySchema),
+});
+
+export const informationResponseSchema = Schema.array({
+  items: Schema.object({
+    type: Schema.requiredString({ valid: [`shared`, `owner`] }),
+    model: Schema.requiredString(),
+    count: Schema.requiredNumber({ sign: Schema.Sign.Positive }),
+  }),
+});

package/src/v1/schemas/admin/user-organization-schemas.ts

@@ -0,0 +1,24 @@
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import { UserOrganizationRole } from "../../types/admin/user-organization-types";
+
+export const addUserOrganizationSchema = Schema.object({
+  user: Schema.requiredNumber(),
+  organization: Schema.requiredNumber(),
+  role: Schema.requiredString({ valid: Object.values(UserOrganizationRole) }),
+  invite: Schema.string({ allow: [null] }),
+  invited_by: Schema.number().allow(null),
+  preferences: Schema.object(),
+  enabled: Schema.requiredBool(),
+  metadata: Schema.object(),
+});
+
+export const updateUserOrganizationSchema = Schema.object({
+  user: Schema.number(),
+  organization: Schema.number(),
+  role: Schema.string({ valid: Object.values(UserOrganizationRole) }),
+  invite: Schema.string({ allow: [null] }),
+  invited_by: Schema.number().allow(null),
+  preferences: Schema.object(),
+  enabled: Schema.bool(),
+  metadata: Schema.object(),
+});

package/src/v1/schemas/admin/user-policy-schemas.ts

@@ -0,0 +1,17 @@
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+
+export const addUserPolicySchema = Schema.object({
+  user: Schema.requiredNumber({ min: 1 }),
+  policy: Schema.requiredNumber({ min: 1 }),
+  version: Schema.requiredNumber({ min: 1 }),
+  metadata: Schema.object(),
+  internal: Schema.object(),
+});
+
+export const updateUserPolicySchema = Schema.object({
+  user: Schema.number({ min: 1 }),
+  policy: Schema.number({ min: 1 }),
+  version: Schema.number({ min: 1 }),
+  metadata: Schema.object(),
+  internal: Schema.object(),
+});

package/src/v1/schemas/admin/user-schemas.ts

@@ -0,0 +1,52 @@
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import { CommunicationType } from "../../types/admin/user-types";
+
+export const addUserSchema = Schema.object({
+  email: Schema.requiredEmail({ max: 200 }),
+  password: Schema.string({ min: 8, allow: [null] }),
+  properties: Schema.object({
+    name: Schema.string(),
+    surnames: Schema.string(),
+    image: Schema.string(),
+  }),
+  preferences: Schema.object({
+    language: Schema.string({ length: 2 }),
+    communications: Schema.object({
+      [CommunicationType.Commercial]: Schema.bool(),
+      [CommunicationType.Newsletter]: Schema.bool(),
+    }),
+  }),
+  utm: Schema.object({
+    medium: Schema.string(),
+    source: Schema.string(),
+    campaign: Schema.string(),
+  }),
+  referrer: Schema.string().optional(),
+  omnipotent: Schema.bool(),
+  metadata: Schema.object(),
+});
+
+export const updateUserSchema = Schema.object({
+  email: Schema.email({ max: 200 }),
+  password: Schema.string({ min: 8 }),
+  properties: Schema.object({
+    name: Schema.string(),
+    surnames: Schema.string(),
+    image: Schema.string({ allow: [null] }),
+  }),
+  preferences: Schema.object({
+    language: Schema.string({ length: 2 }),
+    communications: Schema.object({
+      [CommunicationType.Commercial]: Schema.bool(),
+      [CommunicationType.Newsletter]: Schema.bool(),
+    }),
+  }),
+  utm: Schema.object({
+    medium: Schema.string(),
+    source: Schema.string(),
+    campaign: Schema.string(),
+  }).optional(),
+  referrer: Schema.string().optional(),
+  omnipotent: Schema.bool(),
+  metadata: Schema.object(),
+});

package/src/v1/schemas/auth/auth-schemas.ts

@@ -0,0 +1,55 @@
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import { TempCodeType } from "../../types/auth/otp-types";
+
+export const identityAdminSchema = Schema.object({
+  email: Schema.requiredEmail(),
+});
+
+export const identityTokenSchema = Schema.object({
+  email: Schema.requiredEmail(),
+  password: Schema.requiredString(),
+});
+
+export const confirmSchema = Schema.object({
+  code: Schema.requiredString(),
+});
+
+export const refreshSchema = Schema.object({
+  refresh_token: Schema.requiredString(),
+});
+
+export const organizationTokenSchema = Schema.object({
+  organization: Schema.requiredString(),
+});
+
+export const newOTPSchema = Schema.object({
+  email: Schema.requiredEmail(),
+  flow: Schema.requiredString({ valid: [TempCodeType.OTP, TempCodeType.Password] }),
+});
+
+export const validateOTPSchema = Schema.object({
+  email: Schema.requiredEmail(),
+  code: Schema.requiredString(),
+  flow: Schema.requiredString({ valid: [TempCodeType.OTP, TempCodeType.Password] }),
+});
+
+export const validateRecaptchaSchema = Schema.object({
+  token: Schema.requiredString(),
+});
+
+export const a = Schema.object({
+  client_id: Schema.requiredString(),
+  client_secret: Schema.requiredString(),
+  grant_type: Schema.requiredString({ valid: [`refresh_token`] }),
+  refresh_token: Schema.requiredString(),
+});
+
+export const b = Schema.object({
+  client_id: Schema.requiredString(),
+  client_secret: Schema.requiredString(),
+  grant_type: Schema.requiredString({ valid: [`authorization_code`] }),
+  scope: Schema.requiredString(),
+  redirect_uri: Schema.requiredString(),
+  code: Schema.requiredString(),
+});
+