Chinook AI App

Chinook AI App · GPT 작업

AINIRO Magic Cloudlet

Allows you to interact with your Magic cloudlet

  • GET /magic/modules/chinook/Album-countget_chinook_Album-count

    Counts items from your Album table in your chinook database

  • DELETE /magic/modules/chinook/Albumdelete_chinook_Album

    Delete endpoint deleting one record from your Album table in your chinook database with AlbumId matching argument with authentication and authorisation for root,admin roles

  • GET /magic/modules/chinook/Albumget_chinook_Album

    Read endpoint with paging, sorting, filtering selecting records from your Album table in your chinook database returning AlbumId, Title, ArtistId filtering on AlbumId, Title, ArtistId with authentication and authorisation for root,admin roles

  • POST /magic/modules/chinook/Albumpost_chinook_Album

    Create endpoint inserting one record into your Album table in your chinook database taking AlbumId, Title, ArtistId with authentication and authorisation for root,admin roles

  • PUT /magic/modules/chinook/Albumput_chinook_Album

    Update endpoint updating one record in your Album table in your chinook database filtering which item to update with AlbumId updating Title, ArtistId fields with authentication and authorisation for root,admin roles

  • GET /magic/modules/chinook/Artist-countget_chinook_Artist-count

    Counts items from your Artist table in your chinook database

  • DELETE /magic/modules/chinook/Artistdelete_chinook_Artist

    Delete endpoint deleting one record from your Artist table in your chinook database with ArtistId matching argument with authentication and authorisation for root,admin roles

  • GET /magic/modules/chinook/Artistget_chinook_Artist

    Read endpoint with paging, sorting, filtering selecting records from your Artist table in your chinook database returning ArtistId, Name filtering on ArtistId, Name with authentication and authorisation for root,admin roles

  • POST /magic/modules/chinook/Artistpost_chinook_Artist

    Create endpoint inserting one record into your Artist table in your chinook database taking ArtistId, Name with authentication and authorisation for root,admin roles

  • PUT /magic/modules/chinook/Artistput_chinook_Artist

    Update endpoint updating one record in your Artist table in your chinook database filtering which item to update with ArtistId updating Name fields with authentication and authorisation for root,admin roles

  • GET /magic/modules/chinook/Customer-countget_chinook_Customer-count

    Counts items from your Customer table in your chinook database

  • DELETE /magic/modules/chinook/Customerdelete_chinook_Customer

    Delete endpoint deleting one record from your Customer table in your chinook database with CustomerId matching argument with authentication and authorisation for root,admin roles

  • GET /magic/modules/chinook/Customerget_chinook_Customer

    Read endpoint with paging, sorting, filtering selecting records from your Customer table in your chinook database returning CustomerId, FirstName, LastName, Company, Address, City, State, Country, PostalCode, Phone, Fax, Email, SupportRepId filtering on CustomerId, FirstName, LastName, Company, Addr

  • POST /magic/modules/chinook/Customerpost_chinook_Customer

    Create endpoint inserting one record into your Customer table in your chinook database taking CustomerId, FirstName, LastName, Company, Address, City, State, Country, PostalCode, Phone, Fax, Email, SupportRepId with authentication and authorisation for root,admin roles

  • PUT /magic/modules/chinook/Customerput_chinook_Customer

    Update endpoint updating one record in your Customer table in your chinook database filtering which item to update with CustomerId updating FirstName, LastName, Company, Address, City, State, Country, PostalCode, Phone, Fax, Email, SupportRepId fields with authentication and authorisation for root,a

  • GET /magic/modules/chinook/Employee-countget_chinook_Employee-count

    Counts items from your Employee table in your chinook database

  • DELETE /magic/modules/chinook/Employeedelete_chinook_Employee

    Delete endpoint deleting one record from your Employee table in your chinook database with EmployeeId matching argument with authentication and authorisation for root,admin roles

  • GET /magic/modules/chinook/Employeeget_chinook_Employee

    Read endpoint with paging, sorting, filtering selecting records from your Employee table in your chinook database returning EmployeeId, LastName, FirstName, Title, ReportsTo, BirthDate, HireDate, Address, City, State, Country, PostalCode, Phone, Fax, Email filtering on EmployeeId, LastName, FirstNam

  • POST /magic/modules/chinook/Employeepost_chinook_Employee

    Create endpoint inserting one record into your Employee table in your chinook database taking EmployeeId, LastName, FirstName, Title, ReportsTo, BirthDate, HireDate, Address, City, State, Country, PostalCode, Phone, Fax, Email with authentication and authorisation for root,admin roles

  • PUT /magic/modules/chinook/Employeeput_chinook_Employee

    Update endpoint updating one record in your Employee table in your chinook database filtering which item to update with EmployeeId updating LastName, FirstName, Title, ReportsTo, BirthDate, HireDate, Address, City, State, Country, PostalCode, Phone, Fax, Email fields with authentication and authoris

  • GET /magic/modules/chinook/Genre-countget_chinook_Genre-count

    Counts items from your Genre table in your chinook database

  • DELETE /magic/modules/chinook/Genredelete_chinook_Genre

    Delete endpoint deleting one record from your Genre table in your chinook database with GenreId matching argument with authentication and authorisation for root,admin roles

  • GET /magic/modules/chinook/Genreget_chinook_Genre

    Read endpoint with paging, sorting, filtering selecting records from your Genre table in your chinook database returning GenreId, Name filtering on GenreId, Name with authentication and authorisation for root,admin roles

  • POST /magic/modules/chinook/Genrepost_chinook_Genre

    Create endpoint inserting one record into your Genre table in your chinook database taking GenreId, Name with authentication and authorisation for root,admin roles

  • PUT /magic/modules/chinook/Genreput_chinook_Genre

    Update endpoint updating one record in your Genre table in your chinook database filtering which item to update with GenreId updating Name fields with authentication and authorisation for root,admin roles

  • GET /magic/modules/chinook/Invoice-countget_chinook_Invoice-count

    Counts items from your Invoice table in your chinook database

  • DELETE /magic/modules/chinook/Invoicedelete_chinook_Invoice

    Delete endpoint deleting one record from your Invoice table in your chinook database with InvoiceId matching argument with authentication and authorisation for root,admin roles

  • GET /magic/modules/chinook/Invoiceget_chinook_Invoice

    Read endpoint with paging, sorting, filtering selecting records from your Invoice table in your chinook database returning InvoiceId, CustomerId, InvoiceDate, BillingAddress, BillingCity, BillingState, BillingCountry, BillingPostalCode, Total filtering on InvoiceId, CustomerId, InvoiceDate, BillingA

  • POST /magic/modules/chinook/Invoicepost_chinook_Invoice

    Create endpoint inserting one record into your Invoice table in your chinook database taking InvoiceId, CustomerId, InvoiceDate, BillingAddress, BillingCity, BillingState, BillingCountry, BillingPostalCode, Total with authentication and authorisation for root,admin roles

  • PUT /magic/modules/chinook/Invoiceput_chinook_Invoice

    Update endpoint updating one record in your Invoice table in your chinook database filtering which item to update with InvoiceId updating CustomerId, InvoiceDate, BillingAddress, BillingCity, BillingState, BillingCountry, BillingPostalCode, Total fields with authentication and authorisation for root

  • GET /magic/modules/chinook/InvoiceLine-countget_chinook_InvoiceLine-count

    Counts items from your InvoiceLine table in your chinook database

  • DELETE /magic/modules/chinook/InvoiceLinedelete_chinook_InvoiceLine

    Delete endpoint deleting one record from your InvoiceLine table in your chinook database with InvoiceLineId matching argument with authentication and authorisation for root,admin roles

  • GET /magic/modules/chinook/InvoiceLineget_chinook_InvoiceLine

    Read endpoint with paging, sorting, filtering selecting records from your InvoiceLine table in your chinook database returning InvoiceLineId, InvoiceId, TrackId, UnitPrice, Quantity filtering on InvoiceLineId, InvoiceId, TrackId, UnitPrice, Quantity with authentication and authorisation for root,adm

  • POST /magic/modules/chinook/InvoiceLinepost_chinook_InvoiceLine

    Create endpoint inserting one record into your InvoiceLine table in your chinook database taking InvoiceLineId, InvoiceId, TrackId, UnitPrice, Quantity with authentication and authorisation for root,admin roles

  • PUT /magic/modules/chinook/InvoiceLineput_chinook_InvoiceLine

    Update endpoint updating one record in your InvoiceLine table in your chinook database filtering which item to update with InvoiceLineId updating InvoiceId, TrackId, UnitPrice, Quantity fields with authentication and authorisation for root,admin roles

  • GET /magic/modules/chinook/MediaType-countget_chinook_MediaType-count

    Counts items from your MediaType table in your chinook database

  • DELETE /magic/modules/chinook/MediaTypedelete_chinook_MediaType

    Delete endpoint deleting one record from your MediaType table in your chinook database with MediaTypeId matching argument with authentication and authorisation for root,admin roles

  • GET /magic/modules/chinook/MediaTypeget_chinook_MediaType

    Read endpoint with paging, sorting, filtering selecting records from your MediaType table in your chinook database returning MediaTypeId, Name filtering on MediaTypeId, Name with authentication and authorisation for root,admin roles

  • POST /magic/modules/chinook/MediaTypepost_chinook_MediaType

    Create endpoint inserting one record into your MediaType table in your chinook database taking MediaTypeId, Name with authentication and authorisation for root,admin roles

  • PUT /magic/modules/chinook/MediaTypeput_chinook_MediaType

    Update endpoint updating one record in your MediaType table in your chinook database filtering which item to update with MediaTypeId updating Name fields with authentication and authorisation for root,admin roles

  • GET /magic/modules/chinook/Playlist-countget_chinook_Playlist-count

    Counts items from your Playlist table in your chinook database

  • DELETE /magic/modules/chinook/Playlistdelete_chinook_Playlist

    Delete endpoint deleting one record from your Playlist table in your chinook database with PlaylistId matching argument with authentication and authorisation for root,admin roles

  • GET /magic/modules/chinook/Playlistget_chinook_Playlist

    Read endpoint with paging, sorting, filtering selecting records from your Playlist table in your chinook database returning PlaylistId, Name filtering on PlaylistId, Name with authentication and authorisation for root,admin roles

  • POST /magic/modules/chinook/Playlistpost_chinook_Playlist

    Create endpoint inserting one record into your Playlist table in your chinook database taking PlaylistId, Name with authentication and authorisation for root,admin roles

  • PUT /magic/modules/chinook/Playlistput_chinook_Playlist

    Update endpoint updating one record in your Playlist table in your chinook database filtering which item to update with PlaylistId updating Name fields with authentication and authorisation for root,admin roles

  • GET /magic/modules/chinook/PlaylistTrack-countget_chinook_PlaylistTrack-count

    Counts items from your PlaylistTrack table in your chinook database

  • DELETE /magic/modules/chinook/PlaylistTrackdelete_chinook_PlaylistTrack

    Delete endpoint deleting one record from your PlaylistTrack table in your chinook database with PlaylistId, TrackId matching argument with authentication and authorisation for root,admin roles

  • GET /magic/modules/chinook/PlaylistTrackget_chinook_PlaylistTrack

    Read endpoint with paging, sorting, filtering selecting records from your PlaylistTrack table in your chinook database returning PlaylistId, TrackId filtering on PlaylistId, TrackId with authentication and authorisation for root,admin roles

  • POST /magic/modules/chinook/PlaylistTrackpost_chinook_PlaylistTrack

    Create endpoint inserting one record into your PlaylistTrack table in your chinook database taking PlaylistId, TrackId with authentication and authorisation for root,admin roles

  • GET /magic/modules/chinook/Track-countget_chinook_Track-count

    Counts items from your Track table in your chinook database

  • DELETE /magic/modules/chinook/Trackdelete_chinook_Track

    Delete endpoint deleting one record from your Track table in your chinook database with TrackId matching argument with authentication and authorisation for root,admin roles

  • GET /magic/modules/chinook/Trackget_chinook_Track

    Read endpoint with paging, sorting, filtering selecting records from your Track table in your chinook database returning TrackId, Name, AlbumId, MediaTypeId, GenreId, Composer, Milliseconds, Bytes, UnitPrice filtering on TrackId, Name, AlbumId, MediaTypeId, GenreId, Composer, Milliseconds, Bytes, Un

  • POST /magic/modules/chinook/Trackpost_chinook_Track

    Create endpoint inserting one record into your Track table in your chinook database taking TrackId, Name, AlbumId, MediaTypeId, GenreId, Composer, Milliseconds, Bytes, UnitPrice with authentication and authorisation for root,admin roles

  • PUT /magic/modules/chinook/Trackput_chinook_Track

    Update endpoint updating one record in your Track table in your chinook database filtering which item to update with TrackId updating Name, AlbumId, MediaTypeId, GenreId, Composer, Milliseconds, Bytes, UnitPrice fields with authentication and authorisation for root,admin roles

원본 API 스키마
{
  "openapi": "3.1.0",
  "info": {
    "title": "AINIRO Magic Cloudlet",
    "description": "Allows you to interact with your Magic cloudlet",
    "version": "v16.11.19"
  },
  "servers": [
    {
      "url": "https://sales2-team.us.ainiro.io"
    }
  ],
  "paths": {
    "/magic/modules/chinook/Album-count": {
      "get": {
        "operationId": "get_chinook_Album-count",
        "description": "Counts items from your Album table in your chinook database",
        "parameters": [
          {
            "name": "Album.AlbumId.eq",
            "description": "Album table AlbumId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Album.Title.like",
            "description": "Album table Title column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Album.Title.eq",
            "description": "Album table Title column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Album.ArtistId.eq",
            "description": "Album table ArtistId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "ArtistId.Name.eq",
            "description": "Artist table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "ArtistId.Name.like",
            "description": "Artist table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      }
    },
    "/magic/modules/chinook/Album": {
      "delete": {
        "operationId": "delete_chinook_Album",
        "description": "Delete endpoint deleting one record from your Album table in your chinook database with AlbumId matching argument with authentication and authorisation for root,admin roles",
        "parameters": [
          {
            "name": "AlbumId",
            "description": "Primary key of record to delete",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          }
        ]
      },
      "get": {
        "operationId": "get_chinook_Album",
        "description": "Read endpoint with paging, sorting, filtering selecting records from your Album table in your chinook database returning AlbumId, Title, ArtistId filtering on AlbumId, Title, ArtistId with authentication and authorisation for root,admin roles",
        "parameters": [
          {
            "name": "limit",
            "description": "Number of records to return",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "offset",
            "description": "Offset into the dataset of where to start retrieving records",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "order",
            "description": "What column to order by",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "direction",
            "description": "What direction to order, can be 'asc' or 'desc' implying ascending and descending",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Album.AlbumId.eq",
            "description": "Album table AlbumId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Album.Title.like",
            "description": "Album table Title column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Album.Title.eq",
            "description": "Album table Title column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Album.ArtistId.eq",
            "description": "Album table ArtistId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "ArtistId.Name.eq",
            "description": "Artist table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "ArtistId.Name.like",
            "description": "Artist table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      },
      "post": {
        "operationId": "post_chinook_Album",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Create endpoint inserting one record into your Album table in your chinook database taking AlbumId, Title, ArtistId with authentication and authorisation for root,admin roles",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "AlbumId": {
                    "type": "long",
                    "description": "AlbumId column value"
                  },
                  "Title": {
                    "type": "string",
                    "description": "Title column value"
                  },
                  "ArtistId": {
                    "type": "long",
                    "description": "ArtistId column value"
                  }
                }
              }
            }
          }
        }
      },
      "put": {
        "operationId": "put_chinook_Album",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Update endpoint updating one record in your Album table in your chinook database filtering which item to update with AlbumId updating Title, ArtistId fields with authentication and authorisation for root,admin roles",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "AlbumId": {
                    "type": "long",
                    "description": "AlbumId column value being primary key of record to update"
                  },
                  "Title": {
                    "type": "string",
                    "description": "Title column's new value"
                  },
                  "ArtistId": {
                    "type": "long",
                    "description": "ArtistId column's new value"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/magic/modules/chinook/Artist-count": {
      "get": {
        "operationId": "get_chinook_Artist-count",
        "description": "Counts items from your Artist table in your chinook database",
        "parameters": [
          {
            "name": "Artist.ArtistId.eq",
            "description": "Artist table ArtistId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Artist.Name.like",
            "description": "Artist table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Artist.Name.eq",
            "description": "Artist table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      }
    },
    "/magic/modules/chinook/Artist": {
      "delete": {
        "operationId": "delete_chinook_Artist",
        "description": "Delete endpoint deleting one record from your Artist table in your chinook database with ArtistId matching argument with authentication and authorisation for root,admin roles",
        "parameters": [
          {
            "name": "ArtistId",
            "description": "Primary key of record to delete",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          }
        ]
      },
      "get": {
        "operationId": "get_chinook_Artist",
        "description": "Read endpoint with paging, sorting, filtering selecting records from your Artist table in your chinook database returning ArtistId, Name filtering on ArtistId, Name with authentication and authorisation for root,admin roles",
        "parameters": [
          {
            "name": "limit",
            "description": "Number of records to return",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "offset",
            "description": "Offset into the dataset of where to start retrieving records",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "order",
            "description": "What column to order by",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "direction",
            "description": "What direction to order, can be 'asc' or 'desc' implying ascending and descending",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Artist.ArtistId.eq",
            "description": "Artist table ArtistId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Artist.Name.like",
            "description": "Artist table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Artist.Name.eq",
            "description": "Artist table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      },
      "post": {
        "operationId": "post_chinook_Artist",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Create endpoint inserting one record into your Artist table in your chinook database taking ArtistId, Name with authentication and authorisation for root,admin roles",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "ArtistId": {
                    "type": "long",
                    "description": "ArtistId column value"
                  },
                  "Name": {
                    "type": "string",
                    "description": "Name column value"
                  }
                }
              }
            }
          }
        }
      },
      "put": {
        "operationId": "put_chinook_Artist",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Update endpoint updating one record in your Artist table in your chinook database filtering which item to update with ArtistId updating Name fields with authentication and authorisation for root,admin roles",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "ArtistId": {
                    "type": "long",
                    "description": "ArtistId column value being primary key of record to update"
                  },
                  "Name": {
                    "type": "string",
                    "description": "Name column's new value"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/magic/modules/chinook/Customer-count": {
      "get": {
        "operationId": "get_chinook_Customer-count",
        "description": "Counts items from your Customer table in your chinook database",
        "parameters": [
          {
            "name": "Customer.CustomerId.eq",
            "description": "Customer table CustomerId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Customer.FirstName.like",
            "description": "Customer table FirstName column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.FirstName.eq",
            "description": "Customer table FirstName column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.LastName.like",
            "description": "Customer table LastName column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.LastName.eq",
            "description": "Customer table LastName column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Company.like",
            "description": "Customer table Company column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Company.eq",
            "description": "Customer table Company column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Address.like",
            "description": "Customer table Address column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Address.eq",
            "description": "Customer table Address column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.City.like",
            "description": "Customer table City column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.City.eq",
            "description": "Customer table City column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.State.like",
            "description": "Customer table State column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.State.eq",
            "description": "Customer table State column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Country.like",
            "description": "Customer table Country column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Country.eq",
            "description": "Customer table Country column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.PostalCode.like",
            "description": "Customer table PostalCode column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.PostalCode.eq",
            "description": "Customer table PostalCode column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Phone.like",
            "description": "Customer table Phone column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Phone.eq",
            "description": "Customer table Phone column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Fax.like",
            "description": "Customer table Fax column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Fax.eq",
            "description": "Customer table Fax column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Email.like",
            "description": "Customer table Email column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Email.eq",
            "description": "Customer table Email column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.SupportRepId.eq",
            "description": "Customer table SupportRepId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "SupportRepId.LastName.eq",
            "description": "Employee table LastName column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "SupportRepId.LastName.like",
            "description": "Employee table LastName column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      }
    },
    "/magic/modules/chinook/Customer": {
      "delete": {
        "operationId": "delete_chinook_Customer",
        "description": "Delete endpoint deleting one record from your Customer table in your chinook database with CustomerId matching argument with authentication and authorisation for root,admin roles",
        "parameters": [
          {
            "name": "CustomerId",
            "description": "Primary key of record to delete",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          }
        ]
      },
      "get": {
        "operationId": "get_chinook_Customer",
        "description": "Read endpoint with paging, sorting, filtering selecting records from your Customer table in your chinook database returning CustomerId, FirstName, LastName, Company, Address, City, State, Country, PostalCode, Phone, Fax, Email, SupportRepId filtering on CustomerId, FirstName, LastName, Company, Addr",
        "parameters": [
          {
            "name": "limit",
            "description": "Number of records to return",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "offset",
            "description": "Offset into the dataset of where to start retrieving records",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "order",
            "description": "What column to order by",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "direction",
            "description": "What direction to order, can be 'asc' or 'desc' implying ascending and descending",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.CustomerId.eq",
            "description": "Customer table CustomerId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Customer.FirstName.like",
            "description": "Customer table FirstName column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.FirstName.eq",
            "description": "Customer table FirstName column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.LastName.like",
            "description": "Customer table LastName column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.LastName.eq",
            "description": "Customer table LastName column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Company.like",
            "description": "Customer table Company column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Company.eq",
            "description": "Customer table Company column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Address.like",
            "description": "Customer table Address column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Address.eq",
            "description": "Customer table Address column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.City.like",
            "description": "Customer table City column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.City.eq",
            "description": "Customer table City column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.State.like",
            "description": "Customer table State column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.State.eq",
            "description": "Customer table State column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Country.like",
            "description": "Customer table Country column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Country.eq",
            "description": "Customer table Country column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.PostalCode.like",
            "description": "Customer table PostalCode column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.PostalCode.eq",
            "description": "Customer table PostalCode column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Phone.like",
            "description": "Customer table Phone column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Phone.eq",
            "description": "Customer table Phone column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Fax.like",
            "description": "Customer table Fax column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Fax.eq",
            "description": "Customer table Fax column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Email.like",
            "description": "Customer table Email column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.Email.eq",
            "description": "Customer table Email column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Customer.SupportRepId.eq",
            "description": "Customer table SupportRepId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "SupportRepId.LastName.eq",
            "description": "Employee table LastName column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "SupportRepId.LastName.like",
            "description": "Employee table LastName column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      },
      "post": {
        "operationId": "post_chinook_Customer",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Create endpoint inserting one record into your Customer table in your chinook database taking CustomerId, FirstName, LastName, Company, Address, City, State, Country, PostalCode, Phone, Fax, Email, SupportRepId with authentication and authorisation for root,admin roles",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "CustomerId": {
                    "type": "long",
                    "description": "CustomerId column value"
                  },
                  "FirstName": {
                    "type": "string",
                    "description": "FirstName column value"
                  },
                  "LastName": {
                    "type": "string",
                    "description": "LastName column value"
                  },
                  "Company": {
                    "type": "string",
                    "description": "Company column value"
                  },
                  "Address": {
                    "type": "string",
                    "description": "Address column value"
                  },
                  "City": {
                    "type": "string",
                    "description": "City column value"
                  },
                  "State": {
                    "type": "string",
                    "description": "State column value"
                  },
                  "Country": {
                    "type": "string",
                    "description": "Country column value"
                  },
                  "PostalCode": {
                    "type": "string",
                    "description": "PostalCode column value"
                  },
                  "Phone": {
                    "type": "string",
                    "description": "Phone column value"
                  },
                  "Fax": {
                    "type": "string",
                    "description": "Fax column value"
                  },
                  "Email": {
                    "type": "string",
                    "description": "Email column value"
                  },
                  "SupportRepId": {
                    "type": "long",
                    "description": "SupportRepId column value"
                  }
                }
              }
            }
          }
        }
      },
      "put": {
        "operationId": "put_chinook_Customer",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Update endpoint updating one record in your Customer table in your chinook database filtering which item to update with CustomerId updating FirstName, LastName, Company, Address, City, State, Country, PostalCode, Phone, Fax, Email, SupportRepId fields with authentication and authorisation for root,a",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "CustomerId": {
                    "type": "long",
                    "description": "CustomerId column value being primary key of record to update"
                  },
                  "FirstName": {
                    "type": "string",
                    "description": "FirstName column's new value"
                  },
                  "LastName": {
                    "type": "string",
                    "description": "LastName column's new value"
                  },
                  "Company": {
                    "type": "string",
                    "description": "Company column's new value"
                  },
                  "Address": {
                    "type": "string",
                    "description": "Address column's new value"
                  },
                  "City": {
                    "type": "string",
                    "description": "City column's new value"
                  },
                  "State": {
                    "type": "string",
                    "description": "State column's new value"
                  },
                  "Country": {
                    "type": "string",
                    "description": "Country column's new value"
                  },
                  "PostalCode": {
                    "type": "string",
                    "description": "PostalCode column's new value"
                  },
                  "Phone": {
                    "type": "string",
                    "description": "Phone column's new value"
                  },
                  "Fax": {
                    "type": "string",
                    "description": "Fax column's new value"
                  },
                  "Email": {
                    "type": "string",
                    "description": "Email column's new value"
                  },
                  "SupportRepId": {
                    "type": "long",
                    "description": "SupportRepId column's new value"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/magic/modules/chinook/Employee-count": {
      "get": {
        "operationId": "get_chinook_Employee-count",
        "description": "Counts items from your Employee table in your chinook database",
        "parameters": [
          {
            "name": "Employee.EmployeeId.eq",
            "description": "Employee table EmployeeId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Employee.LastName.like",
            "description": "Employee table LastName column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.LastName.eq",
            "description": "Employee table LastName column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.FirstName.like",
            "description": "Employee table FirstName column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.FirstName.eq",
            "description": "Employee table FirstName column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Title.like",
            "description": "Employee table Title column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Title.eq",
            "description": "Employee table Title column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.ReportsTo.eq",
            "description": "Employee table ReportsTo column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Employee.BirthDate.eq",
            "description": "Employee table BirthDate column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.HireDate.eq",
            "description": "Employee table HireDate column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Address.like",
            "description": "Employee table Address column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Address.eq",
            "description": "Employee table Address column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.City.like",
            "description": "Employee table City column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.City.eq",
            "description": "Employee table City column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.State.like",
            "description": "Employee table State column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.State.eq",
            "description": "Employee table State column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Country.like",
            "description": "Employee table Country column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Country.eq",
            "description": "Employee table Country column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.PostalCode.like",
            "description": "Employee table PostalCode column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.PostalCode.eq",
            "description": "Employee table PostalCode column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Phone.like",
            "description": "Employee table Phone column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Phone.eq",
            "description": "Employee table Phone column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Fax.like",
            "description": "Employee table Fax column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Fax.eq",
            "description": "Employee table Fax column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Email.like",
            "description": "Employee table Email column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Email.eq",
            "description": "Employee table Email column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "ReportsTo.LastName.eq",
            "description": "Employee table LastName column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "ReportsTo.LastName.like",
            "description": "Employee table LastName column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      }
    },
    "/magic/modules/chinook/Employee": {
      "delete": {
        "operationId": "delete_chinook_Employee",
        "description": "Delete endpoint deleting one record from your Employee table in your chinook database with EmployeeId matching argument with authentication and authorisation for root,admin roles",
        "parameters": [
          {
            "name": "EmployeeId",
            "description": "Primary key of record to delete",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          }
        ]
      },
      "get": {
        "operationId": "get_chinook_Employee",
        "description": "Read endpoint with paging, sorting, filtering selecting records from your Employee table in your chinook database returning EmployeeId, LastName, FirstName, Title, ReportsTo, BirthDate, HireDate, Address, City, State, Country, PostalCode, Phone, Fax, Email filtering on EmployeeId, LastName, FirstNam",
        "parameters": [
          {
            "name": "limit",
            "description": "Number of records to return",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "offset",
            "description": "Offset into the dataset of where to start retrieving records",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "order",
            "description": "What column to order by",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "direction",
            "description": "What direction to order, can be 'asc' or 'desc' implying ascending and descending",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.EmployeeId.eq",
            "description": "Employee table EmployeeId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Employee.LastName.like",
            "description": "Employee table LastName column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.LastName.eq",
            "description": "Employee table LastName column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.FirstName.like",
            "description": "Employee table FirstName column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.FirstName.eq",
            "description": "Employee table FirstName column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Title.like",
            "description": "Employee table Title column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Title.eq",
            "description": "Employee table Title column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.ReportsTo.eq",
            "description": "Employee table ReportsTo column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Employee.BirthDate.eq",
            "description": "Employee table BirthDate column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.HireDate.eq",
            "description": "Employee table HireDate column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Address.like",
            "description": "Employee table Address column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Address.eq",
            "description": "Employee table Address column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.City.like",
            "description": "Employee table City column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.City.eq",
            "description": "Employee table City column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.State.like",
            "description": "Employee table State column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.State.eq",
            "description": "Employee table State column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Country.like",
            "description": "Employee table Country column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Country.eq",
            "description": "Employee table Country column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.PostalCode.like",
            "description": "Employee table PostalCode column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.PostalCode.eq",
            "description": "Employee table PostalCode column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Phone.like",
            "description": "Employee table Phone column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Phone.eq",
            "description": "Employee table Phone column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Fax.like",
            "description": "Employee table Fax column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Fax.eq",
            "description": "Employee table Fax column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Email.like",
            "description": "Employee table Email column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Employee.Email.eq",
            "description": "Employee table Email column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "ReportsTo.LastName.eq",
            "description": "Employee table LastName column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "ReportsTo.LastName.like",
            "description": "Employee table LastName column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      },
      "post": {
        "operationId": "post_chinook_Employee",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Create endpoint inserting one record into your Employee table in your chinook database taking EmployeeId, LastName, FirstName, Title, ReportsTo, BirthDate, HireDate, Address, City, State, Country, PostalCode, Phone, Fax, Email with authentication and authorisation for root,admin roles",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "EmployeeId": {
                    "type": "long",
                    "description": "EmployeeId column value"
                  },
                  "LastName": {
                    "type": "string",
                    "description": "LastName column value"
                  },
                  "FirstName": {
                    "type": "string",
                    "description": "FirstName column value"
                  },
                  "Title": {
                    "type": "string",
                    "description": "Title column value"
                  },
                  "ReportsTo": {
                    "type": "long",
                    "description": "ReportsTo column value"
                  },
                  "BirthDate": {
                    "type": "date",
                    "description": "BirthDate column value"
                  },
                  "HireDate": {
                    "type": "date",
                    "description": "HireDate column value"
                  },
                  "Address": {
                    "type": "string",
                    "description": "Address column value"
                  },
                  "City": {
                    "type": "string",
                    "description": "City column value"
                  },
                  "State": {
                    "type": "string",
                    "description": "State column value"
                  },
                  "Country": {
                    "type": "string",
                    "description": "Country column value"
                  },
                  "PostalCode": {
                    "type": "string",
                    "description": "PostalCode column value"
                  },
                  "Phone": {
                    "type": "string",
                    "description": "Phone column value"
                  },
                  "Fax": {
                    "type": "string",
                    "description": "Fax column value"
                  },
                  "Email": {
                    "type": "string",
                    "description": "Email column value"
                  }
                }
              }
            }
          }
        }
      },
      "put": {
        "operationId": "put_chinook_Employee",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Update endpoint updating one record in your Employee table in your chinook database filtering which item to update with EmployeeId updating LastName, FirstName, Title, ReportsTo, BirthDate, HireDate, Address, City, State, Country, PostalCode, Phone, Fax, Email fields with authentication and authoris",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "EmployeeId": {
                    "type": "long",
                    "description": "EmployeeId column value being primary key of record to update"
                  },
                  "LastName": {
                    "type": "string",
                    "description": "LastName column's new value"
                  },
                  "FirstName": {
                    "type": "string",
                    "description": "FirstName column's new value"
                  },
                  "Title": {
                    "type": "string",
                    "description": "Title column's new value"
                  },
                  "ReportsTo": {
                    "type": "long",
                    "description": "ReportsTo column's new value"
                  },
                  "BirthDate": {
                    "type": "date",
                    "description": "BirthDate column's new value"
                  },
                  "HireDate": {
                    "type": "date",
                    "description": "HireDate column's new value"
                  },
                  "Address": {
                    "type": "string",
                    "description": "Address column's new value"
                  },
                  "City": {
                    "type": "string",
                    "description": "City column's new value"
                  },
                  "State": {
                    "type": "string",
                    "description": "State column's new value"
                  },
                  "Country": {
                    "type": "string",
                    "description": "Country column's new value"
                  },
                  "PostalCode": {
                    "type": "string",
                    "description": "PostalCode column's new value"
                  },
                  "Phone": {
                    "type": "string",
                    "description": "Phone column's new value"
                  },
                  "Fax": {
                    "type": "string",
                    "description": "Fax column's new value"
                  },
                  "Email": {
                    "type": "string",
                    "description": "Email column's new value"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/magic/modules/chinook/Genre-count": {
      "get": {
        "operationId": "get_chinook_Genre-count",
        "description": "Counts items from your Genre table in your chinook database",
        "parameters": [
          {
            "name": "Genre.GenreId.eq",
            "description": "Genre table GenreId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Genre.Name.like",
            "description": "Genre table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Genre.Name.eq",
            "description": "Genre table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      }
    },
    "/magic/modules/chinook/Genre": {
      "delete": {
        "operationId": "delete_chinook_Genre",
        "description": "Delete endpoint deleting one record from your Genre table in your chinook database with GenreId matching argument with authentication and authorisation for root,admin roles",
        "parameters": [
          {
            "name": "GenreId",
            "description": "Primary key of record to delete",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          }
        ]
      },
      "get": {
        "operationId": "get_chinook_Genre",
        "description": "Read endpoint with paging, sorting, filtering selecting records from your Genre table in your chinook database returning GenreId, Name filtering on GenreId, Name with authentication and authorisation for root,admin roles",
        "parameters": [
          {
            "name": "limit",
            "description": "Number of records to return",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "offset",
            "description": "Offset into the dataset of where to start retrieving records",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "order",
            "description": "What column to order by",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "direction",
            "description": "What direction to order, can be 'asc' or 'desc' implying ascending and descending",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Genre.GenreId.eq",
            "description": "Genre table GenreId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Genre.Name.like",
            "description": "Genre table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Genre.Name.eq",
            "description": "Genre table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      },
      "post": {
        "operationId": "post_chinook_Genre",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Create endpoint inserting one record into your Genre table in your chinook database taking GenreId, Name with authentication and authorisation for root,admin roles",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "GenreId": {
                    "type": "long",
                    "description": "GenreId column value"
                  },
                  "Name": {
                    "type": "string",
                    "description": "Name column value"
                  }
                }
              }
            }
          }
        }
      },
      "put": {
        "operationId": "put_chinook_Genre",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Update endpoint updating one record in your Genre table in your chinook database filtering which item to update with GenreId updating Name fields with authentication and authorisation for root,admin roles",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "GenreId": {
                    "type": "long",
                    "description": "GenreId column value being primary key of record to update"
                  },
                  "Name": {
                    "type": "string",
                    "description": "Name column's new value"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/magic/modules/chinook/Invoice-count": {
      "get": {
        "operationId": "get_chinook_Invoice-count",
        "description": "Counts items from your Invoice table in your chinook database",
        "parameters": [
          {
            "name": "Invoice.InvoiceId.eq",
            "description": "Invoice table InvoiceId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Invoice.CustomerId.eq",
            "description": "Invoice table CustomerId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Invoice.InvoiceDate.eq",
            "description": "Invoice table InvoiceDate column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingAddress.like",
            "description": "Invoice table BillingAddress column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingAddress.eq",
            "description": "Invoice table BillingAddress column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingCity.like",
            "description": "Invoice table BillingCity column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingCity.eq",
            "description": "Invoice table BillingCity column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingState.like",
            "description": "Invoice table BillingState column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingState.eq",
            "description": "Invoice table BillingState column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingCountry.like",
            "description": "Invoice table BillingCountry column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingCountry.eq",
            "description": "Invoice table BillingCountry column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingPostalCode.like",
            "description": "Invoice table BillingPostalCode column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingPostalCode.eq",
            "description": "Invoice table BillingPostalCode column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.Total.eq",
            "description": "Invoice table Total column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "number"
            }
          },
          {
            "name": "CustomerId.FirstName.eq",
            "description": "Customer table FirstName column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "CustomerId.FirstName.like",
            "description": "Customer table FirstName column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      }
    },
    "/magic/modules/chinook/Invoice": {
      "delete": {
        "operationId": "delete_chinook_Invoice",
        "description": "Delete endpoint deleting one record from your Invoice table in your chinook database with InvoiceId matching argument with authentication and authorisation for root,admin roles",
        "parameters": [
          {
            "name": "InvoiceId",
            "description": "Primary key of record to delete",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          }
        ]
      },
      "get": {
        "operationId": "get_chinook_Invoice",
        "description": "Read endpoint with paging, sorting, filtering selecting records from your Invoice table in your chinook database returning InvoiceId, CustomerId, InvoiceDate, BillingAddress, BillingCity, BillingState, BillingCountry, BillingPostalCode, Total filtering on InvoiceId, CustomerId, InvoiceDate, BillingA",
        "parameters": [
          {
            "name": "limit",
            "description": "Number of records to return",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "offset",
            "description": "Offset into the dataset of where to start retrieving records",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "order",
            "description": "What column to order by",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "direction",
            "description": "What direction to order, can be 'asc' or 'desc' implying ascending and descending",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.InvoiceId.eq",
            "description": "Invoice table InvoiceId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Invoice.CustomerId.eq",
            "description": "Invoice table CustomerId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Invoice.InvoiceDate.eq",
            "description": "Invoice table InvoiceDate column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingAddress.like",
            "description": "Invoice table BillingAddress column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingAddress.eq",
            "description": "Invoice table BillingAddress column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingCity.like",
            "description": "Invoice table BillingCity column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingCity.eq",
            "description": "Invoice table BillingCity column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingState.like",
            "description": "Invoice table BillingState column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingState.eq",
            "description": "Invoice table BillingState column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingCountry.like",
            "description": "Invoice table BillingCountry column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingCountry.eq",
            "description": "Invoice table BillingCountry column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingPostalCode.like",
            "description": "Invoice table BillingPostalCode column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.BillingPostalCode.eq",
            "description": "Invoice table BillingPostalCode column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Invoice.Total.eq",
            "description": "Invoice table Total column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "number"
            }
          },
          {
            "name": "CustomerId.FirstName.eq",
            "description": "Customer table FirstName column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "CustomerId.FirstName.like",
            "description": "Customer table FirstName column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      },
      "post": {
        "operationId": "post_chinook_Invoice",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Create endpoint inserting one record into your Invoice table in your chinook database taking InvoiceId, CustomerId, InvoiceDate, BillingAddress, BillingCity, BillingState, BillingCountry, BillingPostalCode, Total with authentication and authorisation for root,admin roles",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "InvoiceId": {
                    "type": "long",
                    "description": "InvoiceId column value"
                  },
                  "CustomerId": {
                    "type": "long",
                    "description": "CustomerId column value"
                  },
                  "InvoiceDate": {
                    "type": "date",
                    "description": "InvoiceDate column value"
                  },
                  "BillingAddress": {
                    "type": "string",
                    "description": "BillingAddress column value"
                  },
                  "BillingCity": {
                    "type": "string",
                    "description": "BillingCity column value"
                  },
                  "BillingState": {
                    "type": "string",
                    "description": "BillingState column value"
                  },
                  "BillingCountry": {
                    "type": "string",
                    "description": "BillingCountry column value"
                  },
                  "BillingPostalCode": {
                    "type": "string",
                    "description": "BillingPostalCode column value"
                  },
                  "Total": {
                    "type": "decimal",
                    "description": "Total column value"
                  }
                }
              }
            }
          }
        }
      },
      "put": {
        "operationId": "put_chinook_Invoice",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Update endpoint updating one record in your Invoice table in your chinook database filtering which item to update with InvoiceId updating CustomerId, InvoiceDate, BillingAddress, BillingCity, BillingState, BillingCountry, BillingPostalCode, Total fields with authentication and authorisation for root",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "InvoiceId": {
                    "type": "long",
                    "description": "InvoiceId column value being primary key of record to update"
                  },
                  "CustomerId": {
                    "type": "long",
                    "description": "CustomerId column's new value"
                  },
                  "InvoiceDate": {
                    "type": "date",
                    "description": "InvoiceDate column's new value"
                  },
                  "BillingAddress": {
                    "type": "string",
                    "description": "BillingAddress column's new value"
                  },
                  "BillingCity": {
                    "type": "string",
                    "description": "BillingCity column's new value"
                  },
                  "BillingState": {
                    "type": "string",
                    "description": "BillingState column's new value"
                  },
                  "BillingCountry": {
                    "type": "string",
                    "description": "BillingCountry column's new value"
                  },
                  "BillingPostalCode": {
                    "type": "string",
                    "description": "BillingPostalCode column's new value"
                  },
                  "Total": {
                    "type": "decimal",
                    "description": "Total column's new value"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/magic/modules/chinook/InvoiceLine-count": {
      "get": {
        "operationId": "get_chinook_InvoiceLine-count",
        "description": "Counts items from your InvoiceLine table in your chinook database",
        "parameters": [
          {
            "name": "InvoiceLine.InvoiceLineId.eq",
            "description": "InvoiceLine table InvoiceLineId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "InvoiceLine.InvoiceId.eq",
            "description": "InvoiceLine table InvoiceId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "InvoiceLine.TrackId.eq",
            "description": "InvoiceLine table TrackId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "InvoiceLine.UnitPrice.eq",
            "description": "InvoiceLine table UnitPrice column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "number"
            }
          },
          {
            "name": "InvoiceLine.Quantity.eq",
            "description": "InvoiceLine table Quantity column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "InvoiceId.BillingAddress.eq",
            "description": "Invoice table BillingAddress column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "InvoiceId.BillingAddress.like",
            "description": "Invoice table BillingAddress column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "TrackId.Name.eq",
            "description": "Track table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "TrackId.Name.like",
            "description": "Track table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      }
    },
    "/magic/modules/chinook/InvoiceLine": {
      "delete": {
        "operationId": "delete_chinook_InvoiceLine",
        "description": "Delete endpoint deleting one record from your InvoiceLine table in your chinook database with InvoiceLineId matching argument with authentication and authorisation for root,admin roles",
        "parameters": [
          {
            "name": "InvoiceLineId",
            "description": "Primary key of record to delete",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          }
        ]
      },
      "get": {
        "operationId": "get_chinook_InvoiceLine",
        "description": "Read endpoint with paging, sorting, filtering selecting records from your InvoiceLine table in your chinook database returning InvoiceLineId, InvoiceId, TrackId, UnitPrice, Quantity filtering on InvoiceLineId, InvoiceId, TrackId, UnitPrice, Quantity with authentication and authorisation for root,adm",
        "parameters": [
          {
            "name": "limit",
            "description": "Number of records to return",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "offset",
            "description": "Offset into the dataset of where to start retrieving records",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "order",
            "description": "What column to order by",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "direction",
            "description": "What direction to order, can be 'asc' or 'desc' implying ascending and descending",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "InvoiceLine.InvoiceLineId.eq",
            "description": "InvoiceLine table InvoiceLineId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "InvoiceLine.InvoiceId.eq",
            "description": "InvoiceLine table InvoiceId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "InvoiceLine.TrackId.eq",
            "description": "InvoiceLine table TrackId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "InvoiceLine.UnitPrice.eq",
            "description": "InvoiceLine table UnitPrice column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "number"
            }
          },
          {
            "name": "InvoiceLine.Quantity.eq",
            "description": "InvoiceLine table Quantity column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "InvoiceId.BillingAddress.eq",
            "description": "Invoice table BillingAddress column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "InvoiceId.BillingAddress.like",
            "description": "Invoice table BillingAddress column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "TrackId.Name.eq",
            "description": "Track table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "TrackId.Name.like",
            "description": "Track table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      },
      "post": {
        "operationId": "post_chinook_InvoiceLine",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Create endpoint inserting one record into your InvoiceLine table in your chinook database taking InvoiceLineId, InvoiceId, TrackId, UnitPrice, Quantity with authentication and authorisation for root,admin roles",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "InvoiceLineId": {
                    "type": "long",
                    "description": "InvoiceLineId column value"
                  },
                  "InvoiceId": {
                    "type": "long",
                    "description": "InvoiceId column value"
                  },
                  "TrackId": {
                    "type": "long",
                    "description": "TrackId column value"
                  },
                  "UnitPrice": {
                    "type": "decimal",
                    "description": "UnitPrice column value"
                  },
                  "Quantity": {
                    "type": "long",
                    "description": "Quantity column value"
                  }
                }
              }
            }
          }
        }
      },
      "put": {
        "operationId": "put_chinook_InvoiceLine",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Update endpoint updating one record in your InvoiceLine table in your chinook database filtering which item to update with InvoiceLineId updating InvoiceId, TrackId, UnitPrice, Quantity fields with authentication and authorisation for root,admin roles",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "InvoiceLineId": {
                    "type": "long",
                    "description": "InvoiceLineId column value being primary key of record to update"
                  },
                  "InvoiceId": {
                    "type": "long",
                    "description": "InvoiceId column's new value"
                  },
                  "TrackId": {
                    "type": "long",
                    "description": "TrackId column's new value"
                  },
                  "UnitPrice": {
                    "type": "decimal",
                    "description": "UnitPrice column's new value"
                  },
                  "Quantity": {
                    "type": "long",
                    "description": "Quantity column's new value"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/magic/modules/chinook/MediaType-count": {
      "get": {
        "operationId": "get_chinook_MediaType-count",
        "description": "Counts items from your MediaType table in your chinook database",
        "parameters": [
          {
            "name": "MediaType.MediaTypeId.eq",
            "description": "MediaType table MediaTypeId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "MediaType.Name.like",
            "description": "MediaType table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "MediaType.Name.eq",
            "description": "MediaType table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      }
    },
    "/magic/modules/chinook/MediaType": {
      "delete": {
        "operationId": "delete_chinook_MediaType",
        "description": "Delete endpoint deleting one record from your MediaType table in your chinook database with MediaTypeId matching argument with authentication and authorisation for root,admin roles",
        "parameters": [
          {
            "name": "MediaTypeId",
            "description": "Primary key of record to delete",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          }
        ]
      },
      "get": {
        "operationId": "get_chinook_MediaType",
        "description": "Read endpoint with paging, sorting, filtering selecting records from your MediaType table in your chinook database returning MediaTypeId, Name filtering on MediaTypeId, Name with authentication and authorisation for root,admin roles",
        "parameters": [
          {
            "name": "limit",
            "description": "Number of records to return",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "offset",
            "description": "Offset into the dataset of where to start retrieving records",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "order",
            "description": "What column to order by",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "direction",
            "description": "What direction to order, can be 'asc' or 'desc' implying ascending and descending",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "MediaType.MediaTypeId.eq",
            "description": "MediaType table MediaTypeId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "MediaType.Name.like",
            "description": "MediaType table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "MediaType.Name.eq",
            "description": "MediaType table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      },
      "post": {
        "operationId": "post_chinook_MediaType",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Create endpoint inserting one record into your MediaType table in your chinook database taking MediaTypeId, Name with authentication and authorisation for root,admin roles",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "MediaTypeId": {
                    "type": "long",
                    "description": "MediaTypeId column value"
                  },
                  "Name": {
                    "type": "string",
                    "description": "Name column value"
                  }
                }
              }
            }
          }
        }
      },
      "put": {
        "operationId": "put_chinook_MediaType",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Update endpoint updating one record in your MediaType table in your chinook database filtering which item to update with MediaTypeId updating Name fields with authentication and authorisation for root,admin roles",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "MediaTypeId": {
                    "type": "long",
                    "description": "MediaTypeId column value being primary key of record to update"
                  },
                  "Name": {
                    "type": "string",
                    "description": "Name column's new value"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/magic/modules/chinook/Playlist-count": {
      "get": {
        "operationId": "get_chinook_Playlist-count",
        "description": "Counts items from your Playlist table in your chinook database",
        "parameters": [
          {
            "name": "Playlist.PlaylistId.eq",
            "description": "Playlist table PlaylistId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Playlist.Name.like",
            "description": "Playlist table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Playlist.Name.eq",
            "description": "Playlist table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      }
    },
    "/magic/modules/chinook/Playlist": {
      "delete": {
        "operationId": "delete_chinook_Playlist",
        "description": "Delete endpoint deleting one record from your Playlist table in your chinook database with PlaylistId matching argument with authentication and authorisation for root,admin roles",
        "parameters": [
          {
            "name": "PlaylistId",
            "description": "Primary key of record to delete",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          }
        ]
      },
      "get": {
        "operationId": "get_chinook_Playlist",
        "description": "Read endpoint with paging, sorting, filtering selecting records from your Playlist table in your chinook database returning PlaylistId, Name filtering on PlaylistId, Name with authentication and authorisation for root,admin roles",
        "parameters": [
          {
            "name": "limit",
            "description": "Number of records to return",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "offset",
            "description": "Offset into the dataset of where to start retrieving records",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "order",
            "description": "What column to order by",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "direction",
            "description": "What direction to order, can be 'asc' or 'desc' implying ascending and descending",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Playlist.PlaylistId.eq",
            "description": "Playlist table PlaylistId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Playlist.Name.like",
            "description": "Playlist table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Playlist.Name.eq",
            "description": "Playlist table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      },
      "post": {
        "operationId": "post_chinook_Playlist",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Create endpoint inserting one record into your Playlist table in your chinook database taking PlaylistId, Name with authentication and authorisation for root,admin roles",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "PlaylistId": {
                    "type": "long",
                    "description": "PlaylistId column value"
                  },
                  "Name": {
                    "type": "string",
                    "description": "Name column value"
                  }
                }
              }
            }
          }
        }
      },
      "put": {
        "operationId": "put_chinook_Playlist",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Update endpoint updating one record in your Playlist table in your chinook database filtering which item to update with PlaylistId updating Name fields with authentication and authorisation for root,admin roles",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "PlaylistId": {
                    "type": "long",
                    "description": "PlaylistId column value being primary key of record to update"
                  },
                  "Name": {
                    "type": "string",
                    "description": "Name column's new value"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/magic/modules/chinook/PlaylistTrack-count": {
      "get": {
        "operationId": "get_chinook_PlaylistTrack-count",
        "description": "Counts items from your PlaylistTrack table in your chinook database",
        "parameters": [
          {
            "name": "PlaylistTrack.PlaylistId.eq",
            "description": "PlaylistTrack table PlaylistId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "PlaylistTrack.TrackId.eq",
            "description": "PlaylistTrack table TrackId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "PlaylistId.Name.eq",
            "description": "Playlist table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "PlaylistId.Name.like",
            "description": "Playlist table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "TrackId.Name.eq",
            "description": "Track table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "TrackId.Name.like",
            "description": "Track table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      }
    },
    "/magic/modules/chinook/PlaylistTrack": {
      "delete": {
        "operationId": "delete_chinook_PlaylistTrack",
        "description": "Delete endpoint deleting one record from your PlaylistTrack table in your chinook database with PlaylistId, TrackId matching argument with authentication and authorisation for root,admin roles",
        "parameters": [
          {
            "name": "PlaylistId",
            "description": "Primary key of record to delete",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "TrackId",
            "description": "Primary key of record to delete",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          }
        ]
      },
      "get": {
        "operationId": "get_chinook_PlaylistTrack",
        "description": "Read endpoint with paging, sorting, filtering selecting records from your PlaylistTrack table in your chinook database returning PlaylistId, TrackId filtering on PlaylistId, TrackId with authentication and authorisation for root,admin roles",
        "parameters": [
          {
            "name": "limit",
            "description": "Number of records to return",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "offset",
            "description": "Offset into the dataset of where to start retrieving records",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "order",
            "description": "What column to order by",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "direction",
            "description": "What direction to order, can be 'asc' or 'desc' implying ascending and descending",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "PlaylistTrack.PlaylistId.eq",
            "description": "PlaylistTrack table PlaylistId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "PlaylistTrack.TrackId.eq",
            "description": "PlaylistTrack table TrackId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "PlaylistId.Name.eq",
            "description": "Playlist table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "PlaylistId.Name.like",
            "description": "Playlist table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "TrackId.Name.eq",
            "description": "Track table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "TrackId.Name.like",
            "description": "Track table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      },
      "post": {
        "operationId": "post_chinook_PlaylistTrack",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Create endpoint inserting one record into your PlaylistTrack table in your chinook database taking PlaylistId, TrackId with authentication and authorisation for root,admin roles",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "PlaylistId": {
                    "type": "long",
                    "description": "PlaylistId column value"
                  },
                  "TrackId": {
                    "type": "long",
                    "description": "TrackId column value"
                  }
                }
              }
            }
          }
        }
      }
    },
    "/magic/modules/chinook/Track-count": {
      "get": {
        "operationId": "get_chinook_Track-count",
        "description": "Counts items from your Track table in your chinook database",
        "parameters": [
          {
            "name": "Track.TrackId.eq",
            "description": "Track table TrackId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Track.Name.like",
            "description": "Track table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Track.Name.eq",
            "description": "Track table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Track.AlbumId.eq",
            "description": "Track table AlbumId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Track.MediaTypeId.eq",
            "description": "Track table MediaTypeId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Track.GenreId.eq",
            "description": "Track table GenreId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Track.Composer.like",
            "description": "Track table Composer column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Track.Composer.eq",
            "description": "Track table Composer column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Track.Milliseconds.eq",
            "description": "Track table Milliseconds column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Track.Bytes.eq",
            "description": "Track table Bytes column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Track.UnitPrice.eq",
            "description": "Track table UnitPrice column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "number"
            }
          },
          {
            "name": "AlbumId.Title.eq",
            "description": "Album table Title column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "AlbumId.Title.like",
            "description": "Album table Title column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "MediaTypeId.Name.eq",
            "description": "MediaType table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "MediaTypeId.Name.like",
            "description": "MediaType table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "GenreId.Name.eq",
            "description": "Genre table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "GenreId.Name.like",
            "description": "Genre table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      }
    },
    "/magic/modules/chinook/Track": {
      "delete": {
        "operationId": "delete_chinook_Track",
        "description": "Delete endpoint deleting one record from your Track table in your chinook database with TrackId matching argument with authentication and authorisation for root,admin roles",
        "parameters": [
          {
            "name": "TrackId",
            "description": "Primary key of record to delete",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          }
        ]
      },
      "get": {
        "operationId": "get_chinook_Track",
        "description": "Read endpoint with paging, sorting, filtering selecting records from your Track table in your chinook database returning TrackId, Name, AlbumId, MediaTypeId, GenreId, Composer, Milliseconds, Bytes, UnitPrice filtering on TrackId, Name, AlbumId, MediaTypeId, GenreId, Composer, Milliseconds, Bytes, Un",
        "parameters": [
          {
            "name": "limit",
            "description": "Number of records to return",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "offset",
            "description": "Offset into the dataset of where to start retrieving records",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "order",
            "description": "What column to order by",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "direction",
            "description": "What direction to order, can be 'asc' or 'desc' implying ascending and descending",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Track.TrackId.eq",
            "description": "Track table TrackId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Track.Name.like",
            "description": "Track table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Track.Name.eq",
            "description": "Track table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Track.AlbumId.eq",
            "description": "Track table AlbumId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Track.MediaTypeId.eq",
            "description": "Track table MediaTypeId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Track.GenreId.eq",
            "description": "Track table GenreId column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Track.Composer.like",
            "description": "Track table Composer column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Track.Composer.eq",
            "description": "Track table Composer column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "Track.Milliseconds.eq",
            "description": "Track table Milliseconds column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Track.Bytes.eq",
            "description": "Track table Bytes column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "integer"
            }
          },
          {
            "name": "Track.UnitPrice.eq",
            "description": "Track table UnitPrice column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "number"
            }
          },
          {
            "name": "AlbumId.Title.eq",
            "description": "Album table Title column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "AlbumId.Title.like",
            "description": "Album table Title column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "MediaTypeId.Name.eq",
            "description": "MediaType table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "MediaTypeId.Name.like",
            "description": "MediaType table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "GenreId.Name.eq",
            "description": "Genre table Name column equality exact match filtering",
            "in": "query",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "GenreId.Name.like",
            "description": "Genre table Name column wildcard filtering with SQL like '%' comparison",
            "in": "query",
            "schema": {
              "type": "string"
            }
          }
        ]
      },
      "post": {
        "operationId": "post_chinook_Track",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Create endpoint inserting one record into your Track table in your chinook database taking TrackId, Name, AlbumId, MediaTypeId, GenreId, Composer, Milliseconds, Bytes, UnitPrice with authentication and authorisation for root,admin roles",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "TrackId": {
                    "type": "long",
                    "description": "TrackId column value"
                  },
                  "Name": {
                    "type": "string",
                    "description": "Name column value"
                  },
                  "AlbumId": {
                    "type": "long",
                    "description": "AlbumId column value"
                  },
                  "MediaTypeId": {
                    "type": "long",
                    "description": "MediaTypeId column value"
                  },
                  "GenreId": {
                    "type": "long",
                    "description": "GenreId column value"
                  },
                  "Composer": {
                    "type": "string",
                    "description": "Composer column value"
                  },
                  "Milliseconds": {
                    "type": "long",
                    "description": "Milliseconds column value"
                  },
                  "Bytes": {
                    "type": "long",
                    "description": "Bytes column value"
                  },
                  "UnitPrice": {
                    "type": "decimal",
                    "description": "UnitPrice column value"
                  }
                }
              }
            }
          }
        }
      },
      "put": {
        "operationId": "put_chinook_Track",
        "consumes": [
          "application/json"
        ],
        "produces": [
          "application/json"
        ],
        "description": "Update endpoint updating one record in your Track table in your chinook database filtering which item to update with TrackId updating Name, AlbumId, MediaTypeId, GenreId, Composer, Milliseconds, Bytes, UnitPrice fields with authentication and authorisation for root,admin roles",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "TrackId": {
                    "type": "long",
                    "description": "TrackId column value being primary key of record to update"
                  },
                  "Name": {
                    "type": "string",
                    "description": "Name column's new value"
                  },
                  "AlbumId": {
                    "type": "long",
                    "description": "AlbumId column's new value"
                  },
                  "MediaTypeId": {
                    "type": "long",
                    "description": "MediaTypeId column's new value"
                  },
                  "GenreId": {
                    "type": "long",
                    "description": "GenreId column's new value"
                  },
                  "Composer": {
                    "type": "string",
                    "description": "Composer column's new value"
                  },
                  "Milliseconds": {
                    "type": "long",
                    "description": "Milliseconds column's new value"
                  },
                  "Bytes": {
                    "type": "long",
                    "description": "Bytes column's new value"
                  },
                  "UnitPrice": {
                    "type": "decimal",
                    "description": "UnitPrice column's new value"
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}