mappers.ts

/*
 * Copyright (c) Microsoft Corporation.
 * Licensed under the MIT License.
 *
 * Code generated by Microsoft (R) AutoRest Code Generator.
 * Changes may cause incorrect behavior and will be lost if the code is regenerated.
 */

import * as coreHttp from "@azure/core-http";

export const SearchIndexerDataSource: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchIndexerDataSource",
    modelProperties: {
      name: {
        serializedName: "name",
        required: true,
        type: {
          name: "String"
        }
      },
      description: {
        serializedName: "description",
        type: {
          name: "String"
        }
      },
      type: {
        serializedName: "type",
        required: true,
        type: {
          name: "String"
        }
      },
      credentials: {
        serializedName: "credentials",
        type: {
          name: "Composite",
          className: "DataSourceCredentials"
        }
      },
      container: {
        serializedName: "container",
        type: {
          name: "Composite",
          className: "SearchIndexerDataContainer"
        }
      },
      identity: {
        serializedName: "identity",
        type: {
          name: "Composite",
          className: "SearchIndexerDataIdentity"
        }
      },
      dataChangeDetectionPolicy: {
        serializedName: "dataChangeDetectionPolicy",
        type: {
          name: "Composite",
          className: "DataChangeDetectionPolicy"
        }
      },
      dataDeletionDetectionPolicy: {
        serializedName: "dataDeletionDetectionPolicy",
        type: {
          name: "Composite",
          className: "DataDeletionDetectionPolicy"
        }
      },
      etag: {
        serializedName: "@odata\\.etag",
        type: {
          name: "String"
        }
      },
      encryptionKey: {
        serializedName: "encryptionKey",
        type: {
          name: "Composite",
          className: "SearchResourceEncryptionKey"
        }
      }
    }
  }
};

export const DataSourceCredentials: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "DataSourceCredentials",
    modelProperties: {
      connectionString: {
        serializedName: "connectionString",
        type: {
          name: "String"
        }
      }
    }
  }
};

export const SearchIndexerDataContainer: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchIndexerDataContainer",
    modelProperties: {
      name: {
        serializedName: "name",
        required: true,
        type: {
          name: "String"
        }
      },
      query: {
        serializedName: "query",
        type: {
          name: "String"
        }
      }
    }
  }
};

export const SearchIndexerDataIdentity: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchIndexerDataIdentity",
    uberParent: "SearchIndexerDataIdentity",
    polymorphicDiscriminator: {
      serializedName: "@odata\\.type",
      clientName: "odatatype"
    },
    modelProperties: {
      odatatype: {
        serializedName: "@odata\\.type",
        required: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const DataChangeDetectionPolicy: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "DataChangeDetectionPolicy",
    uberParent: "DataChangeDetectionPolicy",
    polymorphicDiscriminator: {
      serializedName: "@odata\\.type",
      clientName: "odatatype"
    },
    modelProperties: {
      odatatype: {
        serializedName: "@odata\\.type",
        required: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const DataDeletionDetectionPolicy: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "DataDeletionDetectionPolicy",
    uberParent: "DataDeletionDetectionPolicy",
    polymorphicDiscriminator: {
      serializedName: "@odata\\.type",
      clientName: "odatatype"
    },
    modelProperties: {
      odatatype: {
        serializedName: "@odata\\.type",
        required: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const SearchResourceEncryptionKey: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchResourceEncryptionKey",
    modelProperties: {
      keyName: {
        serializedName: "keyVaultKeyName",
        required: true,
        type: {
          name: "String"
        }
      },
      keyVersion: {
        serializedName: "keyVaultKeyVersion",
        required: true,
        type: {
          name: "String"
        }
      },
      vaultUri: {
        serializedName: "keyVaultUri",
        required: true,
        type: {
          name: "String"
        }
      },
      accessCredentials: {
        serializedName: "accessCredentials",
        type: {
          name: "Composite",
          className: "AzureActiveDirectoryApplicationCredentials"
        }
      },
      identity: {
        serializedName: "identity",
        type: {
          name: "Composite",
          className: "SearchIndexerDataIdentity"
        }
      }
    }
  }
};

export const AzureActiveDirectoryApplicationCredentials: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "AzureActiveDirectoryApplicationCredentials",
    modelProperties: {
      applicationId: {
        serializedName: "applicationId",
        required: true,
        type: {
          name: "String"
        }
      },
      applicationSecret: {
        serializedName: "applicationSecret",
        type: {
          name: "String"
        }
      }
    }
  }
};

export const SearchError: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchError",
    modelProperties: {
      code: {
        serializedName: "code",
        readOnly: true,
        type: {
          name: "String"
        }
      },
      message: {
        serializedName: "message",
        required: true,
        readOnly: true,
        type: {
          name: "String"
        }
      },
      details: {
        serializedName: "details",
        readOnly: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "SearchError"
            }
          }
        }
      }
    }
  }
};

export const ListDataSourcesResult: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "ListDataSourcesResult",
    modelProperties: {
      dataSources: {
        serializedName: "value",
        required: true,
        readOnly: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "SearchIndexerDataSource"
            }
          }
        }
      }
    }
  }
};

export const SearchIndexer: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchIndexer",
    modelProperties: {
      name: {
        serializedName: "name",
        required: true,
        type: {
          name: "String"
        }
      },
      description: {
        serializedName: "description",
        type: {
          name: "String"
        }
      },
      dataSourceName: {
        serializedName: "dataSourceName",
        required: true,
        type: {
          name: "String"
        }
      },
      skillsetName: {
        serializedName: "skillsetName",
        type: {
          name: "String"
        }
      },
      targetIndexName: {
        serializedName: "targetIndexName",
        required: true,
        type: {
          name: "String"
        }
      },
      schedule: {
        serializedName: "schedule",
        type: {
          name: "Composite",
          className: "IndexingSchedule"
        }
      },
      parameters: {
        serializedName: "parameters",
        type: {
          name: "Composite",
          className: "IndexingParameters"
        }
      },
      fieldMappings: {
        serializedName: "fieldMappings",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "FieldMapping"
            }
          }
        }
      },
      outputFieldMappings: {
        serializedName: "outputFieldMappings",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "FieldMapping"
            }
          }
        }
      },
      isDisabled: {
        serializedName: "disabled",
        nullable: true,
        type: {
          name: "Boolean"
        }
      },
      etag: {
        serializedName: "@odata\\.etag",
        type: {
          name: "String"
        }
      },
      encryptionKey: {
        serializedName: "encryptionKey",
        type: {
          name: "Composite",
          className: "SearchResourceEncryptionKey"
        }
      },
      cache: {
        serializedName: "cache",
        type: {
          name: "Composite",
          className: "SearchIndexerCache"
        }
      }
    }
  }
};

export const IndexingSchedule: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "IndexingSchedule",
    modelProperties: {
      interval: {
        serializedName: "interval",
        required: true,
        type: {
          name: "TimeSpan"
        }
      },
      startTime: {
        serializedName: "startTime",
        type: {
          name: "DateTime"
        }
      }
    }
  }
};

export const IndexingParameters: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "IndexingParameters",
    modelProperties: {
      batchSize: {
        serializedName: "batchSize",
        nullable: true,
        type: {
          name: "Number"
        }
      },
      maxFailedItems: {
        serializedName: "maxFailedItems",
        nullable: true,
        type: {
          name: "Number"
        }
      },
      maxFailedItemsPerBatch: {
        serializedName: "maxFailedItemsPerBatch",
        nullable: true,
        type: {
          name: "Number"
        }
      },
      configuration: {
        serializedName: "configuration",
        type: {
          name: "Composite",
          className: "IndexingParametersConfiguration"
        }
      }
    }
  }
};

export const IndexingParametersConfiguration: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "IndexingParametersConfiguration",
    additionalProperties: { type: { name: "Object" } },
    modelProperties: {
      parsingMode: {
        defaultValue: "default",
        serializedName: "parsingMode",
        type: {
          name: "String"
        }
      },
      excludedFileNameExtensions: {
        serializedName: "excludedFileNameExtensions",
        type: {
          name: "String"
        }
      },
      indexedFileNameExtensions: {
        serializedName: "indexedFileNameExtensions",
        type: {
          name: "String"
        }
      },
      failOnUnsupportedContentType: {
        serializedName: "failOnUnsupportedContentType",
        type: {
          name: "Boolean"
        }
      },
      failOnUnprocessableDocument: {
        serializedName: "failOnUnprocessableDocument",
        type: {
          name: "Boolean"
        }
      },
      indexStorageMetadataOnlyForOversizedDocuments: {
        serializedName: "indexStorageMetadataOnlyForOversizedDocuments",
        type: {
          name: "Boolean"
        }
      },
      delimitedTextHeaders: {
        serializedName: "delimitedTextHeaders",
        type: {
          name: "String"
        }
      },
      delimitedTextDelimiter: {
        serializedName: "delimitedTextDelimiter",
        type: {
          name: "String"
        }
      },
      firstLineContainsHeaders: {
        defaultValue: true,
        serializedName: "firstLineContainsHeaders",
        type: {
          name: "Boolean"
        }
      },
      documentRoot: {
        serializedName: "documentRoot",
        type: {
          name: "String"
        }
      },
      dataToExtract: {
        defaultValue: "contentAndMetadata",
        serializedName: "dataToExtract",
        type: {
          name: "String"
        }
      },
      imageAction: {
        defaultValue: "none",
        serializedName: "imageAction",
        type: {
          name: "String"
        }
      },
      allowSkillsetToReadFileData: {
        serializedName: "allowSkillsetToReadFileData",
        type: {
          name: "Boolean"
        }
      },
      pdfTextRotationAlgorithm: {
        defaultValue: "none",
        serializedName: "pdfTextRotationAlgorithm",
        type: {
          name: "String"
        }
      },
      executionEnvironment: {
        defaultValue: "standard",
        serializedName: "executionEnvironment",
        type: {
          name: "String"
        }
      },
      queryTimeout: {
        defaultValue: "00:05:00",
        serializedName: "queryTimeout",
        type: {
          name: "String"
        }
      }
    }
  }
};

export const FieldMapping: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "FieldMapping",
    modelProperties: {
      sourceFieldName: {
        serializedName: "sourceFieldName",
        required: true,
        type: {
          name: "String"
        }
      },
      targetFieldName: {
        serializedName: "targetFieldName",
        type: {
          name: "String"
        }
      },
      mappingFunction: {
        serializedName: "mappingFunction",
        type: {
          name: "Composite",
          className: "FieldMappingFunction"
        }
      }
    }
  }
};

export const FieldMappingFunction: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "FieldMappingFunction",
    modelProperties: {
      name: {
        serializedName: "name",
        required: true,
        type: {
          name: "String"
        }
      },
      parameters: {
        serializedName: "parameters",
        type: {
          name: "Dictionary",
          value: { type: { name: "any" } }
        }
      }
    }
  }
};

export const SearchIndexerCache: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchIndexerCache",
    modelProperties: {
      storageConnectionString: {
        serializedName: "storageConnectionString",
        type: {
          name: "String"
        }
      },
      enableReprocessing: {
        serializedName: "enableReprocessing",
        nullable: true,
        type: {
          name: "Boolean"
        }
      }
    }
  }
};

export const ListIndexersResult: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "ListIndexersResult",
    modelProperties: {
      indexers: {
        serializedName: "value",
        required: true,
        readOnly: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "SearchIndexer"
            }
          }
        }
      }
    }
  }
};

export const SearchIndexerStatus: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchIndexerStatus",
    modelProperties: {
      status: {
        serializedName: "status",
        required: true,
        readOnly: true,
        type: {
          name: "Enum",
          allowedValues: ["unknown", "error", "running"]
        }
      },
      lastResult: {
        serializedName: "lastResult",
        type: {
          name: "Composite",
          className: "IndexerExecutionResult"
        }
      },
      executionHistory: {
        serializedName: "executionHistory",
        required: true,
        readOnly: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "IndexerExecutionResult"
            }
          }
        }
      },
      limits: {
        serializedName: "limits",
        type: {
          name: "Composite",
          className: "SearchIndexerLimits"
        }
      }
    }
  }
};

export const IndexerExecutionResult: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "IndexerExecutionResult",
    modelProperties: {
      status: {
        serializedName: "status",
        required: true,
        readOnly: true,
        type: {
          name: "Enum",
          allowedValues: ["transientFailure", "success", "inProgress", "reset"]
        }
      },
      errorMessage: {
        serializedName: "errorMessage",
        readOnly: true,
        type: {
          name: "String"
        }
      },
      startTime: {
        serializedName: "startTime",
        readOnly: true,
        type: {
          name: "DateTime"
        }
      },
      endTime: {
        serializedName: "endTime",
        readOnly: true,
        nullable: true,
        type: {
          name: "DateTime"
        }
      },
      errors: {
        serializedName: "errors",
        required: true,
        readOnly: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "SearchIndexerError"
            }
          }
        }
      },
      warnings: {
        serializedName: "warnings",
        required: true,
        readOnly: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "SearchIndexerWarning"
            }
          }
        }
      },
      itemCount: {
        serializedName: "itemsProcessed",
        required: true,
        readOnly: true,
        type: {
          name: "Number"
        }
      },
      failedItemCount: {
        serializedName: "itemsFailed",
        required: true,
        readOnly: true,
        type: {
          name: "Number"
        }
      },
      initialTrackingState: {
        serializedName: "initialTrackingState",
        readOnly: true,
        type: {
          name: "String"
        }
      },
      finalTrackingState: {
        serializedName: "finalTrackingState",
        readOnly: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const SearchIndexerError: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchIndexerError",
    modelProperties: {
      key: {
        serializedName: "key",
        readOnly: true,
        type: {
          name: "String"
        }
      },
      errorMessage: {
        serializedName: "errorMessage",
        required: true,
        readOnly: true,
        type: {
          name: "String"
        }
      },
      statusCode: {
        serializedName: "statusCode",
        required: true,
        readOnly: true,
        type: {
          name: "Number"
        }
      },
      name: {
        serializedName: "name",
        readOnly: true,
        type: {
          name: "String"
        }
      },
      details: {
        serializedName: "details",
        readOnly: true,
        type: {
          name: "String"
        }
      },
      documentationLink: {
        serializedName: "documentationLink",
        readOnly: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const SearchIndexerWarning: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchIndexerWarning",
    modelProperties: {
      key: {
        serializedName: "key",
        readOnly: true,
        type: {
          name: "String"
        }
      },
      message: {
        serializedName: "message",
        required: true,
        readOnly: true,
        type: {
          name: "String"
        }
      },
      name: {
        serializedName: "name",
        readOnly: true,
        type: {
          name: "String"
        }
      },
      details: {
        serializedName: "details",
        readOnly: true,
        type: {
          name: "String"
        }
      },
      documentationLink: {
        serializedName: "documentationLink",
        readOnly: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const SearchIndexerLimits: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchIndexerLimits",
    modelProperties: {
      maxRunTime: {
        serializedName: "maxRunTime",
        readOnly: true,
        type: {
          name: "TimeSpan"
        }
      },
      maxDocumentExtractionSize: {
        serializedName: "maxDocumentExtractionSize",
        readOnly: true,
        type: {
          name: "Number"
        }
      },
      maxDocumentContentCharactersToExtract: {
        serializedName: "maxDocumentContentCharactersToExtract",
        readOnly: true,
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const SearchIndexerSkillset: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchIndexerSkillset",
    modelProperties: {
      name: {
        serializedName: "name",
        required: true,
        type: {
          name: "String"
        }
      },
      description: {
        serializedName: "description",
        type: {
          name: "String"
        }
      },
      skills: {
        serializedName: "skills",
        required: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "SearchIndexerSkill"
            }
          }
        }
      },
      cognitiveServicesAccount: {
        serializedName: "cognitiveServices",
        type: {
          name: "Composite",
          className: "CognitiveServicesAccount"
        }
      },
      knowledgeStore: {
        serializedName: "knowledgeStore",
        type: {
          name: "Composite",
          className: "SearchIndexerKnowledgeStore"
        }
      },
      etag: {
        serializedName: "@odata\\.etag",
        type: {
          name: "String"
        }
      },
      encryptionKey: {
        serializedName: "encryptionKey",
        type: {
          name: "Composite",
          className: "SearchResourceEncryptionKey"
        }
      }
    }
  }
};

export const SearchIndexerSkill: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchIndexerSkill",
    uberParent: "SearchIndexerSkill",
    polymorphicDiscriminator: {
      serializedName: "@odata\\.type",
      clientName: "odatatype"
    },
    modelProperties: {
      odatatype: {
        serializedName: "@odata\\.type",
        required: true,
        type: {
          name: "String"
        }
      },
      name: {
        serializedName: "name",
        type: {
          name: "String"
        }
      },
      description: {
        serializedName: "description",
        type: {
          name: "String"
        }
      },
      context: {
        serializedName: "context",
        type: {
          name: "String"
        }
      },
      inputs: {
        serializedName: "inputs",
        required: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "InputFieldMappingEntry"
            }
          }
        }
      },
      outputs: {
        serializedName: "outputs",
        required: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "OutputFieldMappingEntry"
            }
          }
        }
      }
    }
  }
};

export const InputFieldMappingEntry: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "InputFieldMappingEntry",
    modelProperties: {
      name: {
        serializedName: "name",
        required: true,
        type: {
          name: "String"
        }
      },
      source: {
        serializedName: "source",
        type: {
          name: "String"
        }
      },
      sourceContext: {
        serializedName: "sourceContext",
        type: {
          name: "String"
        }
      },
      inputs: {
        serializedName: "inputs",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "InputFieldMappingEntry"
            }
          }
        }
      }
    }
  }
};

export const OutputFieldMappingEntry: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "OutputFieldMappingEntry",
    modelProperties: {
      name: {
        serializedName: "name",
        required: true,
        type: {
          name: "String"
        }
      },
      targetName: {
        serializedName: "targetName",
        type: {
          name: "String"
        }
      }
    }
  }
};

export const CognitiveServicesAccount: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "CognitiveServicesAccount",
    uberParent: "CognitiveServicesAccount",
    polymorphicDiscriminator: {
      serializedName: "@odata\\.type",
      clientName: "odatatype"
    },
    modelProperties: {
      odatatype: {
        serializedName: "@odata\\.type",
        required: true,
        type: {
          name: "String"
        }
      },
      description: {
        serializedName: "description",
        type: {
          name: "String"
        }
      }
    }
  }
};

export const SearchIndexerKnowledgeStore: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchIndexerKnowledgeStore",
    modelProperties: {
      storageConnectionString: {
        serializedName: "storageConnectionString",
        required: true,
        type: {
          name: "String"
        }
      },
      projections: {
        serializedName: "projections",
        required: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "SearchIndexerKnowledgeStoreProjection"
            }
          }
        }
      }
    }
  }
};

export const SearchIndexerKnowledgeStoreProjection: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchIndexerKnowledgeStoreProjection",
    modelProperties: {
      tables: {
        serializedName: "tables",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "SearchIndexerKnowledgeStoreTableProjectionSelector"
            }
          }
        }
      },
      objects: {
        serializedName: "objects",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "SearchIndexerKnowledgeStoreObjectProjectionSelector"
            }
          }
        }
      },
      files: {
        serializedName: "files",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "SearchIndexerKnowledgeStoreFileProjectionSelector"
            }
          }
        }
      }
    }
  }
};

export const SearchIndexerKnowledgeStoreProjectionSelector: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchIndexerKnowledgeStoreProjectionSelector",
    modelProperties: {
      referenceKeyName: {
        serializedName: "referenceKeyName",
        type: {
          name: "String"
        }
      },
      generatedKeyName: {
        serializedName: "generatedKeyName",
        type: {
          name: "String"
        }
      },
      source: {
        serializedName: "source",
        type: {
          name: "String"
        }
      },
      sourceContext: {
        serializedName: "sourceContext",
        type: {
          name: "String"
        }
      },
      inputs: {
        serializedName: "inputs",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "InputFieldMappingEntry"
            }
          }
        }
      }
    }
  }
};

export const ListSkillsetsResult: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "ListSkillsetsResult",
    modelProperties: {
      skillsets: {
        serializedName: "value",
        required: true,
        readOnly: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "SearchIndexerSkillset"
            }
          }
        }
      }
    }
  }
};

export const SynonymMap: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SynonymMap",
    modelProperties: {
      name: {
        serializedName: "name",
        required: true,
        type: {
          name: "String"
        }
      },
      format: {
        defaultValue: "solr",
        isConstant: true,
        serializedName: "format",
        type: {
          name: "String"
        }
      },
      synonyms: {
        serializedName: "synonyms",
        required: true,
        type: {
          name: "String"
        }
      },
      encryptionKey: {
        serializedName: "encryptionKey",
        type: {
          name: "Composite",
          className: "SearchResourceEncryptionKey"
        }
      },
      etag: {
        serializedName: "@odata\\.etag",
        type: {
          name: "String"
        }
      }
    }
  }
};

export const ListSynonymMapsResult: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "ListSynonymMapsResult",
    modelProperties: {
      synonymMaps: {
        serializedName: "value",
        required: true,
        readOnly: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "SynonymMap"
            }
          }
        }
      }
    }
  }
};

export const SearchIndex: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchIndex",
    modelProperties: {
      name: {
        serializedName: "name",
        required: true,
        type: {
          name: "String"
        }
      },
      fields: {
        serializedName: "fields",
        required: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "SearchField"
            }
          }
        }
      },
      scoringProfiles: {
        serializedName: "scoringProfiles",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "ScoringProfile"
            }
          }
        }
      },
      defaultScoringProfile: {
        serializedName: "defaultScoringProfile",
        type: {
          name: "String"
        }
      },
      corsOptions: {
        serializedName: "corsOptions",
        type: {
          name: "Composite",
          className: "CorsOptions"
        }
      },
      suggesters: {
        serializedName: "suggesters",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "Suggester"
            }
          }
        }
      },
      analyzers: {
        serializedName: "analyzers",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "LexicalAnalyzer"
            }
          }
        }
      },
      tokenizers: {
        serializedName: "tokenizers",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "LexicalTokenizer"
            }
          }
        }
      },
      tokenFilters: {
        serializedName: "tokenFilters",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "TokenFilter"
            }
          }
        }
      },
      charFilters: {
        serializedName: "charFilters",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "CharFilter"
            }
          }
        }
      },
      normalizers: {
        serializedName: "normalizers",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "LexicalNormalizer"
            }
          }
        }
      },
      encryptionKey: {
        serializedName: "encryptionKey",
        type: {
          name: "Composite",
          className: "SearchResourceEncryptionKey"
        }
      },
      similarity: {
        serializedName: "similarity",
        type: {
          name: "Composite",
          className: "Similarity"
        }
      },
      etag: {
        serializedName: "@odata\\.etag",
        type: {
          name: "String"
        }
      }
    }
  }
};

export const SearchField: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchField",
    modelProperties: {
      name: {
        serializedName: "name",
        required: true,
        type: {
          name: "String"
        }
      },
      type: {
        serializedName: "type",
        required: true,
        type: {
          name: "String"
        }
      },
      key: {
        serializedName: "key",
        type: {
          name: "Boolean"
        }
      },
      retrievable: {
        serializedName: "retrievable",
        type: {
          name: "Boolean"
        }
      },
      searchable: {
        serializedName: "searchable",
        type: {
          name: "Boolean"
        }
      },
      filterable: {
        serializedName: "filterable",
        type: {
          name: "Boolean"
        }
      },
      sortable: {
        serializedName: "sortable",
        type: {
          name: "Boolean"
        }
      },
      facetable: {
        serializedName: "facetable",
        type: {
          name: "Boolean"
        }
      },
      analyzer: {
        serializedName: "analyzer",
        nullable: true,
        type: {
          name: "String"
        }
      },
      searchAnalyzer: {
        serializedName: "searchAnalyzer",
        nullable: true,
        type: {
          name: "String"
        }
      },
      indexAnalyzer: {
        serializedName: "indexAnalyzer",
        nullable: true,
        type: {
          name: "String"
        }
      },
      normalizer: {
        serializedName: "normalizer",
        nullable: true,
        type: {
          name: "String"
        }
      },
      synonymMaps: {
        serializedName: "synonymMaps",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      },
      fields: {
        serializedName: "fields",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "SearchField"
            }
          }
        }
      }
    }
  }
};

export const ScoringProfile: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "ScoringProfile",
    modelProperties: {
      name: {
        serializedName: "name",
        required: true,
        type: {
          name: "String"
        }
      },
      textWeights: {
        serializedName: "text",
        type: {
          name: "Composite",
          className: "TextWeights"
        }
      },
      functions: {
        serializedName: "functions",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "ScoringFunction"
            }
          }
        }
      },
      functionAggregation: {
        serializedName: "functionAggregation",
        type: {
          name: "Enum",
          allowedValues: [
            "sum",
            "average",
            "minimum",
            "maximum",
            "firstMatching"
          ]
        }
      }
    }
  }
};

export const TextWeights: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "TextWeights",
    modelProperties: {
      weights: {
        serializedName: "weights",
        required: true,
        type: {
          name: "Dictionary",
          value: { type: { name: "Number" } }
        }
      }
    }
  }
};

export const ScoringFunction: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "ScoringFunction",
    uberParent: "ScoringFunction",
    polymorphicDiscriminator: {
      serializedName: "type",
      clientName: "type"
    },
    modelProperties: {
      type: {
        serializedName: "type",
        required: true,
        type: {
          name: "String"
        }
      },
      fieldName: {
        serializedName: "fieldName",
        required: true,
        type: {
          name: "String"
        }
      },
      boost: {
        serializedName: "boost",
        required: true,
        type: {
          name: "Number"
        }
      },
      interpolation: {
        serializedName: "interpolation",
        type: {
          name: "Enum",
          allowedValues: ["linear", "constant", "quadratic", "logarithmic"]
        }
      }
    }
  }
};

export const CorsOptions: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "CorsOptions",
    modelProperties: {
      allowedOrigins: {
        serializedName: "allowedOrigins",
        required: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      },
      maxAgeInSeconds: {
        serializedName: "maxAgeInSeconds",
        nullable: true,
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const Suggester: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "Suggester",
    modelProperties: {
      name: {
        serializedName: "name",
        required: true,
        type: {
          name: "String"
        }
      },
      searchMode: {
        defaultValue: "analyzingInfixMatching",
        isConstant: true,
        serializedName: "searchMode",
        type: {
          name: "String"
        }
      },
      sourceFields: {
        serializedName: "sourceFields",
        required: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      }
    }
  }
};

export const LexicalAnalyzer: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "LexicalAnalyzer",
    uberParent: "LexicalAnalyzer",
    polymorphicDiscriminator: {
      serializedName: "@odata\\.type",
      clientName: "odatatype"
    },
    modelProperties: {
      odatatype: {
        serializedName: "@odata\\.type",
        required: true,
        type: {
          name: "String"
        }
      },
      name: {
        serializedName: "name",
        required: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const LexicalTokenizer: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "LexicalTokenizer",
    uberParent: "LexicalTokenizer",
    polymorphicDiscriminator: {
      serializedName: "@odata\\.type",
      clientName: "odatatype"
    },
    modelProperties: {
      odatatype: {
        serializedName: "@odata\\.type",
        required: true,
        type: {
          name: "String"
        }
      },
      name: {
        serializedName: "name",
        required: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const TokenFilter: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "TokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: {
      serializedName: "@odata\\.type",
      clientName: "odatatype"
    },
    modelProperties: {
      odatatype: {
        serializedName: "@odata\\.type",
        required: true,
        type: {
          name: "String"
        }
      },
      name: {
        serializedName: "name",
        required: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const CharFilter: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "CharFilter",
    uberParent: "CharFilter",
    polymorphicDiscriminator: {
      serializedName: "@odata\\.type",
      clientName: "odatatype"
    },
    modelProperties: {
      odatatype: {
        serializedName: "@odata\\.type",
        required: true,
        type: {
          name: "String"
        }
      },
      name: {
        serializedName: "name",
        required: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const LexicalNormalizer: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "LexicalNormalizer",
    uberParent: "LexicalNormalizer",
    polymorphicDiscriminator: {
      serializedName: "@odata\\.type",
      clientName: "odatatype"
    },
    modelProperties: {
      odatatype: {
        serializedName: "@odata\\.type",
        required: true,
        type: {
          name: "String"
        }
      },
      name: {
        serializedName: "name",
        required: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const Similarity: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "Similarity",
    uberParent: "Similarity",
    polymorphicDiscriminator: {
      serializedName: "@odata\\.type",
      clientName: "odatatype"
    },
    modelProperties: {
      odatatype: {
        serializedName: "@odata\\.type",
        required: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const ListIndexesResult: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "ListIndexesResult",
    modelProperties: {
      indexes: {
        serializedName: "value",
        required: true,
        readOnly: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "SearchIndex"
            }
          }
        }
      }
    }
  }
};

export const GetIndexStatisticsResult: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "GetIndexStatisticsResult",
    modelProperties: {
      documentCount: {
        serializedName: "documentCount",
        required: true,
        readOnly: true,
        type: {
          name: "Number"
        }
      },
      storageSize: {
        serializedName: "storageSize",
        required: true,
        readOnly: true,
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const AnalyzeRequest: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "AnalyzeRequest",
    modelProperties: {
      text: {
        serializedName: "text",
        required: true,
        type: {
          name: "String"
        }
      },
      analyzer: {
        serializedName: "analyzer",
        type: {
          name: "String"
        }
      },
      tokenizer: {
        serializedName: "tokenizer",
        type: {
          name: "String"
        }
      },
      normalizer: {
        serializedName: "normalizer",
        type: {
          name: "String"
        }
      },
      tokenFilters: {
        serializedName: "tokenFilters",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      },
      charFilters: {
        serializedName: "charFilters",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      }
    }
  }
};

export const AnalyzeResult: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "AnalyzeResult",
    modelProperties: {
      tokens: {
        serializedName: "tokens",
        required: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "AnalyzedTokenInfo"
            }
          }
        }
      }
    }
  }
};

export const AnalyzedTokenInfo: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "AnalyzedTokenInfo",
    modelProperties: {
      token: {
        serializedName: "token",
        required: true,
        readOnly: true,
        type: {
          name: "String"
        }
      },
      startOffset: {
        serializedName: "startOffset",
        required: true,
        readOnly: true,
        type: {
          name: "Number"
        }
      },
      endOffset: {
        serializedName: "endOffset",
        required: true,
        readOnly: true,
        type: {
          name: "Number"
        }
      },
      position: {
        serializedName: "position",
        required: true,
        readOnly: true,
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const ServiceStatistics: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "ServiceStatistics",
    modelProperties: {
      counters: {
        serializedName: "counters",
        type: {
          name: "Composite",
          className: "ServiceCounters"
        }
      },
      limits: {
        serializedName: "limits",
        type: {
          name: "Composite",
          className: "ServiceLimits"
        }
      }
    }
  }
};

export const ServiceCounters: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "ServiceCounters",
    modelProperties: {
      documentCounter: {
        serializedName: "documentCount",
        type: {
          name: "Composite",
          className: "ResourceCounter"
        }
      },
      indexCounter: {
        serializedName: "indexesCount",
        type: {
          name: "Composite",
          className: "ResourceCounter"
        }
      },
      indexerCounter: {
        serializedName: "indexersCount",
        type: {
          name: "Composite",
          className: "ResourceCounter"
        }
      },
      dataSourceCounter: {
        serializedName: "dataSourcesCount",
        type: {
          name: "Composite",
          className: "ResourceCounter"
        }
      },
      storageSizeCounter: {
        serializedName: "storageSize",
        type: {
          name: "Composite",
          className: "ResourceCounter"
        }
      },
      synonymMapCounter: {
        serializedName: "synonymMaps",
        type: {
          name: "Composite",
          className: "ResourceCounter"
        }
      },
      skillsetCounter: {
        serializedName: "skillsetCount",
        type: {
          name: "Composite",
          className: "ResourceCounter"
        }
      }
    }
  }
};

export const ResourceCounter: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "ResourceCounter",
    modelProperties: {
      usage: {
        serializedName: "usage",
        required: true,
        type: {
          name: "Number"
        }
      },
      quota: {
        serializedName: "quota",
        nullable: true,
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const ServiceLimits: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "ServiceLimits",
    modelProperties: {
      maxFieldsPerIndex: {
        serializedName: "maxFieldsPerIndex",
        nullable: true,
        type: {
          name: "Number"
        }
      },
      maxFieldNestingDepthPerIndex: {
        serializedName: "maxFieldNestingDepthPerIndex",
        nullable: true,
        type: {
          name: "Number"
        }
      },
      maxComplexCollectionFieldsPerIndex: {
        serializedName: "maxComplexCollectionFieldsPerIndex",
        nullable: true,
        type: {
          name: "Number"
        }
      },
      maxComplexObjectsInCollectionsPerDocument: {
        serializedName: "maxComplexObjectsInCollectionsPerDocument",
        nullable: true,
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const DistanceScoringParameters: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "DistanceScoringParameters",
    modelProperties: {
      referencePointParameter: {
        serializedName: "referencePointParameter",
        required: true,
        type: {
          name: "String"
        }
      },
      boostingDistance: {
        serializedName: "boostingDistance",
        required: true,
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const FreshnessScoringParameters: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "FreshnessScoringParameters",
    modelProperties: {
      boostingDuration: {
        serializedName: "boostingDuration",
        required: true,
        type: {
          name: "TimeSpan"
        }
      }
    }
  }
};

export const MagnitudeScoringParameters: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "MagnitudeScoringParameters",
    modelProperties: {
      boostingRangeStart: {
        serializedName: "boostingRangeStart",
        required: true,
        type: {
          name: "Number"
        }
      },
      boostingRangeEnd: {
        serializedName: "boostingRangeEnd",
        required: true,
        type: {
          name: "Number"
        }
      },
      shouldBoostBeyondRangeByConstant: {
        serializedName: "constantBoostBeyondRange",
        type: {
          name: "Boolean"
        }
      }
    }
  }
};

export const TagScoringParameters: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "TagScoringParameters",
    modelProperties: {
      tagsParameter: {
        serializedName: "tagsParameter",
        required: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const CustomEntity: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "CustomEntity",
    modelProperties: {
      name: {
        serializedName: "name",
        required: true,
        type: {
          name: "String"
        }
      },
      description: {
        serializedName: "description",
        nullable: true,
        type: {
          name: "String"
        }
      },
      type: {
        serializedName: "type",
        nullable: true,
        type: {
          name: "String"
        }
      },
      subtype: {
        serializedName: "subtype",
        nullable: true,
        type: {
          name: "String"
        }
      },
      id: {
        serializedName: "id",
        nullable: true,
        type: {
          name: "String"
        }
      },
      caseSensitive: {
        serializedName: "caseSensitive",
        nullable: true,
        type: {
          name: "Boolean"
        }
      },
      accentSensitive: {
        serializedName: "accentSensitive",
        nullable: true,
        type: {
          name: "Boolean"
        }
      },
      fuzzyEditDistance: {
        serializedName: "fuzzyEditDistance",
        nullable: true,
        type: {
          name: "Number"
        }
      },
      defaultCaseSensitive: {
        serializedName: "defaultCaseSensitive",
        nullable: true,
        type: {
          name: "Boolean"
        }
      },
      defaultAccentSensitive: {
        serializedName: "defaultAccentSensitive",
        nullable: true,
        type: {
          name: "Boolean"
        }
      },
      defaultFuzzyEditDistance: {
        serializedName: "defaultFuzzyEditDistance",
        nullable: true,
        type: {
          name: "Number"
        }
      },
      aliases: {
        serializedName: "aliases",
        nullable: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "CustomEntityAlias"
            }
          }
        }
      }
    }
  }
};

export const CustomEntityAlias: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "CustomEntityAlias",
    modelProperties: {
      text: {
        serializedName: "text",
        required: true,
        type: {
          name: "String"
        }
      },
      caseSensitive: {
        serializedName: "caseSensitive",
        nullable: true,
        type: {
          name: "Boolean"
        }
      },
      accentSensitive: {
        serializedName: "accentSensitive",
        nullable: true,
        type: {
          name: "Boolean"
        }
      },
      fuzzyEditDistance: {
        serializedName: "fuzzyEditDistance",
        nullable: true,
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const SearchIndexerDataNoneIdentity: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.SearchIndexerDataNoneIdentity",
  type: {
    name: "Composite",
    className: "SearchIndexerDataNoneIdentity",
    uberParent: "SearchIndexerDataIdentity",
    polymorphicDiscriminator:
      SearchIndexerDataIdentity.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerDataIdentity.type.modelProperties
    }
  }
};

export const SearchIndexerDataUserAssignedIdentity: coreHttp.CompositeMapper = {
  serializedName:
    "#Microsoft.Azure.Search.SearchIndexerDataUserAssignedIdentity",
  type: {
    name: "Composite",
    className: "SearchIndexerDataUserAssignedIdentity",
    uberParent: "SearchIndexerDataIdentity",
    polymorphicDiscriminator:
      SearchIndexerDataIdentity.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerDataIdentity.type.modelProperties,
      userAssignedIdentity: {
        serializedName: "userAssignedIdentity",
        required: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const HighWaterMarkChangeDetectionPolicy: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.HighWaterMarkChangeDetectionPolicy",
  type: {
    name: "Composite",
    className: "HighWaterMarkChangeDetectionPolicy",
    uberParent: "DataChangeDetectionPolicy",
    polymorphicDiscriminator:
      DataChangeDetectionPolicy.type.polymorphicDiscriminator,
    modelProperties: {
      ...DataChangeDetectionPolicy.type.modelProperties,
      highWaterMarkColumnName: {
        serializedName: "highWaterMarkColumnName",
        required: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const SqlIntegratedChangeTrackingPolicy: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.SqlIntegratedChangeTrackingPolicy",
  type: {
    name: "Composite",
    className: "SqlIntegratedChangeTrackingPolicy",
    uberParent: "DataChangeDetectionPolicy",
    polymorphicDiscriminator:
      DataChangeDetectionPolicy.type.polymorphicDiscriminator,
    modelProperties: {
      ...DataChangeDetectionPolicy.type.modelProperties
    }
  }
};

export const SoftDeleteColumnDeletionDetectionPolicy: coreHttp.CompositeMapper = {
  serializedName:
    "#Microsoft.Azure.Search.SoftDeleteColumnDeletionDetectionPolicy",
  type: {
    name: "Composite",
    className: "SoftDeleteColumnDeletionDetectionPolicy",
    uberParent: "DataDeletionDetectionPolicy",
    polymorphicDiscriminator:
      DataDeletionDetectionPolicy.type.polymorphicDiscriminator,
    modelProperties: {
      ...DataDeletionDetectionPolicy.type.modelProperties,
      softDeleteColumnName: {
        serializedName: "softDeleteColumnName",
        type: {
          name: "String"
        }
      },
      softDeleteMarkerValue: {
        serializedName: "softDeleteMarkerValue",
        type: {
          name: "String"
        }
      }
    }
  }
};

export const ConditionalSkill: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Skills.Util.ConditionalSkill",
  type: {
    name: "Composite",
    className: "ConditionalSkill",
    uberParent: "SearchIndexerSkill",
    polymorphicDiscriminator: SearchIndexerSkill.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerSkill.type.modelProperties
    }
  }
};

export const KeyPhraseExtractionSkill: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Skills.Text.KeyPhraseExtractionSkill",
  type: {
    name: "Composite",
    className: "KeyPhraseExtractionSkill",
    uberParent: "SearchIndexerSkill",
    polymorphicDiscriminator: SearchIndexerSkill.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerSkill.type.modelProperties,
      defaultLanguageCode: {
        serializedName: "defaultLanguageCode",
        type: {
          name: "String"
        }
      },
      maxKeyPhraseCount: {
        serializedName: "maxKeyPhraseCount",
        nullable: true,
        type: {
          name: "Number"
        }
      },
      modelVersion: {
        serializedName: "modelVersion",
        nullable: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const OcrSkill: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Skills.Vision.OcrSkill",
  type: {
    name: "Composite",
    className: "OcrSkill",
    uberParent: "SearchIndexerSkill",
    polymorphicDiscriminator: SearchIndexerSkill.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerSkill.type.modelProperties,
      defaultLanguageCode: {
        serializedName: "defaultLanguageCode",
        type: {
          name: "String"
        }
      },
      shouldDetectOrientation: {
        serializedName: "detectOrientation",
        type: {
          name: "Boolean"
        }
      },
      lineEnding: {
        serializedName: "lineEnding",
        type: {
          name: "String"
        }
      }
    }
  }
};

export const ImageAnalysisSkill: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Skills.Vision.ImageAnalysisSkill",
  type: {
    name: "Composite",
    className: "ImageAnalysisSkill",
    uberParent: "SearchIndexerSkill",
    polymorphicDiscriminator: SearchIndexerSkill.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerSkill.type.modelProperties,
      defaultLanguageCode: {
        serializedName: "defaultLanguageCode",
        type: {
          name: "String"
        }
      },
      visualFeatures: {
        serializedName: "visualFeatures",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      },
      details: {
        serializedName: "details",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      }
    }
  }
};

export const LanguageDetectionSkill: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Skills.Text.LanguageDetectionSkill",
  type: {
    name: "Composite",
    className: "LanguageDetectionSkill",
    uberParent: "SearchIndexerSkill",
    polymorphicDiscriminator: SearchIndexerSkill.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerSkill.type.modelProperties,
      defaultCountryHint: {
        serializedName: "defaultCountryHint",
        nullable: true,
        type: {
          name: "String"
        }
      },
      modelVersion: {
        serializedName: "modelVersion",
        nullable: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const ShaperSkill: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Skills.Util.ShaperSkill",
  type: {
    name: "Composite",
    className: "ShaperSkill",
    uberParent: "SearchIndexerSkill",
    polymorphicDiscriminator: SearchIndexerSkill.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerSkill.type.modelProperties
    }
  }
};

export const MergeSkill: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Skills.Text.MergeSkill",
  type: {
    name: "Composite",
    className: "MergeSkill",
    uberParent: "SearchIndexerSkill",
    polymorphicDiscriminator: SearchIndexerSkill.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerSkill.type.modelProperties,
      insertPreTag: {
        defaultValue: " ",
        serializedName: "insertPreTag",
        type: {
          name: "String"
        }
      },
      insertPostTag: {
        defaultValue: " ",
        serializedName: "insertPostTag",
        type: {
          name: "String"
        }
      }
    }
  }
};

export const EntityRecognitionSkill: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Skills.Text.EntityRecognitionSkill",
  type: {
    name: "Composite",
    className: "EntityRecognitionSkill",
    uberParent: "SearchIndexerSkill",
    polymorphicDiscriminator: SearchIndexerSkill.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerSkill.type.modelProperties,
      categories: {
        serializedName: "categories",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      },
      defaultLanguageCode: {
        serializedName: "defaultLanguageCode",
        type: {
          name: "String"
        }
      },
      includeTypelessEntities: {
        serializedName: "includeTypelessEntities",
        nullable: true,
        type: {
          name: "Boolean"
        }
      },
      minimumPrecision: {
        serializedName: "minimumPrecision",
        nullable: true,
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const SentimentSkill: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Skills.Text.SentimentSkill",
  type: {
    name: "Composite",
    className: "SentimentSkill",
    uberParent: "SearchIndexerSkill",
    polymorphicDiscriminator: SearchIndexerSkill.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerSkill.type.modelProperties,
      defaultLanguageCode: {
        serializedName: "defaultLanguageCode",
        type: {
          name: "String"
        }
      }
    }
  }
};

export const SentimentSkillV3: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Skills.Text.V3.SentimentSkill",
  type: {
    name: "Composite",
    className: "SentimentSkillV3",
    uberParent: "SearchIndexerSkill",
    polymorphicDiscriminator: SearchIndexerSkill.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerSkill.type.modelProperties,
      defaultLanguageCode: {
        serializedName: "defaultLanguageCode",
        nullable: true,
        type: {
          name: "String"
        }
      },
      includeOpinionMining: {
        serializedName: "includeOpinionMining",
        type: {
          name: "Boolean"
        }
      },
      modelVersion: {
        serializedName: "modelVersion",
        nullable: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const EntityLinkingSkill: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Skills.Text.V3.EntityLinkingSkill",
  type: {
    name: "Composite",
    className: "EntityLinkingSkill",
    uberParent: "SearchIndexerSkill",
    polymorphicDiscriminator: SearchIndexerSkill.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerSkill.type.modelProperties,
      defaultLanguageCode: {
        serializedName: "defaultLanguageCode",
        nullable: true,
        type: {
          name: "String"
        }
      },
      minimumPrecision: {
        constraints: {
          InclusiveMaximum: 1,
          InclusiveMinimum: 0
        },
        serializedName: "minimumPrecision",
        nullable: true,
        type: {
          name: "Number"
        }
      },
      modelVersion: {
        serializedName: "modelVersion",
        nullable: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const EntityRecognitionSkillV3: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Skills.Text.V3.EntityRecognitionSkill",
  type: {
    name: "Composite",
    className: "EntityRecognitionSkillV3",
    uberParent: "SearchIndexerSkill",
    polymorphicDiscriminator: SearchIndexerSkill.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerSkill.type.modelProperties,
      categories: {
        serializedName: "categories",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      },
      defaultLanguageCode: {
        serializedName: "defaultLanguageCode",
        nullable: true,
        type: {
          name: "String"
        }
      },
      minimumPrecision: {
        constraints: {
          InclusiveMaximum: 1,
          InclusiveMinimum: 0
        },
        serializedName: "minimumPrecision",
        nullable: true,
        type: {
          name: "Number"
        }
      },
      modelVersion: {
        serializedName: "modelVersion",
        nullable: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const PIIDetectionSkill: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Skills.Text.PIIDetectionSkill",
  type: {
    name: "Composite",
    className: "PIIDetectionSkill",
    uberParent: "SearchIndexerSkill",
    polymorphicDiscriminator: SearchIndexerSkill.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerSkill.type.modelProperties,
      defaultLanguageCode: {
        serializedName: "defaultLanguageCode",
        nullable: true,
        type: {
          name: "String"
        }
      },
      minimumPrecision: {
        constraints: {
          InclusiveMaximum: 1,
          InclusiveMinimum: 0
        },
        serializedName: "minimumPrecision",
        nullable: true,
        type: {
          name: "Number"
        }
      },
      maskingMode: {
        serializedName: "maskingMode",
        type: {
          name: "String"
        }
      },
      maskingCharacter: {
        constraints: {
          MaxLength: 1
        },
        serializedName: "maskingCharacter",
        nullable: true,
        type: {
          name: "String"
        }
      },
      modelVersion: {
        serializedName: "modelVersion",
        nullable: true,
        type: {
          name: "String"
        }
      },
      piiCategories: {
        serializedName: "piiCategories",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      },
      domain: {
        serializedName: "domain",
        nullable: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const SplitSkill: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Skills.Text.SplitSkill",
  type: {
    name: "Composite",
    className: "SplitSkill",
    uberParent: "SearchIndexerSkill",
    polymorphicDiscriminator: SearchIndexerSkill.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerSkill.type.modelProperties,
      defaultLanguageCode: {
        serializedName: "defaultLanguageCode",
        type: {
          name: "String"
        }
      },
      textSplitMode: {
        serializedName: "textSplitMode",
        type: {
          name: "String"
        }
      },
      maxPageLength: {
        serializedName: "maximumPageLength",
        nullable: true,
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const CustomEntityLookupSkill: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Skills.Text.CustomEntityLookupSkill",
  type: {
    name: "Composite",
    className: "CustomEntityLookupSkill",
    uberParent: "SearchIndexerSkill",
    polymorphicDiscriminator: SearchIndexerSkill.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerSkill.type.modelProperties,
      defaultLanguageCode: {
        serializedName: "defaultLanguageCode",
        nullable: true,
        type: {
          name: "String"
        }
      },
      entitiesDefinitionUri: {
        serializedName: "entitiesDefinitionUri",
        nullable: true,
        type: {
          name: "String"
        }
      },
      inlineEntitiesDefinition: {
        serializedName: "inlineEntitiesDefinition",
        nullable: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "CustomEntity"
            }
          }
        }
      },
      globalDefaultCaseSensitive: {
        serializedName: "globalDefaultCaseSensitive",
        nullable: true,
        type: {
          name: "Boolean"
        }
      },
      globalDefaultAccentSensitive: {
        serializedName: "globalDefaultAccentSensitive",
        nullable: true,
        type: {
          name: "Boolean"
        }
      },
      globalDefaultFuzzyEditDistance: {
        serializedName: "globalDefaultFuzzyEditDistance",
        nullable: true,
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const TextTranslationSkill: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Skills.Text.TranslationSkill",
  type: {
    name: "Composite",
    className: "TextTranslationSkill",
    uberParent: "SearchIndexerSkill",
    polymorphicDiscriminator: SearchIndexerSkill.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerSkill.type.modelProperties,
      defaultToLanguageCode: {
        serializedName: "defaultToLanguageCode",
        required: true,
        type: {
          name: "String"
        }
      },
      defaultFromLanguageCode: {
        serializedName: "defaultFromLanguageCode",
        type: {
          name: "String"
        }
      },
      suggestedFrom: {
        serializedName: "suggestedFrom",
        nullable: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const DocumentExtractionSkill: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Skills.Util.DocumentExtractionSkill",
  type: {
    name: "Composite",
    className: "DocumentExtractionSkill",
    uberParent: "SearchIndexerSkill",
    polymorphicDiscriminator: SearchIndexerSkill.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerSkill.type.modelProperties,
      parsingMode: {
        serializedName: "parsingMode",
        nullable: true,
        type: {
          name: "String"
        }
      },
      dataToExtract: {
        serializedName: "dataToExtract",
        nullable: true,
        type: {
          name: "String"
        }
      },
      configuration: {
        serializedName: "configuration",
        nullable: true,
        type: {
          name: "Dictionary",
          value: { type: { name: "any" } }
        }
      }
    }
  }
};

export const WebApiSkill: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Skills.Custom.WebApiSkill",
  type: {
    name: "Composite",
    className: "WebApiSkill",
    uberParent: "SearchIndexerSkill",
    polymorphicDiscriminator: SearchIndexerSkill.type.polymorphicDiscriminator,
    modelProperties: {
      ...SearchIndexerSkill.type.modelProperties,
      uri: {
        serializedName: "uri",
        required: true,
        type: {
          name: "String"
        }
      },
      httpHeaders: {
        serializedName: "httpHeaders",
        type: {
          name: "Dictionary",
          value: { type: { name: "String" } }
        }
      },
      httpMethod: {
        serializedName: "httpMethod",
        type: {
          name: "String"
        }
      },
      timeout: {
        serializedName: "timeout",
        type: {
          name: "TimeSpan"
        }
      },
      batchSize: {
        serializedName: "batchSize",
        nullable: true,
        type: {
          name: "Number"
        }
      },
      degreeOfParallelism: {
        serializedName: "degreeOfParallelism",
        nullable: true,
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const DefaultCognitiveServicesAccount: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.DefaultCognitiveServices",
  type: {
    name: "Composite",
    className: "DefaultCognitiveServicesAccount",
    uberParent: "CognitiveServicesAccount",
    polymorphicDiscriminator:
      CognitiveServicesAccount.type.polymorphicDiscriminator,
    modelProperties: {
      ...CognitiveServicesAccount.type.modelProperties
    }
  }
};

export const CognitiveServicesAccountKey: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.CognitiveServicesByKey",
  type: {
    name: "Composite",
    className: "CognitiveServicesAccountKey",
    uberParent: "CognitiveServicesAccount",
    polymorphicDiscriminator:
      CognitiveServicesAccount.type.polymorphicDiscriminator,
    modelProperties: {
      ...CognitiveServicesAccount.type.modelProperties,
      key: {
        serializedName: "key",
        required: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const SearchIndexerKnowledgeStoreTableProjectionSelector: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchIndexerKnowledgeStoreTableProjectionSelector",
    modelProperties: {
      ...SearchIndexerKnowledgeStoreProjectionSelector.type.modelProperties,
      tableName: {
        serializedName: "tableName",
        required: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const SearchIndexerKnowledgeStoreBlobProjectionSelector: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchIndexerKnowledgeStoreBlobProjectionSelector",
    modelProperties: {
      ...SearchIndexerKnowledgeStoreProjectionSelector.type.modelProperties,
      storageContainer: {
        serializedName: "storageContainer",
        required: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const DistanceScoringFunction: coreHttp.CompositeMapper = {
  serializedName: "distance",
  type: {
    name: "Composite",
    className: "DistanceScoringFunction",
    uberParent: "ScoringFunction",
    polymorphicDiscriminator: ScoringFunction.type.polymorphicDiscriminator,
    modelProperties: {
      ...ScoringFunction.type.modelProperties,
      parameters: {
        serializedName: "distance",
        type: {
          name: "Composite",
          className: "DistanceScoringParameters"
        }
      }
    }
  }
};

export const FreshnessScoringFunction: coreHttp.CompositeMapper = {
  serializedName: "freshness",
  type: {
    name: "Composite",
    className: "FreshnessScoringFunction",
    uberParent: "ScoringFunction",
    polymorphicDiscriminator: ScoringFunction.type.polymorphicDiscriminator,
    modelProperties: {
      ...ScoringFunction.type.modelProperties,
      parameters: {
        serializedName: "freshness",
        type: {
          name: "Composite",
          className: "FreshnessScoringParameters"
        }
      }
    }
  }
};

export const MagnitudeScoringFunction: coreHttp.CompositeMapper = {
  serializedName: "magnitude",
  type: {
    name: "Composite",
    className: "MagnitudeScoringFunction",
    uberParent: "ScoringFunction",
    polymorphicDiscriminator: ScoringFunction.type.polymorphicDiscriminator,
    modelProperties: {
      ...ScoringFunction.type.modelProperties,
      parameters: {
        serializedName: "magnitude",
        type: {
          name: "Composite",
          className: "MagnitudeScoringParameters"
        }
      }
    }
  }
};

export const TagScoringFunction: coreHttp.CompositeMapper = {
  serializedName: "tag",
  type: {
    name: "Composite",
    className: "TagScoringFunction",
    uberParent: "ScoringFunction",
    polymorphicDiscriminator: ScoringFunction.type.polymorphicDiscriminator,
    modelProperties: {
      ...ScoringFunction.type.modelProperties,
      parameters: {
        serializedName: "tag",
        type: {
          name: "Composite",
          className: "TagScoringParameters"
        }
      }
    }
  }
};

export const CustomAnalyzer: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.CustomAnalyzer",
  type: {
    name: "Composite",
    className: "CustomAnalyzer",
    uberParent: "LexicalAnalyzer",
    polymorphicDiscriminator: LexicalAnalyzer.type.polymorphicDiscriminator,
    modelProperties: {
      ...LexicalAnalyzer.type.modelProperties,
      tokenizerName: {
        serializedName: "tokenizer",
        required: true,
        type: {
          name: "String"
        }
      },
      tokenFilters: {
        serializedName: "tokenFilters",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      },
      charFilters: {
        serializedName: "charFilters",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      }
    }
  }
};

export const PatternAnalyzer: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.PatternAnalyzer",
  type: {
    name: "Composite",
    className: "PatternAnalyzer",
    uberParent: "LexicalAnalyzer",
    polymorphicDiscriminator: LexicalAnalyzer.type.polymorphicDiscriminator,
    modelProperties: {
      ...LexicalAnalyzer.type.modelProperties,
      lowerCaseTerms: {
        defaultValue: true,
        serializedName: "lowercase",
        type: {
          name: "Boolean"
        }
      },
      pattern: {
        defaultValue: "W+",
        serializedName: "pattern",
        type: {
          name: "String"
        }
      },
      flags: {
        serializedName: "flags",
        type: {
          name: "String"
        }
      },
      stopwords: {
        serializedName: "stopwords",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      }
    }
  }
};

export const LuceneStandardAnalyzer: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.StandardAnalyzer",
  type: {
    name: "Composite",
    className: "LuceneStandardAnalyzer",
    uberParent: "LexicalAnalyzer",
    polymorphicDiscriminator: LexicalAnalyzer.type.polymorphicDiscriminator,
    modelProperties: {
      ...LexicalAnalyzer.type.modelProperties,
      maxTokenLength: {
        defaultValue: 255,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "maxTokenLength",
        type: {
          name: "Number"
        }
      },
      stopwords: {
        serializedName: "stopwords",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      }
    }
  }
};

export const StopAnalyzer: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.StopAnalyzer",
  type: {
    name: "Composite",
    className: "StopAnalyzer",
    uberParent: "LexicalAnalyzer",
    polymorphicDiscriminator: LexicalAnalyzer.type.polymorphicDiscriminator,
    modelProperties: {
      ...LexicalAnalyzer.type.modelProperties,
      stopwords: {
        serializedName: "stopwords",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      }
    }
  }
};

export const ClassicTokenizer: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.ClassicTokenizer",
  type: {
    name: "Composite",
    className: "ClassicTokenizer",
    uberParent: "LexicalTokenizer",
    polymorphicDiscriminator: LexicalTokenizer.type.polymorphicDiscriminator,
    modelProperties: {
      ...LexicalTokenizer.type.modelProperties,
      maxTokenLength: {
        defaultValue: 255,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "maxTokenLength",
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const EdgeNGramTokenizer: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.EdgeNGramTokenizer",
  type: {
    name: "Composite",
    className: "EdgeNGramTokenizer",
    uberParent: "LexicalTokenizer",
    polymorphicDiscriminator: LexicalTokenizer.type.polymorphicDiscriminator,
    modelProperties: {
      ...LexicalTokenizer.type.modelProperties,
      minGram: {
        defaultValue: 1,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "minGram",
        type: {
          name: "Number"
        }
      },
      maxGram: {
        defaultValue: 2,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "maxGram",
        type: {
          name: "Number"
        }
      },
      tokenChars: {
        serializedName: "tokenChars",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Enum",
              allowedValues: [
                "letter",
                "digit",
                "whitespace",
                "punctuation",
                "symbol"
              ]
            }
          }
        }
      }
    }
  }
};

export const KeywordTokenizer: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.KeywordTokenizer",
  type: {
    name: "Composite",
    className: "KeywordTokenizer",
    uberParent: "LexicalTokenizer",
    polymorphicDiscriminator: LexicalTokenizer.type.polymorphicDiscriminator,
    modelProperties: {
      ...LexicalTokenizer.type.modelProperties,
      bufferSize: {
        defaultValue: 256,
        serializedName: "bufferSize",
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const KeywordTokenizerV2: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.KeywordTokenizerV2",
  type: {
    name: "Composite",
    className: "KeywordTokenizerV2",
    uberParent: "LexicalTokenizer",
    polymorphicDiscriminator: LexicalTokenizer.type.polymorphicDiscriminator,
    modelProperties: {
      ...LexicalTokenizer.type.modelProperties,
      maxTokenLength: {
        defaultValue: 256,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "maxTokenLength",
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const MicrosoftLanguageTokenizer: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.MicrosoftLanguageTokenizer",
  type: {
    name: "Composite",
    className: "MicrosoftLanguageTokenizer",
    uberParent: "LexicalTokenizer",
    polymorphicDiscriminator: LexicalTokenizer.type.polymorphicDiscriminator,
    modelProperties: {
      ...LexicalTokenizer.type.modelProperties,
      maxTokenLength: {
        defaultValue: 255,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "maxTokenLength",
        type: {
          name: "Number"
        }
      },
      isSearchTokenizer: {
        serializedName: "isSearchTokenizer",
        type: {
          name: "Boolean"
        }
      },
      language: {
        serializedName: "language",
        type: {
          name: "Enum",
          allowedValues: [
            "bangla",
            "bulgarian",
            "catalan",
            "chineseSimplified",
            "chineseTraditional",
            "croatian",
            "czech",
            "danish",
            "dutch",
            "english",
            "french",
            "german",
            "greek",
            "gujarati",
            "hindi",
            "icelandic",
            "indonesian",
            "italian",
            "japanese",
            "kannada",
            "korean",
            "malay",
            "malayalam",
            "marathi",
            "norwegianBokmaal",
            "polish",
            "portuguese",
            "portugueseBrazilian",
            "punjabi",
            "romanian",
            "russian",
            "serbianCyrillic",
            "serbianLatin",
            "slovenian",
            "spanish",
            "swedish",
            "tamil",
            "telugu",
            "thai",
            "ukrainian",
            "urdu",
            "vietnamese"
          ]
        }
      }
    }
  }
};

export const MicrosoftLanguageStemmingTokenizer: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.MicrosoftLanguageStemmingTokenizer",
  type: {
    name: "Composite",
    className: "MicrosoftLanguageStemmingTokenizer",
    uberParent: "LexicalTokenizer",
    polymorphicDiscriminator: LexicalTokenizer.type.polymorphicDiscriminator,
    modelProperties: {
      ...LexicalTokenizer.type.modelProperties,
      maxTokenLength: {
        defaultValue: 255,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "maxTokenLength",
        type: {
          name: "Number"
        }
      },
      isSearchTokenizer: {
        serializedName: "isSearchTokenizer",
        type: {
          name: "Boolean"
        }
      },
      language: {
        serializedName: "language",
        type: {
          name: "Enum",
          allowedValues: [
            "arabic",
            "bangla",
            "bulgarian",
            "catalan",
            "croatian",
            "czech",
            "danish",
            "dutch",
            "english",
            "estonian",
            "finnish",
            "french",
            "german",
            "greek",
            "gujarati",
            "hebrew",
            "hindi",
            "hungarian",
            "icelandic",
            "indonesian",
            "italian",
            "kannada",
            "latvian",
            "lithuanian",
            "malay",
            "malayalam",
            "marathi",
            "norwegianBokmaal",
            "polish",
            "portuguese",
            "portugueseBrazilian",
            "punjabi",
            "romanian",
            "russian",
            "serbianCyrillic",
            "serbianLatin",
            "slovak",
            "slovenian",
            "spanish",
            "swedish",
            "tamil",
            "telugu",
            "turkish",
            "ukrainian",
            "urdu"
          ]
        }
      }
    }
  }
};

export const NGramTokenizer: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.NGramTokenizer",
  type: {
    name: "Composite",
    className: "NGramTokenizer",
    uberParent: "LexicalTokenizer",
    polymorphicDiscriminator: LexicalTokenizer.type.polymorphicDiscriminator,
    modelProperties: {
      ...LexicalTokenizer.type.modelProperties,
      minGram: {
        defaultValue: 1,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "minGram",
        type: {
          name: "Number"
        }
      },
      maxGram: {
        defaultValue: 2,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "maxGram",
        type: {
          name: "Number"
        }
      },
      tokenChars: {
        serializedName: "tokenChars",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Enum",
              allowedValues: [
                "letter",
                "digit",
                "whitespace",
                "punctuation",
                "symbol"
              ]
            }
          }
        }
      }
    }
  }
};

export const PathHierarchyTokenizerV2: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.PathHierarchyTokenizerV2",
  type: {
    name: "Composite",
    className: "PathHierarchyTokenizerV2",
    uberParent: "LexicalTokenizer",
    polymorphicDiscriminator: LexicalTokenizer.type.polymorphicDiscriminator,
    modelProperties: {
      ...LexicalTokenizer.type.modelProperties,
      delimiter: {
        defaultValue: "/",
        serializedName: "delimiter",
        type: {
          name: "String"
        }
      },
      replacement: {
        defaultValue: "/",
        serializedName: "replacement",
        type: {
          name: "String"
        }
      },
      maxTokenLength: {
        defaultValue: 300,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "maxTokenLength",
        type: {
          name: "Number"
        }
      },
      reverseTokenOrder: {
        serializedName: "reverse",
        type: {
          name: "Boolean"
        }
      },
      numberOfTokensToSkip: {
        serializedName: "skip",
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const PatternTokenizer: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.PatternTokenizer",
  type: {
    name: "Composite",
    className: "PatternTokenizer",
    uberParent: "LexicalTokenizer",
    polymorphicDiscriminator: LexicalTokenizer.type.polymorphicDiscriminator,
    modelProperties: {
      ...LexicalTokenizer.type.modelProperties,
      pattern: {
        defaultValue: "W+",
        serializedName: "pattern",
        type: {
          name: "String"
        }
      },
      flags: {
        serializedName: "flags",
        type: {
          name: "String"
        }
      },
      group: {
        defaultValue: -1,
        serializedName: "group",
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const LuceneStandardTokenizer: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.StandardTokenizer",
  type: {
    name: "Composite",
    className: "LuceneStandardTokenizer",
    uberParent: "LexicalTokenizer",
    polymorphicDiscriminator: LexicalTokenizer.type.polymorphicDiscriminator,
    modelProperties: {
      ...LexicalTokenizer.type.modelProperties,
      maxTokenLength: {
        defaultValue: 255,
        serializedName: "maxTokenLength",
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const LuceneStandardTokenizerV2: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.StandardTokenizerV2",
  type: {
    name: "Composite",
    className: "LuceneStandardTokenizerV2",
    uberParent: "LexicalTokenizer",
    polymorphicDiscriminator: LexicalTokenizer.type.polymorphicDiscriminator,
    modelProperties: {
      ...LexicalTokenizer.type.modelProperties,
      maxTokenLength: {
        defaultValue: 255,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "maxTokenLength",
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const UaxUrlEmailTokenizer: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.UaxUrlEmailTokenizer",
  type: {
    name: "Composite",
    className: "UaxUrlEmailTokenizer",
    uberParent: "LexicalTokenizer",
    polymorphicDiscriminator: LexicalTokenizer.type.polymorphicDiscriminator,
    modelProperties: {
      ...LexicalTokenizer.type.modelProperties,
      maxTokenLength: {
        defaultValue: 255,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "maxTokenLength",
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const AsciiFoldingTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.AsciiFoldingTokenFilter",
  type: {
    name: "Composite",
    className: "AsciiFoldingTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      preserveOriginal: {
        serializedName: "preserveOriginal",
        type: {
          name: "Boolean"
        }
      }
    }
  }
};

export const CjkBigramTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.CjkBigramTokenFilter",
  type: {
    name: "Composite",
    className: "CjkBigramTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      ignoreScripts: {
        serializedName: "ignoreScripts",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Enum",
              allowedValues: ["han", "hiragana", "katakana", "hangul"]
            }
          }
        }
      },
      outputUnigrams: {
        serializedName: "outputUnigrams",
        type: {
          name: "Boolean"
        }
      }
    }
  }
};

export const CommonGramTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.CommonGramTokenFilter",
  type: {
    name: "Composite",
    className: "CommonGramTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      commonWords: {
        serializedName: "commonWords",
        required: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      },
      ignoreCase: {
        serializedName: "ignoreCase",
        type: {
          name: "Boolean"
        }
      },
      useQueryMode: {
        serializedName: "queryMode",
        type: {
          name: "Boolean"
        }
      }
    }
  }
};

export const DictionaryDecompounderTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.DictionaryDecompounderTokenFilter",
  type: {
    name: "Composite",
    className: "DictionaryDecompounderTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      wordList: {
        serializedName: "wordList",
        required: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      },
      minWordSize: {
        defaultValue: 5,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "minWordSize",
        type: {
          name: "Number"
        }
      },
      minSubwordSize: {
        defaultValue: 2,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "minSubwordSize",
        type: {
          name: "Number"
        }
      },
      maxSubwordSize: {
        defaultValue: 15,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "maxSubwordSize",
        type: {
          name: "Number"
        }
      },
      onlyLongestMatch: {
        serializedName: "onlyLongestMatch",
        type: {
          name: "Boolean"
        }
      }
    }
  }
};

export const EdgeNGramTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.EdgeNGramTokenFilter",
  type: {
    name: "Composite",
    className: "EdgeNGramTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      minGram: {
        defaultValue: 1,
        serializedName: "minGram",
        type: {
          name: "Number"
        }
      },
      maxGram: {
        defaultValue: 2,
        serializedName: "maxGram",
        type: {
          name: "Number"
        }
      },
      side: {
        serializedName: "side",
        type: {
          name: "Enum",
          allowedValues: ["front", "back"]
        }
      }
    }
  }
};

export const EdgeNGramTokenFilterV2: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.EdgeNGramTokenFilterV2",
  type: {
    name: "Composite",
    className: "EdgeNGramTokenFilterV2",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      minGram: {
        defaultValue: 1,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "minGram",
        type: {
          name: "Number"
        }
      },
      maxGram: {
        defaultValue: 2,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "maxGram",
        type: {
          name: "Number"
        }
      },
      side: {
        serializedName: "side",
        type: {
          name: "Enum",
          allowedValues: ["front", "back"]
        }
      }
    }
  }
};

export const ElisionTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.ElisionTokenFilter",
  type: {
    name: "Composite",
    className: "ElisionTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      articles: {
        serializedName: "articles",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      }
    }
  }
};

export const KeepTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.KeepTokenFilter",
  type: {
    name: "Composite",
    className: "KeepTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      keepWords: {
        serializedName: "keepWords",
        required: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      },
      lowerCaseKeepWords: {
        serializedName: "keepWordsCase",
        type: {
          name: "Boolean"
        }
      }
    }
  }
};

export const KeywordMarkerTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.KeywordMarkerTokenFilter",
  type: {
    name: "Composite",
    className: "KeywordMarkerTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      keywords: {
        serializedName: "keywords",
        required: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      },
      ignoreCase: {
        serializedName: "ignoreCase",
        type: {
          name: "Boolean"
        }
      }
    }
  }
};

export const LengthTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.LengthTokenFilter",
  type: {
    name: "Composite",
    className: "LengthTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      minLength: {
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "min",
        type: {
          name: "Number"
        }
      },
      maxLength: {
        defaultValue: 300,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "max",
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const LimitTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.LimitTokenFilter",
  type: {
    name: "Composite",
    className: "LimitTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      maxTokenCount: {
        defaultValue: 1,
        serializedName: "maxTokenCount",
        type: {
          name: "Number"
        }
      },
      consumeAllTokens: {
        serializedName: "consumeAllTokens",
        type: {
          name: "Boolean"
        }
      }
    }
  }
};

export const NGramTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.NGramTokenFilter",
  type: {
    name: "Composite",
    className: "NGramTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      minGram: {
        defaultValue: 1,
        serializedName: "minGram",
        type: {
          name: "Number"
        }
      },
      maxGram: {
        defaultValue: 2,
        serializedName: "maxGram",
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const NGramTokenFilterV2: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.NGramTokenFilterV2",
  type: {
    name: "Composite",
    className: "NGramTokenFilterV2",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      minGram: {
        defaultValue: 1,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "minGram",
        type: {
          name: "Number"
        }
      },
      maxGram: {
        defaultValue: 2,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "maxGram",
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const PatternCaptureTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.PatternCaptureTokenFilter",
  type: {
    name: "Composite",
    className: "PatternCaptureTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      patterns: {
        serializedName: "patterns",
        required: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      },
      preserveOriginal: {
        defaultValue: true,
        serializedName: "preserveOriginal",
        type: {
          name: "Boolean"
        }
      }
    }
  }
};

export const PatternReplaceTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.PatternReplaceTokenFilter",
  type: {
    name: "Composite",
    className: "PatternReplaceTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      pattern: {
        serializedName: "pattern",
        required: true,
        type: {
          name: "String"
        }
      },
      replacement: {
        serializedName: "replacement",
        required: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const PhoneticTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.PhoneticTokenFilter",
  type: {
    name: "Composite",
    className: "PhoneticTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      encoder: {
        serializedName: "encoder",
        type: {
          name: "Enum",
          allowedValues: [
            "metaphone",
            "doubleMetaphone",
            "soundex",
            "refinedSoundex",
            "caverphone1",
            "caverphone2",
            "cologne",
            "nysiis",
            "koelnerPhonetik",
            "haasePhonetik",
            "beiderMorse"
          ]
        }
      },
      replaceOriginalTokens: {
        defaultValue: true,
        serializedName: "replace",
        type: {
          name: "Boolean"
        }
      }
    }
  }
};

export const ShingleTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.ShingleTokenFilter",
  type: {
    name: "Composite",
    className: "ShingleTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      maxShingleSize: {
        defaultValue: 2,
        constraints: {
          InclusiveMinimum: 2
        },
        serializedName: "maxShingleSize",
        type: {
          name: "Number"
        }
      },
      minShingleSize: {
        defaultValue: 2,
        constraints: {
          InclusiveMinimum: 2
        },
        serializedName: "minShingleSize",
        type: {
          name: "Number"
        }
      },
      outputUnigrams: {
        defaultValue: true,
        serializedName: "outputUnigrams",
        type: {
          name: "Boolean"
        }
      },
      outputUnigramsIfNoShingles: {
        serializedName: "outputUnigramsIfNoShingles",
        type: {
          name: "Boolean"
        }
      },
      tokenSeparator: {
        defaultValue: " ",
        serializedName: "tokenSeparator",
        type: {
          name: "String"
        }
      },
      filterToken: {
        defaultValue: "_",
        serializedName: "filterToken",
        type: {
          name: "String"
        }
      }
    }
  }
};

export const SnowballTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.SnowballTokenFilter",
  type: {
    name: "Composite",
    className: "SnowballTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      language: {
        serializedName: "language",
        required: true,
        type: {
          name: "Enum",
          allowedValues: [
            "armenian",
            "basque",
            "catalan",
            "danish",
            "dutch",
            "english",
            "finnish",
            "french",
            "german",
            "german2",
            "hungarian",
            "italian",
            "kp",
            "lovins",
            "norwegian",
            "porter",
            "portuguese",
            "romanian",
            "russian",
            "spanish",
            "swedish",
            "turkish"
          ]
        }
      }
    }
  }
};

export const StemmerTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.StemmerTokenFilter",
  type: {
    name: "Composite",
    className: "StemmerTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      language: {
        serializedName: "language",
        required: true,
        type: {
          name: "Enum",
          allowedValues: [
            "arabic",
            "armenian",
            "basque",
            "brazilian",
            "bulgarian",
            "catalan",
            "czech",
            "danish",
            "dutch",
            "dutchKp",
            "english",
            "lightEnglish",
            "minimalEnglish",
            "possessiveEnglish",
            "porter2",
            "lovins",
            "finnish",
            "lightFinnish",
            "french",
            "lightFrench",
            "minimalFrench",
            "galician",
            "minimalGalician",
            "german",
            "german2",
            "lightGerman",
            "minimalGerman",
            "greek",
            "hindi",
            "hungarian",
            "lightHungarian",
            "indonesian",
            "irish",
            "italian",
            "lightItalian",
            "sorani",
            "latvian",
            "norwegian",
            "lightNorwegian",
            "minimalNorwegian",
            "lightNynorsk",
            "minimalNynorsk",
            "portuguese",
            "lightPortuguese",
            "minimalPortuguese",
            "portugueseRslp",
            "romanian",
            "russian",
            "lightRussian",
            "spanish",
            "lightSpanish",
            "swedish",
            "lightSwedish",
            "turkish"
          ]
        }
      }
    }
  }
};

export const StemmerOverrideTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.StemmerOverrideTokenFilter",
  type: {
    name: "Composite",
    className: "StemmerOverrideTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      rules: {
        serializedName: "rules",
        required: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      }
    }
  }
};

export const StopwordsTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.StopwordsTokenFilter",
  type: {
    name: "Composite",
    className: "StopwordsTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      stopwords: {
        serializedName: "stopwords",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      },
      stopwordsList: {
        serializedName: "stopwordsList",
        type: {
          name: "Enum",
          allowedValues: [
            "arabic",
            "armenian",
            "basque",
            "brazilian",
            "bulgarian",
            "catalan",
            "czech",
            "danish",
            "dutch",
            "english",
            "finnish",
            "french",
            "galician",
            "german",
            "greek",
            "hindi",
            "hungarian",
            "indonesian",
            "irish",
            "italian",
            "latvian",
            "norwegian",
            "persian",
            "portuguese",
            "romanian",
            "russian",
            "sorani",
            "spanish",
            "swedish",
            "thai",
            "turkish"
          ]
        }
      },
      ignoreCase: {
        serializedName: "ignoreCase",
        type: {
          name: "Boolean"
        }
      },
      removeTrailingStopWords: {
        defaultValue: true,
        serializedName: "removeTrailing",
        type: {
          name: "Boolean"
        }
      }
    }
  }
};

export const SynonymTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.SynonymTokenFilter",
  type: {
    name: "Composite",
    className: "SynonymTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      synonyms: {
        serializedName: "synonyms",
        required: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      },
      ignoreCase: {
        serializedName: "ignoreCase",
        type: {
          name: "Boolean"
        }
      },
      expand: {
        defaultValue: true,
        serializedName: "expand",
        type: {
          name: "Boolean"
        }
      }
    }
  }
};

export const TruncateTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.TruncateTokenFilter",
  type: {
    name: "Composite",
    className: "TruncateTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      length: {
        defaultValue: 300,
        constraints: {
          InclusiveMaximum: 300
        },
        serializedName: "length",
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const UniqueTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.UniqueTokenFilter",
  type: {
    name: "Composite",
    className: "UniqueTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      onlyOnSamePosition: {
        serializedName: "onlyOnSamePosition",
        type: {
          name: "Boolean"
        }
      }
    }
  }
};

export const WordDelimiterTokenFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.WordDelimiterTokenFilter",
  type: {
    name: "Composite",
    className: "WordDelimiterTokenFilter",
    uberParent: "TokenFilter",
    polymorphicDiscriminator: TokenFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...TokenFilter.type.modelProperties,
      generateWordParts: {
        defaultValue: true,
        serializedName: "generateWordParts",
        type: {
          name: "Boolean"
        }
      },
      generateNumberParts: {
        defaultValue: true,
        serializedName: "generateNumberParts",
        type: {
          name: "Boolean"
        }
      },
      catenateWords: {
        serializedName: "catenateWords",
        type: {
          name: "Boolean"
        }
      },
      catenateNumbers: {
        serializedName: "catenateNumbers",
        type: {
          name: "Boolean"
        }
      },
      catenateAll: {
        serializedName: "catenateAll",
        type: {
          name: "Boolean"
        }
      },
      splitOnCaseChange: {
        defaultValue: true,
        serializedName: "splitOnCaseChange",
        type: {
          name: "Boolean"
        }
      },
      preserveOriginal: {
        serializedName: "preserveOriginal",
        type: {
          name: "Boolean"
        }
      },
      splitOnNumerics: {
        defaultValue: true,
        serializedName: "splitOnNumerics",
        type: {
          name: "Boolean"
        }
      },
      stemEnglishPossessive: {
        defaultValue: true,
        serializedName: "stemEnglishPossessive",
        type: {
          name: "Boolean"
        }
      },
      protectedWords: {
        serializedName: "protectedWords",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      }
    }
  }
};

export const MappingCharFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.MappingCharFilter",
  type: {
    name: "Composite",
    className: "MappingCharFilter",
    uberParent: "CharFilter",
    polymorphicDiscriminator: CharFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...CharFilter.type.modelProperties,
      mappings: {
        serializedName: "mappings",
        required: true,
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      }
    }
  }
};

export const PatternReplaceCharFilter: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.PatternReplaceCharFilter",
  type: {
    name: "Composite",
    className: "PatternReplaceCharFilter",
    uberParent: "CharFilter",
    polymorphicDiscriminator: CharFilter.type.polymorphicDiscriminator,
    modelProperties: {
      ...CharFilter.type.modelProperties,
      pattern: {
        serializedName: "pattern",
        required: true,
        type: {
          name: "String"
        }
      },
      replacement: {
        serializedName: "replacement",
        required: true,
        type: {
          name: "String"
        }
      }
    }
  }
};

export const CustomNormalizer: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.CustomNormalizer",
  type: {
    name: "Composite",
    className: "CustomNormalizer",
    uberParent: "LexicalNormalizer",
    polymorphicDiscriminator: LexicalNormalizer.type.polymorphicDiscriminator,
    modelProperties: {
      ...LexicalNormalizer.type.modelProperties,
      tokenFilters: {
        serializedName: "tokenFilters",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      },
      charFilters: {
        serializedName: "charFilters",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "String"
            }
          }
        }
      }
    }
  }
};

export const ClassicSimilarity: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.ClassicSimilarity",
  type: {
    name: "Composite",
    className: "ClassicSimilarity",
    uberParent: "Similarity",
    polymorphicDiscriminator: Similarity.type.polymorphicDiscriminator,
    modelProperties: {
      ...Similarity.type.modelProperties
    }
  }
};

export const BM25Similarity: coreHttp.CompositeMapper = {
  serializedName: "#Microsoft.Azure.Search.BM25Similarity",
  type: {
    name: "Composite",
    className: "BM25Similarity",
    uberParent: "Similarity",
    polymorphicDiscriminator: Similarity.type.polymorphicDiscriminator,
    modelProperties: {
      ...Similarity.type.modelProperties,
      k1: {
        serializedName: "k1",
        nullable: true,
        type: {
          name: "Number"
        }
      },
      b: {
        serializedName: "b",
        nullable: true,
        type: {
          name: "Number"
        }
      }
    }
  }
};

export const SearchIndexerKnowledgeStoreObjectProjectionSelector: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchIndexerKnowledgeStoreObjectProjectionSelector",
    modelProperties: {
      ...SearchIndexerKnowledgeStoreBlobProjectionSelector.type.modelProperties
    }
  }
};

export const SearchIndexerKnowledgeStoreFileProjectionSelector: coreHttp.CompositeMapper = {
  type: {
    name: "Composite",
    className: "SearchIndexerKnowledgeStoreFileProjectionSelector",
    modelProperties: {
      ...SearchIndexerKnowledgeStoreBlobProjectionSelector.type.modelProperties
    }
  }
};

export let discriminators = {
  SearchIndexerDataIdentity: SearchIndexerDataIdentity,
  DataChangeDetectionPolicy: DataChangeDetectionPolicy,
  DataDeletionDetectionPolicy: DataDeletionDetectionPolicy,
  SearchIndexerSkill: SearchIndexerSkill,
  CognitiveServicesAccount: CognitiveServicesAccount,
  ScoringFunction: ScoringFunction,
  LexicalAnalyzer: LexicalAnalyzer,
  LexicalTokenizer: LexicalTokenizer,
  TokenFilter: TokenFilter,
  CharFilter: CharFilter,
  LexicalNormalizer: LexicalNormalizer,
  Similarity: Similarity,
  "SearchIndexerDataIdentity.#Microsoft.Azure.Search.SearchIndexerDataNoneIdentity": SearchIndexerDataNoneIdentity,
  "SearchIndexerDataIdentity.#Microsoft.Azure.Search.SearchIndexerDataUserAssignedIdentity": SearchIndexerDataUserAssignedIdentity,
  "DataChangeDetectionPolicy.#Microsoft.Azure.Search.HighWaterMarkChangeDetectionPolicy": HighWaterMarkChangeDetectionPolicy,
  "DataChangeDetectionPolicy.#Microsoft.Azure.Search.SqlIntegratedChangeTrackingPolicy": SqlIntegratedChangeTrackingPolicy,
  "DataDeletionDetectionPolicy.#Microsoft.Azure.Search.SoftDeleteColumnDeletionDetectionPolicy": SoftDeleteColumnDeletionDetectionPolicy,
  "SearchIndexerSkill.#Microsoft.Skills.Util.ConditionalSkill": ConditionalSkill,
  "SearchIndexerSkill.#Microsoft.Skills.Text.KeyPhraseExtractionSkill": KeyPhraseExtractionSkill,
  "SearchIndexerSkill.#Microsoft.Skills.Vision.OcrSkill": OcrSkill,
  "SearchIndexerSkill.#Microsoft.Skills.Vision.ImageAnalysisSkill": ImageAnalysisSkill,
  "SearchIndexerSkill.#Microsoft.Skills.Text.LanguageDetectionSkill": LanguageDetectionSkill,
  "SearchIndexerSkill.#Microsoft.Skills.Util.ShaperSkill": ShaperSkill,
  "SearchIndexerSkill.#Microsoft.Skills.Text.MergeSkill": MergeSkill,
  "SearchIndexerSkill.#Microsoft.Skills.Text.EntityRecognitionSkill": EntityRecognitionSkill,
  "SearchIndexerSkill.#Microsoft.Skills.Text.SentimentSkill": SentimentSkill,
  "SearchIndexerSkill.#Microsoft.Skills.Text.V3.SentimentSkill": SentimentSkillV3,
  "SearchIndexerSkill.#Microsoft.Skills.Text.V3.EntityLinkingSkill": EntityLinkingSkill,
  "SearchIndexerSkill.#Microsoft.Skills.Text.V3.EntityRecognitionSkill": EntityRecognitionSkillV3,
  "SearchIndexerSkill.#Microsoft.Skills.Text.PIIDetectionSkill": PIIDetectionSkill,
  "SearchIndexerSkill.#Microsoft.Skills.Text.SplitSkill": SplitSkill,
  "SearchIndexerSkill.#Microsoft.Skills.Text.CustomEntityLookupSkill": CustomEntityLookupSkill,
  "SearchIndexerSkill.#Microsoft.Skills.Text.TranslationSkill": TextTranslationSkill,
  "SearchIndexerSkill.#Microsoft.Skills.Util.DocumentExtractionSkill": DocumentExtractionSkill,
  "SearchIndexerSkill.#Microsoft.Skills.Custom.WebApiSkill": WebApiSkill,
  "CognitiveServicesAccount.#Microsoft.Azure.Search.DefaultCognitiveServices": DefaultCognitiveServicesAccount,
  "CognitiveServicesAccount.#Microsoft.Azure.Search.CognitiveServicesByKey": CognitiveServicesAccountKey,
  "ScoringFunction.distance": DistanceScoringFunction,
  "ScoringFunction.freshness": FreshnessScoringFunction,
  "ScoringFunction.magnitude": MagnitudeScoringFunction,
  "ScoringFunction.tag": TagScoringFunction,
  "LexicalAnalyzer.#Microsoft.Azure.Search.CustomAnalyzer": CustomAnalyzer,
  "LexicalAnalyzer.#Microsoft.Azure.Search.PatternAnalyzer": PatternAnalyzer,
  "LexicalAnalyzer.#Microsoft.Azure.Search.StandardAnalyzer": LuceneStandardAnalyzer,
  "LexicalAnalyzer.#Microsoft.Azure.Search.StopAnalyzer": StopAnalyzer,
  "LexicalTokenizer.#Microsoft.Azure.Search.ClassicTokenizer": ClassicTokenizer,
  "LexicalTokenizer.#Microsoft.Azure.Search.EdgeNGramTokenizer": EdgeNGramTokenizer,
  "LexicalTokenizer.#Microsoft.Azure.Search.KeywordTokenizer": KeywordTokenizer,
  "LexicalTokenizer.#Microsoft.Azure.Search.KeywordTokenizerV2": KeywordTokenizerV2,
  "LexicalTokenizer.#Microsoft.Azure.Search.MicrosoftLanguageTokenizer": MicrosoftLanguageTokenizer,
  "LexicalTokenizer.#Microsoft.Azure.Search.MicrosoftLanguageStemmingTokenizer": MicrosoftLanguageStemmingTokenizer,
  "LexicalTokenizer.#Microsoft.Azure.Search.NGramTokenizer": NGramTokenizer,
  "LexicalTokenizer.#Microsoft.Azure.Search.PathHierarchyTokenizerV2": PathHierarchyTokenizerV2,
  "LexicalTokenizer.#Microsoft.Azure.Search.PatternTokenizer": PatternTokenizer,
  "LexicalTokenizer.#Microsoft.Azure.Search.StandardTokenizer": LuceneStandardTokenizer,
  "LexicalTokenizer.#Microsoft.Azure.Search.StandardTokenizerV2": LuceneStandardTokenizerV2,
  "LexicalTokenizer.#Microsoft.Azure.Search.UaxUrlEmailTokenizer": UaxUrlEmailTokenizer,
  "TokenFilter.#Microsoft.Azure.Search.AsciiFoldingTokenFilter": AsciiFoldingTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.CjkBigramTokenFilter": CjkBigramTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.CommonGramTokenFilter": CommonGramTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.DictionaryDecompounderTokenFilter": DictionaryDecompounderTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.EdgeNGramTokenFilter": EdgeNGramTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.EdgeNGramTokenFilterV2": EdgeNGramTokenFilterV2,
  "TokenFilter.#Microsoft.Azure.Search.ElisionTokenFilter": ElisionTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.KeepTokenFilter": KeepTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.KeywordMarkerTokenFilter": KeywordMarkerTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.LengthTokenFilter": LengthTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.LimitTokenFilter": LimitTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.NGramTokenFilter": NGramTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.NGramTokenFilterV2": NGramTokenFilterV2,
  "TokenFilter.#Microsoft.Azure.Search.PatternCaptureTokenFilter": PatternCaptureTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.PatternReplaceTokenFilter": PatternReplaceTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.PhoneticTokenFilter": PhoneticTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.ShingleTokenFilter": ShingleTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.SnowballTokenFilter": SnowballTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.StemmerTokenFilter": StemmerTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.StemmerOverrideTokenFilter": StemmerOverrideTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.StopwordsTokenFilter": StopwordsTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.SynonymTokenFilter": SynonymTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.TruncateTokenFilter": TruncateTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.UniqueTokenFilter": UniqueTokenFilter,
  "TokenFilter.#Microsoft.Azure.Search.WordDelimiterTokenFilter": WordDelimiterTokenFilter,
  "CharFilter.#Microsoft.Azure.Search.MappingCharFilter": MappingCharFilter,
  "CharFilter.#Microsoft.Azure.Search.PatternReplaceCharFilter": PatternReplaceCharFilter,
  "LexicalNormalizer.#Microsoft.Azure.Search.CustomNormalizer": CustomNormalizer,
  "Similarity.#Microsoft.Azure.Search.ClassicSimilarity": ClassicSimilarity,
  "Similarity.#Microsoft.Azure.Search.BM25Similarity": BM25Similarity
};